30 changed files with 311 additions and 1418 deletions
--- a/README.md
+++ b/README.md
@ -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,45 +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, openWakeWord-Original)
- `Computer` (Star-Trek-Style, Community-Modell)
- `Alexa`, `Hey Mycroft`, `Hey Rhasspy` (openWakeWord-Originale)
-
-Community-Modelle stammen aus [fwartner/home-assistant-wakewords-collection](https://github.com/fwartner/home-assistant-wakewords-collection).
-
-**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
@ -784,10 +744,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`,
-  `Hey Rhasspy` funktionieren sofort, eigene Wake-Words muessen aktuell noch als
-  `.onnx`-Datei ins App-Bundle gelegt + zur Liste in `wakeword.ts` hinzugefuegt werden.
-  Die Diagnostic-Upload-UI ist Phase 2.
+- **Wake Word nur auf VM**: Die Bridge hoert auf "ARIA" ueber das lokale Mikrofon der VM.
+  In der App gibt es Energy-basierte Erkennung (Phase 1). On-device "ARIA"-Keyword (Porcupine) 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.
@ -842,7 +800,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

@ -858,5 +815,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)
--- a/android/android/app/build.gradle
+++ b/android/android/app/build.gradle
@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 701
-        versionName "0.0.7.1"
+        versionCode 507
+        versionName "0.0.5.7"
        // 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 {
--- a/android/android/app/src/main/AndroidManifest.xml
+++ b/android/android/app/src/main/AndroidManifest.xml
@ -4,8 +4,6 @@
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
-    <!-- Anruf-State lesen damit TTS bei klingelndem Telefon pausiert -->
-    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

    <application
      android:name=".MainApplication"
--- a/android/android/app/src/main/assets/openwakeword/alexa.onnx
+++ b/android/android/app/src/main/assets/openwakeword/alexa.onnx
--- a/android/android/app/src/main/assets/openwakeword/computer.onnx
+++ b/android/android/app/src/main/assets/openwakeword/computer.onnx
--- a/android/android/app/src/main/assets/openwakeword/embedding_model.onnx
+++ b/android/android/app/src/main/assets/openwakeword/embedding_model.onnx
--- a/android/android/app/src/main/assets/openwakeword/hey_jarvis.onnx
+++ b/android/android/app/src/main/assets/openwakeword/hey_jarvis.onnx
--- a/android/android/app/src/main/assets/openwakeword/hey_mycroft.onnx
+++ b/android/android/app/src/main/assets/openwakeword/hey_mycroft.onnx
--- a/android/android/app/src/main/assets/openwakeword/hey_rhasspy.onnx
+++ b/android/android/app/src/main/assets/openwakeword/hey_rhasspy.onnx
--- a/android/android/app/src/main/assets/openwakeword/melspectrogram.onnx
+++ b/android/android/app/src/main/assets/openwakeword/melspectrogram.onnx
--- a/android/android/app/src/main/java/com/ariacockpit/MainApplication.kt
+++ b/android/android/app/src/main/java/com/ariacockpit/MainApplication.kt
@ -21,8 +21,6 @@ class MainApplication : Application(), ReactApplication {
              add(ApkInstallerPackage())
              add(AudioFocusPackage())
              add(PcmStreamPlayerPackage())
-              add(OpenWakeWordPackage())
-              add(PhoneCallPackage())
            }

        override fun getJSMainModuleName(): String = "index"
--- a/android/android/app/src/main/java/com/ariacockpit/OpenWakeWordModule.kt
+++ b/android/android/app/src/main/java/com/ariacockpit/OpenWakeWordModule.kt
@ -1,369 +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 MEL_BINS = 32
-        private const val DEFAULT_WW_INPUT_FRAMES = 16       // Fallback wenn Modell-Metadata fehlt
-    }
-
-    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"
-    // Anzahl Embedding-Frames die der Wake-Word-Klassifikator pro Inferenz erwartet —
-    // hey_jarvis hat 16, andere Community-Modelle koennen abweichen (z.B. 28).
-    // Wird beim init() aus den Modell-Metadaten gelesen.
-    private var wwInputFrames: Int = DEFAULT_WW_INPUT_FRAMES
-
-    // 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()
-
-            // WW-Input-Frame-Count aus dem Modell lesen — variiert pro Keyword.
-            // Erwartete Form: (1, N, 96), N steht in der Modell-Metadaten.
-            val wwInputInfo = wwSession!!.inputInfo[wwInputName]
-            val wwShape = (wwInputInfo?.info as? ai.onnxruntime.TensorInfo)?.shape
-            wwInputFrames = wwShape?.getOrNull(1)?.toInt()?.takeIf { it > 0 } ?: DEFAULT_WW_INPUT_FRAMES
-
-            Log.i(TAG, "Init OK: model=$modelName wwFrames=$wwInputFrames 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, 1, 1, 96) — rank-4, NICHT (1, 96).
-            // Die Google-Embedding-Pipeline behaelt extra Dimensionen.
-            @Suppress("UNCHECKED_CAST")
-            val embArr = embOut as Array<Array<Array<FloatArray>>>
-            embBuffer.addLast(embArr[0][0][0].copyOf())
-            while (embBuffer.size > wwInputFrames) 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 < wwInputFrames) return
-        val flatEmb = FloatArray(wwInputFrames * EMBEDDING_DIM)
-        var p = 0
-        // Letzte wwInputFrames Embeddings nehmen (embBuffer ist auf wwInputFrames begrenzt)
-        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, wwInputFrames.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
-        }
-    }
-}
--- a/android/android/app/src/main/java/com/ariacockpit/OpenWakeWordPackage.kt
+++ b/android/android/app/src/main/java/com/ariacockpit/OpenWakeWordPackage.kt
@ -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()
-    }
-}
--- a/android/android/app/src/main/java/com/ariacockpit/PcmStreamPlayerModule.kt
+++ b/android/android/app/src/main/java/com/ariacockpit/PcmStreamPlayerModule.kt
@ -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.
-        // 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 MIN_PREROLL_SECONDS = 0.5
        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
-        // 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
+        private const val LEADING_SILENCE_SECONDS = 0.2
    }

    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 = if (prerollSeconds.isFinite() && prerollSeconds >= 0.0) {
-                prerollSeconds.coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
-            } else {
-                DEFAULT_PREROLL_SECONDS
-            }
+            val prerollSec = prerollSeconds
+                .coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
+                .let { if (it.isFinite() && it > 0) it else DEFAULT_PREROLL_SECONDS }

            val channelConfig = if (channels == 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
            val encoding = AudioFormat.ENCODING_PCM_16BIT
@ -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
-                    if (leadingBytes > 0) {
-                        val silence = ByteArray(leadingBytes)
+                    val silenceBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
+                    if (silenceBytes > 0) {
+                        val silence = ByteArray(silenceBytes)
                        var silOff = 0
                        while (silOff < silence.size && !writerShouldStop) {
                            val w = t.write(silence, silOff, silence.size - silOff)
@ -123,74 +114,18 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                        }
                        bytesBuffered += silence.size
                    }
-                    // Bei preroll=0: play() SOFORT nach Leading-Silence aufrufen,
-                    // nicht erst bei Ankunft des ersten echten Chunks. Android's
-                    // 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}")
-                        }
-                    }
-                    // Idle-Cutoff: wenn endRequested NICHT kam aber 30s nichts mehr
-                    // reinkommt, brechen wir ab (Bridge-Crash, verlorener final).
-                    var idleMs = 0L
-                    val maxIdleMs = 30_000L
-                    // Zielpufferfuellung — unter diesem Wasserstand fuettern wir
-                    // Stille rein damit AudioTrack nicht underrunt waehrend die
-                    // Bridge den naechsten Satz rendert. Spotify/YouTube reagieren
-                    // sonst mit eigenmaechtiger Wiederaufnahme nach ~10s Stille.
-                    val underrunGuardFrames = sampleRate / 10  // ~100ms
-                    val silenceFillFrames = sampleRate / 20    // ~50ms pro Refill
-
-                    mainLoop@ while (!writerShouldStop) {
-                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS)
-                        if (data == null) {
+                    while (!writerShouldStop) {
+                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS) ?: run {
                            if (endRequested) {
                                // Falls wir vor Pre-Roll enden (kurzer Text): trotzdem abspielen
                                if (!playbackStarted) {
-                                    try {
-                                        t.play()
-                                        playbackStarted = true
-                                        Log.i(TAG, "Playback gestartet VOR Pre-Roll (kurzer Text, ${bytesBuffered}B gepuffert)")
-                                    } catch (e: Exception) {
-                                        Log.w(TAG, "play() fallback failed: ${e.message}")
-                                    }
+                                    try { t.play() } catch (_: Exception) {}
+                                    playbackStarted = true
                                }
-                                break@mainLoop
+                                return@Thread
                            }
-                            // Underrun-Schutz: Stille reinfuettern wenn der AudioTrack-
-                            // Puffer leerzulaufen droht. Spotify resumed sonst nach
-                            // ~10s Pause auf eigene Faust, obwohl wir den Fokus halten.
-                            if (playbackStarted) {
-                                val framesWritten = bytesBuffered / streamBytesPerFrame
-                                val framesPlayed = t.playbackHeadPosition.toLong()
-                                val framesInBuffer = framesWritten - framesPlayed
-                                if (framesInBuffer < underrunGuardFrames) {
-                                    val fillBytes = silenceFillFrames * streamBytesPerFrame
-                                    val silence = ByteArray(fillBytes)
-                                    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
-                                }
-                            }
-                            idleMs += 50L
-                            if (idleMs >= maxIdleMs) {
-                                Log.w(TAG, "Idle-Cutoff: ${maxIdleMs}ms keine Daten — Stream wird beendet")
-                                break@mainLoop
-                            }
-                            continue@mainLoop
-                        }
-                        idleMs = 0L
+                            null
+                        } ?: continue

                        // Pre-Roll Check: play() erst wenn genug gepuffert
                        if (!playbackStarted && bytesBuffered + data.size >= prerollBytes) {
@ -211,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 {
--- a/android/android/app/src/main/java/com/ariacockpit/PhoneCallModule.kt
+++ b/android/android/app/src/main/java/com/ariacockpit/PhoneCallModule.kt
@ -1,126 +0,0 @@
-package com.ariacockpit
-
-import android.Manifest
-import android.content.Context
-import android.content.pm.PackageManager
-import android.os.Build
-import android.telephony.PhoneStateListener
-import android.telephony.TelephonyCallback
-import android.telephony.TelephonyManager
-import android.util.Log
-import androidx.core.content.ContextCompat
-import com.facebook.react.bridge.Arguments
-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
-
-/**
- * Lauscht auf Anruf-Statusaenderungen — wenn das Telefon klingelt oder ein
- * Anruf laeuft, sendet das Modul ein "PhoneCallStateChanged"-Event an JS.
- *
- * JS-Side stoppt dann die TTS-Wiedergabe damit ARIA nicht mitten ins Gespraech
- * weiterredet. Ohne READ_PHONE_STATE-Permission failt start() leise — der Rest
- * der App funktioniert wie bisher.
- *
- * State-Strings: "idle" | "ringing" | "offhook"
- */
-class PhoneCallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    override fun getName() = "PhoneCall"
-
-    companion object { private const val TAG = "PhoneCall" }
-
-    private var telephonyManager: TelephonyManager? = null
-    private var legacyListener: PhoneStateListener? = null
-    private var modernCallback: Any? = null  // TelephonyCallback ab API 31
-    private var lastState: Int = TelephonyManager.CALL_STATE_IDLE
-
-    @ReactMethod
-    fun start(promise: Promise) {
-        try {
-            val perm = ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.READ_PHONE_STATE)
-            if (perm != PackageManager.PERMISSION_GRANTED) {
-                Log.w(TAG, "READ_PHONE_STATE Permission fehlt — Anruf-Erkennung inaktiv")
-                promise.resolve(false)
-                return
-            }
-            val tm = reactApplicationContext.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
-            if (tm == null) {
-                Log.w(TAG, "TelephonyManager nicht verfuegbar")
-                promise.resolve(false)
-                return
-            }
-            telephonyManager = tm
-
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                val cb = object : TelephonyCallback(), TelephonyCallback.CallStateListener {
-                    override fun onCallStateChanged(state: Int) {
-                        handleStateChange(state)
-                    }
-                }
-                tm.registerTelephonyCallback(reactApplicationContext.mainExecutor, cb)
-                modernCallback = cb
-            } else {
-                @Suppress("DEPRECATION")
-                val l = object : PhoneStateListener() {
-                    override fun onCallStateChanged(state: Int, phoneNumber: String?) {
-                        handleStateChange(state)
-                    }
-                }
-                @Suppress("DEPRECATION")
-                tm.listen(l, PhoneStateListener.LISTEN_CALL_STATE)
-                legacyListener = l
-            }
-            Log.i(TAG, "PhoneCall-Listener aktiv")
-            promise.resolve(true)
-        } catch (e: Exception) {
-            Log.e(TAG, "start fehlgeschlagen", e)
-            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
-        }
-    }
-
-    @ReactMethod
-    fun stop(promise: Promise) {
-        try {
-            val tm = telephonyManager
-            if (tm != null) {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                    (modernCallback as? TelephonyCallback)?.let { tm.unregisterTelephonyCallback(it) }
-                    modernCallback = null
-                } else {
-                    @Suppress("DEPRECATION")
-                    legacyListener?.let { tm.listen(it, PhoneStateListener.LISTEN_NONE) }
-                    legacyListener = null
-                }
-            }
-            telephonyManager = null
-            lastState = TelephonyManager.CALL_STATE_IDLE
-            promise.resolve(true)
-        } catch (e: Exception) {
-            promise.reject("STOP_FAILED", e.message ?: "")
-        }
-    }
-
-    private fun handleStateChange(state: Int) {
-        if (state == lastState) return
-        lastState = state
-        val name = when (state) {
-            TelephonyManager.CALL_STATE_RINGING -> "ringing"
-            TelephonyManager.CALL_STATE_OFFHOOK -> "offhook"
-            TelephonyManager.CALL_STATE_IDLE -> "idle"
-            else -> return
-        }
-        Log.i(TAG, "Telefon-State: $name")
-        val params = Arguments.createMap().apply { putString("state", name) }
-        try {
-            reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("PhoneCallStateChanged", params)
-        } catch (e: Exception) {
-            Log.w(TAG, "Event-emit fehlgeschlagen: ${e.message}")
-        }
-    }
-
-    @ReactMethod fun addListener(eventName: String) {}
-    @ReactMethod fun removeListeners(count: Int) {}
-}
--- a/android/android/app/src/main/java/com/ariacockpit/PhoneCallPackage.kt
+++ b/android/android/app/src/main/java/com/ariacockpit/PhoneCallPackage.kt
@ -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 PhoneCallPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(PhoneCallModule(reactContext))
-    }
-
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
-}
--- a/android/build.sh
+++ b/android/build.sh
@ -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"
-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
+    APK_PATH="app/build/outputs/apk/release/app-release.apk"
 fi

 cd ..
--- a/android/package.json
+++ b/android/package.json
@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.0.7.1",
+  "version": "0.0.5.7",
  "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",
--- a/android/src/components/MessageText.tsx
+++ b/android/src/components/MessageText.tsx
@ -72,28 +72,13 @@ interface Props {
 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"
-    >
+    <Text style={style} selectable>
      {segments.map((seg, i) => {
        if (seg.kind === 'text') {
-          return <Text key={i} selectable>{seg.text}</Text>;
+          return <Text key={i}>{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}
-          >
+          <Text key={i} style={LINK_STYLE} onPress={() => onPress(seg)}>
            {seg.text}
          </Text>
        );
--- a/android/src/components/VoiceButton.tsx
+++ b/android/src/components/VoiceButton.tsx
@ -93,24 +93,18 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
    }
  }, [isRecording]);

-  // 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]);
+  // VAD Silence Callback — Auto-Stop
  useEffect(() => {
    const unsubSilence = audioService.onSilenceDetected(async () => {
-      if (audioService.getRecordingState() !== 'recording') return;
-      const result = await audioService.stopRecording();
+      if (!isRecording) return;
      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.
-  // Guard gegen Doppel-Tap während asyncer Start/Stop.
-  const tapBusy = useRef(false);
+  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop
  const handleTap = async () => {
-    if (disabled || tapBusy.current) return;
-    tapBusy.current = true;
-    try {
-      // Fragen WIR den Service, nicht den React-State (Closure kann stale sein)
-      const svcState = audioService.getRecordingState();
-      if (svcState === 'recording') {
-        // Aufnahme manuell stoppen
-        const result = await audioService.stopRecording();
-        setIsRecording(false);
-        if (result && result.durationMs > 300) {
-          onRecordingComplete(result);
-        }
-      } else if (svcState === 'idle') {
-        // Aufnahme mit Auto-Stop starten
-        const started = await audioService.startRecording(true);
-        if (started) {
-          isLongPress.current = false;
-          setIsRecording(true);
-        }
+    if (disabled) return;
+    if (isRecording) {
+      // Aufnahme manuell stoppen
+      setIsRecording(false);
+      const result = await audioService.stopRecording();
+      if (result && result.durationMs > 300) {
+        onRecordingComplete(result);
+      }
+    } else {
+      // Aufnahme mit Auto-Stop starten
+      const started = await audioService.startRecording(true);
+      if (started) {
+        isLongPress.current = false;
+        setIsRecording(true);
      }
-      // 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;
    }
  };

--- a/android/src/screens/ChatScreen.tsx
+++ b/android/src/screens/ChatScreen.tsx
@ -25,7 +25,6 @@ import RNFS from 'react-native-fs';
 import rvs, { RVSMessage, ConnectionState } from '../services/rvs';
 import audioService from '../services/audio';
 import wakeWordService from '../services/wakeword';
-import phoneCallService from '../services/phoneCall';
 import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
@ -105,8 +104,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);
@ -157,24 +154,6 @@ 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');
-      // Conversation-Focus an Wake-Word-State koppeln: solange wir aktiv im
-      // Dialog sind, soll Spotify dauerhaft gepaust bleiben (auch ueber
-      // Render-Pausen + zwischen Antworten hinweg). Sobald wir zurueck nach
-      // 'armed' oder 'off' fallen, darf Spotify wieder.
-      if (s === 'conversing') audioService.acquireConversationFocus();
-      else audioService.releaseConversationFocus();
-    });
-    return () => unsub();
-  }, []);
-
-  // Anruf-Erkennung: TTS pausieren wenn das Telefon klingelt
-  useEffect(() => {
-    phoneCallService.start().catch(err =>
-      console.warn('[Chat] phoneCall.start fehlgeschlagen', err));
-    return () => { phoneCallService.stop().catch(() => {}); };
  }, []);

  // ttsCanPlayRef live aktuell halten — Closure in onMessage unten liest
@ -284,35 +263,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.
-        // 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).
+        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben
        if (sender === 'stt') {
          const sttText = (message.payload.text as string) || '';
          if (sttText) {
-            setMessages(prev => {
-              const idx = prev.findIndex(m =>
-                m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
-              );
-              const newText = `\uD83C\uDFA4 ${sttText}`;
-              if (idx < 0) {
-                // Defensiv: wenn keine Placeholder im State (z.B. weil sie nie
-                // hinzugefuegt wurde oder schon durch ein anderes Update verloren
-                // ging), die Sprachnachricht trotzdem als neue Bubble einfuegen.
-                // Sonst kommt ARIAs Antwort ohne sichtbare User-Nachricht.
-                return capMessages([...prev, {
-                  id: nextId(),
-                  sender: 'user',
-                  text: newText,
-                  timestamp: message.timestamp,
-                  attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
-                }]);
-              }
-              const next = prev.slice();
-              next[idx] = { ...next[idx], text: newText };
-              return next;
-            });
+            setMessages(prev => prev.map(m =>
+              m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
+                ? { ...m, text: `\uD83C\uDFA4 ${sttText}` }
+                : m
+            ));
          }
          return;
        }
@ -357,10 +316,6 @@ 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 = 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) || '';
@ -613,8 +568,6 @@ 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,
@ -646,8 +599,6 @@ const ChatScreen: React.FC = () => {
      base64: result.base64,
      durationMs: result.durationMs,
      mimeType: result.mimeType,
-      voice: localXttsVoiceRef.current,
-      speed: ttsSpeedRef.current,
      ...(location && { location }),
    });
  }, [getCurrentLocation]);
@ -1045,10 +996,7 @@ const ChatScreen: React.FC = () => {
              style={[styles.wakeWordBtn, wakeWordActive && styles.wakeWordBtnActive]}
              onPress={toggleWakeWord}
            >
-              <Text style={styles.wakeWordIcon}>
-                {wakeWordState === 'conversing' ? '🎙️' :
-                 wakeWordState === 'armed' ? '👂' : '🔇'}
-              </Text>
+              <Text style={styles.wakeWordIcon}>{wakeWordActive ? '👂' : '🔇'}</Text>
            </TouchableOpacity>
          </>
        )}
--- a/android/src/screens/SettingsScreen.tsx
+++ b/android/src/screens/SettingsScreen.tsx
@ -41,9 +41,9 @@ import {
  TTS_SPEED_STORAGE_KEY,
 } from '../services/audio';
 import wakeWordService, {
-  WAKE_KEYWORDS,
-  KEYWORD_LABELS,
+  BUILTIN_KEYWORDS,
  DEFAULT_KEYWORD,
+  WAKE_ACCESS_KEY_STORAGE,
  WAKE_KEYWORD_STORAGE,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
@ -103,6 +103,8 @@ const SettingsScreen: React.FC = () => {
  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);
@ -162,8 +164,11 @@ const SettingsScreen: React.FC = () => {
        if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) setTtsSpeed(n);
      }
    });
+    AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE).then(saved => {
+      if (saved) setWakeAccessKey(saved);
+    });
    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 +678,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,
-          kein Cloud-Roundtrip — Audio verlaesst das Geraet nicht. Wenn das Ohr
-          aktiv ist, hoerst du normal mit; sagst du das Wake-Word, startet eine
-          Konversation mit ARIA.
+          Wenn ein Picovoice-Access-Key eingetragen ist, hoert die App passiv
+          auf das gewaehlte Wake-Word — du kannst dich mit anderen unterhalten,
+          Musik laufen lassen und mit "{wakeKeyword}" eine Konversation mit
+          ARIA starten. Ohne Key oder bei Fehlschlag startet das Ohr direkt
+          eine Konversation (klassischer Modus).
        </Text>

+        <Text style={[styles.toggleLabel, {marginTop: 16}]}>Picovoice Access Key</Text>
+        <View style={{flexDirection: 'row', alignItems: 'center', gap: 8, marginTop: 6}}>
+          <TextInput
+            style={[styles.input, {flex: 1}]}
+            value={wakeAccessKey}
+            onChangeText={setWakeAccessKey}
+            placeholder="kostenlos auf console.picovoice.ai"
+            placeholderTextColor="#666680"
+            secureTextEntry={!wakeAccessKeyVisible}
+            autoCapitalize="none"
+            autoCorrect={false}
+          />
+          <TouchableOpacity
+            onPress={() => setWakeAccessKeyVisible(v => !v)}
+            style={{padding: 8}}
+          >
+            <Text style={{fontSize: 18}}>{wakeAccessKeyVisible ? '🙈' : '👁'}</Text>
+          </TouchableOpacity>
+        </View>
+
        <Text style={[styles.toggleLabel, {marginTop: 16}]}>Wake-Word</Text>
        <Text style={styles.toggleHint}>
-          Eigene Wake-Words via openWakeWord-Notebook trainierbar (gratis).
-          Custom-Upload ueber Diagnostic kommt in einer spaeteren Version.
+          Built-In: sofort verwendbar. "ARIA" als Custom-Keyword kommt spaeter
+          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 +728,7 @@ const SettingsScreen: React.FC = () => {
                styles.keywordChipText,
                wakeKeyword === kw && styles.keywordChipTextActive,
              ]}>
-                {KEYWORD_LABELS[kw]}
+                {kw}
              </Text>
            </TouchableOpacity>
          ))}
@ -714,8 +740,8 @@ const SettingsScreen: React.FC = () => {
            onPress={async () => {
              setWakeStatus('Initialisiere...');
              try {
-                const ok = await wakeWordService.configure(wakeKeyword);
-                setWakeStatus(ok ? `✅ "${KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS]}" bereit` : '❌ Init-Fehler — Logs pruefen');
+                const ok = await wakeWordService.configure(wakeAccessKey, wakeKeyword);
+                setWakeStatus(ok ? `✅ "${wakeKeyword}" bereit` : '❌ Fehlgeschlagen — Access Key pruefen');
              } catch (err: any) {
                setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
              }
--- a/android/src/services/audio.ts
+++ b/android/src/services/audio.ts
@ -95,8 +95,8 @@ 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_MIN = 0.5;
+export const TTS_SPEED_MAX = 2.0;
 export const TTS_SPEED_STORAGE_KEY = 'aria_tts_speed';

 export async function loadTtsSpeed(): Promise<number> {
@ -143,7 +143,7 @@ const MAX_RECORDING_MS = 120000;
 // Pre-Roll: Wie lange Audio im AudioTrack-Buffer liegt bevor play() startet.
 // Einstellbar via Diagnostic/Settings (Key: aria_tts_preroll_sec).
 export const TTS_PREROLL_DEFAULT_SEC = 3.5;
-export const TTS_PREROLL_MIN_SEC = 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,26 +191,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;
-
-  // Conversation-Mode: solange aktiv (Wake-Word Status 'conversing' ODER
-  // wir wissen "ARIA spricht gerade in einem Multi-Turn-Dialog"), halten wir
-  // den AudioFocus DAUERHAFT. Der per-Stream-Release wird unterdrueckt,
-  // damit Spotify nicht in Render-Pausen oder zwischen Antworten zurueckkehrt.
-  private _conversationFocusActive: boolean = false;
-
  // 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() {
@ -218,58 +203,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.
-   *  Im Conversation-Mode (Wake-Word conversing) wird das Release komplett
-   *  unterdrueckt — der Focus bleibt fuer die ganze Konversation gehalten. */
-  private _releaseFocusDeferred(): void {
-    if (this._conversationFocusActive) {
-      this._cancelDeferredFocusRelease();
-      return;
-    }
-    this._cancelDeferredFocusRelease();
-    this.focusReleaseTimer = setTimeout(() => {
-      this.focusReleaseTimer = null;
-      if (this._conversationFocusActive) return;
-      AudioFocus?.release().catch(() => {});
-    }, this.FOCUS_RELEASE_DELAY_MS);
-  }
-
-  private _cancelDeferredFocusRelease(): void {
-    if (this.focusReleaseTimer) {
-      clearTimeout(this.focusReleaseTimer);
-      this.focusReleaseTimer = null;
-    }
-  }
-
-  /** Conversation-Mode beginnt → AudioFocus dauerhaft halten (Spotify bleibt
-   *  pausiert). Idempotent: mehrfaches Aufrufen ist sicher. */
-  acquireConversationFocus(): void {
-    if (this._conversationFocusActive) return;
-    this._conversationFocusActive = true;
-    this._cancelDeferredFocusRelease();
-    console.log('[Audio] Conversation-Focus aktiv (Spotify bleibt gepaust)');
-    AudioFocus?.requestDuck().catch(() => {});
-  }
-
-  /** Conversation-Mode endet → Focus darf wieder freigegeben werden
-   *  (verzoegert, damit eine direkt folgende Antwort nichts kaputtmacht). */
-  releaseConversationFocus(): void {
-    if (!this._conversationFocusActive) return;
-    this._conversationFocusActive = false;
-    console.log('[Audio] Conversation-Focus inaktiv');
-    this._releaseFocusDeferred();
-  }
-
-  /** TTS-Wiedergabe haart stoppen — z.B. wenn ein Anruf reinkommt.
-   *  Released auch sofort den AudioFocus damit der Anruf-Klingelton hoerbar ist. */
-  haltAllPlayback(reason: string = ''): void {
-    console.log('[Audio] haltAllPlayback: %s', reason || '(no reason)');
-    this._conversationFocusActive = false;
-    this.stopPlayback();
-  }
-
  // --- Berechtigungen ---

  async requestMicrophonePermission(): Promise<boolean> {
@ -370,50 +303,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).
-      // 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.
+      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar)
      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',
-                    vadSilenceMs, MAX_RECORDING_MS);
+        console.log('[Audio] VAD-Stille:', vadSilenceMs, '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);
      }
@ -453,9 +371,8 @@ class AudioService {
      await this.recorder.stopRecorder();
      this.recorder.removeRecordBackListener();

-      // Audio-Focus verzoegert freigeben — gleich kommt die TTS-Antwort,
-      // im Gap soll Spotify nicht hochkommen.
-      this._releaseFocusDeferred();
+      // Audio-Focus freigeben — andere Apps duerfen wieder
+      AudioFocus?.release().catch(() => {});

      const durationMs = Date.now() - this.recordingStartTime;
      const hadSpeech = this.speechDetected;
@ -527,13 +444,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.
-   *
-   *  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();
+   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached. */
  async handlePcmChunk(payload: {
    base64: string;
    sampleRate?: number;
@ -542,37 +453,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;
@ -602,7 +488,6 @@ class AudioService {
          this.pcmStreamActive = false;
          return '';
        }
-        this._cancelDeferredFocusRelease();
        AudioFocus?.requestDuck().catch(() => {});
      }
    }
@ -621,12 +506,11 @@ class AudioService {
    if (isFinal) {
      if (!silent) {
        // end() resolved jetzt erst wenn der native Writer-Thread fertig
-        // ist (alle Samples ausgespielt) — danach AudioFocus verzoegert
-        // freigeben, damit Spotify/YouTube nicht im Mikro-Gap zwischen zwei
-        // ARIA-Antworten wieder hochdrehen. Wenn ein neuer Stream innerhalb
-        // FOCUS_RELEASE_DELAY_MS startet, wird das Release abgebrochen.
+        // ist (alle Samples ausgespielt) — danach erst AudioFocus freigeben,
+        // damit Spotify/YouTube nicht waehrend des Pre-Roll-Ausklangs
+        // wieder aufdrehen.
        try { await PcmStreamPlayer!.end(); } catch {}
-        this._releaseFocusDeferred();
+        AudioFocus?.release().catch(() => {});
      }
      this.pcmStreamActive = false;

@ -730,9 +614,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,
-      // bleibt Spotify pausiert.
-      this._releaseFocusDeferred();
+      // Audio-Focus abgeben → andere Apps volle Lautstaerke
+      AudioFocus?.release().catch(() => {});
      // Alle Audio-Teile abgespielt → Listener benachrichtigen
      this.playbackFinishedListeners.forEach(cb => cb());
      return;
@ -740,7 +623,6 @@ class AudioService {

    // Beim ersten Playback-Start: andere Apps ducken
    if (!this.isPlaying) {
-      this._cancelDeferredFocusRelease();
      AudioFocus?.requestDuck().catch(() => {});
    }
    this.isPlaying = true;
@ -826,8 +708,7 @@ class AudioService {
      this.pcmBytesCollected = 0;
      this.pcmMessageId = '';
    }
-    // Audio-Focus sofort freigeben — User hat explizit abgebrochen
-    this._cancelDeferredFocusRelease();
+    // Audio-Focus freigeben
    AudioFocus?.release().catch(() => {});
  }

--- a/android/src/services/phoneCall.ts
+++ b/android/src/services/phoneCall.ts
@ -1,108 +0,0 @@
-/**
- * PhoneCall-Service — pausiert die TTS-Wiedergabe wenn das Telefon klingelt
- * oder ein Anruf laeuft. Native-Bindung an PhoneCallModule.kt.
- *
- * Bei "ringing" oder "offhook" wird audioService.haltAllPlayback() gerufen —
- * ARIA verstummt sofort. Nach dem Auflegen passiert nichts automatisch
- * (Audio kommt nicht zurueck), der User muesste die Antwort manuell
- * nochmal anfordern (Play-Button auf der Nachricht).
- *
- * Permission READ_PHONE_STATE muss vom Nutzer einmalig erteilt werden —
- * wenn nicht, failed start() leise und der Rest funktioniert wie bisher.
- */
-
-import {
-  NativeEventEmitter,
-  NativeModules,
-  PermissionsAndroid,
-  Platform,
-  ToastAndroid,
-} from 'react-native';
-import audioService from './audio';
-
-interface PhoneCallNative {
-  start(): Promise<boolean>;
-  stop(): Promise<boolean>;
-}
-
-const { PhoneCall } = NativeModules as { PhoneCall?: PhoneCallNative };
-
-type PhoneState = 'idle' | 'ringing' | 'offhook';
-
-class PhoneCallService {
-  private started: boolean = false;
-  private subscription: { remove: () => void } | null = null;
-  private lastState: PhoneState = 'idle';
-
-  async start(): Promise<boolean> {
-    if (this.started || !PhoneCall) return false;
-    if (Platform.OS !== 'android') return false;
-
-    // Runtime-Permission holen (nur einmal noetig)
-    try {
-      const granted = await PermissionsAndroid.request(
-        PermissionsAndroid.PERMISSIONS.READ_PHONE_STATE,
-        {
-          title: 'ARIA Cockpit — Anruf-Erkennung',
-          message: 'Damit ARIA bei einem eingehenden Anruf nicht weiterredet, '
-            + 'darf die App den Anruf-Status sehen (Klingeln/Aktiv/Aufgelegt). '
-            + 'Es werden keine Anrufdaten gelesen oder gespeichert.',
-          buttonPositive: 'Erlauben',
-          buttonNegative: 'Spaeter',
-        },
-      );
-      if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
-        console.warn('[PhoneCall] READ_PHONE_STATE Permission abgelehnt');
-        return false;
-      }
-    } catch (err) {
-      console.warn('[PhoneCall] Permission-Anfrage gescheitert', err);
-    }
-
-    try {
-      const ok = await PhoneCall.start();
-      if (!ok) {
-        console.warn('[PhoneCall] Native start() lieferte false (Permission?)');
-        return false;
-      }
-      const emitter = new NativeEventEmitter(NativeModules.PhoneCall as any);
-      this.subscription = emitter.addListener('PhoneCallStateChanged', (e: { state: PhoneState }) => {
-        this._onStateChanged(e.state);
-      });
-      this.started = true;
-      console.log('[PhoneCall] Listener aktiv');
-      return true;
-    } catch (err: any) {
-      console.warn('[PhoneCall] start gescheitert:', err?.message || err);
-      return false;
-    }
-  }
-
-  async stop(): Promise<void> {
-    if (!this.started || !PhoneCall) return;
-    try {
-      this.subscription?.remove();
-      this.subscription = null;
-      await PhoneCall.stop();
-    } catch {}
-    this.started = false;
-    this.lastState = 'idle';
-  }
-
-  private _onStateChanged(state: PhoneState): void {
-    if (state === this.lastState) return;
-    console.log('[PhoneCall] State: %s → %s', this.lastState, state);
-    this.lastState = state;
-    if (state === 'ringing' || state === 'offhook') {
-      audioService.haltAllPlayback(`Telefon-State: ${state}`);
-      ToastAndroid.show(
-        state === 'ringing' ? 'Anruf — ARIA pausiert' : 'Im Gespraech — ARIA pausiert',
-        ToastAndroid.SHORT,
-      );
-    }
-    // idle: nichts automatisch — User soll nichts unbeabsichtigt re-triggern
-  }
-}
-
-const phoneCallService = new PhoneCallService();
-export default phoneCallService;
--- a/android/src/services/updater.ts
+++ b/android/src/services/updater.ts
@ -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');
--- a/android/src/services/wakeword.ts
+++ b/android/src/services/wakeword.ts
@ -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.
- *                Das Mikro ist von OpenWakeWord belegt; AudioRecorder ist aus.
- *   conversing — Wake-Word getriggert (oder Ohr-Tap manuell):
- *                aktive Konversation. OpenWakeWord pausiert (gibt Mikro frei),
+ *   armed      — Ohr aktiv, Porcupine hoert passiv auf das Wake-Word.
+ *                Das Mikro ist von Porcupine belegt; AudioRecorder ist aus.
+ *   conversing — Wake-Word getriggert (oder Ohr-Tap ohne Wake-Word):
+ *                aktive Konversation. Porcupine pausiert (gibt Mikro frei),
 *                AudioRecorder uebernimmt fuer die Aufnahme.
 *                Nach jeder ARIA-Antwort oeffnet das Mikro fuer X Sekunden
 *                (Conversation-Window). Stille im Fenster → zurueck zu armed.
 *
- * Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
- * 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
+ * Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
+ * 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,113 +23,105 @@ 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
- *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
- *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
- *  werden — Diagnostic-Upload ist Phase 2. */
-export const WAKE_KEYWORDS = [
-  'hey_jarvis',
+/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
+ *  Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
+ *  Console — wird spaeter ueber Diagnostic uploadbar. */
+export const BUILTIN_KEYWORDS = [
+  'jarvis',
  'computer',
+  'picovoice',
+  'porcupine',
+  'bumblebee',
+  'terminator',
  'alexa',
-  'hey_mycroft',
-  'hey_rhasspy',
+  'hey google',
+  'ok google',
+  'hey siri',
 ] as const;
-export type WakeKeyword = typeof WAKE_KEYWORDS[number];
-export const DEFAULT_KEYWORD: WakeKeyword = 'hey_jarvis';
-
-/** Hilfs-Mapping fuer die Anzeige im UI. */
-export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
-  hey_jarvis: 'Hey Jarvis',
-  computer: 'Computer',
-  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 };
+export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
+export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';

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

-  private keyword: WakeKeyword = DEFAULT_KEYWORD;
-  private nativeReady: boolean = false;
+  // Picovoice Manager (lazy, da Native Module nicht in jedem Build verfuegbar ist)
+  private porcupine: any = null;
+  private accessKey: string = '';
+  private keyword: string = DEFAULT_KEYWORD;
  private initInProgress: Promise<boolean> | null = null;
-  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.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
-      await this.initNative();
+      this.accessKey = (k || '').trim();
+      this.keyword = (w || DEFAULT_KEYWORD).trim();
+      if (this.accessKey) {
+        // Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
+        await this.initPorcupine();
+      }
    } catch (err) {
      console.warn('[WakeWord] loadFromStorage', err);
    }
  }

-  /** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
-  async configure(keyword: string): Promise<boolean> {
-    const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
-      ? (keyword as WakeKeyword)
-      : DEFAULT_KEYWORD;
-    this.keyword = next;
-    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, next);
+  /** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
+  async configure(accessKey: string, keyword: string): Promise<boolean> {
+    this.accessKey = (accessKey || '').trim();
+    this.keyword = (keyword || DEFAULT_KEYWORD).trim();
+    await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
+    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);

-    // Laufende Instanz stoppen + neu initialisieren
-    await this.disposeNative();
-    const ok = await this.initNative();
-    if (!ok) {
-      ToastAndroid.show(
-        `Wake-Word "${KEYWORD_LABELS[next]}" konnte nicht initialisiert werden — Logs pruefen`,
-        ToastAndroid.LONG,
-      );
-    }
-    return ok;
+    // Laufende Instanz stoppen
+    await this.disposePorcupine();
+    if (!this.accessKey) return false;
+
+    // Neu initialisieren
+    return this.initPorcupine();
  }

-  private async initNative(): Promise<boolean> {
-    if (!OpenWakeWord) {
-      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
-      this.nativeReady = false;
-      return false;
-    }
+  private async initPorcupine(): Promise<boolean> {
    if (this.initInProgress) return this.initInProgress;
    this.initInProgress = (async () => {
      try {
-        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
-        // Subscribe nur einmal
-        if (!this.eventSub) {
-          const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
-          this.eventSub = emitter.addListener('WakeWordDetected', () => {
-            console.log('[WakeWord] Native Detection-Event empfangen');
+        const porcupineRN = require('@picovoice/porcupine-react-native');
+        const { PorcupineManager, BuiltInKeywords } = porcupineRN;
+        // Manche Porcupine-Versionen wollen das BuiltInKeywords-Enum (Objekt
+        // mit keys wie JARVIS, COMPUTER, HEY_GOOGLE), andere akzeptieren
+        // den String direkt. Mappen mit Fallback auf String:
+        const enumKey = this.keyword.toUpperCase().replace(/\s+/g, '_');
+        const kw = (BuiltInKeywords && BuiltInKeywords[enumKey]) || this.keyword;
+        console.log('[WakeWord] Porcupine init: keyword=%s (resolved=%s)',
+                    this.keyword, typeof kw === 'string' ? kw : '[enum]');
+        this.porcupine = await PorcupineManager.fromBuiltInKeywords(
+          this.accessKey,
+          [kw],
+          (keywordIndex: number) => {
+            console.log('[WakeWord] Porcupine callback fired (index=%d)', keywordIndex);
            this.onWakeDetected().catch(err =>
              console.warn('[WakeWord] onWakeDetected crashed:', err));
-          });
-        }
-        this.nativeReady = true;
-        console.log('[WakeWord] Init OK (model=%s)', this.keyword);
+          },
+          // Error handler (wenn Porcupine im Background-Thread crashed,
+          // z.B. beim Audio-Engine-Konflikt mit audio-recorder-player)
+          (error: any) => {
+            console.warn('[WakeWord] Porcupine runtime error:', error?.message || error);
+            // Nicht in Loop crashen — state zurueck auf off damit der User
+            // mit dem Aufnahme-Button wieder normal arbeiten kann
+            this.setState('off');
+            this.disposePorcupine().catch(() => {});
+          },
+        );
+        console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
        return true;
-      } catch (err: any) {
-        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
-        this.nativeReady = false;
+      } catch (err) {
+        console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err);
+        this.porcupine = null;
        return false;
      } finally {
        this.initInProgress = null;
@ -143,39 +130,30 @@ class WakeWordService {
    return this.initInProgress;
  }

-  private async disposeNative(): Promise<void> {
-    if (!OpenWakeWord) return;
-    try { await OpenWakeWord.dispose(); } catch {}
-    this.nativeReady = false;
+  private async disposePorcupine() {
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
+      try { await this.porcupine.delete(); } catch {}
+      this.porcupine = null;
+    }
  }

  /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
  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();
-        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
-        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        await this.porcupine.start();
+        console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
        this.setState('armed');
        return true;
-      } catch (err: any) {
-        console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
-                     err?.message || err);
-        ToastAndroid.show(
-          `Wake-Word-Start failed: ${err?.message || err}`,
-          ToastAndroid.LONG,
-        );
+      } catch (err) {
+        console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:', err);
      }
-    } 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
-    console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
+    // Fallback: direkt in die Konversation
+    console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
    this.setState('conversing');
    setTimeout(() => {
      if (this.state === 'conversing') {
@ -188,20 +166,20 @@ class WakeWordService {
  /** Komplett ausschalten (Ohr abschalten) */
  async stop(): Promise<void> {
    console.log('[WakeWord] Ohr deaktiviert');
-    if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
+    if (this.porcupine) {
+      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.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
    }
    this.setState('conversing');
+    // kurz warten damit Mikrofon frei ist
    setTimeout(() => {
      if (this.state === 'conversing') {
        this.wakeCallbacks.forEach(cb => cb());
@ -210,16 +188,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) {
@ -227,7 +204,6 @@ class WakeWordService {
      }
    }
    console.log('[WakeWord] Konversation zu Ende — Ohr aus');
-    ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
    this.setState('off');
  }

@ -252,10 +228,10 @@ class WakeWordService {
  }

  hasWakeWord(): boolean {
-    return this.nativeReady;
+    return !!this.porcupine;
  }

-  getKeyword(): WakeKeyword {
+  getKeyword(): string {
    return this.keyword;
  }

--- a/bridge/aria_bridge.py
+++ b/bridge/aria_bridge.py
@ -551,15 +551,6 @@ class ARIABridge:
        # 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
-        # Pending Files: wenn die App ein Bild + Text gleichzeitig schickt, kommen
-        # zwei separate RVS-Events ('file' und 'chat') — wir buffern die Files
-        # kurz und mergen sie mit dem nachfolgenden Chat-Text zu einer einzigen
-        # Anfrage an aria-core. Sonst antwortet ARIA zweimal (einmal "warte auf
-        # Anweisung" beim file, einmal auf den Chat-Text).
-        # Liste von Tuples: (file_path, name, file_type, size_kb, width, height)
-        self._pending_files: list[tuple[str, str, str, int, int, int]] = []
-        self._pending_files_flush_task: Optional[asyncio.Task] = None
-        self._PENDING_FILES_WINDOW_SEC: float = 0.8

    def initialize(self) -> None:
        """Initialisiert alle Komponenten.
@ -916,13 +907,18 @@ class ARIABridge:
            logger.info("[core] TTS unterdrueckt (Modus: %s)", self.current_mode.config.name)
            return

-        # Voice bestimmen: App-Override (gesetzt durch letzten chat-Event) > globale
-        # Default-Voice. Der Override wird NICHT pro Antwort verbraucht — sonst nutzt
-        # eine Multi-Turn-Antwort von ARIA (Tool-Use + finale Antwort) ab dem zweiten
-        # TTS-Call wieder die alte Default-Stimme. Der Override bleibt gueltig bis
-        # zum naechsten chat-Event, wo er entweder ueberschrieben oder geloescht wird.
+        # Voice bestimmen: App-Override fuer diesen Request > globale Default-Voice
        xtts_voice = self._next_voice_override or getattr(self, 'xtts_voice', '')
+        # Override verbrauchen (gilt nur fuer genau diese naechste Antwort)
+        if self._next_voice_override:
+            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:
@ -946,8 +942,7 @@ class ARIABridge:
                },
                "timestamp": int(asyncio.get_event_loop().time() * 1000),
            })
-            logger.info("[core] XTTS-Request gesendet (voice=%s, speed=%.2fx): '%s'",
-                        xtts_voice or "default", xtts_speed, tts_text[:60])
+            logger.info("[core] XTTS-Request gesendet (%s): '%s'", xtts_voice or "default", tts_text[:60])
        except Exception as e:
            logger.error("[core] XTTS-Request fehlgeschlagen: %s — kein Audio", e)

@ -1028,51 +1023,6 @@ class ARIABridge:
        except Exception as e:
            logger.debug("[session] Diagnostic nicht erreichbar (%s) — nutze '%s'", e, self._session_key)

-    def _build_pending_files_message(self, user_text: str) -> str:
-        """Baut eine Anweisung an aria-core aus den gepufferten Files + optionalem
-        User-Text. user_text leer → 'warte auf Anweisung'-Variante."""
-        parts: list[str] = []
-        for fp, name, ftype, kb, w, h in self._pending_files:
-            dim = f" {w}x{h}px" if (w and h) else ""
-            kind = "Bild" if ftype.startswith("image/") else "Datei"
-            parts.append(f"- {kind}: {name}{dim} ({ftype}, {kb}KB) liegt unter {fp}")
-        files_summary = "\n".join(parts)
-        n = len(self._pending_files)
-        anhang = "Anhang" if n == 1 else "Anhaenge"
-        if user_text:
-            return (f"Stefan hat dir {n} {anhang} geschickt:\n{files_summary}\n\n"
-                    f"Er sagt dazu: \"{user_text}\"")
-        return (f"Stefan hat dir {n} {anhang} geschickt:\n{files_summary}\n\n"
-                f"Warte auf seine Anweisung was du damit tun sollst.")
-
-    async def _flush_pending_files_after(self, delay: float) -> None:
-        """Wenn nach `delay`s kein chat-Text gekommen ist: Files alleine an
-        aria-core senden ('warte auf Anweisung'-Variante)."""
-        try:
-            await asyncio.sleep(delay)
-        except asyncio.CancelledError:
-            return
-        if not self._pending_files:
-            return
-        text = self._build_pending_files_message("")
-        self._pending_files = []
-        self._pending_files_flush_task = None
-        await self.send_to_core(text, source="app-file")
-
-    async def _flush_pending_files_with_text(self, user_text: str) -> bool:
-        """Wenn ein chat-Text reinkommt waehrend Files gepuffert sind:
-        Files + Text zu einer einzigen aria-core-Nachricht mergen.
-        Returns True wenn gemerged wurde (Caller soll dann nicht nochmal senden)."""
-        if not self._pending_files:
-            return False
-        if self._pending_files_flush_task and not self._pending_files_flush_task.done():
-            self._pending_files_flush_task.cancel()
-        self._pending_files_flush_task = None
-        text = self._build_pending_files_message(user_text)
-        self._pending_files = []
-        await self.send_to_core(text, source="app-file+chat")
-        return True
-
    async def send_to_core(self, text: str, source: str = "bridge") -> None:
        """Sendet Text an aria-core (OpenClaw chat.send Protokoll)."""
        if self.ws_core is None:
@ -1218,32 +1168,21 @@ class ARIABridge:
            if sender in ("aria", "stt"):
                return
            text = payload.get("text", "")
-            # Voice-Override fuer Folgenachrichten setzen — gilt bis zum naechsten
-            # chat-Event. Leerer String "" = explizit Default-Voice (override loeschen).
-            # Field nicht gesendet = vorherigen Override unveraendert lassen (z.B. wenn
-            # cancel_request oder anderer Service die App umgeht).
-            if "voice" in payload:
-                voice_override = payload.get("voice", "") or ""
-                self._next_voice_override = voice_override or None
-                logger.info("[rvs] Voice fuer Antworten: %s",
-                            self._next_voice_override or "(Default)")
+            # Voice-Override fuer die naechste ARIA-Antwort merken
+            voice_override = payload.get("voice", "")
+            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)
-            if "speed" in payload:
-                try:
-                    speed = float(payload.get("speed", 0) or 0)
-                    self._next_speed_override = speed if 0.1 <= speed <= 5.0 else None
-                except (TypeError, ValueError):
-                    self._next_speed_override = None
+            try:
+                speed = float(payload.get("speed", 0) or 0)
+                if 0.25 <= speed <= 4.0:
+                    self._next_speed_override = speed
+            except (TypeError, ValueError):
+                pass
            if text:
-                # Wenn Files gerade gepuffert sind (Bild + Text gleichzeitig
-                # gesendet), mergen wir sie zu einer einzigen Anfrage statt
-                # zwei separater send_to_core-Calls.
-                merged = await self._flush_pending_files_with_text(text)
-                if merged:
-                    logger.info("[rvs] App-Chat (mit Anhaengen): '%s'", text[:80])
-                else:
-                    logger.info("[rvs] App-Chat: '%s'", text[:80])
-                    await self.send_to_core(text, source="app")
+                logger.info("[rvs] App-Chat: '%s'", text[:80])
+                await self.send_to_core(text, source="app")
            return

        if msg_type == "cancel_request":
@ -1297,7 +1236,7 @@ class ARIABridge:
            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):
+                if not (0.25 <= xtts_speed <= 4.0):
                    xtts_speed = 1.0
            except (TypeError, ValueError):
                xtts_speed = 1.0
@ -1402,54 +1341,70 @@ class ARIABridge:
                await self.ws_core.send(raw_message)

        elif msg_type == "file":
-            # Datei von der App: speichern + zu Pending-Queue hinzufuegen.
-            # Wird mit dem nachfolgenden chat-Event (innerhalb PENDING_FILES_WINDOW)
-            # zu einer einzigen aria-core-Anfrage gemerged. Sonst antwortet ARIA
-            # zweimal: einmal "warte auf Anweisung" beim file, einmal auf den Chat.
+            # Datei von der App → als Text-Nachricht an aria-core
            file_name = payload.get("name", "unbekannt")
            file_type = payload.get("type", "")
            file_b64 = payload.get("base64", "")
+            file_size = payload.get("size", 0)
            width = payload.get("width", 0)
            height = payload.get("height", 0)
            logger.info("[rvs] Datei empfangen: %s (%s, %dKB)",
                        file_name, file_type, len(file_b64) // 1365 if file_b64 else 0)

+            # Shared Volume: /shared/ ist in Bridge UND aria-core gemountet
            SHARED_DIR = "/shared/uploads"
            os.makedirs(SHARED_DIR, exist_ok=True)

-            if not file_b64:
-                text = f"Stefan hat eine Datei gesendet ({file_name}, {file_type}) aber die Daten sind leer angekommen."
-                await self.send_to_core(text, source="app-file")
-                return
-
-            if file_type.startswith("image/"):
+            if file_b64 and file_type.startswith("image/"):
+                # Bild in Shared Volume speichern
                ext = ".jpg" if "jpeg" in file_type or "jpg" in file_type else ".png"
                safe_name = f"img_{int(asyncio.get_event_loop().time())}_{file_name.replace('/', '_')}"
                file_path = os.path.join(SHARED_DIR, safe_name if safe_name.endswith(ext) else safe_name + ext)
-            else:
+                with open(file_path, "wb") as f:
+                    f.write(base64.b64decode(file_b64))
+                size_kb = len(file_b64) // 1365
+                logger.info("[rvs] Bild gespeichert: %s (%dKB)", file_path, size_kb)
+                # ERST an aria-core senden (wichtigster Schritt)
+                text = (f"Stefan hat dir ein Bild geschickt: {file_name}"
+                        f"{f' ({width}x{height}px)' if width else ''}"
+                        f", {size_kb}KB."
+                        f" Das Bild liegt unter: {file_path}"
+                        f" Warte auf Stefans Anweisung was du damit tun sollst.")
+                await self.send_to_core(text, source="app-file")
+                # Dann App informieren (optional, darf nicht crashen)
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
+            elif file_b64:
+                # Andere Datei in Shared Volume speichern
                safe_name = f"file_{int(asyncio.get_event_loop().time())}_{file_name.replace('/', '_')}"
                file_path = os.path.join(SHARED_DIR, safe_name)
-            with open(file_path, "wb") as f:
-                f.write(base64.b64decode(file_b64))
-            size_kb = len(file_b64) // 1365
-            logger.info("[rvs] Datei gespeichert: %s (%dKB)", file_path, size_kb)
-
-            # In Pending-Queue + Flush-Timer (anti-spam Buffering)
-            self._pending_files.append((file_path, file_name, file_type, size_kb, int(width or 0), int(height or 0)))
-            if self._pending_files_flush_task and not self._pending_files_flush_task.done():
-                self._pending_files_flush_task.cancel()
-            self._pending_files_flush_task = asyncio.create_task(
-                self._flush_pending_files_after(self._PENDING_FILES_WINDOW_SEC)
-            )
-
-            try:
-                await self._send_to_rvs({
-                    "type": "file_saved",
-                    "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                })
-            except Exception as e:
-                logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
+                with open(file_path, "wb") as f:
+                    f.write(base64.b64decode(file_b64))
+                size_kb = len(file_b64) // 1365
+                logger.info("[rvs] Datei gespeichert: %s (%dKB)", file_path, size_kb)
+                # ERST an aria-core senden
+                text = (f"Stefan hat dir eine Datei geschickt: {file_name}"
+                        f" ({file_type}, {size_kb}KB)."
+                        f" Die Datei liegt unter: {file_path}"
+                        f" Warte auf Stefans Anweisung was du damit tun sollst.")
+                await self.send_to_core(text, source="app-file")
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
+            else:
+                text = f"Stefan hat eine Datei gesendet ({file_name}, {file_type}) aber die Daten sind leer angekommen."
+                await self.send_to_core(text, source="app-file")

        elif msg_type == "file_request":
            # App fordert eine Datei an (Re-Download nach Cache-Leerung)
@ -1488,18 +1443,17 @@ class ARIABridge:
            if not audio_b64:
                logger.warning("[rvs] Audio ohne Daten empfangen")
                return
-            # Voice-Override fuer Folgenachrichten — gleiche Semantik wie beim chat-Event.
-            if "voice" in payload:
-                voice_override = payload.get("voice", "") or ""
-                self._next_voice_override = voice_override or None
-                logger.info("[rvs] Voice fuer Antworten (via Audio): %s",
-                            self._next_voice_override or "(Default)")
-            if "speed" in payload:
-                try:
-                    speed = float(payload.get("speed", 0) or 0)
-                    self._next_speed_override = speed if 0.1 <= speed <= 5.0 else None
-                except (TypeError, ValueError):
-                    self._next_speed_override = None
+            # Voice-Override fuer die kommende ARIA-Antwort (App-lokal gewaehlt)
+            voice_override = payload.get("voice", "")
+            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.25 <= speed <= 4.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))
--- a/diagnostic/index.html
+++ b/diagnostic/index.html
@ -145,15 +145,6 @@
      </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
@ -1639,29 +1630,10 @@

    // ── 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;
@ -1686,12 +1658,7 @@
      }
      document.getElementById('voice-preview-status').textContent = '⏳ Rendere...';
      document.getElementById('voice-preview-play').disabled = true;
-      send({
-        action: 'preview_voice',
-        voice: currentPreviewVoice,
-        text,
-        speed: currentPreviewSpeed,
-      });
+      send({ action: 'preview_voice', voice: currentPreviewVoice, text });
    }

    function deleteXttsVoice(name) {
--- a/diagnostic/server.js
+++ b/diagnostic/server.js
@ -1469,7 +1469,7 @@ wss.on("connection", (ws) => {
      } 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);
+        handleVoicePreview(ws, msg.voice || "", msg.text || "Hallo.");
      } else if (msg.action === "check_tts") {
        handleCheckTTS(ws);
      } else if (msg.action === "check_desktop") {
@ -1704,11 +1704,8 @@ function _handlePreviewChunk(payload) {
  }
 }

-async function handleVoicePreview(clientWs, voice, text, speed) {
+async function handleVoicePreview(clientWs, voice, text) {
  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
@ -1723,10 +1720,10 @@ async function handleVoicePreview(clientWs, voice, text, speed) {
        }
      }
    }, 60000);
-    log("info", "server", `Voice-Preview: voice="${voice}" speed=${spd.toFixed(1)}x text="${text.slice(0, 60)}"`);
+    log("info", "server", `Voice-Preview: voice="${voice}" text="${text.slice(0, 60)}"`);
    sendToRVS_raw({
      type: "xtts_request",
-      payload: { text, language: "de", requestId, voice, speed: spd },
+      payload: { text, language: "de", requestId, voice, speed: 1.0 },
      timestamp: Date.now(),
    });
  } catch (err) {
--- a/xtts/f5tts/bridge.py
+++ b/xtts/f5tts/bridge.py
@ -239,8 +239,6 @@ class F5Runner:

    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str,
                        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,
@ -509,8 +507,7 @@ 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)",
-                len(sentences), voice or "default", speed, ref_wav_str)
+    logger.info("F5-TTS: %d Satz(e), voice=%s (%s)", len(sentences), voice or "default", ref_wav_str)

    chunk_index = 0
    pcm_sr = TARGET_SR
@ -765,7 +762,7 @@ async def run_loop(runner: F5Runner) -> None:
                                speed = float(payload.get("speed") or 1.0)
                            except (TypeError, ValueError):
                                speed = 1.0
-                            if not (0.1 <= speed <= 5.0):
+                            if not (0.25 <= speed <= 4.0):
                                speed = 1.0
                            await _tts_queue.put((
                                payload.get("text", ""),