release: bump version to 0.0.7.8

Bug: Wenn eine Aufnahme leer war, nur Wake-Word-Echo enthielt oder STT
sonstwie nichts erkannt hat, sendet die Bridge KEIN stt-Event zurueck —
die Placeholder-Bubble "Spracheingabe wird verarbeitet" blieb fuer immer
im Chat. Folge-Aufnahmen matchten dann via Substring-Fallback die ALTE
Placeholder, der echte Text landete in der falschen Bubble.

Fix: nach jedem audio-send einen 30s-Timer starten. Wenn nach Ablauf die
Bubble (per audioRequestId identifiziert) immer noch "verarbeitet" ist,
wird sie entfernt + Toast "nicht erkannt" zeigt das dem User.

So bleibt der State sauber + audioRequestId-Match auf zukuenftige
Aufnahmen findet die richtige Bubble (statt die hinterbliebene Placeholder).

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

README.md

@@ -378,9 +378,13 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 ### Features
 
 - Text-Chat mit ARIA
-- **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
+- **Sprachaufnahme**: Tap-to-Talk (tippen startet, tippen stoppt, Auto-Stop bei Stille via VAD)
 - **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
-- **VAD (Voice Activity Detection)**: Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme 120s.
+- **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)**: Adaptive Schwelle (Baseline aus ersten 500ms Mic-Pegel + 6dB Offset). Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme einstellbar (1–30 min, Default 5 min)
+- **Barge-In**: Wenn du waehrend ARIAs Antwort eine neue Sprach-/Text-Nachricht reinschickst, wird sie unterbrochen + bekommt den Hint "das ist eine Korrektur"
+- **Wake-Word waehrend TTS**: Du kannst "Computer" sagen waehrend ARIA noch redet — AcousticEchoCanceler verhindert dass ARIAs eigene Stimme das Wake-Word triggert
+- **Anruf-Pause**: TTS verstummt automatisch wenn das Telefon klingelt (READ_PHONE_STATE Permission)
 - **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.
 - **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
@@ -398,6 +402,45 @@ 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 🎙️, **Bereit-Sound** (Ding-Dong, optional in Settings) + Toast "🎤 sprich jetzt" sobald das Mikro wirklich offen ist
+- 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
@@ -744,8 +787,10 @@ 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 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.
+- **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.
 - **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.
@@ -798,8 +843,16 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] Whisper STT auf die Gamebox ausgelagert (CUDA float16, fast Echtzeit)
 - [x] **F5-TTS ersetzt XTTS** — bessere Voice-Cloning-Qualitaet, Whisper-auto-transkribierter Referenz-Text
 - [x] Audio-Pause statt Ducking (TRANSIENT statt MAY_DUCK) + release-Timing fix
-- [x] VAD-Stille-Toleranz und Max-Aufnahme einstellbar (1-8s, 120s)
+- [x] VAD-Stille-Toleranz einstellbar (1-8s) + adaptive Mikro-Baseline + Max-Aufnahme einstellbar (1-30 min)
+- [x] Barge-In: User kann ARIA waehrend Antwort unterbrechen, aria-core bekommt Kontext-Hint
+- [x] Anruf-Pause: TTS verstummt bei eingehendem Anruf (PhoneStateListener)
+- [x] Settings-Sub-Screens: 8 Kategorien statt langer Liste
+- [x] APK ABI-Split arm64-v8a: 35 MB statt 136 MB
+- [x] Sprachnachrichten-Bubble: audioRequestId statt Substring-Match — keine vertauschten Bubbles mehr bei parallelen Aufnahmen
+- [x] Bereit-Sound (Airplane Ding-Dong) wenn Mikro nach Wake-Word offen ist — akustische Bestaetigung, in Settings abschaltbar
+- [x] Wake-Word parallel zu TTS mit AcousticEchoCanceler — "Computer" sagen waehrend ARIA spricht stoppt sie und oeffnet Mikro
 - [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
 
@@ -815,5 +868,5 @@ docker exec aria-core ssh aria-wohnung hostname
 - [ ] STARFACE Telefonie-Skill
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
-- [ ] Porcupine Wake Word (on-device "ARIA" in der App)
+- [ ] Custom-`.onnx`-Upload fuer Wake-Word ueber Diagnostic (ohne App-Rebuild)
 - [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 509
-        versionName "0.0.5.9"
+        versionCode 708
+        versionName "0.0.7.8"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }
@@ -104,6 +104,19 @@ 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 {
@@ -111,6 +124,9 @@ 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 {

android/android/app/src/main/AndroidManifest.xml

@@ -4,6 +4,8 @@
     <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"

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

@@ -21,6 +21,8 @@ class MainApplication : Application(), ReactApplication {
               add(ApkInstallerPackage())
               add(AudioFocusPackage())
               add(PcmStreamPlayerPackage())
+              add(OpenWakeWordPackage())
+              add(PhoneCallPackage())
             }
 
         override fun getJSMainModuleName(): String = "index"

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

@@ -0,0 +1,413 @@
+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.media.audiofx.AcousticEchoCanceler
+import android.media.audiofx.AutomaticGainControl
+import android.media.audiofx.NoiseSuppressor
+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
+
+    // Audio-Effects: Echo-Cancellation (gegen ARIAs eigene TTS-Stimme die sonst
+    // das Wake-Word triggern wuerde) + Noise-Suppression. Per VOICE_COMMUNICATION
+    // Audio-Source schon vorhanden, aber explizites Aktivieren ist robuster.
+    private var aec: AcousticEchoCanceler? = null
+    private var ns: NoiseSuppressor? = null
+    private var agc: AutomaticGainControl? = 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)
+
+            // VOICE_COMMUNICATION-Source: aktiviert auf den meisten Android-Geraeten
+            // automatisch Echo-Cancellation + Noise-Suppression. Wichtig damit
+            // ARIAs eigene Stimme nicht das Wake-Word triggert wenn parallel
+            // zur TTS-Wiedergabe gelauscht wird.
+            val record = AudioRecord(
+                MediaRecorder.AudioSource.VOICE_COMMUNICATION,
+                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
+
+            // Audio-Effects ZUSAETZLICH explizit aktivieren — manche Geraete
+            // benoetigen das, obwohl VOICE_COMMUNICATION es eigentlich schon
+            // mitbringt. Failure ist nicht kritisch (continue ohne Effects).
+            try {
+                if (AcousticEchoCanceler.isAvailable()) {
+                    aec = AcousticEchoCanceler.create(record.audioSessionId)?.apply { enabled = true }
+                    Log.i(TAG, "AEC aktiviert (enabled=${aec?.enabled})")
+                }
+            } catch (e: Exception) { Log.w(TAG, "AEC failed: ${e.message}") }
+            try {
+                if (NoiseSuppressor.isAvailable()) {
+                    ns = NoiseSuppressor.create(record.audioSessionId)?.apply { enabled = true }
+                }
+            } catch (e: Exception) { Log.w(TAG, "NS failed: ${e.message}") }
+            try {
+                if (AutomaticGainControl.isAvailable()) {
+                    agc = AutomaticGainControl.create(record.audioSessionId)?.apply { enabled = true }
+                }
+            } catch (e: Exception) { Log.w(TAG, "AGC failed: ${e.message}") }
+
+            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)
+        }
+    }
+
+    private fun releaseAudioEffects() {
+        try { aec?.release() } catch (_: Exception) {}
+        try { ns?.release() } catch (_: Exception) {}
+        try { agc?.release() } catch (_: Exception) {}
+        aec = null; ns = null; agc = null
+    }
+
+    @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
+        releaseAudioEffects()
+        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
+        releaseAudioEffects()
+        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
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+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()
+    }
+}

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

@@ -39,7 +39,10 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
         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.2
+        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
     }
 
     override fun getName() = "PcmStreamPlayer"
@@ -109,9 +112,9 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                 val t = track ?: return@Thread
                 try {
                     // Leading-Silence in den Buffer — gibt AudioTrack Zeit anzufahren.
-                    val silenceBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
-                    if (silenceBytes > 0) {
-                        val silence = ByteArray(silenceBytes)
+                    val leadingBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
+                    if (leadingBytes > 0) {
+                        val silence = ByteArray(leadingBytes)
                         var silOff = 0
                         while (silOff < silence.size && !writerShouldStop) {
                             val w = t.write(silence, silOff, silence.size - silOff)
@@ -120,8 +123,34 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         }
                         bytesBuffered += silence.size
                     }
-                    while (!writerShouldStop) {
-                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS) ?: run {
+                    // 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) {
                             if (endRequested) {
                                 // Falls wir vor Pre-Roll enden (kurzer Text): trotzdem abspielen
                                 if (!playbackStarted) {
@@ -133,10 +162,35 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                                         Log.w(TAG, "play() fallback failed: ${e.message}")
                                     }
                                 }
-                                return@Thread
+                                break@mainLoop
                             }
-                            null
-                        } ?: continue
+                            // 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
 
                         // Pre-Roll Check: play() erst wenn genug gepuffert
                         if (!playbackStarted && bytesBuffered + data.size >= prerollBytes) {
@@ -157,6 +211,19 @@ 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 {

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

@@ -0,0 +1,126 @@
+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) {}
+}

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

@@ -0,0 +1,16 @@
+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()
+    }
+}

android/build.sh

@@ -167,10 +167,23 @@ export CI=true
 
 if [ "$MODE" = "debug" ]; then
     ./gradlew assembleDebug
-    APK_PATH="app/build/outputs/apk/debug/app-debug.apk"
+    OUT_DIR="app/build/outputs/apk/debug"
 else
     ./gradlew assembleRelease
-    APK_PATH="app/build/outputs/apk/release/app-release.apk"
+    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
 fi
 
 cd ..

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.0.5.9",
+  "version": "0.0.7.8",
   "private": true,
   "scripts": {
     "android": "react-native run-android",
@@ -24,9 +24,7 @@
     "react-native-camera-kit": "^13.0.0",
     "@react-native-async-storage/async-storage": "^1.21.0",
     "react-native-fs": "^2.20.0",
-    "react-native-audio-recorder-player": "^3.6.7",
-    "@picovoice/porcupine-react-native": "3.0.5",
-    "@picovoice/react-native-voice-processor": "1.2.3"
+    "react-native-audio-recorder-player": "^3.6.7"
   },
   "devDependencies": {
     "typescript": "^5.3.3",

android/src/components/MessageText.tsx

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

android/src/components/VoiceButton.tsx

@@ -44,7 +44,6 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
   const [meterDb, setMeterDb] = useState(-160);
   const pulseAnim = useRef(new Animated.Value(1)).current;
   const durationTimer = useRef<ReturnType<typeof setInterval> | null>(null);
-  const isLongPress = useRef(false);
 
   // Puls-Animation starten/stoppen
   useEffect(() => {
@@ -117,31 +116,10 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     if (disabled || isRecording) return;
     const started = await audioService.startRecording(true); // autoStop = true
     if (started) {
-      isLongPress.current = false;
       setIsRecording(true);
     }
   }, [disabled, isRecording]);
 
-  // Push-to-Talk: Lang druecken
-  const handlePressIn = async () => {
-    if (disabled || isRecording) return;
-    isLongPress.current = true;
-    const started = await audioService.startRecording(false); // kein autoStop
-    if (started) {
-      setIsRecording(true);
-    }
-  };
-
-  const handlePressOut = async () => {
-    if (!isRecording || !isLongPress.current) return;
-    isLongPress.current = false;
-    setIsRecording(false);
-    const result = await audioService.stopRecording();
-    if (result && result.durationMs > 300) {
-      onRecordingComplete(result);
-    }
-  };
-
   // Tap-to-Talk: Einmal tippen startet mit Auto-Stop.
   // Guard gegen Doppel-Tap während asyncer Start/Stop.
   const tapBusy = useRef(false);
@@ -162,7 +140,6 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
         // Aufnahme mit Auto-Stop starten
         const started = await audioService.startRecording(true);
         if (started) {
-          isLongPress.current = false;
           setIsRecording(true);
         }
       }
@@ -201,10 +178,6 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
           isRecording && styles.buttonOuterRecording,
           { transform: [{ scale: pulseAnim }] },
         ]}
-        onStartShouldSetResponder={() => true}
-        onResponderGrant={handlePressIn}
-        onResponderRelease={handlePressOut}
-        onResponderTerminate={handlePressOut}
       >
         <TouchableOpacity
           activeOpacity={0.8}

android/src/screens/ChatScreen.tsx

@@ -25,6 +25,8 @@ 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 { playWakeReadySound } from '../services/wakeReadySound';
 import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
@@ -54,6 +56,10 @@ interface ChatMessage {
   messageId?: string;
   /** Lokaler Pfad zur gecachten TTS-Audio-Datei (file://...) */
   audioPath?: string;
+  /** Korrelations-ID fuer Sprachnachrichten — wird mit dem STT-Result zurueck-
+   *  gespiegelt damit wir die EXAKT richtige Placeholder-Bubble ersetzen,
+   *  auch wenn mehrere Aufnahmen parallel offen sind. */
+  audioRequestId?: string;
 }
 
 // --- Konstanten ---
@@ -104,6 +110,8 @@ 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);
@@ -154,6 +162,24 @@ 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
@@ -262,17 +288,51 @@ const ChatScreen: React.FC = () => {
 
       if (message.type === 'chat') {
         const sender = (message.payload.sender as string) || '';
+        const dbgText = ((message.payload.text as string) || '').slice(0, 60);
+        console.log('[Chat] chat-event sender=%s text=%s', sender || '(none)', dbgText);
 
-        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben
+        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben.
+        // WICHTIG: Nur die ERSTE noch unaufgeloeste Aufnahme matchen — sonst
+        // wuerde bei zwei kurz hintereinander gesendeten Audios beide Bubbles
+        // den gleichen Text bekommen (Bug: zweite Antwort ueberschreibt erste).
         if (sender === 'stt') {
           const sttText = (message.payload.text as string) || '';
-          if (sttText) {
-            setMessages(prev => prev.map(m =>
-              m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
-                ? { ...m, text: `\uD83C\uDFA4 ${sttText}` }
-                : m
-            ));
+          const sttAudioReqId = (message.payload.audioRequestId as string) || '';
+          if (!sttText) {
+            return;
           }
+          setMessages(prev => {
+            const newText = `\uD83C\uDFA4 ${sttText}`;
+            // Primaer: matche per audioRequestId (eindeutig pro Aufnahme).
+            // So gibt's keine Verwechslung wenn zwei Audios kurz hintereinander
+            // gesendet wurden und ihre STT-Results ueberlappen.
+            if (sttAudioReqId) {
+              const idxById = prev.findIndex(m => m.audioRequestId === sttAudioReqId);
+              if (idxById >= 0) {
+                const next = prev.slice();
+                next[idxById] = { ...next[idxById], text: newText };
+                return next;
+              }
+            }
+            // Fallback: alte Bridge-Version ohne audioRequestId \u2014 match per Substring,
+            // nimmt die ERSTE noch unaufgeloeste Placeholder.
+            const idx = prev.findIndex(m =>
+              m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
+            );
+            if (idx >= 0) {
+              const next = prev.slice();
+              next[idx] = { ...next[idx], text: newText };
+              return next;
+            }
+            // Letzter Fallback: gar keine Placeholder \u2192 neue Bubble einfuegen
+            return capMessages([...prev, {
+              id: nextId(),
+              sender: 'user',
+              text: newText,
+              timestamp: message.timestamp,
+              attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
+            }]);
+          });
           return;
         }
 
@@ -434,7 +494,14 @@ const ChatScreen: React.FC = () => {
       // Conversation-Window: User hat X Sekunden um anzufangen, sonst Konversation aus
       const windowMs = await loadConvWindowMs();
       const started = await audioService.startRecording(true, windowMs);
-      if (!started) {
+      if (started) {
+        // Erst JETZT signalisieren dass das Mikro wirklich offen ist —
+        // vorher war's noch in der Init-Phase. So weiss der User exakt
+        // ab wann er reden kann. "Bereit"-Sound (Ding-Dong) ist optional
+        // ueber Settings → Wake-Word abschaltbar.
+        ToastAndroid.show('🎤 Mikro offen — sprich jetzt', ToastAndroid.SHORT);
+        playWakeReadySound().catch(() => {});
+      } else {
         // Mikrofon nicht verfuegbar, naechsten Versuch
         wakeWordService.resume();
       }
@@ -445,13 +512,17 @@ const ChatScreen: React.FC = () => {
       const result = await audioService.stopRecording();
       if (result && result.durationMs > 500) {
         // User hat im Fenster gesprochen → Sprachnachricht senden
+        // Barge-In: laufende ARIA-Aktivitaet abbrechen wenn welche da ist.
+        const wasInterrupted = interruptAriaIfBusy();
         const location = await getCurrentLocation();
+        const audioRequestId = `audio_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
         const userMsg: ChatMessage = {
           id: nextId(),
           sender: 'user',
           text: '🎙 Spracheingabe wird verarbeitet...',
           timestamp: Date.now(),
           attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
+          audioRequestId,
         };
         setMessages(prev => capMessages([...prev, userMsg]));
         rvs.send('audio', {
@@ -460,8 +531,11 @@ const ChatScreen: React.FC = () => {
           mimeType: result.mimeType,
           voice: localXttsVoiceRef.current,
           speed: ttsSpeedRef.current,
+          interrupted: wasInterrupted,
+          audioRequestId,
           ...(location && { location }),
         });
+        scheduleStaleAudioCleanup(audioRequestId);
         // resume() wird durch onPlaybackFinished nach ARIAs Antwort getriggert.
       } else {
         // Kein Speech im Window → Konversation beenden (Ohr geht aus oder
@@ -472,9 +546,43 @@ const ChatScreen: React.FC = () => {
       }
     });
 
+    // Barge-In via Wake-Word: User sagt "Computer" waehrend ARIA spricht.
+    // Wake-Word-Service hat bei TTS-Start parallel zu lauschen begonnen
+    // (mit AcousticEchoCanceler damit ARIAs eigene Stimme nicht triggert).
+    const unsubBarge = wakeWordService.onBargeIn(async () => {
+      console.log('[Chat] Barge-In via Wake-Word — TTS abbrechen + neue Aufnahme');
+      audioService.haltAllPlayback('barge-in via wake-word');
+      setAgentActivity({ activity: 'idle', tool: '' });
+      rvs.send('cancel_request' as any, {});
+      // Kurze Pause damit halt durchgreift, dann neue Aufnahme starten
+      await new Promise(r => setTimeout(r, 150));
+      const windowMs = await loadConvWindowMs();
+      const started = await audioService.startRecording(true, windowMs);
+      if (started) {
+        ToastAndroid.show('🎤 Mikro offen — sprich jetzt', ToastAndroid.SHORT);
+        playWakeReadySound().catch(() => {});
+      }
+    });
+
+    // TTS-Lifecycle: solange ARIA spricht und Wake-Word verfuegbar ist,
+    // parallel mitlauschen — User kann "Computer" sagen statt manuell tappen.
+    const unsubTtsStart = audioService.onPlaybackStarted(() => {
+      if (wakeWordService.isConversing() && wakeWordService.hasWakeWord()) {
+        wakeWordService.startBargeListening().catch(() => {});
+      }
+    });
+    const unsubTtsEnd = audioService.onPlaybackFinished(() => {
+      // Vor naechster Aufnahme: barge-listening aus damit der AudioRecorder
+      // das Mikro greifen kann.
+      wakeWordService.stopBargeListening().catch(() => {});
+    });
+
     return () => {
       unsubWake();
       unsubSilence();
+      unsubBarge();
+      unsubTtsStart();
+      unsubTtsEnd();
     };
   }, [wakeWordActive]);
 
@@ -549,6 +657,25 @@ const ChatScreen: React.FC = () => {
 
   // --- Nachricht senden ---
 
+  // Aufraeumen von "verarbeitet"-Placeholder die nie ein STT-Result bekommen
+  // haben (leere Aufnahme, Wake-Word-Echo, STT-Fehler etc). Nach 30s werden
+  // sie automatisch entfernt damit nicht-erkannte Aufnahmen nicht den State
+  // verstopfen + naechste echte Aufnahmen die richtige Bubble ersetzen koennen.
+  const scheduleStaleAudioCleanup = useCallback((audioRequestId: string) => {
+    setTimeout(() => {
+      setMessages(prev => {
+        const idx = prev.findIndex(m =>
+          m.audioRequestId === audioRequestId &&
+          m.text.includes('Spracheingabe wird verarbeitet')
+        );
+        if (idx < 0) return prev;
+        console.log('[Chat] Sprachnachricht ohne STT-Result entfernt: %s', audioRequestId);
+        ToastAndroid.show('Sprachnachricht nicht erkannt — entfernt', ToastAndroid.SHORT);
+        return prev.filter((_, i) => i !== idx);
+      });
+    }, 30000);
+  }, []);
+
   const sendTextMessage = useCallback(async () => {
     const text = inputText.trim();
 
@@ -562,6 +689,8 @@ const ChatScreen: React.FC = () => {
 
     setInputText('');
 
+    // Barge-In: laufende ARIA-Aktivitaet abbrechen wenn welche da ist.
+    const wasInterrupted = interruptAriaIfBusy();
     const location = await getCurrentLocation();
 
     const userMsg: ChatMessage = {
@@ -572,14 +701,17 @@ const ChatScreen: React.FC = () => {
     };
     setMessages(prev => capMessages([...prev, userMsg]));
 
+    console.log('[Chat] sende mit voice=%s speed=%s interrupted=%s',
+                localXttsVoiceRef.current || '(default)', ttsSpeedRef.current, wasInterrupted);
     // An RVS senden — mit geraetelokaler Voice (Bridge nutzt sie fuer die Antwort)
     rvs.send('chat', {
       text,
       voice: localXttsVoiceRef.current,
       speed: ttsSpeedRef.current,
+      interrupted: wasInterrupted,
       ...(location && { location }),
     });
-  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments]);
+  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments, interruptAriaIfBusy]);
 
   // Anfrage abbrechen — sofort lokalen Indicator weg, Bridge triggert doctor --fix
   const cancelRequest = useCallback(() => {
@@ -587,15 +719,37 @@ const ChatScreen: React.FC = () => {
     rvs.send('cancel_request' as any, {});
   }, []);
 
+  // Barge-In: wenn der User waehrend ARIA arbeitet/spricht eine neue Sprach-
+  // Nachricht aufnimmt, alte Aktivitaet sofort abbrechen — TTS verstummen,
+  // aria-core-Run via cancel_request abbrechen. So kann man "ach vergiss es,
+  // mach lieber X" sagen wie in einem echten Gespraech.
+  const interruptAriaIfBusy = useCallback(() => {
+    const speaking = audioService.isPlayingAudio();
+    const thinking = agentActivity.activity !== 'idle';
+    if (!speaking && !thinking) return false;
+    console.log('[Chat] Barge-In: speaking=%s thinking=%s — interrupting ARIA',
+                speaking, thinking);
+    if (speaking) audioService.haltAllPlayback('user spricht (barge-in)');
+    if (thinking) {
+      setAgentActivity({ activity: 'idle', tool: '' });
+      rvs.send('cancel_request' as any, {});
+    }
+    return true;
+  }, [agentActivity]);
+
   // Sprachaufnahme abgeschlossen
   const handleVoiceRecording = useCallback(async (result: RecordingResult) => {
+    // Barge-In: laufende ARIA-Aktivitaet abbrechen falls aktiv.
+    const wasInterrupted = interruptAriaIfBusy();
     const location = await getCurrentLocation();
+    const audioRequestId = `audio_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
 
     const userMsg: ChatMessage = {
       id: nextId(),
       sender: 'user',
       text: '🎙 Spracheingabe wird verarbeitet...',
       timestamp: Date.now(),
+      audioRequestId,
     };
     setMessages(prev => capMessages([...prev, userMsg]));
 
@@ -603,9 +757,14 @@ const ChatScreen: React.FC = () => {
       base64: result.base64,
       durationMs: result.durationMs,
       mimeType: result.mimeType,
+      voice: localXttsVoiceRef.current,
+      speed: ttsSpeedRef.current,
+      interrupted: wasInterrupted,
+      audioRequestId,
       ...(location && { location }),
     });
-  }, [getCurrentLocation]);
+    scheduleStaleAudioCleanup(audioRequestId);
+  }, [getCurrentLocation, interruptAriaIfBusy, scheduleStaleAudioCleanup]);
 
   // Datei auswaehlen → zur Pending-Liste hinzufuegen
   const handleFileSelected = useCallback(async (file: FileData) => {
@@ -1000,7 +1159,10 @@ const ChatScreen: React.FC = () => {
               style={[styles.wakeWordBtn, wakeWordActive && styles.wakeWordBtnActive]}
               onPress={toggleWakeWord}
             >
-              <Text style={styles.wakeWordIcon}>{wakeWordActive ? '👂' : '🔇'}</Text>
+              <Text style={styles.wakeWordIcon}>
+                {wakeWordState === 'conversing' ? '🎙️' :
+                 wakeWordState === 'armed' ? '👂' : '🔇'}
+              </Text>
             </TouchableOpacity>
           </>
         )}

android/src/screens/SettingsScreen.tsx

@@ -35,15 +35,24 @@ import {
   CONV_WINDOW_MIN_SEC,
   CONV_WINDOW_MAX_SEC,
   CONV_WINDOW_STORAGE_KEY,
+  MAX_RECORDING_DEFAULT_SEC,
+  MAX_RECORDING_MIN_SEC,
+  MAX_RECORDING_MAX_SEC,
+  MAX_RECORDING_STORAGE_KEY,
   TTS_SPEED_DEFAULT,
   TTS_SPEED_MIN,
   TTS_SPEED_MAX,
   TTS_SPEED_STORAGE_KEY,
 } from '../services/audio';
+import {
+  isWakeReadySoundEnabled,
+  setWakeReadySoundEnabled,
+  playWakeReadySound,
+} from '../services/wakeReadySound';
 import wakeWordService, {
-  BUILTIN_KEYWORDS,
+  WAKE_KEYWORDS,
+  KEYWORD_LABELS,
   DEFAULT_KEYWORD,
-  WAKE_ACCESS_KEY_STORAGE,
   WAKE_KEYWORD_STORAGE,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
@@ -72,6 +81,18 @@ interface EventEntry {
 
 type LogTab = 'live' | 'events';
 
+// Settings-Sub-Screens. Reihenfolge im Hauptmenue.
+const SETTINGS_SECTIONS = [
+  { id: 'connection',   icon: '🔌', label: 'Verbindung',     desc: 'Server, Token, Status, Verbindungslog' },
+  { id: 'general',      icon: '⚙️', label: 'Allgemein',      desc: 'Betriebsmodus, GPS-Standort' },
+  { id: 'voice_input',  icon: '🎙️', label: 'Spracheingabe',  desc: 'Stille-Toleranz, Aufnahmedauer' },
+  { id: 'wake_word',    icon: '👂', label: 'Wake-Word',      desc: 'Wake-Word-Auswahl' },
+  { id: 'voice_output', icon: '🔊', label: 'Sprachausgabe',  desc: 'Stimmen, Pre-Roll, Geschwindigkeit' },
+  { id: 'storage',      icon: '📁', label: 'Speicher',       desc: 'Anhang-Speicherort, Auto-Download' },
+  { id: 'protocol',     icon: '📜', label: 'Protokoll',      desc: 'Privatsphaere, Backup' },
+  { id: 'about',        icon: 'ℹ️', label: 'Ueber',          desc: 'App-Version, Update' },
+] as const;
+
 // Container-Farben fuer Live-Logs
 const SOURCE_COLORS: Record<string, string> = {
   'aria-core': '#4A9EFF',   // Blau
@@ -102,17 +123,21 @@ const SettingsScreen: React.FC = () => {
   const [ttsPrerollSec, setTtsPrerollSec] = useState<number>(TTS_PREROLL_DEFAULT_SEC);
   const [vadSilenceSec, setVadSilenceSec] = useState<number>(VAD_SILENCE_DEFAULT_SEC);
   const [convWindowSec, setConvWindowSec] = useState<number>(CONV_WINDOW_DEFAULT_SEC);
+  const [maxRecordingSec, setMaxRecordingSec] = useState<number>(MAX_RECORDING_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 [wakeReadySound, setWakeReadySound] = useState<boolean>(true);
   const [editingPath, setEditingPath] = useState(false);
   const [xttsVoice, setXttsVoice] = useState('');
   const [loadingVoice, setLoadingVoice] = useState<string | null>(null);
   const [availableVoices, setAvailableVoices] = useState<Array<{name: string, size: number}>>([]);
   const [voiceCloneVisible, setVoiceCloneVisible] = useState(false);
   const [tempPath, setTempPath] = useState('');
+  // Sub-Screen Navigation: null = Hauptmenue, sonst eine der Section-IDs.
+  // So bleibt aller geteilte State im selben Component-Closure und wir
+  // brauchen keine react-navigation-Stack-Setup.
+  const [currentSection, setCurrentSection] = useState<string | null>(null);
 
   let logIdCounter = 0;
 
@@ -158,18 +183,24 @@ const SettingsScreen: React.FC = () => {
         }
       }
     });
+    AsyncStorage.getItem(MAX_RECORDING_STORAGE_KEY).then(saved => {
+      if (saved != null) {
+        const n = parseFloat(saved);
+        if (isFinite(n) && n >= MAX_RECORDING_MIN_SEC && n <= MAX_RECORDING_MAX_SEC) {
+          setMaxRecordingSec(n);
+        }
+      }
+    });
     AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY).then(saved => {
       if (saved != null) {
         const n = parseFloat(saved);
         if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) setTtsSpeed(n);
       }
     });
-    AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE).then(saved => {
-      if (saved) setWakeAccessKey(saved);
-    });
     AsyncStorage.getItem(WAKE_KEYWORD_STORAGE).then(saved => {
-      if (saved) setWakeKeyword(saved);
+      if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
     });
+    isWakeReadySoundEnabled().then(setWakeReadySound);
     AsyncStorage.getItem('aria_xtts_voice').then(saved => {
       if (saved) setXttsVoice(saved);
     });
@@ -485,7 +516,39 @@ const SettingsScreen: React.FC = () => {
     />
     <ScrollView style={styles.container} contentContainerStyle={styles.content}>
 
+      {currentSection === null && (
+        <>
+          {SETTINGS_SECTIONS.map(s => (
+            <TouchableOpacity
+              key={s.id}
+              style={styles.menuItem}
+              onPress={() => setCurrentSection(s.id)}
+            >
+              <Text style={styles.menuItemIcon}>{s.icon}</Text>
+              <View style={styles.menuItemTextWrap}>
+                <Text style={styles.menuItemLabel}>{s.label}</Text>
+                <Text style={styles.menuItemDesc}>{s.desc}</Text>
+              </View>
+              <Text style={styles.menuItemChevron}>›</Text>
+            </TouchableOpacity>
+          ))}
+        </>
+      )}
+
+      {currentSection !== null && (
+        <TouchableOpacity
+          style={styles.subScreenHeader}
+          onPress={() => setCurrentSection(null)}
+        >
+          <Text style={styles.subScreenBack}>‹</Text>
+          <Text style={styles.subScreenTitle}>
+            {SETTINGS_SECTIONS.find(s => s.id === currentSection)?.label || ''}
+          </Text>
+        </TouchableOpacity>
+      )}
+
       {/* === Verbindung === */}
+      {currentSection === 'connection' && (<>
       <Text style={styles.sectionTitle}>Verbindung</Text>
       <View style={styles.card}>
         {/* Status-Anzeige */}
@@ -582,8 +645,10 @@ const SettingsScreen: React.FC = () => {
           <Text style={styles.clearButtonText}>Log l{'\u00F6'}schen</Text>
         </TouchableOpacity>
       </View>
+      </>)}
 
       {/* === Modus === */}
+      {currentSection === 'general' && (<>
       <Text style={styles.sectionTitle}>Betriebsmodus</Text>
       <View style={styles.card}>
         <ModeSelector currentModeId={currentMode} onModeChange={handleModeChange} />
@@ -607,8 +672,10 @@ const SettingsScreen: React.FC = () => {
           />
         </View>
       </View>
+      </>)}
 
       {/* === Spracheingabe (geraetelokal) === */}
+      {currentSection === 'voice_input' && (<>
       <Text style={styles.sectionTitle}>Spracheingabe</Text>
       <View style={styles.card}>
         <Text style={styles.toggleLabel}>Stille-Toleranz</Text>
@@ -676,46 +743,60 @@ const SettingsScreen: React.FC = () => {
             <Text style={styles.prerollButtonText}>+1</Text>
           </TouchableOpacity>
         </View>
+
+        <Text style={[styles.toggleLabel, {marginTop: 24}]}>Maximale Aufnahmedauer</Text>
+        <Text style={styles.toggleHint}>
+          Notbremse: nach so vielen Minuten wird die Aufnahme automatisch beendet,
+          auch wenn keine Stille erkannt wurde. Nuetzlich fuer lange Erklaerungen
+          oder Diktate. Default: {Math.round(MAX_RECORDING_DEFAULT_SEC / 60)} Min, max {Math.round(MAX_RECORDING_MAX_SEC / 60)} Min.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.max(MAX_RECORDING_MIN_SEC, maxRecordingSec - 60);
+              setMaxRecordingSec(next);
+              AsyncStorage.setItem(MAX_RECORDING_STORAGE_KEY, String(next));
+            }}
+            disabled={maxRecordingSec <= MAX_RECORDING_MIN_SEC}
+          >
+            <Text style={styles.prerollButtonText}>−1m</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>{Math.round(maxRecordingSec / 60)} min</Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.min(MAX_RECORDING_MAX_SEC, maxRecordingSec + 60);
+              setMaxRecordingSec(next);
+              AsyncStorage.setItem(MAX_RECORDING_STORAGE_KEY, String(next));
+            }}
+            disabled={maxRecordingSec >= MAX_RECORDING_MAX_SEC}
+          >
+            <Text style={styles.prerollButtonText}>+1m</Text>
+          </TouchableOpacity>
+        </View>
       </View>
 
-      {/* === Wake-Word (geraetelokal) === */}
+      </>)}
+
+      {/* === Wake-Word (komplett on-device, openWakeWord) === */}
+      {currentSection === 'wake_word' && (<>
       <Text style={styles.sectionTitle}>Wake-Word</Text>
       <View style={styles.card}>
         <Text style={styles.toggleHint}>
-          Wenn ein Picovoice-Access-Key eingetragen ist, hoert die App passiv
-          auf das gewaehlte Wake-Word — du kannst dich mit anderen unterhalten,
-          Musik laufen lassen und mit "{wakeKeyword}" eine Konversation mit
-          ARIA starten. Ohne Key oder bei Fehlschlag startet das Ohr direkt
-          eine Konversation (klassischer Modus).
+          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.
         </Text>
 
-        <Text style={[styles.toggleLabel, {marginTop: 16}]}>Picovoice Access Key</Text>
-        <View style={{flexDirection: 'row', alignItems: 'center', gap: 8, marginTop: 6}}>
-          <TextInput
-            style={[styles.input, {flex: 1}]}
-            value={wakeAccessKey}
-            onChangeText={setWakeAccessKey}
-            placeholder="kostenlos auf console.picovoice.ai"
-            placeholderTextColor="#666680"
-            secureTextEntry={!wakeAccessKeyVisible}
-            autoCapitalize="none"
-            autoCorrect={false}
-          />
-          <TouchableOpacity
-            onPress={() => setWakeAccessKeyVisible(v => !v)}
-            style={{padding: 8}}
-          >
-            <Text style={{fontSize: 18}}>{wakeAccessKeyVisible ? '🙈' : '👁'}</Text>
-          </TouchableOpacity>
-        </View>
-
         <Text style={[styles.toggleLabel, {marginTop: 16}]}>Wake-Word</Text>
         <Text style={styles.toggleHint}>
-          Built-In: sofort verwendbar. "ARIA" als Custom-Keyword kommt spaeter
-          ueber Diagnostic-Upload.
+          Eigene Wake-Words via openWakeWord-Notebook trainierbar (gratis).
+          Custom-Upload ueber Diagnostic kommt in einer spaeteren Version.
         </Text>
         <View style={{flexDirection: 'row', flexWrap: 'wrap', gap: 6, marginTop: 8}}>
-          {BUILTIN_KEYWORDS.map(kw => (
+          {WAKE_KEYWORDS.map(kw => (
             <TouchableOpacity
               key={kw}
               style={[
@@ -728,7 +809,7 @@ const SettingsScreen: React.FC = () => {
                 styles.keywordChipText,
                 wakeKeyword === kw && styles.keywordChipTextActive,
               ]}>
-                {kw}
+                {KEYWORD_LABELS[kw]}
               </Text>
             </TouchableOpacity>
           ))}
@@ -740,8 +821,8 @@ const SettingsScreen: React.FC = () => {
             onPress={async () => {
               setWakeStatus('Initialisiere...');
               try {
-                const ok = await wakeWordService.configure(wakeAccessKey, wakeKeyword);
-                setWakeStatus(ok ? `✅ "${wakeKeyword}" bereit` : '❌ Fehlgeschlagen — Access Key pruefen');
+                const ok = await wakeWordService.configure(wakeKeyword);
+                setWakeStatus(ok ? `✅ "${KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS]}" bereit` : '❌ Init-Fehler — Logs pruefen');
               } catch (err: any) {
                 setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
               }
@@ -754,9 +835,36 @@ const SettingsScreen: React.FC = () => {
         {!!wakeStatus && (
           <Text style={{marginTop: 8, fontSize: 12, color: '#8888AA'}}>{wakeStatus}</Text>
         )}
+
+        <View style={[styles.toggleRow, {marginTop: 20, borderTopWidth: 1, borderTopColor: '#1E1E2E', paddingTop: 16}]}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Bereit-Sound abspielen</Text>
+            <Text style={styles.toggleHint}>
+              Kurzer Ding-Dong wenn das Mikro nach Wake-Word offen ist —
+              akustische Bestaetigung dass du jetzt sprechen darfst.
+            </Text>
+          </View>
+          <Switch
+            value={wakeReadySound}
+            onValueChange={async (val) => {
+              setWakeReadySound(val);
+              await setWakeReadySoundEnabled(val);
+              if (val) {
+                // Direkt eine Vorschau abspielen damit der User weiss wie's klingt.
+                // playWakeReadySound checked das gerade gesetzte Flag — wenn val=true,
+                // wird abgespielt; bei false bleibt es still.
+                setTimeout(() => playWakeReadySound().catch(() => {}), 150);
+              }
+            }}
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={wakeReadySound ? '#FFFFFF' : '#666680'}
+          />
+        </View>
       </View>
+      </>)}
 
       {/* === Sprachausgabe (geraetelokal) === */}
+      {currentSection === 'voice_output' && (<>
       <Text style={styles.sectionTitle}>Sprachausgabe</Text>
       <View style={styles.card}>
         <View style={styles.toggleRow}>
@@ -899,7 +1007,10 @@ const SettingsScreen: React.FC = () => {
         )}
       </View>
 
+      </>)}
+
       {/* === Speicher === */}
+      {currentSection === 'storage' && (<>
       <Text style={styles.sectionTitle}>Anhang-Speicher</Text>
       <View style={styles.card}>
         <View style={styles.toggleRow}>
@@ -974,7 +1085,10 @@ const SettingsScreen: React.FC = () => {
         )}
       </View>
 
+      </>)}
+
       {/* === Logs === */}
+      {currentSection === 'protocol' && (<>
       <Text style={styles.sectionTitle}>Protokoll</Text>
       <View style={styles.card}>
         {/* Tab-Umschalter */}
@@ -1053,8 +1167,10 @@ const SettingsScreen: React.FC = () => {
           <Text style={styles.clearButtonText}>Protokoll l\u00F6schen</Text>
         </TouchableOpacity>
       </View>
+      </>)}
 
       {/* === About === */}
+      {currentSection === 'about' && (<>
       <Text style={styles.sectionTitle}>{'\u00DC'}ber</Text>
       <View style={styles.card}>
         <Text style={styles.aboutTitle}>ARIA Cockpit</Text>
@@ -1074,6 +1190,7 @@ const SettingsScreen: React.FC = () => {
           <Text style={styles.connectButtonText}>Auf Updates pr{'\u00FC'}fen</Text>
         </TouchableOpacity>
       </View>
+      </>)}
 
       {/* Platz am Ende */}
       <View style={styles.bottomSpacer} />
@@ -1102,6 +1219,58 @@ const styles = StyleSheet.create({
     marginBottom: 8,
     marginLeft: 4,
   },
+  menuItem: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#1E1E2E',
+    borderRadius: 10,
+    paddingVertical: 14,
+    paddingHorizontal: 14,
+    marginBottom: 8,
+  },
+  menuItemIcon: {
+    fontSize: 22,
+    marginRight: 14,
+    width: 28,
+    textAlign: 'center',
+  },
+  menuItemTextWrap: {
+    flex: 1,
+  },
+  menuItemLabel: {
+    color: '#FFFFFF',
+    fontSize: 16,
+    fontWeight: '600',
+  },
+  menuItemDesc: {
+    color: '#8888AA',
+    fontSize: 12,
+    marginTop: 2,
+  },
+  menuItemChevron: {
+    color: '#8888AA',
+    fontSize: 24,
+    fontWeight: '300',
+    marginLeft: 8,
+  },
+  subScreenHeader: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    paddingVertical: 8,
+    marginBottom: 8,
+  },
+  subScreenBack: {
+    color: '#0096FF',
+    fontSize: 32,
+    fontWeight: '300',
+    marginRight: 12,
+    lineHeight: 36,
+  },
+  subScreenTitle: {
+    color: '#FFFFFF',
+    fontSize: 20,
+    fontWeight: '700',
+  },
   card: {
     backgroundColor: '#12122A',
     borderRadius: 14,

android/src/services/audio.ts

@@ -6,7 +6,7 @@
  * Nutzt react-native-audio-recorder-player fuer Aufnahme.
  */
 
-import { Platform, PermissionsAndroid, NativeModules } from 'react-native';
+import { Platform, PermissionsAndroid, NativeModules, ToastAndroid } from 'react-native';
 import Sound from 'react-native-sound';
 import RNFS from 'react-native-fs';
 import AsyncStorage from '@react-native-async-storage/async-storage';
@@ -72,9 +72,16 @@ const AUDIO_SAMPLE_RATE = 16000;
 const AUDIO_CHANNELS = 1;
 const AUDIO_ENCODING = 'audio/wav';
 
-// VAD (Voice Activity Detection) — Stille-Erkennung
-const VAD_SILENCE_THRESHOLD_DB = -45;  // dB unter dem als "Stille" gilt
-const VAD_SPEECH_THRESHOLD_DB = -28;   // dB ueber dem als "Sprache" gilt (Sprach-Gate) — hoeher = weniger Umgebungsgeraeusche
+// VAD (Voice Activity Detection) — Stille-Erkennung.
+// Fallback-Werte falls die adaptive Baseline-Messung fehlschlaegt (z.B. weil
+// das Mikro keine metering-Updates liefert). Adaptive Werte werden zur
+// Laufzeit aus den ersten BASELINE_SAMPLES gemessen und auf baseline+offset
+// gesetzt — funktioniert in lauten wie leisen Umgebungen.
+const VAD_SILENCE_FALLBACK_DB = -38;   // Fallback Stille-Schwelle
+const VAD_SPEECH_FALLBACK_DB = -22;    // Fallback Sprach-Schwelle
+const VAD_SILENCE_OFFSET_DB = 6;       // Sprache = Baseline + 6dB
+const VAD_SPEECH_OFFSET_DB = 12;       // sicheres Speech = Baseline + 12dB
+const VAD_BASELINE_SAMPLES = 5;        // 5 × 100ms = 500ms Baseline
 const VAD_SPEECH_MIN_MS = 500;         // ms Sprache bevor Aufnahme zaehlt — laenger = keine Huestler/Klopfer mehr
 
 // VAD-Stille (in Sekunden) — wie lange Sprechpause toleriert wird, bevor
@@ -138,7 +145,24 @@ async function loadVadSilenceMs(): Promise<number> {
 
 // Max-Dauer einer Aufnahme (Notbremse gegen Runaway-Loops). Auf 2 Minuten
 // hochgezogen damit auch laengere Erklaerungen durchgehen.
-const MAX_RECORDING_MS = 120000;
+// Default 5 Minuten — konfigurierbar in den App-Settings (1-30 Minuten).
+export const MAX_RECORDING_DEFAULT_SEC = 300;
+export const MAX_RECORDING_MIN_SEC = 60;
+export const MAX_RECORDING_MAX_SEC = 1800;
+export const MAX_RECORDING_STORAGE_KEY = 'aria_max_recording_sec';
+
+export async function loadMaxRecordingMs(): Promise<number> {
+  try {
+    const raw = await AsyncStorage.getItem(MAX_RECORDING_STORAGE_KEY);
+    if (raw != null) {
+      const n = parseFloat(raw);
+      if (isFinite(n) && n >= MAX_RECORDING_MIN_SEC && n <= MAX_RECORDING_MAX_SEC) {
+        return Math.round(n * 1000);
+      }
+    }
+  } catch {}
+  return MAX_RECORDING_DEFAULT_SEC * 1000;
+}
 
 // Pre-Roll: Wie lange Audio im AudioTrack-Buffer liegt bevor play() startet.
 // Einstellbar via Diagnostic/Settings (Key: aria_tts_preroll_sec).
@@ -191,6 +215,19 @@ 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;
@@ -199,12 +236,80 @@ class AudioService {
   // Latch damit der Silence-Callback pro Aufnahme genau einmal feuert
   private silenceFired: boolean = false;
   private noSpeechTimer: ReturnType<typeof setTimeout> | null = null;
+  // Adaptive Schwellen — werden in den ersten 500ms aus dem Mikro-Pegel
+  // gemessen. baseline = avg dB der ersten 5 Samples, dann:
+  //   silence  = baseline + VAD_SILENCE_OFFSET_DB  (6dB ueber ambient)
+  //   speech   = baseline + VAD_SPEECH_OFFSET_DB   (12dB ueber ambient = klares Reden)
+  // Funktioniert sowohl im stillen Buero als auch im lauten Cafe.
+  private vadBaselineSamples: number[] = [];
+  private vadAdaptiveSilenceDb: number = VAD_SILENCE_FALLBACK_DB;
+  private vadAdaptiveSpeechDb: number = VAD_SPEECH_FALLBACK_DB;
 
   constructor() {
     this.recorder = new AudioRecorderPlayer();
     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();
+  }
+
+  /** True wenn ARIA gerade was abspielt — egal ob WAV-Queue oder PCM-Stream.
+   *  Nuetzlich fuer "Barge-In": wenn der User spricht waehrend ARIA spricht,
+   *  soll die ARIA-Wiedergabe abgebrochen + die neue User-Message verarbeitet
+   *  werden ("ach vergiss es, mach lieber X"). */
+  isPlayingAudio(): boolean {
+    return this.isPlaying || this.pcmStreamActive;
+  }
+
   // --- Berechtigungen ---
 
   async requestMicrophonePermission(): Promise<boolean> {
@@ -276,8 +381,25 @@ class AudioService {
         const db = e.currentMetering ?? -160;
         this.meterListeners.forEach(cb => cb(db));
 
+        // Adaptive Baseline: erste 5 Samples (~500ms) sammeln, dann Schwellen
+        // anpassen. -160 (kein Metering) ignorieren — sonst wird die Baseline
+        // sinnlos niedrig.
+        if (this.vadBaselineSamples.length < VAD_BASELINE_SAMPLES) {
+          if (db > -100) {
+            this.vadBaselineSamples.push(db);
+            if (this.vadBaselineSamples.length === VAD_BASELINE_SAMPLES) {
+              const avg = this.vadBaselineSamples.reduce((a, b) => a + b, 0) / VAD_BASELINE_SAMPLES;
+              this.vadAdaptiveSilenceDb = avg + VAD_SILENCE_OFFSET_DB;
+              this.vadAdaptiveSpeechDb = avg + VAD_SPEECH_OFFSET_DB;
+              const msg = `VAD: ambient=${avg.toFixed(0)}dB stille>${this.vadAdaptiveSilenceDb.toFixed(0)}dB`;
+              console.log('[Audio] %s speech>%s', msg, this.vadAdaptiveSpeechDb.toFixed(1));
+              try { ToastAndroid.show(msg, ToastAndroid.SHORT); } catch {}
+            }
+          }
+        }
+
         // Sprach-Gate: Erkennen ob tatsaechlich gesprochen wird
-        if (db > VAD_SPEECH_THRESHOLD_DB) {
+        if (db > this.vadAdaptiveSpeechDb) {
           if (!this.speechDetected && this.speechStartTime === 0) {
             this.speechStartTime = Date.now();
           }
@@ -292,7 +414,7 @@ class AudioService {
 
         // VAD: Stille erkennen (nur wenn Sprache erkannt wurde)
         if (this.vadEnabled) {
-          if (db > VAD_SILENCE_THRESHOLD_DB) {
+          if (db > this.vadAdaptiveSilenceDb) {
             this.lastSpeechTime = Date.now();
           }
         }
@@ -302,9 +424,16 @@ class AudioService {
       this.lastSpeechTime = Date.now();
       this.speechDetected = false;
       this.speechStartTime = 0;
+      // VAD-Adaptive zurueckgesetzt: Baseline wird in den ersten 500ms neu
+      // gemessen. Bis dahin gelten die Fallback-Schwellen — die sind etwas
+      // empfindlicher als die alten Werte (-38 statt -45 fuer Stille).
+      this.vadBaselineSamples = [];
+      this.vadAdaptiveSilenceDb = VAD_SILENCE_FALLBACK_DB;
+      this.vadAdaptiveSpeechDb = VAD_SPEECH_FALLBACK_DB;
       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).
@@ -328,17 +457,19 @@ class AudioService {
       };
       if (autoStop) {
         const vadSilenceMs = await loadVadSilenceMs();
-        console.log('[Audio] VAD-Stille:', vadSilenceMs, 'ms');
+        const maxRecordingMs = await loadMaxRecordingMs();
+        console.log('[Audio] startRecording: autoStop=true, VAD-Stille=%dms, MAX=%dms',
+                    vadSilenceMs, maxRecordingMs);
         this.vadTimer = setInterval(() => {
           const silenceDuration = Date.now() - this.lastSpeechTime;
           if (silenceDuration >= vadSilenceMs) {
-            fireSilenceOnce(`VAD ${silenceDuration}ms Stille`);
+            fireSilenceOnce(`VAD ${silenceDuration}ms Stille (Schwelle=${vadSilenceMs}ms)`);
           }
         }, 200);
-        // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
+        // Notbremse: Nach maxRecordingMs zwangsweise stoppen
         this.maxDurationTimer = setTimeout(() => {
-          fireSilenceOnce(`Max-Dauer ${MAX_RECORDING_MS}ms`);
-        }, MAX_RECORDING_MS);
+          fireSilenceOnce(`Max-Dauer ${maxRecordingMs}ms`);
+        }, maxRecordingMs);
       }
 
       // Conversation-Window: Wenn der User innerhalb noSpeechTimeoutMs nicht
@@ -386,8 +517,9 @@ class AudioService {
       await this.recorder.stopRecorder();
       this.recorder.removeRecordBackListener();
 
-      // Audio-Focus freigeben — andere Apps duerfen wieder
-      AudioFocus?.release().catch(() => {});
+      // Audio-Focus verzoegert freigeben — gleich kommt die TTS-Antwort,
+      // im Gap soll Spotify nicht hochkommen.
+      this._releaseFocusDeferred();
 
       const durationMs = Date.now() - this.recordingStartTime;
       const hadSpeech = this.speechDetected;
@@ -459,7 +591,13 @@ class AudioService {
 
   /** Einen PCM-Chunk aus einer audio_pcm Nachricht empfangen.
    *  silent=true → nur cachen, nicht abspielen (z.B. wenn TTS geraetelokal gemutet).
-   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached. */
+   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached.
+   *
+   *  Wrapper serialisiert aufeinanderfolgende Chunk-Calls via Promise-Queue —
+   *  sonst gabs bei kurzen Streams einen Race: final-Chunk konnte `end()` rufen
+   *  BEVOR der vorherige `start()` im Native-Modul fertig war. Der Writer-
+   *  Thread sah dann endRequested=true ohne jemals Chunks zu verarbeiten. */
+  private _pcmChunkQueue: Promise<any> = Promise.resolve();
   async handlePcmChunk(payload: {
     base64: string;
     sampleRate?: number;
@@ -468,6 +606,24 @@ 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) {
@@ -510,7 +666,9 @@ class AudioService {
           this.pcmStreamActive = false;
           return '';
         }
+        this._cancelDeferredFocusRelease();
         AudioFocus?.requestDuck().catch(() => {});
+        this._firePlaybackStarted();
       }
     }
 
@@ -528,11 +686,12 @@ class AudioService {
     if (isFinal) {
       if (!silent) {
         // end() resolved jetzt erst wenn der native Writer-Thread fertig
-        // ist (alle Samples ausgespielt) — danach erst AudioFocus freigeben,
-        // damit Spotify/YouTube nicht waehrend des Pre-Roll-Ausklangs
-        // wieder aufdrehen.
+        // 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.
         try { await PcmStreamPlayer!.end(); } catch {}
-        AudioFocus?.release().catch(() => {});
+        this._releaseFocusDeferred();
       }
       this.pcmStreamActive = false;
 
@@ -624,6 +783,7 @@ class AudioService {
 
   // Callback wenn alle Audio-Teile abgespielt sind
   private playbackFinishedListeners: (() => void)[] = [];
+  private playbackStartedListeners: (() => void)[] = [];
 
   onPlaybackFinished(callback: () => void): () => void {
     this.playbackFinishedListeners.push(callback);
@@ -632,20 +792,38 @@ class AudioService {
     };
   }
 
+  /** Callback wenn ARIAs TTS-Wiedergabe startet — fuer Wake-Word-parallel-
+   *  Listening waehrend ARIA spricht (Barge-In via "Computer" sagen). */
+  onPlaybackStarted(callback: () => void): () => void {
+    this.playbackStartedListeners.push(callback);
+    return () => {
+      this.playbackStartedListeners = this.playbackStartedListeners.filter(cb => cb !== callback);
+    };
+  }
+
+  private _firePlaybackStarted(): void {
+    this.playbackStartedListeners.forEach(cb => {
+      try { cb(); } catch (e) { console.warn('[Audio] playbackStarted listener err:', e); }
+    });
+  }
+
   /** Naechstes Audio aus der Queue abspielen */
   private async _playNext(): Promise<void> {
     if (this.audioQueue.length === 0) {
       this.isPlaying = false;
-      // Audio-Focus abgeben → andere Apps volle Lautstaerke
-      AudioFocus?.release().catch(() => {});
+      // Audio-Focus verzoegert abgeben → wenn gleich noch eine Antwort kommt,
+      // bleibt Spotify pausiert.
+      this._releaseFocusDeferred();
       // Alle Audio-Teile abgespielt → Listener benachrichtigen
       this.playbackFinishedListeners.forEach(cb => cb());
       return;
     }
 
-    // Beim ersten Playback-Start: andere Apps ducken
+    // Beim ersten Playback-Start: andere Apps ducken + Listener informieren
     if (!this.isPlaying) {
+      this._cancelDeferredFocusRelease();
       AudioFocus?.requestDuck().catch(() => {});
+      this._firePlaybackStarted();
     }
     this.isPlaying = true;
 
@@ -730,7 +908,8 @@ class AudioService {
       this.pcmBytesCollected = 0;
       this.pcmMessageId = '';
     }
-    // Audio-Focus freigeben
+    // Audio-Focus sofort freigeben — User hat explizit abgebrochen
+    this._cancelDeferredFocusRelease();
     AudioFocus?.release().catch(() => {});
   }
 

android/src/services/phoneCall.ts

@@ -0,0 +1,108 @@
+/**
+ * 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;

android/src/services/updater.ts

@@ -29,6 +29,11 @@ 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) {
@@ -45,6 +50,30 @@ 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;
@@ -111,6 +140,10 @@ 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');

android/src/services/wakeReadySound.ts

@@ -0,0 +1,71 @@
+/**
+ * Spielt einen kurzen "Bereit"-Sound (Airplane Ding-Dong) wenn das Mikrofon
+ * nach Wake-Word-Erkennung wirklich offen ist. Datei liegt in
+ * android/app/src/main/res/raw/wake_ready_sound.mp3 — wird ueber Android's
+ * Resource-System per react-native-sound abgespielt.
+ *
+ * Toggle: AsyncStorage-Key 'aria_wake_ready_sound_enabled' (default true).
+ */
+
+import Sound from 'react-native-sound';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export const WAKE_READY_SOUND_STORAGE_KEY = 'aria_wake_ready_sound_enabled';
+
+Sound.setCategory('Playback', false);
+
+let cachedSound: Sound | null = null;
+let cachedFailed = false;
+
+function getSound(): Promise<Sound | null> {
+  if (cachedFailed) return Promise.resolve(null);
+  if (cachedSound) return Promise.resolve(cachedSound);
+  return new Promise(resolve => {
+    const s = new Sound('wake_ready_sound', Sound.MAIN_BUNDLE, (err) => {
+      if (err) {
+        console.warn('[WakeReadySound] Konnte nicht geladen werden:', err);
+        cachedFailed = true;
+        resolve(null);
+        return;
+      }
+      cachedSound = s;
+      resolve(s);
+    });
+  });
+}
+
+/** True wenn der User den "Bereit"-Sound aktiviert hat. Default: true. */
+export async function isWakeReadySoundEnabled(): Promise<boolean> {
+  try {
+    const raw = await AsyncStorage.getItem(WAKE_READY_SOUND_STORAGE_KEY);
+    if (raw === null) return true;  // Default an
+    return raw === 'true';
+  } catch {
+    return true;
+  }
+}
+
+export async function setWakeReadySoundEnabled(enabled: boolean): Promise<void> {
+  try {
+    await AsyncStorage.setItem(WAKE_READY_SOUND_STORAGE_KEY, String(enabled));
+  } catch {}
+}
+
+/** Spielt den Bereit-Sound einmal ab — non-blocking. Wenn der User ihn
+ *  in den Settings deaktiviert hat oder die Datei nicht ladbar ist,
+ *  passiert einfach nichts. */
+export async function playWakeReadySound(): Promise<void> {
+  if (!(await isWakeReadySoundEnabled())) return;
+  const s = await getSound();
+  if (!s) return;
+  try {
+    s.stop(() => {
+      s.setCurrentTime(0);
+      s.play((success) => {
+        if (!success) console.warn('[WakeReadySound] Wiedergabe fehlgeschlagen');
+      });
+    });
+  } catch (e) {
+    console.warn('[WakeReadySound] play() Exception:', e);
+  }
+}

android/src/services/wakeword.ts

@@ -1,21 +1,26 @@
 /**
  * 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, 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),
+ *   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),
  *                AudioRecorder uebernimmt fuer die Aufnahme.
  *                Nach jeder ARIA-Antwort oeffnet das Mikro fuer X Sekunden
  *                (Conversation-Window). Stille im Fenster → zurueck zu armed.
  *
- * Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
- * direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
- * geht dann nach 'off' statt 'armed'.
+ * Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
+ * 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
  */
 
+import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
 type WakeWordCallback = () => void;
@@ -23,105 +28,118 @@ type StateCallback = (state: WakeWordState) => void;
 
 export type WakeWordState = 'off' | 'armed' | 'conversing';
 
-export const WAKE_ACCESS_KEY_STORAGE = 'aria_wake_access_key';
 export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';
 
-/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
- *  Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
- *  Console — wird spaeter ueber Diagnostic uploadbar. */
-export const BUILTIN_KEYWORDS = [
-  'jarvis',
+/** 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',
   'computer',
-  'picovoice',
-  'porcupine',
-  'bumblebee',
-  'terminator',
   'alexa',
-  'hey google',
-  'ok google',
-  'hey siri',
+  'hey_mycroft',
+  'hey_rhasspy',
 ] as const;
-export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
-export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
+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 };
 
 class WakeWordService {
   private state: WakeWordState = 'off';
   private wakeCallbacks: WakeWordCallback[] = [];
   private stateCallbacks: StateCallback[] = [];
+  /** Barge-In-Callbacks: feuern wenn Wake-Word WAEHREND ARIA spricht erkannt
+   *  wird. ChatScreen reagiert mit TTS-stop + neuer Aufnahme. */
+  private bargeCallbacks: WakeWordCallback[] = [];
+  /** True solange Wake-Word parallel zu TTS aktiv ist. */
+  private bargeListening: 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 keyword: WakeKeyword = DEFAULT_KEYWORD;
+  private nativeReady: boolean = false;
   private initInProgress: Promise<boolean> | null = null;
+  private eventSub: { remove: () => void } | null = null;
 
-  /** Beim App-Start aufrufen — laedt Settings, baut Porcupine wenn Key da ist. */
+  /** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
   async loadFromStorage(): Promise<void> {
     try {
-      const k = await AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE);
       const w = await AsyncStorage.getItem(WAKE_KEYWORD_STORAGE);
-      this.accessKey = (k || '').trim();
-      this.keyword = (w || DEFAULT_KEYWORD).trim();
-      if (this.accessKey) {
-        // Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
-        await this.initPorcupine();
-      }
+      const wt = (w || DEFAULT_KEYWORD).trim() as WakeKeyword;
+      this.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
+      await this.initNative();
     } catch (err) {
       console.warn('[WakeWord] loadFromStorage', err);
     }
   }
 
-  /** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
-  async configure(accessKey: string, keyword: string): Promise<boolean> {
-    this.accessKey = (accessKey || '').trim();
-    this.keyword = (keyword || DEFAULT_KEYWORD).trim();
-    await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
-    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);
+  /** 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);
 
-    // Laufende Instanz stoppen
-    await this.disposePorcupine();
-    if (!this.accessKey) return false;
-
-    // Neu initialisieren
-    return this.initPorcupine();
+    // 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;
   }
 
-  private async initPorcupine(): Promise<boolean> {
+  private async initNative(): Promise<boolean> {
+    if (!OpenWakeWord) {
+      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
+      this.nativeReady = false;
+      return false;
+    }
     if (this.initInProgress) return this.initInProgress;
     this.initInProgress = (async () => {
       try {
-        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);
+        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');
             this.onWakeDetected().catch(err =>
               console.warn('[WakeWord] onWakeDetected crashed:', err));
-          },
-          // Error handler (wenn Porcupine im Background-Thread crashed,
-          // z.B. beim Audio-Engine-Konflikt mit audio-recorder-player)
-          (error: any) => {
-            console.warn('[WakeWord] Porcupine runtime error:', error?.message || error);
-            // Nicht in Loop crashen — state zurueck auf off damit der User
-            // mit dem Aufnahme-Button wieder normal arbeiten kann
-            this.setState('off');
-            this.disposePorcupine().catch(() => {});
-          },
-        );
-        console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
+          });
+        }
+        this.nativeReady = true;
+        console.log('[WakeWord] Init OK (model=%s)', this.keyword);
         return true;
-      } catch (err) {
-        console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err);
-        this.porcupine = null;
+      } catch (err: any) {
+        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
+        this.nativeReady = false;
         return false;
       } finally {
         this.initInProgress = null;
@@ -130,30 +148,39 @@ class WakeWordService {
     return this.initInProgress;
   }
 
-  private async disposePorcupine() {
-    if (this.porcupine) {
-      try { await this.porcupine.stop(); } catch {}
-      try { await this.porcupine.delete(); } catch {}
-      this.porcupine = null;
-    }
+  private async disposeNative(): Promise<void> {
+    if (!OpenWakeWord) return;
+    try { await OpenWakeWord.dispose(); } catch {}
+    this.nativeReady = false;
   }
 
   /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
   async start(): Promise<boolean> {
     if (this.state !== 'off') return true;
-    if (this.porcupine) {
-      // Passives Lauschen via Porcupine
+    if (this.nativeReady && OpenWakeWord) {
       try {
-        await this.porcupine.start();
-        console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
+        await OpenWakeWord.start();
+        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
+        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return true;
-      } catch (err) {
-        console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:', err);
+      } 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,
+        );
       }
+    } 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 die Konversation
-    console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
+    // Fallback: direkt in Konversation
+    console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
     this.setState('conversing');
     setTimeout(() => {
       if (this.state === 'conversing') {
@@ -166,20 +193,32 @@ class WakeWordService {
   /** Komplett ausschalten (Ohr abschalten) */
   async stop(): Promise<void> {
     console.log('[WakeWord] Ohr deaktiviert');
-    if (this.porcupine) {
-      try { await this.porcupine.stop(); } catch {}
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
     }
+    this.bargeListening = false;
     this.setState('off');
   }
 
-  /** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
+  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
   private async onWakeDetected(): Promise<void> {
-    console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
-    if (this.porcupine) {
-      try { await this.porcupine.stop(); } catch {}
+    console.log('[WakeWord] Wake-Word "%s" erkannt! (state=%s, barge=%s)',
+                this.keyword, this.state, this.bargeListening);
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.bargeListening = false;
+    // Wenn wir bereits in 'conversing' sind und der Trigger waehrend ARIAs TTS
+    // kam (Barge-In via Wake-Word), feuern wir einen separaten Callback damit
+    // ChatScreen das TTS abbrechen + neue Aufnahme starten kann. Sonst normal.
+    if (this.state === 'conversing') {
+      this.bargeCallbacks.forEach(cb => {
+        try { cb(); } catch (e) { console.warn('[WakeWord] barge cb err:', e); }
+      });
+      // Kein erneutes setState — wir bleiben in 'conversing'.
+      return;
     }
     this.setState('conversing');
-    // kurz warten damit Mikrofon frei ist
     setTimeout(() => {
       if (this.state === 'conversing') {
         this.wakeCallbacks.forEach(cb => cb());
@@ -187,16 +226,46 @@ class WakeWordService {
     }, 200);
   }
 
+  /** Wake-Word PARALLEL zur TTS-Wiedergabe lauschen lassen — User kann
+   *  "Computer" sagen waehrend ARIA noch redet, AcousticEchoCanceler im
+   *  Native-Modul verhindert dass ARIAs eigene Stimme triggert.
+   *  Voraussetzung: AudioRecorder muss frei sein (Recording aus). Wenn der
+   *  AudioRecorder gerade laeuft, hat der Vorrang — Wake-Word geht nicht. */
+  async startBargeListening(): Promise<void> {
+    if (!this.nativeReady || !OpenWakeWord) return;
+    if (this.state !== 'conversing') return;
+    if (this.bargeListening) return;
+    try {
+      await OpenWakeWord.start();
+      this.bargeListening = true;
+      console.log('[WakeWord] Barge-Listening aktiv (parallel zu TTS)');
+    } catch (err) {
+      console.warn('[WakeWord] Barge-Listening start fehlgeschlagen:', err);
+    }
+  }
+
+  /** Barge-Listening wieder aus — z.B. wenn der AudioRecorder fuer die
+   *  naechste Aufnahme das Mikro braucht. */
+  async stopBargeListening(): Promise<void> {
+    if (!this.bargeListening) return;
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.bargeListening = false;
+    console.log('[WakeWord] Barge-Listening aus');
+  }
+
   /** Konversation beenden — User hat im Window nichts gesagt.
-   *  Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
+   *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
    *  Ohne: zurueck zu 'off'.
    */
   async endConversation(): Promise<void> {
     if (this.state !== 'conversing') return;
-    if (this.porcupine && this.accessKey) {
+    if (this.nativeReady && OpenWakeWord) {
       try {
-        await this.porcupine.start();
+        await OpenWakeWord.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) {
@@ -204,6 +273,7 @@ class WakeWordService {
       }
     }
     console.log('[WakeWord] Konversation zu Ende — Ohr aus');
+    ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
     this.setState('off');
   }
 
@@ -228,10 +298,10 @@ class WakeWordService {
   }
 
   hasWakeWord(): boolean {
-    return !!this.porcupine;
+    return this.nativeReady;
   }
 
-  getKeyword(): string {
+  getKeyword(): WakeKeyword {
     return this.keyword;
   }
 
@@ -244,6 +314,19 @@ class WakeWordService {
     };
   }
 
+  /** Subscribe auf Barge-In-Events: Wake-Word erkannt waehrend ARIA noch
+   *  spricht. ChatScreen sollte dann TTS abbrechen + neue Aufnahme starten. */
+  onBargeIn(callback: WakeWordCallback): () => void {
+    this.bargeCallbacks.push(callback);
+    return () => {
+      this.bargeCallbacks = this.bargeCallbacks.filter(cb => cb !== callback);
+    };
+  }
+
+  isBargeListening(): boolean {
+    return this.bargeListening;
+  }
+
   onStateChange(callback: StateCallback): () => void {
     this.stateCallbacks.push(callback);
     return () => {

bridge/aria_bridge.py

@@ -551,6 +551,15 @@ 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.
@@ -907,18 +916,13 @@ class ARIABridge:
             logger.info("[core] TTS unterdrueckt (Modus: %s)", self.current_mode.config.name)
             return
 
-        # Voice bestimmen: App-Override fuer diesen Request > globale Default-Voice
+        # 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.
         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:
@@ -942,7 +946,8 @@ class ARIABridge:
                 },
                 "timestamp": int(asyncio.get_event_loop().time() * 1000),
             })
-            logger.info("[core] XTTS-Request gesendet (%s): '%s'", xtts_voice or "default", tts_text[:60])
+            logger.info("[core] XTTS-Request gesendet (voice=%s, speed=%.2fx): '%s'",
+                        xtts_voice or "default", xtts_speed, tts_text[:60])
         except Exception as e:
             logger.error("[core] XTTS-Request fehlgeschlagen: %s — kein Audio", e)
 
@@ -1023,6 +1028,51 @@ 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:
@@ -1168,21 +1218,41 @@ class ARIABridge:
             if sender in ("aria", "stt"):
                 return
             text = payload.get("text", "")
-            # 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)
+            # 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)")
             # Speed-Override (TTS-Wiedergabegeschwindigkeit, pro Geraet)
-            try:
-                speed = float(payload.get("speed", 0) or 0)
-                if 0.1 <= speed <= 5.0:
-                    self._next_speed_override = speed
-            except (TypeError, ValueError):
-                pass
+            if "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
             if text:
-                logger.info("[rvs] App-Chat: '%s'", text[:80])
-                await self.send_to_core(text, source="app")
+                interrupted = bool(payload.get("interrupted", False))
+                # 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:
+                    core_text = (
+                        f"[Hinweis: Stefan hat dich gerade unterbrochen waehrend du noch "
+                        f"gesprochen oder gearbeitet hast. Folgendes ist eine Korrektur, "
+                        f"Ergaenzung oder ein Themenwechsel zu deiner letzten Antwort.] "
+                        f"{text}"
+                        if interrupted else text
+                    )
+                    logger.info("[rvs] App-Chat%s: '%s'",
+                                " [BARGE-IN]" if interrupted else "", text[:80])
+                    await self.send_to_core(core_text, source="app" + (" [barge-in]" if interrupted else ""))
             return
 
         if msg_type == "cancel_request":
@@ -1341,70 +1411,54 @@ class ARIABridge:
                 await self.ws_core.send(raw_message)
 
         elif msg_type == "file":
-            # Datei von der App → als Text-Nachricht an aria-core
+            # 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.
             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 file_b64 and file_type.startswith("image/"):
-                # Bild in Shared Volume speichern
+            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/"):
                 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)
-                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
+            else:
                 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)
-                # 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")
+            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)
 
         elif msg_type == "file_request":
             # App fordert eine Datei an (Re-Download nach Cache-Leerung)
@@ -1443,20 +1497,25 @@ class ARIABridge:
             if not audio_b64:
                 logger.warning("[rvs] Audio ohne Daten empfangen")
                 return
-            # 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.1 <= speed <= 5.0:
-                    self._next_speed_override = speed
-            except (TypeError, ValueError):
-                pass
-            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB",
-                        mime_type, duration_ms, len(audio_b64) // 1365)
-            asyncio.create_task(self._process_app_audio(audio_b64, mime_type))
+            # 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
+            interrupted = bool(payload.get("interrupted", False))
+            audio_request_id = payload.get("audioRequestId", "") or ""
+            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB%s%s",
+                        mime_type, duration_ms, len(audio_b64) // 1365,
+                        " [BARGE-IN]" if interrupted else "",
+                        f" reqId={audio_request_id[:16]}" if audio_request_id else "")
+            asyncio.create_task(self._process_app_audio(audio_b64, mime_type, interrupted, audio_request_id))
 
         elif msg_type == "stt_response":
             # Antwort der whisper-bridge auf unseren stt_request
@@ -1512,8 +1571,19 @@ class ARIABridge:
     _STT_REMOTE_TIMEOUT_READY_S = 45.0
     _STT_REMOTE_TIMEOUT_LOADING_S = 300.0
 
-    async def _process_app_audio(self, audio_b64: str, mime_type: str) -> None:
-        """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal."""
+    async def _process_app_audio(self, audio_b64: str, mime_type: str,
+                                  interrupted: bool = False,
+                                  audio_request_id: str = "") -> None:
+        """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal.
+
+        interrupted=True wenn der User waehrend ARIA noch sprach/dachte aufgenommen hat
+        (Barge-In). Wird als Hinweis-Praefix an aria-core mitgegeben damit ARIA die
+        Korrektur/Unterbrechung in den Kontext einordnen kann statt als reine
+        Folgefrage zu behandeln.
+
+        audio_request_id: Korrelations-ID die die App im audio-Event mitschickt — wird
+        unveraendert ans STT-Result zurueckgegeben damit die App die EXAKT richtige
+        'wird verarbeitet'-Bubble ersetzen kann (auch bei mehreren parallelen Aufnahmen)."""
         # Erst Remote versuchen
         text = await self._stt_remote(audio_b64, mime_type)
         if text is None:
@@ -1525,19 +1595,35 @@ class ARIABridge:
 
         if text.strip():
             logger.info("[rvs] STT Ergebnis: '%s'", text[:80])
+            # Barge-In-Hinweis: gibt ARIA den Kontext dass sie unterbrochen wurde
+            # und dies eine Korrektur/Aenderung der vorherigen Anweisung sein kann.
+            core_text = (
+                f"[Hinweis: Stefan hat dich gerade unterbrochen waehrend du noch "
+                f"gesprochen oder gearbeitet hast. Folgendes ist eine Korrektur, "
+                f"Ergaenzung oder ein Themenwechsel zu deiner letzten Antwort.] "
+                f"{text}"
+                if interrupted else text
+            )
             # ERST an aria-core senden (wichtigster Schritt)
-            await self.send_to_core(text, source="app-voice")
+            await self.send_to_core(core_text, source="app-voice" + (" [barge-in]" if interrupted else ""))
             # STT-Text an RVS senden (fuer Anzeige in App + Diagnostic)
             # sender="stt" damit Bridge es ignoriert (kein Loop)
             try:
-                await self._send_to_rvs({
+                stt_payload = {
+                    "text": text,
+                    "sender": "stt",
+                }
+                if audio_request_id:
+                    stt_payload["audioRequestId"] = audio_request_id
+                ok = await self._send_to_rvs({
                     "type": "chat",
-                    "payload": {
-                        "text": text,
-                        "sender": "stt",
-                    },
+                    "payload": stt_payload,
                     "timestamp": int(asyncio.get_event_loop().time() * 1000),
                 })
+                if ok:
+                    logger.info("[rvs] STT-Text an RVS broadcastet (sender=stt)")
+                else:
+                    logger.warning("[rvs] STT-Text NICHT broadcastet — _send_to_rvs lieferte False")
             except Exception as e:
                 logger.warning("[rvs] STT-Text konnte nicht an RVS gesendet werden: %s", e)
         else:

diagnostic/index.html

@@ -63,24 +63,35 @@
     .log-entry.pipeline-sep { color: #333; margin: 6px 0 2px; }
 
     .chat-box { background: #080810; border: 1px solid #1E1E2E; border-radius: 6px;
-                min-height: 120px; max-height: 250px; overflow-y: auto; padding: 8px; margin-bottom: 8px; }
-    .chat-msg { margin-bottom: 6px; padding: 6px 10px; border-radius: 6px; font-size: 13px; line-height: 1.5; word-wrap: break-word; }
-    .chat-msg.sent { background: #0096FF; color: #fff; margin-left: 20%; text-align: right; }
-    .chat-msg.received { background: #1E1E2E; margin-right: 20%; }
-    .chat-msg.error { background: #3B1010; color: #FF6B6B; }
-    .chat-msg .meta { font-size: 10px; color: rgba(255,255,255,0.4); margin-top: 2px; }
+                min-height: 120px; max-height: 250px; overflow-y: auto;
+                padding: 12px; margin-bottom: 8px; display: flex; flex-direction: column; gap: 8px; }
+    .chat-msg { padding: 10px 14px; border-radius: 14px; font-size: 14px; line-height: 1.5;
+                word-wrap: break-word; max-width: 80%; white-space: pre-wrap;
+                box-shadow: 0 1px 2px rgba(0,0,0,0.4); }
+    .chat-msg.sent { background: #0096FF; color: #fff; align-self: flex-end;
+                     border-bottom-right-radius: 4px; }
+    .chat-msg.received { background: #1E1E2E; color: #E8E8F0; align-self: flex-start;
+                         border-bottom-left-radius: 4px; }
+    .chat-msg.error { background: #3B1010; color: #FF6B6B; align-self: flex-start; }
+    .chat-msg .meta { font-size: 10px; color: rgba(255,255,255,0.4); margin-top: 4px;
+                      display: block; }
     .chat-msg a { color: #66BBFF; text-decoration: underline; }
     .chat-msg.sent a { color: #CCEEFF; }
-    .chat-msg .chat-media { max-width: 100%; max-height: 200px; border-radius: 4px; margin-top: 4px; cursor: pointer; display: block; }
+    .chat-msg .chat-media { max-width: 100%; max-height: 200px; border-radius: 8px;
+                            margin-top: 6px; cursor: pointer; display: block; }
     .chat-msg .chat-media:hover { opacity: 0.85; }
     .lightbox-overlay { display:none; position:fixed; top:0; left:0; right:0; bottom:0; background:rgba(0,0,0,0.92);
                         z-index:2000; justify-content:center; align-items:center; cursor:pointer; }
     .lightbox-overlay.open { display:flex; }
     .lightbox-overlay img, .lightbox-overlay video { max-width:95vw; max-height:95vh; border-radius:8px; }
 
-    .input-row { display: flex; gap: 6px; }
-    .input-row input { flex: 1; background: #1E1E2E; border: 1px solid #333; border-radius: 6px;
-                       padding: 8px 12px; color: #E0E0F0; font-family: inherit; font-size: 13px; }
+    .input-row { display: flex; gap: 6px; align-items: flex-end; }
+    .input-row input, .input-row textarea {
+        flex: 1; background: #1E1E2E; border: 1px solid #333; border-radius: 6px;
+        padding: 8px 12px; color: #E0E0F0; font-family: inherit; font-size: 13px;
+    }
+    .input-row textarea { resize: none; min-height: 38px; max-height: 200px; line-height: 1.4;
+                          overflow-y: auto; }
 
     /* Terminal Modal */
     .modal-overlay { display:none; position:fixed; top:0; left:0; right:0; bottom:0; background:rgba(0,0,0,0.85);
@@ -282,7 +293,7 @@
           📎
           <input type="file" id="diag-file-input" multiple accept="image/*,application/pdf,.doc,.docx,.txt" style="display:none;" onchange="handleDiagFileSelect(this.files)">
         </label>
-        <input type="text" id="chat-input" placeholder="Nachricht an ARIA..." onpaste="handleDiagPaste(event)">
+        <textarea id="chat-input" placeholder="Nachricht an ARIA... (Enter sendet, Shift+Enter neue Zeile)" rows="2" onpaste="handleDiagPaste(event)" oninput="autoResizeTextarea(this)"></textarea>
         <button class="btn" id="btn-gw" onclick="testGateway()">Gateway senden</button>
         <button class="btn" id="btn-rvs" onclick="testRVS()">Via RVS senden</button>
       </div>
@@ -300,7 +311,7 @@
       <span style="animation:pulse 1s infinite;">&#x1F4AD;</span> <span id="thinking-text-fs">ARIA denkt...</span>
     </div>
     <div class="input-row" style="margin-top:8px;">
-      <input type="text" id="chat-input-fs" placeholder="Nachricht an ARIA..." onkeydown="if(event.key==='Enter'){testRVSFS();event.preventDefault();}">
+      <textarea id="chat-input-fs" placeholder="Nachricht an ARIA... (Enter sendet, Shift+Enter neue Zeile)" rows="2" oninput="autoResizeTextarea(this)"></textarea>
       <button class="btn" onclick="testGatewayFS()">Gateway senden</button>
       <button class="btn" onclick="testRVSFS()">Via RVS senden</button>
     </div>
@@ -2069,10 +2080,23 @@
       return str.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
     }
 
-    // Enter-Taste sendet via Gateway
-    document.getElementById('chat-input').addEventListener('keydown', (e) => {
-      if (e.key === 'Enter') testRVS();
-    });
+    // Auto-Resize fuer Textarea — wuchst mit dem Inhalt bis zum max-height
+    function autoResizeTextarea(el) {
+      el.style.height = 'auto';
+      el.style.height = Math.min(el.scrollHeight, 200) + 'px';
+    }
+
+    // Enter sendet, Shift+Enter macht neue Zeile (chat-Standard).
+    function chatInputKeydown(e, sendFn) {
+      if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault();
+        sendFn();
+        // Textarea zurueck auf 2 rows setzen
+        e.target.style.height = 'auto';
+      }
+    }
+    document.getElementById('chat-input').addEventListener('keydown', (e) => chatInputKeydown(e, testRVS));
+    document.getElementById('chat-input-fs').addEventListener('keydown', (e) => chatInputKeydown(e, testRVSFS));
 
     // Escape schliesst Lightbox
     document.addEventListener('keydown', (e) => {

diagnostic/server.js

@@ -716,11 +716,24 @@ function sendToRVS_withResponse(sendType, sendPayload, expectType, clientWs) {
 
 function sendToRVS_raw(msgObj) {
   if (!RVS_HOST || !RVS_TOKEN) return;
+  const payload = JSON.stringify(msgObj);
+  // Persistente Connection bevorzugen — die ist garantiert connected
+  // und wird vom RVS direkt an alle anderen Clients (App, Bridge) broadcastet.
+  // Frische Connections hatten Race-Probleme: die WS war nach dem send manchmal
+  // schon zu, bevor RVS broadcasten konnte → App-Nachrichten verloren.
+  if (rvsWs && rvsWs.readyState === WebSocket.OPEN) {
+    try {
+      rvsWs.send(payload);
+      return;
+    } catch (err) {
+      log("warn", "rvs", `persistente Verbindung send failed (${err.message}) — Fallback frische WS`);
+    }
+  }
   const proto = RVS_TLS === "true" ? "wss" : "ws";
   const url = `${proto}://${RVS_HOST}:${RVS_PORT}?token=${RVS_TOKEN}`;
   const freshWs = new WebSocket(url);
   freshWs.on("open", () => {
-    freshWs.send(JSON.stringify(msgObj));
+    freshWs.send(payload);
     setTimeout(() => { try { freshWs.close(); } catch (_) {} }, 5000);
   });
   freshWs.on("error", () => {});

docker-compose.yml

@@ -9,7 +9,7 @@ services:
     command: >-
       sh -c "apk add --no-cache openssh-client bash curl &&
       npm install -g @anthropic-ai/claude-code claude-max-api-proxy &&
-      DIST=$(find /usr/local/lib -path '*/claude-max-api-proxy/dist' -type d | head -1) &&
+      DIST=$$(find /usr/local/lib -path '*/claude-max-api-proxy/dist' -type d | head -1) &&
       sed -i 's/startServer({ port })/startServer({ port, host: process.env.HOST || \"127.0.0.1\" })/' $$DIST/server/standalone.js &&
       sed -i 's/if (model\.includes/if ((model||\"claude-sonnet-4\").includes/g' $$DIST/adapter/cli-to-openai.js &&
       sed -i '1i\\function _t(c){return typeof c===\"string\"?c:Array.isArray(c)?c.filter(function(b){return b.type===\"text\"}).map(function(b){return b.text||\"\"}).join(\"\"):String(c)}' $$DIST/adapter/openai-to-cli.js &&

issue.md

@@ -87,16 +87,37 @@
 - [x] App Text-Rendering: Nachrichten selektierbar + Autolink fuer URLs/E-Mails/Telefonnummern (Browser/Mail/Dialer)
 - [x] TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings → 0.5-2.0x in 0.1-Schritten, Default 1.0)
 - [x] Diagnostic: Voice-Preview-Modal (Play-Icon vor Delete-X, Textfeld mit Default, WAV im Browser abspielen)
+- [x] **Wake-Word komplett on-device via openWakeWord (ONNX Runtime)** — Porcupine raus, kein API-Key/keine Lizenzgebuehren mehr. Mitgelieferte Keywords: hey_jarvis, computer, alexa, hey_mycroft, hey_rhasspy
+- [x] Wake-Word Embedding rank-4 Fix (Pipeline-Bug der das Triggern verhinderte) + Frame-Count aus Modell-Metadaten lesen
+- [x] APK ABI-Split auf arm64-v8a — von ~136 MB auf ~35 MB, Auto-Update-Downloads aufs Phone deutlich kleiner
+- [x] PCM-Underrun-Schutz: Stille-Fill in Render-Pausen verhindert Spotify-Auto-Resume nach 10s Stillstand
+- [x] Conversation-Focus-Lifecycle: AudioFocus haengt am Wake-Word-State 'conversing' statt an einzelnen Streams — Spotify bleibt durchgehend gepaust, auch zwischen mehreren Antworten
+- [x] PhoneStateListener: TTS pausiert bei eingehendem Anruf (READ_PHONE_STATE Permission)
+- [x] Voice-Override behaelt Stimme ueber alle TTS-Calls einer Antwort (vorher: nach erstem TTS-Call zurueck auf Default)
+- [x] Sprachnachricht-Bubble defensiv: STT-Result fuegt neue Bubble hinzu wenn Placeholder fehlt (Race-Schutz)
+- [x] Bild + Text als EINE Anfrage: Bridge buffert files 800ms, merged mit folgendem chat-Text zu einem send_to_core (statt zwei getrennten ARIA-Antworten)
+- [x] Diagnostic-Chat: bubblige Formatierung, mehrzeiliges Eingabefeld (textarea, Enter sendet, Shift+Enter neue Zeile)
+- [x] Diagnostic→App: persistente RVS-Connection statt frische pro Send (Race-Probleme mit Zombie-WS geloest)
+- [x] Adaptive VAD-Schwelle: Baseline aus den ersten 500ms Mic-Pegel, Stille = baseline+6dB / Sprache = baseline+12dB. Funktioniert in lauten wie leisen Umgebungen
+- [x] Max-Aufnahmedauer konfigurierbar in Settings (1-30 min, Default 5 min) — laengere Diktate moeglich
+- [x] Barge-In: User kann ARIA waehrend Antwort/Tool-Use unterbrechen, alte Aktivitaet wird abgebrochen, Bridge gibt aria-core einen Kontext-Hint dass es eine Korrektur ist
+- [x] Push-to-Talk raus, nur noch Tap-to-Talk (verhinderte Touch-Race-Probleme)
+- [x] Settings-Sub-Screens: 8 Kategorien (Verbindung, Allgemein, Spracheingabe, Wake-Word, Sprachausgabe, Speicher, Protokoll, Ueber) statt langer Liste
+- [x] Textauswahl in Bubbles wieder funktional (nested Text+onPress raus, dataDetectorType="all" macht Links automatisch klickbar)
+- [x] **Placeholder-Race bei parallelen Sprachnachrichten geloest**: jede Aufnahme bekommt eine eindeutige audioRequestId, Bridge gibt sie ans STT-Result zurueck — App matcht jetzt punktgenau die richtige Bubble statt per Substring "Spracheingabe wird verarbeitet"
+- [x] Mikro-Offen-Toast "🎤 sprich jetzt" erscheint erst wenn audioService.startRecording wirklich erfolgreich war (statt ~400ms vorher beim Wake-Word-Detect)
+- [x] **Bereit-Sound (Airplane Ding-Dong) wenn Mikro nach Wake-Word offen** — akustische Bestaetigung statt nur Toast. Toggle in Settings → Wake-Word, default aktiv
+- [x] **Wake-Word parallel zu TTS** mit AcousticEchoCanceler: User sagt "Computer" waehrend ARIA spricht → TTS verstummt sofort, neue Aufnahme startet. Native AEC verhindert dass ARIAs eigene Stimme das Wake-Word triggert. Audio-Source ist VOICE_COMMUNICATION + zusaetzlich AEC/NS/AGC-Effekte aktiviert
 
 ## Offen
 
 ### Bugs
-- [ ] App: Wake-Word "jarvis" triggert nicht zuverlaessig (Porcupine-Debugging via ADB-Logcat ausstehend)
-- [ ] App: Stuerzt beim Lauschen ab, eventuell bei Nebengeraeuschen (Porcupine + Mic-Race, errorCallback haelt's jetzt zurueck — Dauertest ausstehend)
 
 ### App Features
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
 - [ ] Background Audio Service (TTS auch bei minimierter App)
+- [ ] Custom-Wake-Word-Upload via Diagnostic (eigene .onnx-Files ohne App-Rebuild)
+- [ ] Pause+Resume bei Anruf: aktuell wird der TTS-Stream bei Klingeln hart gestoppt, schoener waere Pause + Resume nach Auflegen
 
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)

xtts/f5tts/bridge.py

@@ -239,6 +239,8 @@ 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,
@@ -507,7 +509,8 @@ 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 (%s)", len(sentences), voice or "default", ref_wav_str)
+    logger.info("F5-TTS: %d Satz(e), voice=%s, speed=%.2fx (%s)",
+                len(sentences), voice or "default", speed, ref_wav_str)
 
     chunk_index = 0
     pcm_sr = TARGET_SR