fix: WebSocket max_size hochgedreht — voice_upload sprengte Default 1MB

Symptom: aria-whisper-bridge bekam beim ersten internen stt_request (via voice_upload mit WAV als base64, ~2.4MB) den Frame zu Gesicht, default ws-max ist 1MB → mit Close-Code 1009 abgewiesen → Verbindung tot → naechster stt_request lief in Timeout → lokales Fallback. Fixes: - whisper-bridge: max_size=50*1024*1024 in websockets.connect() (gleicher Wert wie f5tts-bridge schon hat) - RVS-Server: maxPayload=50*1024*1024 in WebSocketServer-Optionen, damit der Server die Frames nicht selbst auf 1MB cappt bevor er sie an die Bridge weiterleitet. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
fix(whisper): kein eager preload mehr — wartet auf config-Broadcast
2026-04-24 16:54:36 +02:00 · 2026-04-24 16:50:46 +02:00 · 2026-04-24 16:25:53 +02:00 · 2026-04-24 16:24:47 +02:00 · 2026-04-24 16:21:19 +02:00 · 2026-04-24 16:08:10 +02:00
32 changed files with 303 additions and 1602 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)
@@ -380,7 +380,6 @@ 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
 - **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
 - **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.
@@ -399,44 +398,6 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 - GPS-Position (optional)
 - QR-Code Scanner fuer Token-Pairing
 ### Wake-Word (openWakeWord, on-device)
 Wake-Word-Erkennung laeuft komplett **on-device** ueber [openWakeWord](https://github.com/dscripka/openWakeWord)
 mit ONNX Runtime — kein API-Key, kein Cloud-Roundtrip, kein Cent Lizenzgebuehren,
 und das Audio verlaesst das Geraet nie.
 **Mitgelieferte Wake-Words** (ONNX-Dateien in `android/android/app/src/main/assets/openwakeword/`):
 - `Hey Jarvis` (Default)
 - `Alexa`
 - `Hey Mycroft`
 - `Hey Rhasspy`
 **Bedienung:**
 - App → **Einstellungen** → **Wake-Word** → gewuenschtes Keyword waehlen → **Speichern + Aktivieren**
 - **Ohr-Button (👂)** in der Statusleiste tippen → Wake-Word ist scharf, App hoert passiv mit
 - Wake-Word sagen → Symbol wechselt auf 🎙️, Konversation laeuft
 - Nach jeder ARIA-Antwort oeffnet sich das Mikro nochmal — Stille → zurueck zu 👂
 - Erneut tippen → Ohr aus (🔇)
 **Eigene Wake-Words trainieren** (gratis, ~30 Min):
 1. openWakeWord Trainings-Notebook auf Colab oeffnen (Link im
   [openWakeWord Repo](https://github.com/dscripka/openWakeWord) unter "Training Custom Models")
 2. Wake-Word-Phrase eingeben (z.B. "ARIA", "Hey Stefan"), Notebook ausfuehren —
   das Notebook generiert synthetische Trainings-Beispiele und trainiert das Modell.
 3. Resultierende `.onnx`-Datei runterladen
 4. Datei in `android/android/app/src/main/assets/openwakeword/` ablegen
 5. In `android/src/services/wakeword.ts` den Dateinamen (ohne `.onnx`) zur
   `WAKE_KEYWORDS`-Liste hinzufuegen
 6. APK neu bauen
 *(Diagnostic-Upload fuer Custom-`.onnx` ohne Rebuild kommt spaeter.)*
 **Tuning** (in [wakeword.ts](android/src/services/wakeword.ts)):
 - `DEFAULT_THRESHOLD = 0.5` — Score-Schwelle (raise auf 0.6–0.7 bei False-Positives)
 - `DEFAULT_PATIENCE = 2` — wie viele Frames ueber Threshold noetig
 - `DEFAULT_DEBOUNCE_MS = 1500` — Mindestabstand zwischen zwei Triggern
 ### Ersteinrichtung (Dev-Maschine, einmalig)
 ```bash
@@ -689,33 +650,6 @@ In der Diagnostic unter Einstellungen → Sprachausgabe:
 > **Tipp:** Fuer beste Ergebnisse: saubere Aufnahme, eine Stimme, kein Hintergrund,
 > 10-30 Sekunden Gesamtlaenge. Mehrere kurze Dateien werden zusammengefuegt.
 ### Deutsches Fine-Tune (bessere Qualitaet auf Deutsch)
 Das Default-Modell `F5TTS_v1_Base` ist primaer auf Englisch + Chinesisch trainiert
 und liefert auf Deutsch merklich schwaechere Voice-Cloning-Qualitaet als XTTS es
 tat. Community-Fine-Tune von [aihpi](https://huggingface.co/aihpi/F5-TTS-German)
 auf dem Emilia-Dataset + Common Voice 19.0 funktioniert deutlich besser.
 **Konfiguration ueber Diagnostic → "F5-TTS Modell-Tuning (advanced)":**
 | Feld | Wert |
 |------|------|
 | Modell-Architektur | `F5TTS_Base` *(nicht v1_Base! Fine-Tune basiert auf der alten Architektur)* |
 | Custom Checkpoint | `hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors` |
 | Custom Vocab | `hf://aihpi/F5-TTS-German/vocab.txt` |
 | cfg_strength | `2.0` |
 | nfe_step | `32` |
 → "Anwenden" klicken. Die `hf://`-Pfade werden einmalig automatisch runter-
 geladen (~3-5GB, landet im `xtts/hf-cache/`) und bei Container-Restart aus
 dem Cache wiederverwendet.
 > **Warnung zur BigVGAN-Variante** (`F5TTS_Base_bigvgan/model_295000.safetensors`):
 > funktioniert AKTUELL NICHT mit dieser Bridge. Die f5-tts Library laedt
 > per Default den Vocos-Vocoder, die BigVGAN-Weights sind damit inkompatibel
 > → Modell produziert NaN, App bleibt stumm. Nur die **Vocos-Variante
 > (F5TTS_Base/model_365000.safetensors)** nutzen.
 ---
 ## Docker Volumes
@@ -783,10 +717,8 @@ docker exec aria-core ssh aria-wohnung hostname
 - **Proxy Cold Start**: Jede Nachricht spawnt einen neuen `claude --print` Prozess.
  Dadurch ist ARIA langsamer als die direkte Claude CLI. Timeout ist auf 900s (15 Min).
 - **Kein Streaming zur App**: Die App zeigt erst die fertige Antwort, keine Streaming-Tokens.
- **Wake-Word in der App nur eingebaute Keywords**: `Hey Jarvis`, `Alexa`, `Hey Mycroft`,
+- **Wake Word nur auf VM**: Die Bridge hoert auf "ARIA" ueber das lokale Mikrofon der VM.
-  `Hey Rhasspy` funktionieren sofort, eigene Wake-Words muessen aktuell noch als
+  In der App gibt es Energy-basierte Erkennung (Phase 1). On-device "ARIA"-Keyword (Porcupine) ist Phase 2.
  `.onnx`-Datei ins App-Bundle gelegt + zur Liste in `wakeword.ts` hinzugefuegt werden.
  Die Diagnostic-Upload-UI ist Phase 2.
 - **Audio-Format**: App nimmt AAC/MP4 auf, Bridge konvertiert via FFmpeg zu 16kHz PCM.
 - **RVS Zombie-Connections**: WebSocket-Verbindungen sterben gelegentlich ohne Fehlermeldung.
  Bridge hat Ping-Check (5s), Diagnostic nutzt frische Verbindungen pro Request.
@@ -841,7 +773,6 @@ docker exec aria-core ssh aria-wohnung hostname
 - [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
 - [x] Wake-Word on-device via openWakeWord (ONNX Runtime, kein API-Key) + State-Icon
 ### Phase 2 — ARIA wird produktiv
@@ -857,5 +788,5 @@ docker exec aria-core ssh aria-wohnung hostname
 - [ ] STARFACE Telefonie-Skill
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
- [ ] Custom-`.onnx`-Upload fuer Wake-Word ueber Diagnostic (ohne App-Rebuild)
+- [ ] Porcupine Wake Word (on-device "ARIA" in der App)
 - [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)
@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 607
+        versionCode 506
-        versionName "0.0.6.7"
+        versionName "0.0.5.6"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -104,19 +104,6 @@ android {
            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
        }
    }
    // ABI-Split: nur arm64-v8a (jedes Android-Phone seit ~2017). Bringt die
    // APK von ~136 MB auf ~35 MB — relevant weil ONNX Runtime + die anderen
    // Native-Libs sonst pro Architektur dazukommen. Wer 32-bit oder Emulator
    // braucht, kann hier "armeabi-v7a", "x86_64" etc. ergaenzen.
    splits {
        abi {
            enable true
            reset()
            include "arm64-v8a"
            universalApk false
        }
    }
 }
 dependencies {
@@ -124,9 +111,6 @@ dependencies {
    implementation("com.facebook.react:react-android")
    implementation("com.facebook.react:flipper-integration")
    // ONNX Runtime fuer on-device Wake-Word (openWakeWord ONNX-Modelle in assets/openwakeword/)
    implementation("com.microsoft.onnxruntime:onnxruntime-android:1.17.1")
    if (hermesEnabled.toBoolean()) {
        implementation("com.facebook.react:hermes-android")
    } else {
@@ -21,7 +21,6 @@ class MainApplication : Application(), ReactApplication {
              add(ApkInstallerPackage())
              add(AudioFocusPackage())
              add(PcmStreamPlayerPackage())
              add(OpenWakeWordPackage())
            }
        override fun getJSMainModuleName(): String = "index"
@@ -1,357 +0,0 @@
 package com.ariacockpit
 import ai.onnxruntime.OnnxTensor
 import ai.onnxruntime.OrtEnvironment
 import ai.onnxruntime.OrtSession
 import android.Manifest
 import android.content.pm.PackageManager
 import android.media.AudioFormat
 import android.media.AudioRecord
 import android.media.MediaRecorder
 import android.util.Log
 import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import java.nio.FloatBuffer
 import java.util.concurrent.atomic.AtomicBoolean
 /**
 * Wake-Word Erkennung on-device via openWakeWord (https://github.com/dscripka/openWakeWord).
 *
 * Drei-stufige ONNX Pipeline:
 *   1. Audio (16kHz mono int16, 1280-Sample-Chunks) → Melspectrogram → 32-mel Frames
 *   2. 76 Mel-Frames Sliding Window (stride 8) → Speech-Embedding → 96-dim Vektor
 *   3. Letzte 16 Embeddings (~1.28s Kontext) → Wake-Word-Klassifikator → Sigmoid-Score
 *
 *  Modelle liegen in assets/openwakeword/ (mel + embedding shared, plus pro Keyword
 *  ein eigenes .onnx). Erkennung feuert nach `patience` aufeinanderfolgenden
 *  Frames ueber `threshold` und unterdrueckt Wiederholungen fuer `debounceMs`.
 *
 *  Emittiert "WakeWordDetected" als RN-Event wenn ein Trigger erkannt wurde.
 */
 class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
    override fun getName() = "OpenWakeWord"
    companion object {
        private const val TAG = "OpenWakeWord"
        private const val SAMPLE_RATE = 16000
        private const val CHUNK_SAMPLES = 1280               // 80ms @ 16kHz
        private const val MEL_FRAMES_PER_EMBEDDING = 76      // Embedding-Fenster
        private const val EMBEDDING_STRIDE = 8               // Slide um 8 Mel-Frames
        private const val EMBEDDING_DIM = 96
        private const val WW_INPUT_FRAMES = 16               // 16 Embeddings = ~1.28s
        private const val MEL_BINS = 32
    }
    private val env: OrtEnvironment = OrtEnvironment.getEnvironment()
    private var melSession: OrtSession? = null
    private var embSession: OrtSession? = null
    private var wwSession: OrtSession? = null
    private var melInputName: String = "input"
    private var embInputName: String = "input_1"
    private var wwInputName: String = "input"
    // Konfiguration
    private var threshold: Float = 0.5f
    private var patience: Int = 2
    private var debounceMs: Long = 1500
    private var modelName: String = "hey_jarvis"
    // Audio-Capture-Thread
    private var audioRecord: AudioRecord? = null
    private val running = AtomicBoolean(false)
    private var captureThread: Thread? = null
    // Inferenz-State
    private val melBuffer: ArrayList<FloatArray> = ArrayList(256)   // Liste von 32-dim Frames
    private var melProcessedIdx: Int = 0
    private val embBuffer: ArrayDeque<FloatArray> = ArrayDeque(32)  // Ringpuffer letzter Embeddings
    private var consecutiveAboveThreshold: Int = 0
    private var lastDetectionMs: Long = 0L
    /**
     *  Initialisiert die ONNX-Sessions fuer ein bestimmtes Wake-Word.
     *  modelName: dateiname ohne Suffix (z.B. "hey_jarvis", "alexa", "hey_mycroft", "hey_rhasspy")
     */
    @ReactMethod
    fun init(modelName: String, threshold: Double, patience: Int, debounceMs: Int, promise: Promise) {
        try {
            disposeSessions()
            this.modelName = modelName
            this.threshold = threshold.toFloat()
            this.patience = patience.coerceAtLeast(1)
            this.debounceMs = debounceMs.toLong()
            val ctx = reactApplicationContext
            val melBytes = ctx.assets.open("openwakeword/melspectrogram.onnx").use { it.readBytes() }
            val embBytes = ctx.assets.open("openwakeword/embedding_model.onnx").use { it.readBytes() }
            val wwBytes = ctx.assets.open("openwakeword/$modelName.onnx").use { it.readBytes() }
            val opts = OrtSession.SessionOptions()
            melSession = env.createSession(melBytes, opts)
            embSession = env.createSession(embBytes, opts)
            wwSession = env.createSession(wwBytes, opts)
            melInputName = melSession!!.inputNames.first()
            embInputName = embSession!!.inputNames.first()
            wwInputName = wwSession!!.inputNames.first()
            Log.i(TAG, "Init OK: model=$modelName threshold=$threshold patience=$patience " +
                    "debounce=${debounceMs}ms (inputs: mel=$melInputName emb=$embInputName ww=$wwInputName)")
            promise.resolve(true)
        } catch (e: Exception) {
            Log.e(TAG, "Init fehlgeschlagen: ${e.message}", e)
            disposeSessions()
            promise.reject("INIT_FAILED", e.message ?: "Unbekannter Fehler", e)
        }
    }
    @ReactMethod
    fun start(promise: Promise) {
        if (running.get()) {
            promise.resolve(true)
            return
        }
        if (melSession == null || embSession == null || wwSession == null) {
            promise.reject("NOT_INITIALIZED", "init() muss vor start() aufgerufen werden")
            return
        }
        // Berechtigung pruefen — der App-Code holt die ueblicherweise schon vorher,
        // aber wir bestehen hier explizit darauf damit AudioRecord nicht stumm
        // failt.
        val perm = ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.RECORD_AUDIO)
        if (perm != PackageManager.PERMISSION_GRANTED) {
            promise.reject("NO_MIC_PERMISSION", "RECORD_AUDIO Permission fehlt")
            return
        }
        try {
            val minBuf = AudioRecord.getMinBufferSize(
                SAMPLE_RATE,
                AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_PCM_16BIT,
            ).coerceAtLeast(CHUNK_SAMPLES * 2 * 4)
            val record = AudioRecord(
                MediaRecorder.AudioSource.MIC,
                SAMPLE_RATE,
                AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_PCM_16BIT,
                minBuf,
            )
            if (record.state != AudioRecord.STATE_INITIALIZED) {
                record.release()
                promise.reject("AUDIO_INIT", "AudioRecord nicht initialisiert (Mikro belegt?)")
                return
            }
            audioRecord = record
            resetInferenceState()
            running.set(true)
            record.startRecording()
            captureThread = Thread({ captureLoop() }, "OpenWakeWordCapture").apply {
                isDaemon = true
                start()
            }
            Log.i(TAG, "Lauschen gestartet (model=$modelName)")
            promise.resolve(true)
        } catch (e: Exception) {
            Log.e(TAG, "start fehlgeschlagen", e)
            running.set(false)
            audioRecord?.release()
            audioRecord = null
            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
        }
    }
    @ReactMethod
    fun stop(promise: Promise) {
        running.set(false)
        try {
            captureThread?.join(1500)
        } catch (_: InterruptedException) {}
        captureThread = null
        try { audioRecord?.stop() } catch (_: Exception) {}
        try { audioRecord?.release() } catch (_: Exception) {}
        audioRecord = null
        Log.i(TAG, "Lauschen gestoppt")
        promise.resolve(true)
    }
    @ReactMethod
    fun dispose(promise: Promise) {
        running.set(false)
        try { captureThread?.join(1000) } catch (_: InterruptedException) {}
        captureThread = null
        try { audioRecord?.stop() } catch (_: Exception) {}
        try { audioRecord?.release() } catch (_: Exception) {}
        audioRecord = null
        disposeSessions()
        promise.resolve(true)
    }
    @ReactMethod
    fun isAvailable(promise: Promise) {
        // Wake-Word ist immer verfuegbar (kein API-Key, alles on-device)
        promise.resolve(true)
    }
    // RN-Event-Subscriptions — RN-Konvention, sonst Warnung im Debug-Build
    @ReactMethod fun addListener(eventName: String) {}
    @ReactMethod fun removeListeners(count: Int) {}
    private fun disposeSessions() {
        try { melSession?.close() } catch (_: Exception) {}
        try { embSession?.close() } catch (_: Exception) {}
        try { wwSession?.close() } catch (_: Exception) {}
        melSession = null
        embSession = null
        wwSession = null
    }
    private fun resetInferenceState() {
        melBuffer.clear()
        melProcessedIdx = 0
        embBuffer.clear()
        consecutiveAboveThreshold = 0
        lastDetectionMs = 0L
    }
    private fun emitDetected() {
        val params = com.facebook.react.bridge.Arguments.createMap().apply {
            putString("model", modelName)
        }
        try {
            reactApplicationContext
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                .emit("WakeWordDetected", params)
        } catch (e: Exception) {
            Log.w(TAG, "emit fehlgeschlagen: ${e.message}")
        }
    }
    private fun captureLoop() {
        val buf = ShortArray(CHUNK_SAMPLES)
        val record = audioRecord ?: return
        Log.i(TAG, "Capture-Loop gestartet")
        while (running.get()) {
            var read = 0
            while (read < CHUNK_SAMPLES && running.get()) {
                val n = record.read(buf, read, CHUNK_SAMPLES - read)
                if (n <= 0) {
                    Log.w(TAG, "AudioRecord.read returned $n — Loop ende")
                    running.set(false)
                    return
                }
                read += n
            }
            if (!running.get()) break
            try {
                processChunk(buf)
            } catch (e: Exception) {
                Log.w(TAG, "processChunk: ${e.message}")
            }
        }
        Log.i(TAG, "Capture-Loop beendet")
    }
    /** Verarbeitet einen 1280-Sample int16 Audio-Chunk. */
    private fun processChunk(audio: ShortArray) {
        // 1) Audio → mel (output (1, 1, frames, 32))
        val floats = FloatArray(audio.size) { audio[it].toFloat() }
        val melTensor = OnnxTensor.createTensor(
            env,
            FloatBuffer.wrap(floats),
            longArrayOf(1L, audio.size.toLong()),
        )
        val melResult = melSession!!.run(mapOf(melInputName to melTensor))
        val melOut = melResult.get(0).value
        melTensor.close()
        @Suppress("UNCHECKED_CAST")
        val mel4 = melOut as Array<Array<Array<FloatArray>>>
        val frames = mel4[0][0]
        // openWakeWord wendet `mel/10 + 2` an, bevor es ans Embedding-Modell geht
        for (frame in frames) {
            val scaled = FloatArray(frame.size) { frame[it] / 10f + 2f }
            melBuffer.add(scaled)
        }
        melResult.close()
        // 2) Sliding window: alle vollstaendigen 76-Frame-Fenster verarbeiten
        while (melBuffer.size >= melProcessedIdx + MEL_FRAMES_PER_EMBEDDING) {
            val flat = FloatArray(MEL_FRAMES_PER_EMBEDDING * MEL_BINS)
            var pos = 0
            for (i in 0 until MEL_FRAMES_PER_EMBEDDING) {
                val src = melBuffer[melProcessedIdx + i]
                System.arraycopy(src, 0, flat, pos, MEL_BINS)
                pos += MEL_BINS
            }
            val embIn = OnnxTensor.createTensor(
                env,
                FloatBuffer.wrap(flat),
                longArrayOf(1L, MEL_FRAMES_PER_EMBEDDING.toLong(), MEL_BINS.toLong(), 1L),
            )
            val embRes = embSession!!.run(mapOf(embInputName to embIn))
            val embOut = embRes.get(0).value
            embIn.close()
            // Erwartete Output-Form: (1, 96) → Array<FloatArray>
            @Suppress("UNCHECKED_CAST")
            val embArr = embOut as Array<FloatArray>
            embBuffer.addLast(embArr[0].copyOf())
            while (embBuffer.size > WW_INPUT_FRAMES) embBuffer.removeFirst()
            embRes.close()
            melProcessedIdx += EMBEDDING_STRIDE
        }
        // Mel-Buffer trimmen — verhindert Memory-Wachstum
        if (melProcessedIdx > MEL_FRAMES_PER_EMBEDDING) {
            val keepFrom = melProcessedIdx - MEL_FRAMES_PER_EMBEDDING
            val newList = ArrayList<FloatArray>(melBuffer.size - keepFrom)
            for (i in keepFrom until melBuffer.size) newList.add(melBuffer[i])
            melBuffer.clear()
            melBuffer.addAll(newList)
            melProcessedIdx = MEL_FRAMES_PER_EMBEDDING
        }
        // 3) Klassifikation — sobald wir 16 Embeddings haben
        if (embBuffer.size < WW_INPUT_FRAMES) return
        val flatEmb = FloatArray(WW_INPUT_FRAMES * EMBEDDING_DIM)
        var p = 0
        for (e in embBuffer) {
            System.arraycopy(e, 0, flatEmb, p, EMBEDDING_DIM)
            p += EMBEDDING_DIM
        }
        val wwIn = OnnxTensor.createTensor(
            env,
            FloatBuffer.wrap(flatEmb),
            longArrayOf(1L, WW_INPUT_FRAMES.toLong(), EMBEDDING_DIM.toLong()),
        )
        val wwRes = wwSession!!.run(mapOf(wwInputName to wwIn))
        val wwOut = wwRes.get(0).value
        wwIn.close()
        // Erwartete Output-Form: (1, 1) → Array<FloatArray>
        @Suppress("UNCHECKED_CAST")
        val score = (wwOut as Array<FloatArray>)[0][0]
        wwRes.close()
        if (score >= threshold) {
            consecutiveAboveThreshold++
            if (consecutiveAboveThreshold >= patience) {
                val now = System.currentTimeMillis()
                if (now - lastDetectionMs >= debounceMs) {
                    lastDetectionMs = now
                    consecutiveAboveThreshold = 0
                    Log.i(TAG, "Wake-Word erkannt! score=$score model=$modelName")
                    emitDetected()
                }
            }
        } else {
            consecutiveAboveThreshold = 0
        }
    }
 }
@@ -1,16 +0,0 @@
 package com.ariacockpit
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 class OpenWakeWordPackage : ReactPackage {
    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
        return listOf(OpenWakeWordModule(reactContext))
    }
    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
        return emptyList()
    }
 }
@@ -32,17 +32,11 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
        private const val TAG = "PcmStreamPlayer"
        // Fallback wenn JS keinen Wert uebergibt.
        private const val DEFAULT_PREROLL_SECONDS = 3.5
-        // 0.0 = sofortige Wiedergabe — play() direkt beim ersten Chunk.
+        private const val MIN_PREROLL_SECONDS = 0.5
        // Macht Sinn fuer F5-TTS weil Render so schnell ist dass ein Puffer
        // unnoetig ist und bei kurzen Saetzen sogar stoeren kann.
        private const val MIN_PREROLL_SECONDS = 0.0
        private const val MAX_PREROLL_SECONDS = 10.0
        // Stille am Stream-Anfang, damit AudioTrack sauber anfaehrt und die
        // ersten Samples nicht abgeschnitten werden (XTTS-Warmup + play()-Latenz).
-        private const val LEADING_SILENCE_SECONDS = 0.3
+        private const val LEADING_SILENCE_SECONDS = 0.2
        // Stille am Ende — puffert das Hardware-Flushen damit die letzten
        // echten Samples garantiert ausgespielt werden bevor stop() kommt.
        private const val TRAILING_SILENCE_SECONDS = 0.3
    }
    override fun getName() = "PcmStreamPlayer"
@@ -65,12 +59,9 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
            // Alte Session beenden falls vorhanden
            stopInternal()
-            // Nur NaN/Inf → Default. 0.0 ist gueltig (= sofortige Wiedergabe).
+            val prerollSec = prerollSeconds
-            val prerollSec = if (prerollSeconds.isFinite() && prerollSeconds >= 0.0) {
+                .coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
-                prerollSeconds.coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
+                .let { if (it.isFinite() && it > 0) it else DEFAULT_PREROLL_SECONDS }
            } else {
                DEFAULT_PREROLL_SECONDS
            }
            val channelConfig = if (channels == 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
            val encoding = AudioFormat.ENCODING_PCM_16BIT
@@ -112,9 +103,9 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                val t = track ?: return@Thread
                try {
                    // Leading-Silence in den Buffer — gibt AudioTrack Zeit anzufahren.
-                    val leadingBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
+                    val silenceBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
-                    if (leadingBytes > 0) {
+                    if (silenceBytes > 0) {
-                        val silence = ByteArray(leadingBytes)
+                        val silence = ByteArray(silenceBytes)
                        var silOff = 0
                        while (silOff < silence.size && !writerShouldStop) {
                            val w = t.write(silence, silOff, silence.size - silOff)
@@ -123,38 +114,18 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                        }
                        bytesBuffered += silence.size
                    }
-                    // Bei preroll=0: play() SOFORT nach Leading-Silence aufrufen,
+                    while (!writerShouldStop) {
-                    // nicht erst bei Ankunft des ersten echten Chunks. Android's
+                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS) ?: run {
                    // AudioTrack haelt den Play-State und wartet auf neue Samples.
                    // So verschluckt es keine Worte wenn der erste Chunk erst
                    // nach play()-Startup-Latenz eintrifft.
                    if (prerollBytes == 0 && !playbackStarted) {
                        try {
                            t.play()
                            playbackStarted = true
                            Log.i(TAG, "Playback sofort gestartet (preroll=0, ${bytesBuffered}B silence)")
                        } catch (e: Exception) {
                            Log.w(TAG, "play() sofort failed: ${e.message}")
                        }
                    }
                    mainLoop@ while (!writerShouldStop) {
                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS)
                        if (data == null) {
                            if (endRequested) {
                                // Falls wir vor Pre-Roll enden (kurzer Text): trotzdem abspielen
                                if (!playbackStarted) {
-                                    try {
+                                    try { t.play() } catch (_: Exception) {}
-                                        t.play()
+                                    playbackStarted = true
                                        playbackStarted = true
                                        Log.i(TAG, "Playback gestartet VOR Pre-Roll (kurzer Text, ${bytesBuffered}B gepuffert)")
                                    } catch (e: Exception) {
                                        Log.w(TAG, "play() fallback failed: ${e.message}")
                                    }
                                }
-                                break@mainLoop
+                                return@Thread
                            }
-                            continue@mainLoop
+                            null
-                        }
+                        } ?: continue
                        // Pre-Roll Check: play() erst wenn genug gepuffert
                        if (!playbackStarted && bytesBuffered + data.size >= prerollBytes) {
@@ -175,19 +146,6 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                        }
                        bytesBuffered += data.size
                    }
                    // Trailing-Silence damit die letzten echten Samples garantiert
                    // durch das Hardware-Buffering kommen bevor stop() sie abschneidet
                    val trailingBytes = ((sampleRate * channels * 2) * TRAILING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
                    if (trailingBytes > 0 && !writerShouldStop) {
                        val silence = ByteArray(trailingBytes)
                        var silOff = 0
                        while (silOff < silence.size && !writerShouldStop) {
                            val w = t.write(silence, silOff, silence.size - silOff)
                            if (w <= 0) break
                            silOff += w
                        }
                        bytesBuffered += silence.size
                    }
                } catch (e: Exception) {
                    Log.w(TAG, "Writer-Thread Fehler: ${e.message}")
                } finally {
@@ -167,23 +167,10 @@ export CI=true
 if [ "$MODE" = "debug" ]; then
    ./gradlew assembleDebug
-    OUT_DIR="app/build/outputs/apk/debug"
+    APK_PATH="app/build/outputs/apk/debug/app-debug.apk"
 else
    ./gradlew assembleRelease
-    OUT_DIR="app/build/outputs/apk/release"
+    APK_PATH="app/build/outputs/apk/release/app-release.apk"
 fi
 # Mit ABI-Splits heisst die APK z.B. app-arm64-v8a-release.apk statt
 # app-release.apk. arm64-v8a-Variante zuerst probieren (das ist unser
 # Standard), Universal-APK als Fallback falls Splits deaktiviert sind.
 if [ -f "$OUT_DIR/app-arm64-v8a-${MODE}.apk" ]; then
    APK_PATH="$OUT_DIR/app-arm64-v8a-${MODE}.apk"
 elif [ -f "$OUT_DIR/app-${MODE}.apk" ]; then
    APK_PATH="$OUT_DIR/app-${MODE}.apk"
 else
    echo -e "${RED}Keine passende APK in $OUT_DIR gefunden${NC}"
    cd ..
    exit 1
 fi
 cd ..
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.0.6.7",
+  "version": "0.0.5.6",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -24,7 +24,9 @@
    "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"
+    "react-native-audio-recorder-player": "^3.6.7",
    "@picovoice/porcupine-react-native": "3.0.5",
    "@picovoice/react-native-voice-processor": "1.2.3"
  },
  "devDependencies": {
    "typescript": "^5.3.3",
@@ -1,105 +0,0 @@
 /**
 * MessageText — rendert Chat-Text mit Auto-Linkifizierung:
 *   - http(s)://... → tippbar, oeffnet im Browser
 *   - mailto: oder plain E-Mail → tippbar, oeffnet Mail-App
 *   - Telefonnummern → tippbar, oeffnet Android-Dialer
 *
 * Text ist durchgaengig markierbar/kopierbar (selectable).
 */
 import React from 'react';
 import { Text, Linking, TextStyle, StyleProp } from 'react-native';
 // Regex kombiniert URL | Email | Telefonnummer.
 // Gruppenreihenfolge ist wichtig fuer die Erkennung unten.
 //
 // URL: http://... oder https://... bis zum ersten Whitespace / Anfuehrungszeichen.
 // Email: simpler Standard-Match (kein RFC-kompatibel aber gut genug).
 // Telefon: internationale Form (+49..., 0049..., 0176...), darf Leerzeichen
 //         / Bindestriche / Schraegstriche / Klammern enthalten, mindestens 7
 //         Ziffern insgesamt. Vermeidet banale Zahlen (Uhrzeiten, Datum).
 const LINK_REGEX = new RegExp(
  '(https?:\\/\\/[^\\s<>"]+)' +                                // 1: URL
  '|([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,})' +        // 2: Email
  '|((?:\\+|00)\\d[\\d\\s()\\-\\/]{6,}\\d|0\\d{2,4}[\\s\\/\\-]?[\\d\\s\\-\\/]{5,}\\d)', // 3: Telefon
  'g',
 );
 const LINK_STYLE = { color: '#0096FF', textDecorationLine: 'underline' } as TextStyle;
 interface Segment {
  text: string;
  kind: 'text' | 'url' | 'email' | 'phone';
 }
 function tokenize(raw: string): Segment[] {
  const out: Segment[] = [];
  let lastEnd = 0;
  LINK_REGEX.lastIndex = 0;
  let m: RegExpExecArray | null;
  while ((m = LINK_REGEX.exec(raw)) !== null) {
    if (m.index > lastEnd) {
      out.push({ text: raw.slice(lastEnd, m.index), kind: 'text' });
    }
    if (m[1]) out.push({ text: m[1], kind: 'url' });
    else if (m[2]) out.push({ text: m[2], kind: 'email' });
    else if (m[3]) out.push({ text: m[3], kind: 'phone' });
    lastEnd = LINK_REGEX.lastIndex;
  }
  if (lastEnd < raw.length) out.push({ text: raw.slice(lastEnd), kind: 'text' });
  return out;
 }
 function onPress(seg: Segment) {
  try {
    if (seg.kind === 'url') {
      Linking.openURL(seg.text);
    } else if (seg.kind === 'email') {
      Linking.openURL(`mailto:${seg.text}`);
    } else if (seg.kind === 'phone') {
      // Android-Dialer erwartet tel:-Schema ohne Leerzeichen/Bindestriche
      const clean = seg.text.replace(/[\s\-\/()]/g, '');
      Linking.openURL(`tel:${clean}`);
    }
  } catch {}
 }
 interface Props {
  text: string;
  style?: StyleProp<TextStyle>;
 }
 const MessageText: React.FC<Props> = ({ text, style }) => {
  const segments = React.useMemo(() => tokenize(text), [text]);
  return (
    <Text
      style={style}
      selectable
      // dataDetectorType ist Android-only und macht Phone/URL/Email zusaetzlich
      // ueber System-Detection klickbar — als Fallback falls unsere Regex-
      // Tokens nicht passen.
      dataDetectorType="all"
    >
      {segments.map((seg, i) => {
        if (seg.kind === 'text') {
          return <Text key={i} selectable>{seg.text}</Text>;
        }
        return (
          <Text
            key={i}
            selectable
            style={LINK_STYLE}
            onPress={() => onPress(seg)}
            // Long-Press soll an den Parent durch fuer Selection
            onLongPress={undefined}
            suppressHighlighting={false}
          >
            {seg.text}
          </Text>
        );
      })}
    </Text>
  );
 };
 export default MessageText;
@@ -93,24 +93,18 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
    }
  }, [isRecording]);
-  // VAD Silence Callback — Auto-Stop.
+  // VAD Silence Callback — Auto-Stop
  // WICHTIG: NICHT auf isRecording prüfen (Closure ist stale) — stattdessen
  // audioService selber fragen. Empty deps → Listener wird EINMAL registriert.
  // audioService garantiert jetzt dass der Callback pro Aufnahme nur einmal
  // feuert (silenceFired-Latch).
  const onCompleteRef = useRef(onRecordingComplete);
  useEffect(() => { onCompleteRef.current = onRecordingComplete; }, [onRecordingComplete]);
  useEffect(() => {
    const unsubSilence = audioService.onSilenceDetected(async () => {
-      if (audioService.getRecordingState() !== 'recording') return;
+      if (!isRecording) return;
      const result = await audioService.stopRecording();
      setIsRecording(false);
      const result = await audioService.stopRecording();
      if (result && result.durationMs > 500) {
-        onCompleteRef.current(result);
+        onRecordingComplete(result);
      }
    });
    return unsubSilence;
-  }, []);
+  }, [isRecording, onRecordingComplete]);
  // Auto-Start fuer Wake Word (extern getriggert)
  const startAutoRecording = useCallback(async () => {
@@ -142,35 +136,23 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
    }
  };
-  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop.
+  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop
  // Guard gegen Doppel-Tap während asyncer Start/Stop.
  const tapBusy = useRef(false);
  const handleTap = async () => {
-    if (disabled || tapBusy.current) return;
+    if (disabled) return;
-    tapBusy.current = true;
+    if (isRecording) {
-    try {
+      // Aufnahme manuell stoppen
-      // Fragen WIR den Service, nicht den React-State (Closure kann stale sein)
+      setIsRecording(false);
-      const svcState = audioService.getRecordingState();
+      const result = await audioService.stopRecording();
-      if (svcState === 'recording') {
+      if (result && result.durationMs > 300) {
-        // Aufnahme manuell stoppen
+        onRecordingComplete(result);
-        const result = await audioService.stopRecording();
+      }
-        setIsRecording(false);
+    } else {
-        if (result && result.durationMs > 300) {
+      // Aufnahme mit Auto-Stop starten
-          onRecordingComplete(result);
+      const started = await audioService.startRecording(true);
-        }
+      if (started) {
-      } else if (svcState === 'idle') {
+        isLongPress.current = false;
-        // Aufnahme mit Auto-Stop starten
+        setIsRecording(true);
        const started = await audioService.startRecording(true);
        if (started) {
          isLongPress.current = false;
          setIsRecording(true);
        }
      }
      // svcState === 'processing': Stopp in progress — nichts tun, User
      // muss nochmal tippen wenn fertig. Aber wir blockieren mit tapBusy
      // kurz damit der User's UI-Feedback synchron bleibt.
    } finally {
      tapBusy.current = false;
    }
  };
@@ -29,8 +29,7 @@ import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
 import CameraUpload, { PhotoData } from '../components/CameraUpload';
-import MessageText from '../components/MessageText';
+import { RecordingResult, loadConvWindowMs } from '../services/audio';
 import { RecordingResult, loadConvWindowMs, loadTtsSpeed, TTS_SPEED_DEFAULT } from '../services/audio';
 import Geolocation from '@react-native-community/geolocation';
 // --- Typen ---
@@ -104,8 +103,6 @@ const ChatScreen: React.FC = () => {
  const [showCameraUpload, setShowCameraUpload] = useState(false);
  const [gpsEnabled, setGpsEnabled] = useState(false);
  const [wakeWordActive, setWakeWordActive] = useState(false);
  // Genauer State (off/armed/conversing) fuer UI-Feedback am Button
  const [wakeWordState, setWakeWordState] = useState<'off' | 'armed' | 'conversing'>('off');
  const [fullscreenImage, setFullscreenImage] = useState<string | null>(null);
  const [searchQuery, setSearchQuery] = useState('');
  const [searchVisible, setSearchVisible] = useState(false);
@@ -119,13 +116,6 @@ const ChatScreen: React.FC = () => {
  const [ttsMuted, setTtsMuted] = useState(false);
  // Gerätelokale XTTS-Voice-Wahl (bevorzugt gegenueber dem globalen Default)
  const localXttsVoiceRef = useRef<string>('');
  // Geraetelokale TTS-Wiedergabegeschwindigkeit (speed-Param an F5-TTS)
  const ttsSpeedRef = useRef<number>(TTS_SPEED_DEFAULT);
  // Spiegelung der TTS-Settings in einer Ref — damit die onMessage-Closure
  // (useEffect mit []-deps) IMMER die aktuellen Werte sieht. Ohne Ref
  // bliebe canPlay auf dem Mount-Initial-Wert haengen (mute ignoriert,
  // oder AsyncStorage-Load nicht beruecksichtigt).
  const ttsCanPlayRef = useRef<boolean>(true);
  const flatListRef = useRef<FlatList>(null);
  const messageIdCounter = useRef(0);
@@ -145,7 +135,6 @@ const ChatScreen: React.FC = () => {
      setTtsMuted(muted === 'true'); // default false
      const voice = await AsyncStorage.getItem('aria_xtts_voice');
      localXttsVoiceRef.current = voice || '';
      ttsSpeedRef.current = await loadTtsSpeed();
    };
    loadTtsSettings();
    // Poll alle 2s um Settings-Aenderung mitzubekommen (einfache Loesung ohne Context)
@@ -156,19 +145,8 @@ const ChatScreen: React.FC = () => {
  // Wake Word: einmalig laden + Porcupine vorbereiten (wenn Access Key gesetzt)
  useEffect(() => {
    wakeWordService.loadFromStorage().catch(() => {});
    const unsub = wakeWordService.onStateChange((s) => {
      setWakeWordState(s);
      setWakeWordActive(s !== 'off');
    });
    return () => unsub();
  }, []);
  // ttsCanPlayRef live aktuell halten — Closure in onMessage unten liest
  // darueber statt direkt ttsDeviceEnabled/ttsMuted (sonst stale).
  useEffect(() => {
    ttsCanPlayRef.current = ttsDeviceEnabled && !ttsMuted;
  }, [ttsDeviceEnabled, ttsMuted]);
  const toggleMute = useCallback(() => {
    setTtsMuted(prev => {
      const next = !prev;
@@ -270,22 +248,15 @@ const ChatScreen: React.FC = () => {
      if (message.type === 'chat') {
        const sender = (message.payload.sender as string) || '';
-        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben.
+        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben
        // WICHTIG: Nur die ERSTE noch unaufgeloeste Aufnahme matchen — sonst
        // wuerde bei zwei kurz hintereinander gesendeten Audios beide Bubbles
        // den gleichen Text bekommen (Bug: zweite Antwort ueberschreibt erste).
        if (sender === 'stt') {
          const sttText = (message.payload.text as string) || '';
          if (sttText) {
-            setMessages(prev => {
+            setMessages(prev => prev.map(m =>
-              const idx = prev.findIndex(m =>
+              m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
-                m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
+                ? { ...m, text: `\uD83C\uDFA4 ${sttText}` }
-              );
+                : m
-              if (idx < 0) return prev;
+            ));
              const next = prev.slice();
              next[idx] = { ...next[idx], text: `\uD83C\uDFA4 ${sttText}` };
              return next;
            });
          }
          return;
        }
@@ -328,12 +299,7 @@ const ChatScreen: React.FC = () => {
      }
      // TTS-Audio abspielen wenn vorhanden — respektiert geraetelokalen Mute/Disable
-      // WICHTIG: via Ref statt direkt state lesen, sonst ist's stale (Closure-Bug).
+      const canPlay = ttsDeviceEnabled && !ttsMuted;
      const canPlay = ttsCanPlayRef.current;
      if (message.type === 'audio_pcm' || (message.type === 'audio' && message.payload.base64)) {
        console.log('[Chat] audio-msg canPlay=%s (enabled=%s muted=%s)',
                    canPlay, ttsDeviceEnabled, ttsMuted);
      }
      if (message.type === 'audio' && message.payload.base64) {
        const b64 = message.payload.base64 as string;
        const refId = (message.payload.messageId as string) || '';
@@ -473,7 +439,6 @@ const ChatScreen: React.FC = () => {
          durationMs: result.durationMs,
          mimeType: result.mimeType,
          voice: localXttsVoiceRef.current,
          speed: ttsSpeedRef.current,
          ...(location && { location }),
        });
        // resume() wird durch onPlaybackFinished nach ARIAs Antwort getriggert.
@@ -495,12 +460,7 @@ const ChatScreen: React.FC = () => {
  // Wake Word Toggle Handler
  const toggleWakeWord = useCallback(async () => {
    if (wakeWordActive) {
-      // Vor Porcupine-Stop: eventuelle laufende Aufnahme abbrechen. Sonst
+      wakeWordService.stop();
      // bleibt audioService.recordingState=='recording' haengen und der
      // normale Aufnahme-Button wirkt nicht mehr (startRecording lehnt
      // ab weil "Aufnahme laeuft bereits").
      try { await audioService.stopRecording(); } catch {}
      await wakeWordService.stop();
      setWakeWordActive(false);
    } else {
      const started = await wakeWordService.start();
@@ -586,13 +546,10 @@ const ChatScreen: React.FC = () => {
    };
    setMessages(prev => capMessages([...prev, userMsg]));
    console.log('[Chat] sende mit voice=%s speed=%s',
                localXttsVoiceRef.current || '(default)', ttsSpeedRef.current);
    // An RVS senden — mit geraetelokaler Voice (Bridge nutzt sie fuer die Antwort)
    rvs.send('chat', {
      text,
      voice: localXttsVoiceRef.current,
      speed: ttsSpeedRef.current,
      ...(location && { location }),
    });
  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments]);
@@ -702,7 +659,6 @@ const ChatScreen: React.FC = () => {
      rvs.send('chat', {
        text: messageText,
        voice: localXttsVoiceRef.current,
        speed: ttsSpeedRef.current,
        ...(location && { location }),
      });
    }
@@ -777,10 +733,9 @@ const ChatScreen: React.FC = () => {
        ))}
        {/* Text (nicht anzeigen wenn nur "Anhang empfangen" und ein Bild da ist) */}
        {!(item.text === 'Anhang empfangen' && item.attachments?.some(a => a.type === 'image' && a.uri)) && (
-          <MessageText
+          <Text style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}>
-            text={item.text}
+            {item.text}
-            style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}
+          </Text>
          />
        )}
        {/* Play-Button fuer ARIA-Nachrichten — Cache bevorzugt, sonst Bridge-TTS mit aktueller Engine */}
        {!isUser && item.text.length > 0 && (
@@ -795,7 +750,6 @@ const ChatScreen: React.FC = () => {
                rvs.send('tts_request' as any, {
                  text: item.text,
                  voice: localXttsVoiceRef.current,
                  speed: ttsSpeedRef.current,
                  messageId: item.messageId || '',
                });
              }
@@ -1016,10 +970,7 @@ const ChatScreen: React.FC = () => {
              style={[styles.wakeWordBtn, wakeWordActive && styles.wakeWordBtnActive]}
              onPress={toggleWakeWord}
            >
-              <Text style={styles.wakeWordIcon}>
+              <Text style={styles.wakeWordIcon}>{wakeWordActive ? '👂' : '🔇'}</Text>
                {wakeWordState === 'conversing' ? '🎙️' :
                 wakeWordState === 'armed' ? '👂' : '🔇'}
              </Text>
            </TouchableOpacity>
          </>
        )}
@@ -35,15 +35,11 @@ import {
  CONV_WINDOW_MIN_SEC,
  CONV_WINDOW_MAX_SEC,
  CONV_WINDOW_STORAGE_KEY,
  TTS_SPEED_DEFAULT,
  TTS_SPEED_MIN,
  TTS_SPEED_MAX,
  TTS_SPEED_STORAGE_KEY,
 } from '../services/audio';
 import wakeWordService, {
-  WAKE_KEYWORDS,
+  BUILTIN_KEYWORDS,
  KEYWORD_LABELS,
  DEFAULT_KEYWORD,
  WAKE_ACCESS_KEY_STORAGE,
  WAKE_KEYWORD_STORAGE,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
@@ -102,7 +98,8 @@ const SettingsScreen: React.FC = () => {
  const [ttsPrerollSec, setTtsPrerollSec] = useState<number>(TTS_PREROLL_DEFAULT_SEC);
  const [vadSilenceSec, setVadSilenceSec] = useState<number>(VAD_SILENCE_DEFAULT_SEC);
  const [convWindowSec, setConvWindowSec] = useState<number>(CONV_WINDOW_DEFAULT_SEC);
-  const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
+  const [wakeAccessKey, setWakeAccessKey] = useState<string>('');
  const [wakeAccessKeyVisible, setWakeAccessKeyVisible] = useState(false);
  const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
  const [wakeStatus, setWakeStatus] = useState<string>('');
  const [editingPath, setEditingPath] = useState(false);
@@ -156,14 +153,11 @@ const SettingsScreen: React.FC = () => {
        }
      }
    });
-    AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY).then(saved => {
+    AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE).then(saved => {
-      if (saved != null) {
+      if (saved) setWakeAccessKey(saved);
        const n = parseFloat(saved);
        if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) setTtsSpeed(n);
      }
    });
    AsyncStorage.getItem(WAKE_KEYWORD_STORAGE).then(saved => {
-      if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
+      if (saved) setWakeKeyword(saved);
    });
    AsyncStorage.getItem('aria_xtts_voice').then(saved => {
      if (saved) setXttsVoice(saved);
@@ -673,23 +667,44 @@ const SettingsScreen: React.FC = () => {
        </View>
      </View>
-      {/* === Wake-Word (komplett on-device, openWakeWord) === */}
+      {/* === Wake-Word (geraetelokal) === */}
      <Text style={styles.sectionTitle}>Wake-Word</Text>
      <View style={styles.card}>
        <Text style={styles.toggleHint}>
-          Lokale Erkennung via openWakeWord (ONNX, on-device). Kein API-Key,
+          Wenn ein Picovoice-Access-Key eingetragen ist, hoert die App passiv
-          kein Cloud-Roundtrip — Audio verlaesst das Geraet nicht. Wenn das Ohr
+          auf das gewaehlte Wake-Word — du kannst dich mit anderen unterhalten,
-          aktiv ist, hoerst du normal mit; sagst du das Wake-Word, startet eine
+          Musik laufen lassen und mit "{wakeKeyword}" eine Konversation mit
-          Konversation mit ARIA.
+          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}>
-          Eigene Wake-Words via openWakeWord-Notebook trainierbar (gratis).
+          Built-In: sofort verwendbar. "ARIA" als Custom-Keyword kommt spaeter
-          Custom-Upload ueber Diagnostic kommt in einer spaeteren Version.
+          ueber Diagnostic-Upload.
        </Text>
        <View style={{flexDirection: 'row', flexWrap: 'wrap', gap: 6, marginTop: 8}}>
-          {WAKE_KEYWORDS.map(kw => (
+          {BUILTIN_KEYWORDS.map(kw => (
            <TouchableOpacity
              key={kw}
              style={[
@@ -702,7 +717,7 @@ const SettingsScreen: React.FC = () => {
                styles.keywordChipText,
                wakeKeyword === kw && styles.keywordChipTextActive,
              ]}>
-                {KEYWORD_LABELS[kw]}
+                {kw}
              </Text>
            </TouchableOpacity>
          ))}
@@ -714,8 +729,8 @@ const SettingsScreen: React.FC = () => {
            onPress={async () => {
              setWakeStatus('Initialisiere...');
              try {
-                const ok = await wakeWordService.configure(wakeKeyword);
+                const ok = await wakeWordService.configure(wakeAccessKey, wakeKeyword);
-                setWakeStatus(ok ? `✅ "${KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS]}" bereit` : '❌ Init-Fehler — Logs pruefen');
+                setWakeStatus(ok ? `✅ "${wakeKeyword}" bereit` : '❌ Fehlgeschlagen — Access Key pruefen');
              } catch (err: any) {
                setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
              }
@@ -785,38 +800,6 @@ const SettingsScreen: React.FC = () => {
                <Text style={styles.prerollButtonText}>+0.5</Text>
              </TouchableOpacity>
            </View>
            <Text style={[styles.toggleLabel, {marginTop: 24}]}>Sprechgeschwindigkeit</Text>
            <Text style={styles.toggleHint}>
              Wie schnell ARIA spricht. 1.0 = Normal. Niedriger = langsamer, hoeher = schneller.
              Wird an F5-TTS als speed-Param uebergeben und pro Geraet gespeichert.
              Default: {TTS_SPEED_DEFAULT.toFixed(1)}x.
            </Text>
            <View style={styles.prerollRow}>
              <TouchableOpacity
                style={styles.prerollButton}
                onPress={() => {
                  const next = Math.max(TTS_SPEED_MIN, Math.round((ttsSpeed - 0.1) * 10) / 10);
                  setTtsSpeed(next);
                  AsyncStorage.setItem(TTS_SPEED_STORAGE_KEY, String(next));
                }}
                disabled={ttsSpeed <= TTS_SPEED_MIN}
              >
                <Text style={styles.prerollButtonText}>−0.1</Text>
              </TouchableOpacity>
              <Text style={styles.prerollValue}>{ttsSpeed.toFixed(1)} x</Text>
              <TouchableOpacity
                style={styles.prerollButton}
                onPress={() => {
                  const next = Math.min(TTS_SPEED_MAX, Math.round((ttsSpeed + 0.1) * 10) / 10);
                  setTtsSpeed(next);
                  AsyncStorage.setItem(TTS_SPEED_STORAGE_KEY, String(next));
                }}
                disabled={ttsSpeed >= TTS_SPEED_MAX}
              >
                <Text style={styles.prerollButtonText}>+0.1</Text>
              </TouchableOpacity>
            </View>
          </View>
        )}
@@ -92,24 +92,6 @@ export const CONV_WINDOW_MIN_SEC = 3.0;
 export const CONV_WINDOW_MAX_SEC = 20.0;
 export const CONV_WINDOW_STORAGE_KEY = 'aria_conv_window_sec';
 // TTS-Wiedergabegeschwindigkeit — wird pro Geraet gespeichert und an die
 // Bridge mitgegeben (speed-Param im F5-TTS infer()). 1.0 = normal.
 export const TTS_SPEED_DEFAULT = 1.0;
 export const TTS_SPEED_MIN = 0.1;
 export const TTS_SPEED_MAX = 5.0;
 export const TTS_SPEED_STORAGE_KEY = 'aria_tts_speed';
 export async function loadTtsSpeed(): Promise<number> {
  try {
    const raw = await AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY);
    if (raw != null) {
      const n = parseFloat(raw);
      if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) return n;
    }
  } catch {}
  return TTS_SPEED_DEFAULT;
 }
 export async function loadConvWindowMs(): Promise<number> {
  try {
    const raw = await AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY);
@@ -143,7 +125,7 @@ const MAX_RECORDING_MS = 120000;
 // Pre-Roll: Wie lange Audio im AudioTrack-Buffer liegt bevor play() startet.
 // Einstellbar via Diagnostic/Settings (Key: aria_tts_preroll_sec).
 export const TTS_PREROLL_DEFAULT_SEC = 3.5;
-export const TTS_PREROLL_MIN_SEC = 0;     // 0 = sofort abspielen (F5-TTS ist schnell genug)
+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';
@@ -191,20 +173,11 @@ class AudioService {
  private pcmBytesCollected: number = 0;
  private readonly PCM_MAX_CACHE_BYTES = 30 * 1024 * 1024; // 30MB
  // AudioFocus wird verzoegert freigegeben — wenn ARIA eine zweite Antwort
  // direkt hinterherschickt (oder ein neuer Stream startet), bleibt Spotify
  // pausiert. Ohne diese Verzoegerung springt Spotify im Mikro-Sekunden-Gap
  // zwischen zwei Streams kurz wieder an.
  private focusReleaseTimer: ReturnType<typeof setTimeout> | null = null;
  private readonly FOCUS_RELEASE_DELAY_MS = 800;
  // VAD State
  private vadEnabled: boolean = false;
  private lastSpeechTime: number = 0;
  private vadTimer: ReturnType<typeof setInterval> | null = null;
  private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
  // Latch damit der Silence-Callback pro Aufnahme genau einmal feuert
  private silenceFired: boolean = false;
  private noSpeechTimer: ReturnType<typeof setTimeout> | null = null;
  constructor() {
@@ -212,24 +185,6 @@ class AudioService {
    this.recorder.setSubscriptionDuration(0.1); // 100ms Metering-Updates
  }
  /** AudioFocus mit kleiner Verzoegerung freigeben — Spotify/YouTube
   *  springen sonst im Gap zwischen zwei TTS-Streams (oder wenn ARIA
   *  eine zweite Antwort direkt hinterherschickt) kurz wieder an. */
  private _releaseFocusDeferred(): void {
    this._cancelDeferredFocusRelease();
    this.focusReleaseTimer = setTimeout(() => {
      this.focusReleaseTimer = null;
      AudioFocus?.release().catch(() => {});
    }, this.FOCUS_RELEASE_DELAY_MS);
  }
  private _cancelDeferredFocusRelease(): void {
    if (this.focusReleaseTimer) {
      clearTimeout(this.focusReleaseTimer);
      this.focusReleaseTimer = null;
    }
  }
  // --- Berechtigungen ---
  async requestMicrophonePermission(): Promise<boolean> {
@@ -330,50 +285,35 @@ class AudioService {
      this.setState('recording');
      // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
      this._cancelDeferredFocusRelease();
      AudioFocus?.requestExclusive().catch(() => {});
-      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar).
+      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar)
      // WICHTIG: jeder Trigger (VAD-Stille / Max-Dauer / No-Speech-Window)
      // disable SOFORT den VAD-Flag und clear den Timer, BEVOR die Listener
      // gefeuert werden. Sonst feuert das setInterval weiter alle 200ms und
      // ruft stopRecording parallel auf → audio-recorder-player crasht.
      this.vadEnabled = autoStop;
      this.silenceFired = false;
      const fireSilenceOnce = (reason: string) => {
        if (this.silenceFired) return;
        this.silenceFired = true;
        this.vadEnabled = false;
        if (this.vadTimer) { clearInterval(this.vadTimer); this.vadTimer = null; }
        if (this.maxDurationTimer) { clearTimeout(this.maxDurationTimer); this.maxDurationTimer = null; }
        if (this.noSpeechTimer) { clearTimeout(this.noSpeechTimer); this.noSpeechTimer = null; }
        console.log('[Audio] Silence-Fire: %s', reason);
        this.silenceListeners.forEach(cb => {
          try { cb(); } catch (e) { console.warn('[Audio] silence listener err:', e); }
        });
      };
      if (autoStop) {
        const vadSilenceMs = await loadVadSilenceMs();
-        console.log('[Audio] startRecording: autoStop=true, VAD-Stille=%dms, MAX=%dms',
+        console.log('[Audio] VAD-Stille:', vadSilenceMs, 'ms');
                    vadSilenceMs, MAX_RECORDING_MS);
        this.vadTimer = setInterval(() => {
          const silenceDuration = Date.now() - this.lastSpeechTime;
          if (silenceDuration >= vadSilenceMs) {
-            fireSilenceOnce(`VAD ${silenceDuration}ms Stille (Schwelle=${vadSilenceMs}ms)`);
+            console.log(`[Audio] VAD: ${silenceDuration}ms Stille — Auto-Stop`);
            this.silenceListeners.forEach(cb => cb());
          }
        }, 200);
        // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
        this.maxDurationTimer = setTimeout(() => {
-          fireSilenceOnce(`Max-Dauer ${MAX_RECORDING_MS}ms`);
+          console.warn(`[Audio] Max-Dauer ${MAX_RECORDING_MS}ms erreicht — Zwangs-Stop`);
          this.silenceListeners.forEach(cb => cb());
        }, MAX_RECORDING_MS);
      }
      // Conversation-Window: Wenn der User innerhalb noSpeechTimeoutMs nicht
-      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie).
+      // 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') {
-            fireSilenceOnce(`Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache`);
+            console.log(`[Audio] Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache — Stop`);
            this.silenceListeners.forEach(cb => cb());
          }
        }, noSpeechTimeoutMs);
      }
@@ -413,9 +353,8 @@ class AudioService {
      await this.recorder.stopRecorder();
      this.recorder.removeRecordBackListener();
-      // Audio-Focus verzoegert freigeben — gleich kommt die TTS-Antwort,
+      // Audio-Focus freigeben — andere Apps duerfen wieder
-      // im Gap soll Spotify nicht hochkommen.
+      AudioFocus?.release().catch(() => {});
      this._releaseFocusDeferred();
      const durationMs = Date.now() - this.recordingStartTime;
      const hadSpeech = this.speechDetected;
@@ -487,13 +426,7 @@ class AudioService {
  /** Einen PCM-Chunk aus einer audio_pcm Nachricht empfangen.
   *  silent=true → nur cachen, nicht abspielen (z.B. wenn TTS geraetelokal gemutet).
-   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached.
+   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached. */
   *
   *  Wrapper serialisiert aufeinanderfolgende Chunk-Calls via Promise-Queue —
   *  sonst gabs bei kurzen Streams einen Race: final-Chunk konnte `end()` rufen
   *  BEVOR der vorherige `start()` im Native-Modul fertig war. Der Writer-
   *  Thread sah dann endRequested=true ohne jemals Chunks zu verarbeiten. */
  private _pcmChunkQueue: Promise<any> = Promise.resolve();
  async handlePcmChunk(payload: {
    base64: string;
    sampleRate?: number;
@@ -502,37 +435,12 @@ class AudioService {
    chunk?: number;
    final?: boolean;
    silent?: boolean;
  }): Promise<string> {
    const p = this._pcmChunkQueue.then(() => this._handlePcmChunkImpl(payload)).catch(err => {
      console.warn('[Audio] handlePcmChunk queued err:', err);
      return '';
    });
    // Chain only on the side effect — callers still get the per-call result
    this._pcmChunkQueue = p;
    return p;
  }
  private async _handlePcmChunkImpl(payload: {
    base64: string;
    sampleRate?: number;
    channels?: number;
    messageId?: string;
    chunk?: number;
    final?: boolean;
    silent?: boolean;
  }): Promise<string> {
    const silent = !!payload.silent;
    if (!silent && !PcmStreamPlayer) {
      console.warn('[Audio] PcmStreamPlayer Native Module nicht verfuegbar');
      return '';
    }
    // Debug-Log bei Chunk 0 eines neuen Streams — damit man im adb logcat
    // sieht warum der Auto-Playback greift oder nicht.
    if ((payload.chunk ?? 0) === 0 && !this.pcmStreamActive) {
      console.log('[Audio] PCM-Stream start: silent=%s messageId=%s sr=%s ch=%s',
                  silent, payload.messageId || '(none)',
                  payload.sampleRate, payload.channels);
    }
    const messageId = payload.messageId || '';
    const sampleRate = payload.sampleRate || 24000;
@@ -562,7 +470,6 @@ class AudioService {
          this.pcmStreamActive = false;
          return '';
        }
        this._cancelDeferredFocusRelease();
        AudioFocus?.requestDuck().catch(() => {});
      }
    }
@@ -581,12 +488,11 @@ class AudioService {
    if (isFinal) {
      if (!silent) {
        // end() resolved jetzt erst wenn der native Writer-Thread fertig
-        // ist (alle Samples ausgespielt) — danach AudioFocus verzoegert
+        // ist (alle Samples ausgespielt) — danach erst AudioFocus freigeben,
-        // freigeben, damit Spotify/YouTube nicht im Mikro-Gap zwischen zwei
+        // damit Spotify/YouTube nicht waehrend des Pre-Roll-Ausklangs
-        // ARIA-Antworten wieder hochdrehen. Wenn ein neuer Stream innerhalb
+        // wieder aufdrehen.
        // FOCUS_RELEASE_DELAY_MS startet, wird das Release abgebrochen.
        try { await PcmStreamPlayer!.end(); } catch {}
-        this._releaseFocusDeferred();
+        AudioFocus?.release().catch(() => {});
      }
      this.pcmStreamActive = false;
@@ -690,9 +596,8 @@ class AudioService {
  private async _playNext(): Promise<void> {
    if (this.audioQueue.length === 0) {
      this.isPlaying = false;
-      // Audio-Focus verzoegert abgeben → wenn gleich noch eine Antwort kommt,
+      // Audio-Focus abgeben → andere Apps volle Lautstaerke
-      // bleibt Spotify pausiert.
+      AudioFocus?.release().catch(() => {});
      this._releaseFocusDeferred();
      // Alle Audio-Teile abgespielt → Listener benachrichtigen
      this.playbackFinishedListeners.forEach(cb => cb());
      return;
@@ -700,7 +605,6 @@ class AudioService {
    // Beim ersten Playback-Start: andere Apps ducken
    if (!this.isPlaying) {
      this._cancelDeferredFocusRelease();
      AudioFocus?.requestDuck().catch(() => {});
    }
    this.isPlaying = true;
@@ -786,8 +690,7 @@ class AudioService {
      this.pcmBytesCollected = 0;
      this.pcmMessageId = '';
    }
-    // Audio-Focus sofort freigeben — User hat explizit abgebrochen
+    // Audio-Focus freigeben
    this._cancelDeferredFocusRelease();
    AudioFocus?.release().catch(() => {});
  }
@@ -29,11 +29,6 @@ class UpdateService {
  private downloading = false;
  constructor() {
    // Beim Start alte APK-Reste aus dem Cache wegraeumen — wenn diese App
    // laeuft, sind frueher heruntergeladene APKs entweder schon installiert
    // oder unvollstaendig gewesen. Spart sonst pro Update 20-30MB auf dem Handy.
    this.cleanupOldApks().catch(() => {});
    // Auf update_available Nachrichten lauschen
    rvs.onMessage((msg: RVSMessage) => {
      if (msg.type === 'update_available' as any) {
@@ -50,30 +45,6 @@ class UpdateService {
    });
  }
  /** Raeumt alte heruntergeladene APK-Dateien aus dem Cache auf. */
  private async cleanupOldApks(): Promise<void> {
    try {
      const files = await RNFS.readDir(RNFS.CachesDirectoryPath);
      const apks = files.filter(f => /\.apk$/i.test(f.name));
      let freed = 0;
      for (const f of apks) {
        try {
          const size = parseInt(f.size as any, 10) || 0;
          await RNFS.unlink(f.path);
          freed += size;
          console.log(`[Update] Alte APK geloescht: ${f.name} (${(size / 1024 / 1024).toFixed(1)}MB)`);
        } catch (err: any) {
          console.warn(`[Update] APK-Loeschen fehlgeschlagen: ${f.name} (${err?.message || err})`);
        }
      }
      if (apks.length > 0) {
        console.log(`[Update] Cleanup fertig: ${apks.length} APKs entfernt, ${(freed / 1024 / 1024).toFixed(1)}MB freigegeben`);
      }
    } catch (err: any) {
      console.warn(`[Update] Cleanup-Fehler: ${err?.message || err}`);
    }
  }
  /** Bei App-Start Update pruefen */
  checkForUpdate(): void {
    if (this.checking) return;
@@ -140,10 +111,6 @@ class UpdateService {
        });
      });
      // Vor dem Schreiben alte APKs im Cache wegraeumen — falls mehrere
      // Updates in einer Session gezogen werden
      await this.cleanupOldApks();
      // Base64 als APK-Datei speichern
      const destPath = `${RNFS.CachesDirectoryPath}/${apkData.fileName}`;
      await RNFS.writeFile(destPath, apkData.base64, 'base64');
@@ -1,26 +1,21 @@
 /**
 * Gespraechsmodus / Wake Word Service
 *
 * Wake-Word-Engine: openWakeWord (https://github.com/dscripka/openWakeWord),
 * komplett on-device via ONNX Runtime in Native-Kotlin (siehe
 * OpenWakeWordModule.kt + assets/openwakeword/). Kein API-Key, kein Cloud-
 * Roundtrip, kein Cent Lizenzgebuehren.
 *
 * Drei Zustaende:
 *   off        — Ohr aus, nichts laeuft
- *   armed      — Ohr aktiv, openWakeWord hoert passiv auf das Wake-Word.
+ *   armed      — Ohr aktiv, Porcupine hoert passiv auf das Wake-Word.
- *                Das Mikro ist von OpenWakeWord belegt; AudioRecorder ist aus.
+ *                Das Mikro ist von Porcupine belegt; AudioRecorder ist aus.
- *   conversing — Wake-Word getriggert (oder Ohr-Tap manuell):
+ *   conversing — Wake-Word getriggert (oder Ohr-Tap ohne Wake-Word):
- *                aktive Konversation. OpenWakeWord pausiert (gibt Mikro frei),
+ *                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.
 *
- * Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
+ * Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
- * 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
+ * direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
 * geht dann nach 'off' statt 'armed'.
 */
 import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 type WakeWordCallback = () => void;
@@ -28,111 +23,85 @@ 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';
-/** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
+/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
- *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
+ *  Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
- *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
+ *  Console — wird spaeter ueber Diagnostic uploadbar. */
- *  werden — Diagnostic-Upload ist Phase 2. */
+export const BUILTIN_KEYWORDS = [
-export const WAKE_KEYWORDS = [
+  'jarvis',
-  'hey_jarvis',
+  'computer',
  'picovoice',
  'porcupine',
  'bumblebee',
  'terminator',
  'alexa',
-  'hey_mycroft',
+  'hey google',
-  'hey_rhasspy',
+  'ok google',
  'hey siri',
 ] as const;
-export type WakeKeyword = typeof WAKE_KEYWORDS[number];
+export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
-export const DEFAULT_KEYWORD: WakeKeyword = 'hey_jarvis';
+export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
 /** Hilfs-Mapping fuer die Anzeige im UI. */
 export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
  hey_jarvis: 'Hey Jarvis',
  alexa: 'Alexa',
  hey_mycroft: 'Hey Mycroft',
  hey_rhasspy: 'Hey Rhasspy',
 };
 // Detection-Tuning — kann in Settings spaeter konfigurierbar werden.
 const DEFAULT_THRESHOLD = 0.5;
 const DEFAULT_PATIENCE = 2;
 const DEFAULT_DEBOUNCE_MS = 1500;
 interface OpenWakeWordModule {
  init(modelName: string, threshold: number, patience: number, debounceMs: number): Promise<boolean>;
  start(): Promise<boolean>;
  stop(): Promise<boolean>;
  dispose(): Promise<boolean>;
  isAvailable(): Promise<boolean>;
 }
 const { OpenWakeWord } = NativeModules as { OpenWakeWord?: OpenWakeWordModule };
 class WakeWordService {
  private state: WakeWordState = 'off';
  private wakeCallbacks: WakeWordCallback[] = [];
  private stateCallbacks: StateCallback[] = [];
-  private keyword: WakeKeyword = DEFAULT_KEYWORD;
+  // Picovoice Manager (lazy, da Native Module nicht in jedem Build verfuegbar ist)
-  private nativeReady: boolean = false;
+  private porcupine: any = null;
  private accessKey: string = '';
  private keyword: string = DEFAULT_KEYWORD;
  private initInProgress: Promise<boolean> | null = null;
  private eventSub: { remove: () => void } | null = null;
-  /** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
+  /** 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);
-      const wt = (w || DEFAULT_KEYWORD).trim() as WakeKeyword;
+      this.accessKey = (k || '').trim();
-      this.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
+      this.keyword = (w || DEFAULT_KEYWORD).trim();
-      await this.initNative();
+      if (this.accessKey) {
        // Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
        await this.initPorcupine();
      }
    } catch (err) {
      console.warn('[WakeWord] loadFromStorage', err);
    }
  }
-  /** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
+  /** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
-  async configure(keyword: string): Promise<boolean> {
+  async configure(accessKey: string, keyword: string): Promise<boolean> {
-    const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
+    this.accessKey = (accessKey || '').trim();
-      ? (keyword as WakeKeyword)
+    this.keyword = (keyword || DEFAULT_KEYWORD).trim();
-      : DEFAULT_KEYWORD;
+    await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
-    this.keyword = next;
+    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);
    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, next);
-    // Laufende Instanz stoppen + neu initialisieren
+    // Laufende Instanz stoppen
-    await this.disposeNative();
+    await this.disposePorcupine();
-    const ok = await this.initNative();
+    if (!this.accessKey) return false;
-    if (!ok) {
+
-      ToastAndroid.show(
+    // Neu initialisieren
-        `Wake-Word "${KEYWORD_LABELS[next]}" konnte nicht initialisiert werden — Logs pruefen`,
+    return this.initPorcupine();
        ToastAndroid.LONG,
      );
    }
    return ok;
  }
-  private async initNative(): Promise<boolean> {
+  private async initPorcupine(): Promise<boolean> {
    if (!OpenWakeWord) {
      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
      this.nativeReady = false;
      return false;
    }
    if (this.initInProgress) return this.initInProgress;
    this.initInProgress = (async () => {
      try {
-        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
+        const { PorcupineManager } = require('@picovoice/porcupine-react-native');
-        // Subscribe nur einmal
+        // Built-In Keyword-Identifier sind lower-case strings im SDK
-        if (!this.eventSub) {
+        this.porcupine = await PorcupineManager.fromBuiltInKeywords(
-          const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
+          this.accessKey,
-          this.eventSub = emitter.addListener('WakeWordDetected', () => {
+          [this.keyword],
-            console.log('[WakeWord] Native Detection-Event empfangen');
+          (_keywordIndex: number) => this.onWakeDetected(),
-            this.onWakeDetected().catch(err =>
+        );
-              console.warn('[WakeWord] onWakeDetected crashed:', err));
+        console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
          });
        }
        this.nativeReady = true;
        console.log('[WakeWord] Init OK (model=%s)', this.keyword);
        return true;
-      } catch (err: any) {
+      } catch (err) {
-        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
+        console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err);
-        this.nativeReady = false;
+        this.porcupine = null;
        return false;
      } finally {
        this.initInProgress = null;
@@ -141,39 +110,30 @@ class WakeWordService {
    return this.initInProgress;
  }
-  private async disposeNative(): Promise<void> {
+  private async disposePorcupine() {
-    if (!OpenWakeWord) return;
+    if (this.porcupine) {
-    try { await OpenWakeWord.dispose(); } catch {}
+      try { await this.porcupine.stop(); } catch {}
-    this.nativeReady = false;
+      try { await this.porcupine.delete(); } catch {}
      this.porcupine = null;
    }
  }
  /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
  async start(): Promise<boolean> {
    if (this.state !== 'off') return true;
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine) {
      // Passives Lauschen via Porcupine
      try {
-        await OpenWakeWord.start();
+        await this.porcupine.start();
-        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
+        console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
        this.setState('armed');
        return true;
-      } catch (err: any) {
+      } catch (err) {
-        console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
+        console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:', err);
                     err?.message || err);
        ToastAndroid.show(
          `Wake-Word-Start failed: ${err?.message || err}`,
          ToastAndroid.LONG,
        );
      }
    } else {
      console.warn('[WakeWord] Native-Modul nicht bereit — Direkt-Aufnahme-Fallback');
      ToastAndroid.show(
        'Wake-Word nicht aktiv — direkte Aufnahme startet (Mikro hoert mit)',
        ToastAndroid.LONG,
      );
    }
-    // Fallback: direkt in Konversation
+    // Fallback: direkt in die Konversation
-    console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
+    console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
    this.setState('conversing');
    setTimeout(() => {
      if (this.state === 'conversing') {
@@ -186,20 +146,20 @@ class WakeWordService {
  /** Komplett ausschalten (Ohr abschalten) */
  async stop(): Promise<void> {
    console.log('[WakeWord] Ohr deaktiviert');
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine) {
-      try { await OpenWakeWord.stop(); } catch {}
+      try { await this.porcupine.stop(); } catch {}
    }
    this.setState('off');
  }
-  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
+  /** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
  private async onWakeDetected(): Promise<void> {
    console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
-    ToastAndroid.show(`Wake-Word "${KEYWORD_LABELS[this.keyword]}" erkannt — sprich jetzt`, ToastAndroid.SHORT);
+    if (this.porcupine) {
-    if (this.nativeReady && OpenWakeWord) {
+      try { await this.porcupine.stop(); } catch {}
      try { await OpenWakeWord.stop(); } catch {}
    }
    this.setState('conversing');
    // kurz warten damit Mikrofon frei ist
    setTimeout(() => {
      if (this.state === 'conversing') {
        this.wakeCallbacks.forEach(cb => cb());
@@ -208,16 +168,15 @@ class WakeWordService {
  }
  /** Konversation beenden — User hat im Window nichts gesagt.
-   *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
+   *  Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
   *  Ohne: zurueck zu 'off'.
   */
  async endConversation(): Promise<void> {
    if (this.state !== 'conversing') return;
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine && this.accessKey) {
      try {
-        await OpenWakeWord.start();
+        await this.porcupine.start();
        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
        ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
        this.setState('armed');
        return;
      } catch (err) {
@@ -225,7 +184,6 @@ class WakeWordService {
      }
    }
    console.log('[WakeWord] Konversation zu Ende — Ohr aus');
    ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
    this.setState('off');
  }
@@ -250,10 +208,10 @@ class WakeWordService {
  }
  hasWakeWord(): boolean {
-    return this.nativeReady;
+    return !!this.porcupine;
  }
-  getKeyword(): WakeKeyword {
+  getKeyword(): string {
    return this.keyword;
  }
@@ -541,16 +541,9 @@ class ARIABridge:
        # Wird fuer die direkt folgende ARIA-Antwort genutzt und dann zurueckgesetzt.
        # So kann jedes Geraet seine bevorzugte Stimme bekommen (pro Request).
        self._next_voice_override: Optional[str] = None
        # Gleiche Logik fuer die Wiedergabegeschwindigkeit (F5-TTS speed-Param,
        # App-Setting aria_tts_speed, 1.0 = normal).
        self._next_speed_override: Optional[float] = None
        # STT-Requests die aktuell auf Antwort von der whisper-bridge (Gamebox) warten.
        # requestId → Future mit dem Text (oder None bei Fehler).
        self._pending_stt: dict[str, asyncio.Future] = {}
        # whisper-bridge service_status: True wenn ready, False/None wenn loading/unbekannt.
        # Beeinflusst das Timeout fuer stt_request — bei "loading" warten wir laenger,
        # weil das Modell beim ersten Request noch ~1-2 Min runtergeladen werden kann.
        self._remote_stt_ready: bool = False
    def initialize(self) -> None:
        """Initialisiert alle Komponenten.
@@ -914,12 +907,6 @@ class ARIABridge:
            logger.info("[core] Nutze Voice-Override: %s", self._next_voice_override)
            self._next_voice_override = None
        # Speed ebenfalls aus App-Override nehmen (fallback 1.0)
        xtts_speed = self._next_speed_override or 1.0
        if self._next_speed_override:
            logger.info("[core] Nutze Speed-Override: %.2fx", self._next_speed_override)
            self._next_speed_override = None
        tts_text = tts_text_preview or text
        if not tts_text:
            logger.info("[core] TTS-Text leer nach Cleanup — uebersprungen")
@@ -935,15 +922,13 @@ class ARIABridge:
                "payload": {
                    "text": tts_text,
                    "voice": xtts_voice,
                    "speed": xtts_speed,
                    "language": "de",
                    "requestId": xtts_request_id,
                    "messageId": message_id,
                },
                "timestamp": int(asyncio.get_event_loop().time() * 1000),
            })
-            logger.info("[core] XTTS-Request gesendet (voice=%s, speed=%.2fx): '%s'",
+            logger.info("[core] XTTS-Request gesendet (%s): '%s'", xtts_voice or "default", tts_text[:60])
                        xtts_voice or "default", xtts_speed, tts_text[:60])
        except Exception as e:
            logger.error("[core] XTTS-Request fehlgeschlagen: %s — kein Audio", e)
@@ -1174,13 +1159,6 @@ class ARIABridge:
            if voice_override:
                self._next_voice_override = voice_override
                logger.info("[rvs] Voice-Override fuer naechste Antwort: %s", voice_override)
            # Speed-Override (TTS-Wiedergabegeschwindigkeit, pro Geraet)
            try:
                speed = float(payload.get("speed", 0) or 0)
                if 0.1 <= speed <= 5.0:
                    self._next_speed_override = speed
            except (TypeError, ValueError):
                pass
            if text:
                logger.info("[rvs] App-Chat: '%s'", text[:80])
                await self.send_to_core(text, source="app")
@@ -1233,14 +1211,8 @@ class ARIABridge:
            if not text:
                return
            tts_text = clean_text_for_tts(text) or text
-            # Voice + Speed aus App-Payload gewinnen, sonst global/default
+            # Voice aus App-Payload gewinnt, sonst global
            xtts_voice = payload.get("voice", "") or getattr(self, 'xtts_voice', '')
            try:
                xtts_speed = float(payload.get("speed", 0) or 0)
                if not (0.1 <= xtts_speed <= 5.0):
                    xtts_speed = 1.0
            except (TypeError, ValueError):
                xtts_speed = 1.0
            try:
                xtts_request_id = str(uuid.uuid4())
                if message_id:
@@ -1250,7 +1222,6 @@ class ARIABridge:
                    "payload": {
                        "text": tts_text,
                        "voice": xtts_voice,
                        "speed": xtts_speed,
                        "language": "de",
                        "requestId": xtts_request_id,
                        "messageId": message_id,
@@ -1449,12 +1420,6 @@ class ARIABridge:
            if voice_override:
                self._next_voice_override = voice_override
                logger.info("[rvs] Voice-Override (via Audio): %s", voice_override)
            try:
                speed = float(payload.get("speed", 0) or 0)
                if 0.1 <= speed <= 5.0:
                    self._next_speed_override = speed
            except (TypeError, ValueError):
                pass
            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB",
                        mime_type, duration_ms, len(audio_b64) // 1365)
            asyncio.create_task(self._process_app_audio(audio_b64, mime_type))
@@ -1477,41 +1442,13 @@ class ARIABridge:
                future.set_result(text)
            return
        elif msg_type == "service_status":
            # Gamebox-Bridges (whisper / f5tts) melden ihren Lade-Status.
            # Wir nutzen das fuer den dynamischen STT-Timeout: solange whisper
            # im 'loading' steckt, geben wir der Bridge mehr Zeit (Modell-Download
            # kann 1-2 Min dauern), statt nach 45s lokal zu fallbacken.
            svc = payload.get("service", "")
            state = payload.get("state", "")
            if svc == "whisper":
                was_ready = self._remote_stt_ready
                self._remote_stt_ready = (state == "ready")
                if self._remote_stt_ready != was_ready:
                    logger.info("[rvs] whisper-bridge -> %s", state)
            return
        elif msg_type == "config_request":
            # Eine andere Bridge (whisper/f5tts) bittet um die aktuelle Voice-
            # Config — passiert wenn sie sich connected, weil sie sonst die
            # Diagnostic-Settings nicht kennt. Wir broadcasten die persistierte
            # Config (auch beim normalen Connect von aria-bridge selber, aber
            # da war eventuell die andere Bridge noch nicht connected).
            requester = payload.get("service", "?")
            logger.info("[rvs] config_request von %s — broadcaste Voice-Config", requester)
            asyncio.create_task(self._broadcast_persisted_config())
            return
        else:
            logger.debug("[rvs] Unbekannter Typ: %s", msg_type)
    # STT-Orchestrierung: zuerst Remote (Gamebox), Fallback lokal.
-    # Zwei Timeouts:
+    # Timeout grosszuegig gewaehlt, damit auch ein erstmaliger Modell-Load
-    #   ready=True   → 45s reicht selbst fuer lange Audios
+    # auf der Gamebox (bis ~30s bei large-v3) durchgeht.
-    #   ready=False  → 300s, weil das Modell evtl. noch heruntergeladen wird
+    _STT_REMOTE_TIMEOUT_S = 45.0
    #                  (large-v3 ~3GB, kann auf der Gamebox 1-2 Min dauern).
    _STT_REMOTE_TIMEOUT_READY_S = 45.0
    _STT_REMOTE_TIMEOUT_LOADING_S = 300.0
    async def _process_app_audio(self, audio_b64: str, mime_type: str) -> None:
        """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal."""
@@ -1577,12 +1514,7 @@ class ARIABridge:
            if not ok:
                logger.warning("[rvs] stt_request konnte nicht gesendet werden — skip Remote")
                return None
-            timeout_s = (self._STT_REMOTE_TIMEOUT_READY_S
+            return await asyncio.wait_for(future, timeout=self._STT_REMOTE_TIMEOUT_S)
                         if self._remote_stt_ready
                         else self._STT_REMOTE_TIMEOUT_LOADING_S)
            logger.info("[rvs] STT-Timeout %ds (whisper-bridge %s)",
                        int(timeout_s), "ready" if self._remote_stt_ready else "loading")
            return await asyncio.wait_for(future, timeout=timeout_s)
        except asyncio.TimeoutError:
            logger.warning("[rvs] Remote-STT Timeout (%.0fs)", self._STT_REMOTE_TIMEOUT_S)
            return None
@@ -136,34 +136,6 @@
    </div>
  </div>
  <!-- Voice-Preview Modal -->
  <div id="voice-preview-modal" style="display:none;position:fixed;inset:0;z-index:1000;background:rgba(0,0,0,0.7);align-items:center;justify-content:center;">
    <div style="background:#1A1A2E;border:1px solid #2A2A3E;border-radius:10px;padding:20px;max-width:560px;width:90%;display:flex;flex-direction:column;gap:12px;">
      <div style="display:flex;align-items:center;justify-content:space-between;">
        <h3 style="margin:0;color:#fff;">Stimmen-Preview: <span id="voice-preview-name">—</span></h3>
        <button onclick="closeVoicePreview()" style="background:none;border:none;color:#8888AA;font-size:22px;cursor:pointer;">&times;</button>
      </div>
      <textarea id="voice-preview-text" rows="4"
        style="background:#0D0D1A;border:1px solid #2A2A3E;border-radius:6px;padding:10px;color:#fff;font-size:13px;resize:vertical;"></textarea>
      <div style="display:flex;align-items:center;gap:10px;font-size:12px;color:#8888AA;">
        <span style="min-width:120px;">Geschwindigkeit:</span>
        <button onclick="adjustPreviewSpeed(-0.1)" class="btn secondary" style="padding:4px 10px;font-size:12px;">−0.1</button>
        <span id="voice-preview-speed-value" style="min-width:52px;text-align:center;color:#fff;font-weight:600;">1.0 x</span>
        <button onclick="adjustPreviewSpeed(0.1)" class="btn secondary" style="padding:4px 10px;font-size:12px;">+0.1</button>
        <span style="color:#555570;font-size:11px;">(nur fuer dieses Modal, wird nicht gespeichert)</span>
      </div>
      <div style="display:flex;gap:8px;align-items:center;">
        <button id="voice-preview-play" onclick="playVoicePreview()" class="btn primary" style="padding:8px 16px;">
          ▶ Abspielen
        </button>
        <span id="voice-preview-status" style="color:#8888AA;font-size:11px;flex:1;"></span>
      </div>
      <audio id="voice-preview-audio" controls style="width:100%;display:none;"></audio>
    </div>
  </div>
  <!-- Disk-Space Warnung (dynamisch gesetzt) -->
  <div id="disk-banner" style="display:none;position:sticky;top:0;z-index:500;padding:10px 14px;border-radius:0;margin:-16px -16px 12px -16px;font-size:13px;">
    <div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap;">
@@ -497,25 +469,23 @@
              Hardcoded Defaults: F5TTS_v1_Base, cfg_strength=2.5, nfe_step=32.
            </div>
-            <label style="color:#8888AA;font-size:12px;">
+            <label style="color:#8888AA;font-size:12px;">Modell-ID:</label>
              Modell-Architektur (F5TTS_v1_Base = Default multilingual, F5TTS_Base = fuer die meisten Fine-Tunes):
            </label>
            <input type="text" id="diag-f5tts-model"
              placeholder="F5TTS_v1_Base"
              style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
            <label style="color:#8888AA;font-size:12px;">
-              Custom Checkpoint — HF-Pfad (hf://user/repo/file) oder lokaler Container-Pfad. Leer = Default.
+              Custom Checkpoint (HF-Repo "user/repo" oder Container-Pfad, leer = Default):
            </label>
            <input type="text" id="diag-f5tts-ckpt"
-              placeholder="z.B. hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors"
+              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 — muss zum Checkpoint passen. Leer = Default.
+              Custom Vocab (passend zum Checkpoint, optional):
            </label>
            <input type="text" id="diag-f5tts-vocab"
-              placeholder="z.B. hf://aihpi/F5-TTS-German/vocab.txt"
+              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;">
@@ -958,24 +928,6 @@
          return;
        }
        if (msg.type === 'voice_preview_audio') {
          const statusEl = document.getElementById('voice-preview-status');
          const audio = document.getElementById('voice-preview-audio');
          const playBtn = document.getElementById('voice-preview-play');
          if (playBtn) playBtn.disabled = false;
          if (msg.error) {
            if (statusEl) statusEl.textContent = '❌ Fehler: ' + msg.error;
            return;
          }
          if (msg.base64 && audio) {
            audio.src = 'data:audio/wav;base64,' + msg.base64;
            audio.style.display = 'block';
            audio.play().catch(() => {});
            if (statusEl) statusEl.textContent = '✅ fertig';
          }
          return;
        }
        if (msg.type === 'voice_ready') {
          const v = msg.payload?.voice || '';
          const err = msg.payload?.error;
@@ -1625,75 +1577,16 @@
      html += '<div style="display:flex;flex-direction:column;gap:4px;">';
      for (const v of voices) {
        const esc = (s) => String(s).replace(/[&<>"']/g, c => ({ "&":"&amp;", "<":"&lt;", ">":"&gt;", '"':"&quot;", "'":"&#39;" }[c]));
        const jsName = esc(v.name).replace(/'/g, "\\'");
        html += `<div style="display:flex;align-items:center;gap:8px;background:#1E1E2E;border-radius:4px;padding:4px 8px;font-size:12px;">`
              + `<span style="flex:1;color:#E0E0F0;">${esc(v.name)}</span>`
              + `<span style="color:#555570;font-size:10px;">${(v.size/1024).toFixed(0)}KB</span>`
-              + `<button class="btn secondary" onclick="openVoicePreview('${jsName}')" style="padding:2px 8px;font-size:12px;" title="Stimme anhoeren">▶</button>`
+              + `<button class="btn secondary" onclick="deleteXttsVoice('${esc(v.name).replace(/'/g, "\\'")}')" style="padding:2px 8px;font-size:10px;color:#FF6B6B;" title="Stimme loeschen">X</button>`
              + `<button class="btn secondary" onclick="deleteXttsVoice('${jsName}')" style="padding:2px 8px;font-size:10px;color:#FF6B6B;" title="Stimme loeschen">X</button>`
              + `</div>`;
      }
      html += '</div>';
      box.innerHTML = html;
    }
    // ── Voice Preview Modal ─────────────────────────
    const VOICE_PREVIEW_DEFAULT = 'Hallo, ich bin ARIA. Das hier ist ein kleiner Test damit du meine Stimme beurteilen kannst.';
    const PREVIEW_SPEED_DEFAULT = 1.0;
    const PREVIEW_SPEED_MIN = 0.1;
    const PREVIEW_SPEED_MAX = 5.0;
    let currentPreviewVoice = '';
    let currentPreviewSpeed = PREVIEW_SPEED_DEFAULT;
    function _refreshPreviewSpeedLabel() {
      const el = document.getElementById('voice-preview-speed-value');
      if (el) el.textContent = currentPreviewSpeed.toFixed(1) + ' x';
    }
    function adjustPreviewSpeed(delta) {
      const next = Math.round((currentPreviewSpeed + delta) * 10) / 10;
      if (next < PREVIEW_SPEED_MIN || next > PREVIEW_SPEED_MAX) return;
      currentPreviewSpeed = next;
      _refreshPreviewSpeedLabel();
    }
    function openVoicePreview(name) {
      currentPreviewVoice = name;
      // Speed bei jedem Oeffnen zuruecksetzen — bewusst kein persist
      currentPreviewSpeed = PREVIEW_SPEED_DEFAULT;
      _refreshPreviewSpeedLabel();
      document.getElementById('voice-preview-name').textContent = name;
      // Text bei jedem Oeffnen zuruecksetzen
      document.getElementById('voice-preview-text').value = VOICE_PREVIEW_DEFAULT;
      document.getElementById('voice-preview-status').textContent = '';
      const audio = document.getElementById('voice-preview-audio');
      audio.style.display = 'none';
      audio.src = '';
      document.getElementById('voice-preview-modal').style.display = 'flex';
    }
    function closeVoicePreview() {
      document.getElementById('voice-preview-modal').style.display = 'none';
      const audio = document.getElementById('voice-preview-audio');
      try { audio.pause(); } catch {}
    }
    function playVoicePreview() {
      const text = (document.getElementById('voice-preview-text').value || '').trim();
      if (!text) {
        document.getElementById('voice-preview-status').textContent = 'Text leer';
        return;
      }
      document.getElementById('voice-preview-status').textContent = '⏳ Rendere...';
      document.getElementById('voice-preview-play').disabled = true;
      send({
        action: 'preview_voice',
        voice: currentPreviewVoice,
        text,
        speed: currentPreviewSpeed,
      });
    }
    function deleteXttsVoice(name) {
      if (!confirm(`Stimme "${name}" endgueltig loeschen?`)) return;
      send({ action: 'xtts_delete_voice', name });
@@ -653,9 +653,6 @@ function connectRVS(forcePlain) {
          log("info", "rvs", `service_status ${svc} ${state}${model ? ` (${model})` : ""}`);
        }
        broadcast({ type: "service_status", payload: msg.payload });
      } else if (msg.type === "audio_pcm" && msg.payload && _previewPending.size > 0) {
        // PCM-Chunks einer laufenden Voice-Preview — sammeln + WAV bauen
        _handlePreviewChunk(msg.payload);
      } else {
        log("debug", "rvs", `Nachricht: ${JSON.stringify(msg).slice(0, 150)}`);
      }
@@ -1442,14 +1439,19 @@ wss.on("connection", (ws) => {
          xttsVoice: msg.xttsVoice || "",
        };
        if (msg.whisperModel !== undefined) voiceConfig.whisperModel = msg.whisperModel;
-        // F5-TTS Tuning-Felder — immer mit dem vom User gesendeten Wert setzen,
+        // F5-TTS Tuning-Felder — leere Strings entfernen damit der Default greift
-        // auch leeren String. Leer = "reset auf Hard-Default". Sonst merkt die
+        if (msg.f5ttsModel !== undefined) {
-        // Bridge nicht dass der User den Wert loeschen wollte (absent key war
+          if (msg.f5ttsModel) voiceConfig.f5ttsModel = msg.f5ttsModel;
-        // vorher 'keep current' semantik → BigVGAN blieb drin obwohl User
+          else delete voiceConfig.f5ttsModel;
-        // leer eingetragen hatte).
+        }
-        if (msg.f5ttsModel !== undefined)     voiceConfig.f5ttsModel = msg.f5ttsModel || "";
+        if (msg.f5ttsCkptFile !== undefined) {
-        if (msg.f5ttsCkptFile !== undefined)  voiceConfig.f5ttsCkptFile = msg.f5ttsCkptFile || "";
+          if (msg.f5ttsCkptFile) voiceConfig.f5ttsCkptFile = msg.f5ttsCkptFile;
-        if (msg.f5ttsVocabFile !== undefined) voiceConfig.f5ttsVocabFile = msg.f5ttsVocabFile || "";
+          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;
        }
@@ -1468,8 +1470,6 @@ wss.on("connection", (ws) => {
        handleSaveTriggers(ws, msg.triggers || []);
      } else if (msg.action === "test_tts") {
        handleTestTTS(ws, msg.text || "Test");
      } else if (msg.action === "preview_voice") {
        handleVoicePreview(ws, msg.voice || "", msg.text || "Hallo.", msg.speed);
      } else if (msg.action === "check_tts") {
        handleCheckTTS(ws);
      } else if (msg.action === "check_desktop") {
@@ -1642,98 +1642,6 @@ async function handleSaveTriggers(clientWs, triggers) {
 }
 // ── TTS Diagnose (XTTS) ───────────────────────────────
 // ── Voice Preview ────────────────────────────────────────
 // Sammelt audio_pcm Chunks einer Preview-Anfrage, baut am Ende eine WAV
 // und schickt sie base64-kodiert an den Browser-Client.
 //
 // Map requestId → { clientWs, chunks: [Buffer], sampleRate, channels }
 const _previewPending = new Map();
 function _buildWavFromPcm(pcmBuf, sampleRate, channels) {
  const bitsPerSample = 16;
  const byteRate = sampleRate * channels * bitsPerSample / 8;
  const blockAlign = channels * bitsPerSample / 8;
  const dataSize = pcmBuf.length;
  const header = Buffer.alloc(44);
  header.write("RIFF", 0);
  header.writeUInt32LE(36 + dataSize, 4);
  header.write("WAVE", 8);
  header.write("fmt ", 12);
  header.writeUInt32LE(16, 16);            // subchunk1 size
  header.writeUInt16LE(1, 20);             // PCM
  header.writeUInt16LE(channels, 22);
  header.writeUInt32LE(sampleRate, 24);
  header.writeUInt32LE(byteRate, 28);
  header.writeUInt16LE(blockAlign, 32);
  header.writeUInt16LE(bitsPerSample, 34);
  header.write("data", 36);
  header.writeUInt32LE(dataSize, 40);
  return Buffer.concat([header, pcmBuf]);
 }
 function _handlePreviewChunk(payload) {
  const reqId = payload?.requestId || "";
  const entry = _previewPending.get(reqId);
  if (!entry) return;
  if (payload.base64) {
    try { entry.chunks.push(Buffer.from(payload.base64, "base64")); } catch {}
  }
  if (!entry.sampleRate && payload.sampleRate) entry.sampleRate = payload.sampleRate;
  if (!entry.channels && payload.channels) entry.channels = payload.channels;
  if (payload.final) {
    _previewPending.delete(reqId);
    try {
      const pcm = Buffer.concat(entry.chunks);
      const wav = _buildWavFromPcm(pcm, entry.sampleRate || 24000, entry.channels || 1);
      const b64 = wav.toString("base64");
      if (entry.clientWs && entry.clientWs.readyState === 1) {
        entry.clientWs.send(JSON.stringify({
          type: "voice_preview_audio",
          base64: b64,
          size: wav.length,
        }));
      }
    } catch (err) {
      if (entry.clientWs && entry.clientWs.readyState === 1) {
        entry.clientWs.send(JSON.stringify({
          type: "voice_preview_audio",
          error: err.message,
        }));
      }
    }
  }
 }
 async function handleVoicePreview(clientWs, voice, text, speed) {
  try {
    // Speed clampen — Browser-Slider ist 0.1-5.0
    let spd = parseFloat(speed);
    if (!isFinite(spd) || spd < 0.1 || spd > 5.0) spd = 1.0;
    const requestId = crypto.randomUUID();
    _previewPending.set(requestId, { clientWs, chunks: [], sampleRate: 0, channels: 0 });
    // Timeout safety net
    setTimeout(() => {
      if (_previewPending.has(requestId)) {
        _previewPending.delete(requestId);
        if (clientWs && clientWs.readyState === 1) {
          clientWs.send(JSON.stringify({
            type: "voice_preview_audio",
            error: "Timeout (60s) — keine Antwort vom f5tts-bridge",
          }));
        }
      }
    }, 60000);
    log("info", "server", `Voice-Preview: voice="${voice}" speed=${spd.toFixed(1)}x text="${text.slice(0, 60)}"`);
    sendToRVS_raw({
      type: "xtts_request",
      payload: { text, language: "de", requestId, voice, speed: spd },
      timestamp: Date.now(),
    });
  } catch (err) {
    clientWs.send(JSON.stringify({ type: "voice_preview_audio", error: err.message }));
  }
 }
 async function handleTestTTS(clientWs, text) {
  try {
    log("info", "server", `TTS-Test via XTTS: "${text}"`);
@@ -70,34 +70,22 @@
 - [x] VAD-Stille einstellbar in App-Settings (1.0-8.0s, Default 2.8s)
 - [x] MAX_RECORDING auf 120s — laengere Erklaerungen moeglich
 - [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
 - [x] F5-TTS: Referenz-WAV-Preprocessing — Loudness-Normalisierung -16 LUFS + Silence-Trim + 10s Clip fuer konsistente Cloning-Quali
 - [x] F5-TTS: deutsches Fine-Tune (aihpi/F5-TTS-German, Vocos-Variante) via hf:// Pfad in Diagnostic konfigurierbar
 - [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
 - [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
 - [x] Dynamischer STT-Timeout in aria-bridge: 300s waehrend whisper-bridge 'loading', 45s wenn 'ready'
 - [x] service_status Broadcasts: f5tts/whisper melden Lade-Status, Banner in Diagnostic (unten rechts) + App (oben)
 - [x] config_request Pattern: Bridges fragen beim Connect die aktuelle Voice-Config an, aria-bridge antwortet
 - [x] F5-TTS Tuning via Diagnostic (Modell-ID, Checkpoint, cfg_strength, nfe_step) statt ENV-Vars — Hot-Reload bei Modell-Wechsel
 - [x] Conversation-Window: Gespraechsmodus endet nach X Sekunden Stille (1.0-20.0s, Default 8s, einstellbar in Settings)
 - [x] Porcupine Wake-Word-Integration in der App (Built-In Keywords + Custom spaeter, per Geraet einstellbar)
 - [x] HF-Cache als Bind-Mount statt Docker Volume — kein .vhdx-Bloat auf Docker Desktop / Windows
 - [x] cleanup-windows.ps1 / .bat: VHDX-Cleanup via diskpart (ohne Hyper-V) mit Self-Elevation
 - [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
 - [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
 - [x] App Text-Rendering: Nachrichten selektierbar + Autolink fuer URLs/E-Mails/Telefonnummern (Browser/Mail/Dialer)
 - [x] TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings → 0.5-2.0x in 0.1-Schritten, Default 1.0)
 - [x] Diagnostic: Voice-Preview-Modal (Play-Icon vor Delete-X, Textfeld mit Default, WAV im Browser abspielen)
 ## Offen
 ### Bugs
- [ ] App: Wake-Word "jarvis" triggert nicht zuverlaessig (Porcupine-Debugging via ADB-Logcat ausstehend)
+- [ ] NO_REPLY wird als "NO" im Chat angezeigt — sollte still verworfen werden (Token nicht gesaeubert)
 - [ ] App: Stuerzt beim Lauschen ab, eventuell bei Nebengeraeuschen (Porcupine + Mic-Race, errorCallback haelt's jetzt zurueck — Dauertest ausstehend)
 ### App Features
 - [ ] Wake Word on-device (Porcupine "ARIA" Keyword, Phase 2 — passives Lauschen)
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
 - [ ] Background Audio Service (TTS auch bei minimierter App)
 ### TTS / Audio
 - [ ] Audio-Normalisierung (Lautstaerke zwischen Saetzen/Chunks angleichen)
 - [ ] F5-TTS: Streaming-Inferenz testen (nativ statt satzweise) wenn ein passendes Backend kommt
 - [ ] F5-TTS: Optional Deepspeed-Beschleunigung pruefen
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
 - [ ] Auto-Compacting und Memory/Brain Verwaltung (SQLite?)
@@ -22,7 +22,6 @@ const ALLOWED_TYPES = new Set([
  "voice_preload", "voice_ready",
  "stt_request", "stt_response",
  "service_status",
  "config_request",
 ]);
 // 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,7 +1,3 @@
 # HuggingFace Model-Cache (Whisper + F5-TTS, geteilt zwischen den
 # beiden Bridges via Bind-Mount, kann mehrere GB werden)
 hf-cache/
 # Voice-Samples (lokal, gehoert nicht ins Repo)
 voices/
@@ -31,11 +31,11 @@ services:
              capabilities: [gpu]
    volumes:
      - ./voices:/voices                         # WAV + TXT Referenz
-      - ./hf-cache:/root/.cache/huggingface      # HF-Cache als Bind-Mount.
+                                                 # KEIN HF-Cache-Mount mehr —
-                                                 # Direkt sichtbar im xtts/hf-cache/,
+                                                 # Modell wird beim Start neu
-                                                 # einfach manuell zu loeschen, kein
+                                                 # gezogen. Diagnostic zeigt
-                                                 # Docker-Desktop .vhdx Bloat.
+                                                 # "TTS laedt..." Banner bis
-                                                 # Wird mit whisper-bridge geteilt.
+                                                 # service_status: ready kommt.
    environment:
      # Bootstrap-only — alle anderen F5-TTS-Settings (Modell, cfg_strength,
      # nfe_step, Custom-Checkpoint) kommen ueber Diagnostic via RVS-config.
@@ -77,9 +77,6 @@ services:
      - WHISPER_DEVICE=${WHISPER_DEVICE:-cuda}
      - WHISPER_COMPUTE_TYPE=${WHISPER_COMPUTE_TYPE:-float16}
      - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-de}
-    volumes:
+    # KEIN HF-Cache-Mount — Whisper-Modell wird beim Start neu gezogen.
-      - ./hf-cache:/root/.cache/huggingface      # gleicher Cache wie f5tts-bridge —
+    # Wechsel via Diagnostic triggert ebenso Re-Download.
                                                 # ein Modell muss nur einmal pro
                                                 # Maschine geladen werden, kein
                                                 # Re-Download bei Container-Restart.
    restart: unless-stopped
@@ -73,12 +73,6 @@ VOICES_DIR = Path(os.getenv("VOICES_DIR", "/voices"))
 PCM_CHUNK_BYTES = 8192   # ~170ms @ 24kHz mono s16
 TARGET_SR = 24000        # F5-TTS native
 # F5-TTS hat ein 12s Hard-Limit fuer Referenz-Audio. Laengere WAVs werden
 # vom Modell stumm abgeschnitten — aber unser ref_text bleibt lang und passt
 # dann nicht mehr zum gekuerzten Audio (Quali leidet, warmup-Render ist
 # unnoetig lange). Wir clippen explizit auf 10s + re-transkribieren den Text
 # damit beide synchron bleiben.
 REF_MAX_SECONDS = 10.0
 # Wird in einer Uebergangsphase als "ungueltige Referenz" erkannt (alte voices,
 # die hochgeladen wurden bevor die whisper-bridge online war). Bei Erkennung
@@ -99,33 +93,6 @@ def _get_f5tts_cls():
    return _F5TTS_cls
 def _resolve_hf_path(p: str) -> str:
    """Wenn p mit 'hf://' anfaengt → aus HuggingFace Hub runterladen,
    lokalen Pfad zurueckgeben. Sonst unveraendert.
    Format: hf://user/repo/path/to/file.ext
    Beispiel: hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors
    """
    if not p or not p.startswith("hf://"):
        return p
    try:
        from huggingface_hub import hf_hub_download
        rest = p[5:]
        parts = rest.split("/", 2)
        if len(parts) < 3:
            logger.warning("Ungueltiges hf:// Format: %s (erwarte hf://user/repo/path)", p)
            return p
        repo_id = f"{parts[0]}/{parts[1]}"
        filename = parts[2]
        logger.info("HF-Download: %s aus %s", filename, repo_id)
        local = hf_hub_download(repo_id=repo_id, filename=filename)
        logger.info("HF-Download fertig: %s", local)
        return local
    except Exception as e:
        logger.exception("HF-Download fehlgeschlagen fuer %s: %s", p, e)
        return p
 class F5Runner:
    """Haelt das F5-TTS-Modell. Synthese laeuft im Executor (blocking).
@@ -149,16 +116,14 @@ class F5Runner:
    def _load_blocking(self) -> None:
        cls = _get_f5tts_cls()
        ckpt_resolved = _resolve_hf_path(self.ckpt_file) if self.ckpt_file else ""
        vocab_resolved = _resolve_hf_path(self.vocab_file) if self.vocab_file else ""
        logger.info("Lade F5-TTS '%s' (device=%s, ckpt=%s)...",
-                    self.model_id, F5TTS_DEVICE, ckpt_resolved or "default")
+                    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 ckpt_resolved:
+        if self.ckpt_file:
-            kwargs["ckpt_file"] = ckpt_resolved
+            kwargs["ckpt_file"] = self.ckpt_file
-        if vocab_resolved:
+        if self.vocab_file:
-            kwargs["vocab_file"] = vocab_resolved
+            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)",
@@ -175,31 +140,10 @@ class F5Runner:
    async def update_config(self, payload: dict) -> None:
        """Liest f5tts*-Felder aus einem config-Broadcast.
-        Bei Modell-relevantem Wechsel wird neu geladen.
+        Bei Modell-relevantem Wechsel wird neu geladen."""
-
+        new_model = (payload.get("f5ttsModel") or "").strip() or self.model_id
-        Semantik:
+        new_ckpt = payload.get("f5ttsCkptFile", self.ckpt_file) or ""
-          - key fehlt in payload     → aktuellen Wert behalten
+        new_vocab = payload.get("f5ttsVocabFile", self.vocab_file) or ""
          - key da, nicht-leerer str → diesen Wert nehmen
          - key da, leerer string    → RESET auf Hard-Default (User hat Feld
                                       in Diagnostic geleert und Apply geklickt)
        """
        if "f5ttsModel" in payload:
            v = (payload.get("f5ttsModel") or "").strip()
            new_model = v if v else DEFAULT_F5TTS_MODEL
        else:
            new_model = self.model_id
        if "f5ttsCkptFile" in payload:
            v = payload.get("f5ttsCkptFile") or ""
            new_ckpt = v.strip() if isinstance(v, str) else ""
        else:
            new_ckpt = self.ckpt_file
        if "f5ttsVocabFile" in payload:
            v = payload.get("f5ttsVocabFile") or ""
            new_vocab = v.strip() if isinstance(v, str) else ""
        else:
            new_vocab = self.vocab_file
        try:
            new_cfg = float(payload.get("f5ttsCfgStrength", self.cfg_strength))
        except (TypeError, ValueError):
@@ -237,10 +181,7 @@ class F5Runner:
        else:
            logger.info("F5-TTS Live-Config: cfg_strength=%.2f nfe=%d", new_cfg, new_nfe)
-    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str,
+    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
                        speed: float = 1.0) -> tuple[np.ndarray, int]:
        logger.info("infer() text=%d chars, speed=%.2f, cfg=%.2f, nfe=%d",
                    len(gen_text), speed, self.cfg_strength, self.nfe_step)
        wav, sr, _ = self.model.infer(
            ref_file=ref_wav,
            ref_text=ref_text,
@@ -249,7 +190,6 @@ class F5Runner:
            seed=-1,
            cfg_strength=self.cfg_strength,
            nfe_step=self.nfe_step,
            speed=speed,
        )
        # F5-TTS gibt float32 1D-Array — auf 24kHz sample-rate standard
        if not isinstance(wav, np.ndarray):
@@ -258,11 +198,10 @@ class F5Runner:
            wav = wav.squeeze()
        return wav.astype(np.float32), int(sr)
-    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str,
+    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
                         speed: float = 1.0) -> tuple[np.ndarray, int]:
        await self.ensure_loaded()
        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text, speed)
+        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text)
 # ── Helpers ─────────────────────────────────────────────────
@@ -294,15 +233,7 @@ def split_sentences(text: str, max_len: int = 350) -> list[str]:
 def float_to_pcm16(wav: np.ndarray) -> bytes:
-    """Float32 (-1..+1) → int16 little-endian bytes.
+    """Float32 (-1..+1) → int16 little-endian bytes."""
    F5-TTS generiert gelegentlich NaN/Inf bei Instabilitaeten — ohne sanitize
    waere der Cast zu int16 undefiniert (RuntimeWarning + kaputter Sound).
    """
    nan_count = int(np.isnan(wav).sum() + np.isinf(wav).sum())
    if nan_count > 0:
        logger.warning("F5-TTS Output enthaelt %d NaN/Inf samples — ersetze mit 0", nan_count)
        wav = np.nan_to_num(wav, nan=0.0, posinf=1.0, neginf=-1.0)
    wav = np.clip(wav, -1.0, 1.0)
    pcm = (wav * 32767.0).astype(np.int16)
    return pcm.tobytes()
@@ -317,51 +248,32 @@ def voice_paths(name: str) -> tuple[Path, Path]:
    return VOICES_DIR / f"{safe}.wav", VOICES_DIR / f"{safe}.txt"
-def normalize_ref_wav(src_wav: Path, max_seconds: float = REF_MAX_SECONDS) -> tuple[Path, bool]:
+def ensure_24k_mono_wav(src_wav: Path) -> Path:
-    """Bringt die Referenz-WAV in F5-TTS-freundliche Form:
+    """F5-TTS moechte 24kHz mono als Referenz — ffmpeg konvertiert inplace.
-      * 24kHz mono
+    Wenn das File schon passt, wird nichts geaendert. Sonst wird es
-      * max max_seconds Dauer
+    reingeschrieben (Original wird ueberschrieben).
      * Stille am Anfang + Ende abgeschnitten (silenceremove-Filter)
      * Lautheit auf -16 LUFS normalisiert (loudnorm-Filter) damit
        das Modell konsistente Amplituden sieht
    F5-TTS reagiert empfindlich auf leise / verrauschte / zerhackte
    Referenzen. Konsistente, saubere Input-Lautheit hilft der Quali.
    Returns:
        (path, was_modified) — was_modified=True wenn die Datei wirklich
        geaendert wurde (Caller sollte dann den passenden .txt invalidieren).
    """
    try:
        info = sf.info(str(src_wav))
        if info.samplerate == TARGET_SR and info.channels == 1:
            return src_wav
    except Exception:
        pass
    tmp_out = src_wav.with_suffix(".conv.wav")
    # silenceremove am Anfang: bis -50dB gesprochen wird
    # silenceremove am Ende: ueber -50dB rein, dann 0.5s stille als Cutoff
    # loudnorm: EBU R128, Ziel -16 LUFS
    af = ("silenceremove=start_periods=1:start_duration=0.05:start_threshold=-50dB,"
          "silenceremove=stop_periods=1:stop_duration=0.5:stop_threshold=-50dB,"
          "loudnorm=I=-16:TP=-1.5:LRA=11")
    cmd = ["ffmpeg", "-y", "-i", str(src_wav),
-           "-af", af,
+           "-ar", str(TARGET_SR), "-ac", "1", "-f", "wav", str(tmp_out)]
           "-ar", str(TARGET_SR), "-ac", "1",
           "-t", str(max_seconds),
           "-f", "wav", str(tmp_out)]
    r = subprocess.run(cmd, capture_output=True, timeout=30)
    if r.returncode != 0:
-        logger.warning("ffmpeg-Normalisierung von %s fehlgeschlagen: %s",
+        logger.warning("ffmpeg-Konvertierung von %s fehlgeschlagen: %s",
-                       src_wav, r.stderr.decode(errors="replace")[:300])
+                       src_wav, r.stderr.decode(errors="replace")[:200])
        try:
            tmp_out.unlink()
        except OSError:
            pass
-        return src_wav, False
+        return src_wav
    os.replace(tmp_out, src_wav)
-    try:
+    return src_wav
        info = sf.info(str(src_wav))
        logger.info("Referenz-WAV normalisiert: %s (%.1fs, %dHz mono, -16 LUFS, silence getrimmt)",
                    src_wav.name, info.duration, info.samplerate)
    except Exception:
        logger.info("Referenz-WAV normalisiert: %s", src_wav.name)
    return src_wav, True
 async def _send(ws, mtype: str, payload: dict) -> None:
@@ -400,10 +312,7 @@ async def request_transcription(ws, wav_path: Path, language: str = "de") -> Opt
            "requestId": request_id,
            "audio": audio_b64,
            "mimeType": "audio/wav",
-            # KEIN hardcoded model — whisper-bridge nimmt das bereits
+            "model": "small",  # klein reicht fuer Voice-Referenz
            # geladene. Sonst wuerde hier ein Swap auf 'small' passieren und
            # danach muesste das in Diagnostic konfigurierte Modell (z.B.
            # large-v3) wieder geladen werden → doppelter Download.
            "language": language,
        })
        return await asyncio.wait_for(fut, timeout=_STT_TIMEOUT_S)
@@ -426,9 +335,9 @@ _tts_queue: asyncio.Queue[tuple] = asyncio.Queue()
 async def _tts_worker(ws, runner: F5Runner) -> None:
    """Serialisiert Synthesen — GPU kann sonst OOM gehen."""
    while True:
-        text, voice, request_id, message_id, language, speed = await _tts_queue.get()
+        text, voice, request_id, message_id, language = await _tts_queue.get()
        try:
-            await _do_tts(ws, runner, text, voice, request_id, message_id, language, speed)
+            await _do_tts(ws, runner, text, voice, request_id, message_id, language)
        except Exception:
            logger.exception("TTS-Worker Fehler")
        finally:
@@ -436,26 +345,10 @@ async def _tts_worker(ws, runner: F5Runner) -> None:
 async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
-                  request_id: str, message_id: str, language: str,
+                  request_id: str, message_id: str, language: str) -> None:
                  speed: float = 1.0) -> None:
    t0 = time.time()
    ref_wav_path, ref_txt_path = voice_paths(voice) if voice else (None, None)
    # WAV zu lang? F5-TTS limitiert intern auf 12s, dann passt der txt nicht
    # mehr zum Audio. Wir clippen explizit auf 10s und invalidieren den txt,
    # damit er on-the-fly passend zum gekuerzten Audio neu transkribiert wird.
    if voice and ref_wav_path and ref_wav_path.exists():
        try:
            info = sf.info(str(ref_wav_path))
            if info.duration > REF_MAX_SECONDS + 0.5:
                logger.info("Voice '%s' WAV ist %.1fs (>%.0fs) → clippen + txt neu",
                            voice, info.duration, REF_MAX_SECONDS)
                _, modified = normalize_ref_wav(ref_wav_path)
                if modified and ref_txt_path and ref_txt_path.exists():
                    ref_txt_path.unlink()
        except Exception as e:
            logger.warning("Konnte WAV-Dauer nicht pruefen: %s", e)
    # Legacy-Platzhalter erkennen → behandeln als "kein txt" und neu transkribieren
    if voice and ref_txt_path and ref_txt_path.exists():
        try:
@@ -509,14 +402,13 @@ async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
            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, speed=%.2fx (%s)",
+    logger.info("F5-TTS: %d Satz(e), voice=%s (%s)", len(sentences), voice or "default", ref_wav_str)
                len(sentences), voice or "default", speed, 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, speed)
+            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
@@ -599,9 +491,8 @@ async def handle_voice_upload(ws, payload: dict) -> None:
        size_kb = wav_path.stat().st_size / 1024
        logger.info("Voice WAV gespeichert: %s (%.0fKB)", wav_path, size_kb)
-        # Auf 24kHz mono clippen auf 10s (F5-TTS Hard-Limit ist 12s,
+        # Auf 24kHz mono normalisieren (falls App in anderem Format liefert)
-        # kuerzer = schnellerer Warmup + Text+Audio bleiben aligned)
+        ensure_24k_mono_wav(wav_path)
        normalize_ref_wav(wav_path)
        # Transkription ueber whisper-bridge anfragen
        logger.info("Transkribiere '%s' via whisper-bridge...", name)
@@ -722,30 +613,22 @@ async def run_loop(runner: F5Runner) -> None:
                tls_fallback_tried = False
                # Status-Broadcast: erst loading, dann ready nach erfolgreichem Load.
-                # Plus: config_request damit wir die persistierte Diagnostic-Config
+                # Modell wird hier (nicht ausserhalb der Schleife) gestartet damit
-                # bekommen, falls aria-bridge ihre nicht von alleine sendet.
+                # 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:
-                        if runner.model is not None:
+                        await runner.ensure_loaded()
-                            logger.info("Initial: broadcaste ready (Modell schon im RAM: %s)", runner.model_id)
+                        await _broadcast_status(ws, "ready",
-                            await _broadcast_status(ws, "ready",
+                                                model=runner.model_id,
-                                                    model=runner.model_id,
+                                                loadSeconds=runner.last_load_seconds)
                                                    loadSeconds=runner.last_load_seconds)
                        else:
                            logger.info("Initial: broadcaste loading + lade Modell '%s'", runner.model_id)
                            await _broadcast_status(ws, "loading", model=runner.model_id)
                            await runner.ensure_loaded()
                            await _broadcast_status(ws, "ready",
                                                    model=runner.model_id,
                                                    loadSeconds=runner.last_load_seconds)
                        logger.info("Initial: sende config_request an aria-bridge")
                        await _send(ws, "config_request", {"service": "f5tts"})
                    except Exception as e:
-                        logger.exception("Initial-Load crashed: %s", e)
+                        await _broadcast_status(ws, "error", error=str(e)[:200])
                        try:
                            await _broadcast_status(ws, "error", error=str(e)[:200])
                        except Exception:
                            pass
                asyncio.create_task(_load_with_status())
                # TTS-Worker fuer diese Verbindung starten
@@ -761,19 +644,12 @@ async def run_loop(runner: F5Runner) -> None:
                        payload = msg.get("payload", {}) or {}
                        if mtype == "xtts_request":
                            try:
                                speed = float(payload.get("speed") or 1.0)
                            except (TypeError, ValueError):
                                speed = 1.0
                            if not (0.1 <= speed <= 5.0):
                                speed = 1.0
                            await _tts_queue.put((
                                payload.get("text", ""),
                                payload.get("voice", "") or "",
                                payload.get("requestId", ""),
                                payload.get("messageId", ""),
                                payload.get("language", "de"),
                                speed,
                            ))
                        elif mtype == "voice_upload":
                            asyncio.create_task(handle_voice_upload(ws, payload))
@@ -143,11 +143,7 @@ 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")
-    # Modell-Auswahl:
+    model = payload.get("model") or WHISPER_MODEL
    #   payload.model gesetzt  → nimm das (aria-bridge sendet's basierend auf Config)
    #   sonst + Modell geladen → behalt das aktuelle (kein sinnloser Swap)
    #   sonst                  → fallback auf ENV-Default
    model = payload.get("model") or (runner.model_size if runner.model is not None else WHISPER_MODEL)
    language = payload.get("language") or WHISPER_LANGUAGE
    if not audio_b64:
@@ -224,26 +220,15 @@ async def run_loop(runner: WhisperRunner) -> None:
                retry_s = 2
                tls_fallback_tried = False
-                # Initialer Status-Broadcast — uebertont alten "ready"-State
+                # KEIN initialer Preload. Der aria-bridge broadcastet kurz nach
-                # im App/Diagnostic Banner (sonst denkt der User noch alles ist
+                # RVS-Connect die persistierte Config (whisperModel) — wir laden
-                # gut von vorher). Wenn Modell schon geladen → ready, sonst
+                # erst wenn der drinsteht, sonst wuerde 2x geladen werden
-                # loading mit aktuellem (Default-)Namen.
+                # (small als ENV-Default + dann das echte Modell).
-                # Plus: config_request an aria-bridge — wir wissen nicht ob
+                # Wenn ein stt_request schneller kommt als die Config: ensure_loaded
-                # sie auch grad reconnected hat oder schon laenger online ist.
+                # im Handler greift dann ein und laedt das angeforderte Modell.
-                async def _initial_handshake():
+                if runner.model is not None:
-                    try:
+                    # Wir sind reconnectet — Modell schon im RAM, einfach 'ready'
-                        if runner.model is not None:
+                    asyncio.create_task(_broadcast_status(ws, "ready", model=runner.model_size))
                            logger.info("Initial: broadcaste ready (Modell schon im RAM: %s)", runner.model_size)
                            await _broadcast_status(ws, "ready", model=runner.model_size)
                        else:
                            init_model = runner.model_size or WHISPER_MODEL
                            logger.info("Initial: broadcaste loading (model=%s)", init_model)
                            await _broadcast_status(ws, "loading", model=init_model)
                        logger.info("Initial: sende config_request an aria-bridge")
                        await _send(ws, "config_request", {"service": "whisper"})
                    except Exception as e:
                        logger.exception("Initial-Handshake crashed: %s", e)
                asyncio.create_task(_initial_handshake())
                async for raw in ws:
                    try: