release: bump version to 0.0.8.2

Wenn die adaptive Baseline-Logik in einer Umgebung nicht zuverlaessig
greift (Stefan: "manchmal funktioniert die Stille-Erkennung nicht"),
kann der User die Schwelle jetzt manuell setzen.

Settings → Spracheingabe:
- "Stille-Pegel (dB)" mit −1/+1 Buttons + "Auf automatisch zuruecksetzen"
- Range −55 bis −15 dB, default "auto" (= adaptive Baseline)
- Info-Icon (i) oeffnet Modal mit Erklaerung:
  • dB-Skala (negativ, naeher 0 = lauter)
  • Faustregel-Pegel mit Farb-Code (−45 sensibel, −38 ausgewogen, −25 robust)
  • Klarstellung "niedrigere Zahl = sensibler"

audio.ts:
- VAD_SILENCE_DB_OVERRIDE_KEY in AsyncStorage
- loadVadSilenceDbOverride() liefert null oder Zahl
- startRecording: wenn Override gesetzt, Adaptive-Baseline uebersteuert.
  Speech-Schwelle wird auf Override + 10 dB gesetzt. Toast zeigt
  "VAD: manuell stille>-XX dB"

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

README.md

@@ -378,10 +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
 - **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
-- **VAD (Voice Activity Detection)**: Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme 120s.
+- **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
@@ -415,7 +418,7 @@ Community-Modelle stammen aus [fwartner/home-assistant-wakewords-collection](htt
 **Bedienung:**
 - App → **Einstellungen** → **Wake-Word** → gewuenschtes Keyword waehlen → **Speichern + Aktivieren**
 - **Ohr-Button (👂)** in der Statusleiste tippen → Wake-Word ist scharf, App hoert passiv mit
-- Wake-Word sagen → Symbol wechselt auf 🎙️, Konversation laeuft
+- 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 (🔇)
 
@@ -565,8 +568,7 @@ aria-data/
 │   └── diag-state/                 ← Diagnostic persistenter State
 │
 │   (im Shared Volume /shared/config/):
-│   ├── voice_config.json           ← TTS-Einstellungen (Stimme, Speed, Engine)
+│   ├── voice_config.json           ← TTS-Einstellungen (Stimme, Speed, F5-TTS-Tuning)
-│   ├── highlight_triggers.json     ← Highlight-Trigger Woerter
 │   └── chat_backup.jsonl           ← Nachrichten-Backup (on-the-fly)
 │
 └── ssh/                            ← SSH Keys fuer VM-Zugriff
@@ -813,7 +815,7 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] SSH-Zugriff auf VM (aria-wohnung)
 - [x] Diagnostic Web-UI + Einstellungen
 - [x] Session-Verwaltung + Chat-History
-- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed, Highlight-Trigger) — durch XTTS v2 Voice Cloning ersetzt
+- [x] Stimmen-Einstellungen (frueher Piper Ramona/Thorsten, Highlight-Trigger) — durch XTTS, dann F5-TTS Voice Cloning ersetzt
 - [x] Piper komplett entfernt — nur noch XTTS v2 als TTS (Gaming-PC)
 - [x] Streaming TTS: PCM-Chunks direkt in AudioTrack, nahtlose Wiedergabe
 - [x] TTS satzweise fuer lange Texte
@@ -840,7 +842,17 @@ 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] GPS-Position mit Nachrichten mitsenden (Toggle in Settings) — ARIA nutzt sie nur bei standortbezogenen Fragen, im Chat sichtbar nur in ihrer Antwort
+- [x] Sprachnachrichten ohne STT-Result werden nach Timeout automatisch entfernt (skaliert mit Aufnahmedauer)
+- [x] Background Audio Service: TTS, Wake-Word-Lauschen + Aufnahme laufen auch bei minimierter App weiter (Foreground-Service mit mediaPlayback|microphone, dynamische Notification)
 - [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
 

android/android/app/build.gradle

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

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

@@ -6,6 +6,14 @@
     <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" />
+    <!-- Foreground-Service damit TTS auch bei minimierter App weiterlaeuft.
+         FOREGROUND_SERVICE_MICROPHONE ist Pflicht ab Android 14 wenn der
+         Service waehrend des Backgrounds aufs Mikro zugreift (Wake-Word,
+         Aufnahme im Gespraechsmodus). -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
       android:name=".MainApplication"
@@ -37,5 +45,10 @@
           android:name="android.support.FILE_PROVIDER_PATHS"
           android:resource="@xml/file_paths" />
       </provider>
+
+      <service
+        android:name=".AriaPlaybackService"
+        android:exported="false"
+        android:foregroundServiceType="mediaPlayback|microphone" />
     </application>
 </manifest>

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

@@ -0,0 +1,108 @@
+package com.ariacockpit
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.core.app.NotificationCompat
+
+/**
+ * Foreground-Service der den App-Prozess waehrend TTS-Wiedergabe am Leben
+ * haelt — Android killt sonst den Prozess sobald die App im Hintergrund ist
+ * und ARIA verstummt mitten im Satz.
+ *
+ * Notification ist persistent (ongoing) waehrend der Service laeuft.
+ * Tap auf die Notification bringt MainActivity zurueck nach vorne.
+ *
+ * foregroundServiceType="mediaPlayback" ist Pflicht ab Android 14, sonst
+ * wirft startForeground() eine SecurityException.
+ */
+class AriaPlaybackService : Service() {
+    companion object {
+        private const val TAG = "AriaPlaybackService"
+        private const val CHANNEL_ID = "aria_playback"
+        private const val NOTIFICATION_ID = 1042
+        const val EXTRA_REASON = "reason"  // "tts" | "wake" | "rec" | ""
+    }
+
+    private var currentReason: String = ""
+
+    override fun onCreate() {
+        super.onCreate()
+        ensureNotificationChannel()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val reason = intent?.getStringExtra(EXTRA_REASON) ?: ""
+        currentReason = reason
+        Log.i(TAG, "Foreground-Service start/update (reason=$reason)")
+        try {
+            startForeground(NOTIFICATION_ID, buildNotification(reason))
+        } catch (e: Exception) {
+            Log.e(TAG, "startForeground fehlgeschlagen", e)
+            stopSelf()
+        }
+        // START_NOT_STICKY: wenn Android den Service killt, NICHT automatisch
+        // wieder starten — die App entscheidet wann der Service noetig ist.
+        return START_NOT_STICKY
+    }
+
+    override fun onDestroy() {
+        Log.i(TAG, "Foreground-Service gestoppt")
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    private fun ensureNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val nm = getSystemService(NotificationManager::class.java) ?: return
+            if (nm.getNotificationChannel(CHANNEL_ID) == null) {
+                val channel = NotificationChannel(
+                    CHANNEL_ID,
+                    "ARIA Audio-Wiedergabe",
+                    NotificationManager.IMPORTANCE_LOW,
+                ).apply {
+                    description = "Notification waehrend ARIA spricht (haelt die App im Hintergrund am Leben)"
+                    setShowBadge(false)
+                }
+                nm.createNotificationChannel(channel)
+            }
+        }
+    }
+
+    private fun buildNotification(reason: String): Notification {
+        val launchIntent = Intent(this, MainActivity::class.java).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        }
+        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+        else
+            PendingIntent.FLAG_UPDATE_CURRENT
+        val pendingIntent = PendingIntent.getActivity(this, 0, launchIntent, pendingFlags)
+
+        val (title, body) = when (reason) {
+            "tts"  -> "ARIA spricht" to "Antwort wird abgespielt — antippen oeffnet die App"
+            "rec"  -> "ARIA hoert zu" to "Sprachaufnahme laeuft — antippen oeffnet die App"
+            "wake" -> "ARIA bereit"   to "Wake-Word lauscht passiv — antippen oeffnet die App"
+            else   -> "ARIA aktiv"    to "Hintergrund-Modus — antippen oeffnet die App"
+        }
+
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true)
+            .setShowWhen(false)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setCategory(NotificationCompat.CATEGORY_SERVICE)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .build()
+    }
+}

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

@@ -0,0 +1,59 @@
+package com.ariacockpit
+
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+/**
+ * RN-Bridge fuer den AriaPlaybackService.
+ *
+ * Wird vom JS waehrend einer TTS-Wiedergabe gestartet damit Android den
+ * App-Prozess nicht killt wenn die App im Hintergrund ist (= ARIA spricht
+ * weiter, auch wenn Stefan die App minimiert hat).
+ *
+ * Service stoppt entweder explizit per stop() oder wird von Android
+ * mitgekillt wenn der Prozess weg ist (was bei Foreground-Service nur
+ * passiert wenn der User die App force-stopped).
+ */
+class BackgroundAudioModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "BackgroundAudio"
+
+    companion object { private const val TAG = "BackgroundAudio" }
+
+    @ReactMethod
+    fun start(reason: String, promise: Promise) {
+        try {
+            val ctx = reactApplicationContext
+            val intent = Intent(ctx, AriaPlaybackService::class.java)
+            intent.putExtra(AriaPlaybackService.EXTRA_REASON, reason ?: "")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                ctx.startForegroundService(intent)
+            } else {
+                ctx.startService(intent)
+            }
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "start fehlgeschlagen: ${e.message}")
+            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
+        }
+    }
+
+    @ReactMethod
+    fun stop(promise: Promise) {
+        try {
+            val ctx = reactApplicationContext
+            ctx.stopService(Intent(ctx, AriaPlaybackService::class.java))
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "stop fehlgeschlagen: ${e.message}")
+            promise.reject("STOP_FAILED", e.message ?: "Unbekannter Fehler", e)
+        }
+    }
+
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+}

android/android/app/src/main/java/com/ariacockpit/BackgroundAudioPackage.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 BackgroundAudioPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(BackgroundAudioModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

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

@@ -23,6 +23,7 @@ class MainApplication : Application(), ReactApplication {
               add(PcmStreamPlayerPackage())
               add(OpenWakeWordPackage())
               add(PhoneCallPackage())
+              add(BackgroundAudioPackage())
             }
 
         override fun getJSMainModuleName(): String = "index"

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

@@ -8,6 +8,9 @@ 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
@@ -70,6 +73,13 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
     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
@@ -146,8 +156,12 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
                 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.MIC,
+                MediaRecorder.AudioSource.VOICE_COMMUNICATION,
                 SAMPLE_RATE,
                 AudioFormat.CHANNEL_IN_MONO,
                 AudioFormat.ENCODING_PCM_16BIT,
@@ -159,6 +173,27 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
                 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()
@@ -179,6 +214,13 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
         }
     }
 
+    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)
@@ -189,6 +231,7 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
         try { audioRecord?.stop() } catch (_: Exception) {}
         try { audioRecord?.release() } catch (_: Exception) {}
         audioRecord = null
+        releaseAudioEffects()
         Log.i(TAG, "Lauschen gestoppt")
         promise.resolve(true)
     }
@@ -201,6 +244,7 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
         try { audioRecord?.stop() } catch (_: Exception) {}
         try { audioRecord?.release() } catch (_: Exception) {}
         audioRecord = null
+        releaseAudioEffects()
         disposeSessions()
         promise.resolve(true)
     }

android/package.json

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

android/src/components/MessageText.tsx

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

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

@@ -19,6 +19,7 @@ import {
   ScrollView,
   Modal,
   ToastAndroid,
+  AppState,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
@@ -26,6 +27,11 @@ 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 {
+  acquireBackgroundAudio,
+  releaseBackgroundAudio,
+} from '../services/backgroundAudio';
 import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
@@ -55,6 +61,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 ---
@@ -137,9 +147,10 @@ const ChatScreen: React.FC = () => {
     return `msg_${Date.now()}_${messageIdCounter.current}`;
   };
 
-  // TTS-Settings beim Mount + bei Screen-Fokus neu laden (damit Settings-Toggle sofort greift)
+  // TTS- + GPS-Settings beim Mount + alle 2s neu laden (damit Settings-Toggle
+  // sofort greift, ohne Context- oder Event-System)
   useEffect(() => {
-    const loadTtsSettings = async () => {
+    const loadSettings = async () => {
       const enabled = await AsyncStorage.getItem('aria_tts_enabled');
       setTtsDeviceEnabled(enabled !== 'false'); // default true
       const muted = await AsyncStorage.getItem('aria_tts_muted');
@@ -147,10 +158,11 @@ const ChatScreen: React.FC = () => {
       const voice = await AsyncStorage.getItem('aria_xtts_voice');
       localXttsVoiceRef.current = voice || '';
       ttsSpeedRef.current = await loadTtsSpeed();
+      const gps = await AsyncStorage.getItem('aria_gps_enabled');
+      setGpsEnabled(gps === 'true');
     };
-    loadTtsSettings();
+    loadSettings();
-    // Poll alle 2s um Settings-Aenderung mitzubekommen (einfache Loesung ohne Context)
+    const interval = setInterval(loadSettings, 2000);
-    const interval = setInterval(loadTtsSettings, 2000);
     return () => clearInterval(interval);
   }, []);
 
@@ -166,6 +178,11 @@ const ChatScreen: React.FC = () => {
       // 'armed' oder 'off' fallen, darf Spotify wieder.
       if (s === 'conversing') audioService.acquireConversationFocus();
       else audioService.releaseConversationFocus();
+      // Foreground-Service-Slot 'wake' — solange das Ohr ueberhaupt aktiv ist
+      // (armed oder conversing), soll der App-Prozess im Hintergrund am Leben
+      // bleiben damit Mikro-Lauschen + Aufnahme weiterlaufen.
+      if (s !== 'off') acquireBackgroundAudio('wake').catch(() => {});
+      else releaseBackgroundAudio('wake').catch(() => {});
     });
     return () => unsub();
   }, []);
@@ -177,6 +194,31 @@ const ChatScreen: React.FC = () => {
     return () => { phoneCallService.stop().catch(() => {}); };
   }, []);
 
+  // App-Resume: kurzer Wake-Word-Cooldown — beim Wechsel Background→Foreground
+  // gibt's haeufig Audio-Pegel-Spikes (AudioFocus-Switch, AudioTrack re-route)
+  // die openWakeWord sonst faelschlich als Wake-Word interpretiert.
+  useEffect(() => {
+    let lastState: string = AppState.currentState;
+    const sub = AppState.addEventListener('change', (next) => {
+      if (lastState !== 'active' && next === 'active') {
+        wakeWordService.setResumeCooldown(1500);
+      }
+      lastState = next;
+    });
+    return () => sub.remove();
+  }, []);
+
+  // Recording-State an Background-Service-Slot 'rec' koppeln — damit das Mikro
+  // auch im Hintergrund weiter aufnehmen darf (Android killt den App-Prozess
+  // sonst und die Aufnahme bricht ab).
+  useEffect(() => {
+    const unsub = audioService.onStateChange((s) => {
+      if (s === 'recording') acquireBackgroundAudio('rec').catch(() => {});
+      else releaseBackgroundAudio('rec').catch(() => {});
+    });
+    return () => unsub();
+  }, []);
+
   // ttsCanPlayRef live aktuell halten — Closure in onMessage unten liest
   // darueber statt direkt ttsDeviceEnabled/ttsMuted (sonst stale).
   useEffect(() => {
@@ -283,6 +325,8 @@ 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.
         // WICHTIG: Nur die ERSTE noch unaufgeloeste Aufnahme matchen — sonst
@@ -290,30 +334,42 @@ const ChatScreen: React.FC = () => {
         // den gleichen Text bekommen (Bug: zweite Antwort ueberschreibt erste).
         if (sender === 'stt') {
           const sttText = (message.payload.text as string) || '';
-          if (sttText) {
+          const sttAudioReqId = (message.payload.audioRequestId as string) || '';
-            setMessages(prev => {
+          if (!sttText) {
-              const idx = prev.findIndex(m =>
+            return;
-                m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
+          }
-              );
+          setMessages(prev => {
-              const newText = `\uD83C\uDFA4 ${sttText}`;
+            const newText = `\uD83C\uDFA4 ${sttText}`;
-              if (idx < 0) {
+            // Primaer: matche per audioRequestId (eindeutig pro Aufnahme).
-                // Defensiv: wenn keine Placeholder im State (z.B. weil sie nie
+            // So gibt's keine Verwechslung wenn zwei Audios kurz hintereinander
-                // hinzugefuegt wurde oder schon durch ein anderes Update verloren
+            // gesendet wurden und ihre STT-Results ueberlappen.
-                // ging), die Sprachnachricht trotzdem als neue Bubble einfuegen.
+            if (sttAudioReqId) {
-                // Sonst kommt ARIAs Antwort ohne sichtbare User-Nachricht.
+              const idxById = prev.findIndex(m => m.audioRequestId === sttAudioReqId);
-                return capMessages([...prev, {
+              if (idxById >= 0) {
-                  id: nextId(),
+                const next = prev.slice();
-                  sender: 'user',
+                next[idxById] = { ...next[idxById], text: newText };
-                  text: newText,
+                return next;
-                  timestamp: message.timestamp,
-                  attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
-                }]);
               }
+            }
+            // 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;
         }
 
@@ -475,7 +531,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();
       }
@@ -486,13 +549,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', {
@@ -501,8 +568,11 @@ const ChatScreen: React.FC = () => {
           mimeType: result.mimeType,
           voice: localXttsVoiceRef.current,
           speed: ttsSpeedRef.current,
+          interrupted: wasInterrupted,
+          audioRequestId,
           ...(location && { location }),
         });
+        scheduleStaleAudioCleanup(audioRequestId, result.durationMs);
         // resume() wird durch onPlaybackFinished nach ARIAs Antwort getriggert.
       } else {
         // Kein Speech im Window → Konversation beenden (Ohr geht aus oder
@@ -513,9 +583,47 @@ 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.
+    // PLUS: Foreground-Service-Slot 'tts' belegen damit Android den App-
+    // Prozess nicht killt wenn die App im Hintergrund ist.
+    const unsubTtsStart = audioService.onPlaybackStarted(() => {
+      acquireBackgroundAudio('tts').catch(() => {});
+      if (wakeWordService.isConversing() && wakeWordService.hasWakeWord()) {
+        wakeWordService.startBargeListening().catch(() => {});
+      }
+    });
+    const unsubTtsEnd = audioService.onPlaybackFinished(() => {
+      releaseBackgroundAudio('tts').catch(() => {});
+      // Vor naechster Aufnahme: barge-listening aus damit der AudioRecorder
+      // das Mikro greifen kann.
+      wakeWordService.stopBargeListening().catch(() => {});
+    });
+
     return () => {
       unsubWake();
       unsubSilence();
+      unsubBarge();
+      unsubTtsStart();
+      unsubTtsEnd();
     };
   }, [wakeWordActive]);
 
@@ -590,6 +698,29 @@ 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). Timeout skaliert
+  // mit der Aufnahmedauer — Whisper braucht auf der Gamebox grob real-time/5,
+  // plus Bridge-Roundtrip + Network. Formel: 60s Buffer + 1x Aufnahmedauer.
+  // Bei 5min Aufnahme = 6 min Wait, bei 5s Aufnahme = 65s. Sicher genug damit
+  // langsame STTs nicht versehentlich aufgeraeumt werden.
+  const scheduleStaleAudioCleanup = useCallback((audioRequestId: string, recordingMs: number) => {
+    const timeoutMs = 60000 + recordingMs;
+    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 nach %dms entfernt: %s',
+                    timeoutMs, audioRequestId);
+        ToastAndroid.show('Sprachnachricht nicht erkannt — entfernt', ToastAndroid.SHORT);
+        return prev.filter((_, i) => i !== idx);
+      });
+    }, timeoutMs);
+  }, []);
+
   const sendTextMessage = useCallback(async () => {
     const text = inputText.trim();
 
@@ -603,6 +734,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 = {
@@ -613,16 +746,17 @@ const ChatScreen: React.FC = () => {
     };
     setMessages(prev => capMessages([...prev, userMsg]));
 
-    console.log('[Chat] sende mit voice=%s speed=%s',
+    console.log('[Chat] sende mit voice=%s speed=%s interrupted=%s',
-                localXttsVoiceRef.current || '(default)', ttsSpeedRef.current);
+                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(() => {
@@ -630,15 +764,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]));
 
@@ -648,9 +804,23 @@ const ChatScreen: React.FC = () => {
       mimeType: result.mimeType,
       voice: localXttsVoiceRef.current,
       speed: ttsSpeedRef.current,
+      interrupted: wasInterrupted,
+      audioRequestId,
       ...(location && { location }),
     });
-  }, [getCurrentLocation]);
+    scheduleStaleAudioCleanup(audioRequestId, result.durationMs);
+
+    // Manueller Mikro-Stop waehrend Wake-Word-Konversation: User hat explizit
+    // den Knopf gedrueckt → er moechte nicht in den automatischen Multi-Turn-
+    // Modus, sondern nach ARIAs Antwort zurueck zu passivem Wake-Word-Lauschen.
+    // Bei VAD-Auto-Stop (Wake-Word-Pfad) laeuft das ueber den silence-callback
+    // und endet mit resume() — der manuelle Stop hier ist der "ich bin fertig"-
+    // Knopf.
+    if (wakeWordService.isConversing()) {
+      console.log('[Chat] Manueller Stop in Konversation → endConversation, zurueck zu armed');
+      await wakeWordService.endConversation();
+    }
+  }, [getCurrentLocation, interruptAriaIfBusy, scheduleStaleAudioCleanup]);
 
   // Datei auswaehlen → zur Pending-Liste hinzufuegen
   const handleFileSelected = useCallback(async (file: FileData) => {

android/src/screens/SettingsScreen.tsx

@@ -17,6 +17,7 @@ import {
   Platform,
   ToastAndroid,
   ActivityIndicator,
+  Modal,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
@@ -35,11 +36,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,
+  VAD_SILENCE_DB_DEFAULT,
+  VAD_SILENCE_DB_MIN,
+  VAD_SILENCE_DB_MAX,
+  VAD_SILENCE_DB_OVERRIDE_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, {
   WAKE_KEYWORDS,
   KEYWORD_LABELS,
@@ -72,6 +86,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,15 +128,24 @@ 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);
+  // null = automatisch (adaptive Baseline), sonst manueller dB-Override
+  const [vadSilenceDb, setVadSilenceDb] = useState<number | null>(null);
+  const [showVadInfo, setShowVadInfo] = useState(false);
   const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
   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;
 
@@ -132,6 +167,9 @@ const SettingsScreen: React.FC = () => {
     AsyncStorage.getItem('aria_tts_enabled').then(saved => {
       if (saved !== null) setTtsEnabled(saved === 'true');
     });
+    AsyncStorage.getItem('aria_gps_enabled').then(saved => {
+      if (saved !== null) setGpsEnabled(saved === 'true');
+    });
     AsyncStorage.getItem(TTS_PREROLL_STORAGE_KEY).then(saved => {
       if (saved != null) {
         const n = parseFloat(saved);
@@ -156,6 +194,22 @@ 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(VAD_SILENCE_DB_OVERRIDE_KEY).then(saved => {
+      if (saved != null && saved !== '') {
+        const n = parseFloat(saved);
+        if (isFinite(n) && n >= VAD_SILENCE_DB_MIN && n <= VAD_SILENCE_DB_MAX) {
+          setVadSilenceDb(n);
+        }
+      }
+    });
     AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY).then(saved => {
       if (saved != null) {
         const n = parseFloat(saved);
@@ -165,6 +219,7 @@ const SettingsScreen: React.FC = () => {
     AsyncStorage.getItem(WAKE_KEYWORD_STORAGE).then(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);
     });
@@ -401,7 +456,7 @@ const SettingsScreen: React.FC = () => {
 
   const handleGPSToggle = useCallback((value: boolean) => {
     setGpsEnabled(value);
-    // In Produktion: Wert in AsyncStorage persistieren
+    AsyncStorage.setItem('aria_gps_enabled', String(value)).catch(() => {});
   }, []);
 
   // --- XTTS Voice ---
@@ -480,7 +535,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 */}
@@ -577,8 +664,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} />
@@ -591,7 +680,11 @@ const SettingsScreen: React.FC = () => {
           <View style={styles.toggleInfo}>
             <Text style={styles.toggleLabel}>GPS-Position mitsenden</Text>
             <Text style={styles.toggleHint}>
-              Standort wird automatisch an Nachrichten angehaengt
+              Position (lat/lon) wird mit jeder Nachricht an ARIA mitgeschickt.
+              Sie sieht's nur intern und nutzt es bei standortbezogenen Fragen
+              ("wo bin ich?", "Wetter hier?"), erwaehnt es sonst nicht.
+              Im Chat-Verlauf bleibt die Bubble unveraendert — nur ARIAs
+              Antwort kann darauf eingehen.
             </Text>
           </View>
           <Switch
@@ -602,8 +695,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>
@@ -671,9 +766,130 @@ 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 style={{flexDirection: 'row', alignItems: 'center', marginTop: 24, gap: 8}}>
+          <Text style={styles.toggleLabel}>Stille-Pegel (dB)</Text>
+          <TouchableOpacity onPress={() => setShowVadInfo(true)} style={styles.infoBtn}>
+            <Text style={styles.infoBtnText}>i</Text>
+          </TouchableOpacity>
+        </View>
+        <Text style={styles.toggleHint}>
+          Welcher Mikro-Pegel als "Stille" gilt. Standard: automatisch (Baseline aus
+          den ersten 500ms). Manuell setzen wenn Auto nicht zuverlaessig greift.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = vadSilenceDb == null
+                ? VAD_SILENCE_DB_DEFAULT - 1
+                : Math.max(VAD_SILENCE_DB_MIN, vadSilenceDb - 1);
+              setVadSilenceDb(next);
+              AsyncStorage.setItem(VAD_SILENCE_DB_OVERRIDE_KEY, String(next));
+            }}
+          >
+            <Text style={styles.prerollButtonText}>−1</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>
+            {vadSilenceDb == null ? 'auto' : `${vadSilenceDb} dB`}
+          </Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = vadSilenceDb == null
+                ? VAD_SILENCE_DB_DEFAULT + 1
+                : Math.min(VAD_SILENCE_DB_MAX, vadSilenceDb + 1);
+              setVadSilenceDb(next);
+              AsyncStorage.setItem(VAD_SILENCE_DB_OVERRIDE_KEY, String(next));
+            }}
+          >
+            <Text style={styles.prerollButtonText}>+1</Text>
+          </TouchableOpacity>
+        </View>
+        {vadSilenceDb != null && (
+          <TouchableOpacity
+            onPress={() => {
+              setVadSilenceDb(null);
+              AsyncStorage.removeItem(VAD_SILENCE_DB_OVERRIDE_KEY);
+            }}
+            style={{alignSelf: 'center', marginTop: 8, paddingVertical: 6, paddingHorizontal: 12}}
+          >
+            <Text style={{color: '#0096FF', fontSize: 13}}>↻ Auf automatisch zuruecksetzen</Text>
+          </TouchableOpacity>
+        )}
       </View>
 
+      <Modal
+        visible={showVadInfo}
+        transparent
+        animationType="fade"
+        onRequestClose={() => setShowVadInfo(false)}
+      >
+        <View style={styles.modalOverlay}>
+          <View style={styles.modalCard}>
+            <Text style={styles.modalTitle}>Stille-Pegel (dB)</Text>
+            <Text style={styles.modalText}>
+              Lautstaerken werden in Dezibel (dB) gemessen — negative Werte, je
+              hoeher (naeher an 0), desto lauter.{'\n\n'}
+              <Text style={{fontWeight: '700'}}>Standard:</Text> automatisch.
+              Die App misst die ersten 500ms Hintergrundpegel und setzt die
+              Stille-Schwelle auf Baseline + 6 dB. Funktioniert in den meisten
+              Umgebungen.{'\n\n'}
+              <Text style={{fontWeight: '700'}}>Manuell:</Text> Pegel unter dem
+              eingestellten Wert gilt als "Stille" → Aufnahme stoppt.{'\n\n'}
+              <Text style={{fontWeight: '700'}}>Faustregel:</Text>{'\n'}
+              • <Text style={{color: '#FFD60A'}}>−45 dB</Text> sehr empfindlich (stoppt schnell, auch bei Atmen){'\n'}
+              • <Text style={{color: '#34C759'}}>−38 dB</Text> ausgewogen (typische Bueroumgebung){'\n'}
+              • <Text style={{color: '#FF6B6B'}}>−25 dB</Text> unempfindlich (laute Umgebung, nur klare Sprache zaehlt){'\n\n'}
+              <Text style={{color: '#8888AA'}}>Niedrigere Zahl (z.B. −50) = sensibler.{'\n'}
+              Hoehere Zahl (z.B. −20) = robuster gegen Hintergrundlaerm,
+              braucht aber lautere Sprache.</Text>
+            </Text>
+            <TouchableOpacity
+              style={[styles.connectButton, {marginTop: 16, alignSelf: 'stretch'}]}
+              onPress={() => setShowVadInfo(false)}
+            >
+              <Text style={styles.connectButtonText}>OK</Text>
+            </TouchableOpacity>
+          </View>
+        </View>
+      </Modal>
+      </>)}
+
       {/* === Wake-Word (komplett on-device, openWakeWord) === */}
+      {currentSection === 'wake_word' && (<>
       <Text style={styles.sectionTitle}>Wake-Word</Text>
       <View style={styles.card}>
         <Text style={styles.toggleHint}>
@@ -728,9 +944,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}>
@@ -873,7 +1116,10 @@ const SettingsScreen: React.FC = () => {
         )}
       </View>
 
+      </>)}
+
       {/* === Speicher === */}
+      {currentSection === 'storage' && (<>
       <Text style={styles.sectionTitle}>Anhang-Speicher</Text>
       <View style={styles.card}>
         <View style={styles.toggleRow}>
@@ -948,7 +1194,10 @@ const SettingsScreen: React.FC = () => {
         )}
       </View>
 
+      </>)}
+
       {/* === Logs === */}
+      {currentSection === 'protocol' && (<>
       <Text style={styles.sectionTitle}>Protokoll</Text>
       <View style={styles.card}>
         {/* Tab-Umschalter */}
@@ -1027,8 +1276,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>
@@ -1048,6 +1299,7 @@ const SettingsScreen: React.FC = () => {
           <Text style={styles.connectButtonText}>Auf Updates pr{'\u00FC'}fen</Text>
         </TouchableOpacity>
       </View>
+      </>)}
 
       {/* Platz am Ende */}
       <View style={styles.bottomSpacer} />
@@ -1076,6 +1328,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,
@@ -1433,6 +1737,48 @@ const styles = StyleSheet.create({
     textAlign: 'center',
   },
 
+  infoBtn: {
+    width: 22,
+    height: 22,
+    borderRadius: 11,
+    borderWidth: 1.5,
+    borderColor: '#0096FF',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  infoBtnText: {
+    color: '#0096FF',
+    fontSize: 13,
+    fontWeight: '700',
+    fontStyle: 'italic',
+    lineHeight: 16,
+  },
+  modalOverlay: {
+    flex: 1,
+    backgroundColor: 'rgba(0,0,0,0.7)',
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+  },
+  modalCard: {
+    backgroundColor: '#1E1E2E',
+    borderRadius: 14,
+    padding: 20,
+    maxWidth: 460,
+    width: '100%',
+  },
+  modalTitle: {
+    color: '#FFFFFF',
+    fontSize: 18,
+    fontWeight: '700',
+    marginBottom: 12,
+  },
+  modalText: {
+    color: '#E0E0F0',
+    fontSize: 14,
+    lineHeight: 20,
+  },
+
   keywordChip: {
     backgroundColor: '#1E1E2E',
     borderWidth: 1,

android/src/services/audio.ts

@@ -6,10 +6,11 @@
  * 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';
+import { acquireBackgroundAudio, releaseBackgroundAudio, stopBackgroundAudio } from './backgroundAudio';
 import AudioRecorderPlayer, {
   AudioEncoderAndroidType,
   AudioSourceAndroidType,
@@ -72,11 +73,41 @@ const AUDIO_SAMPLE_RATE = 16000;
 const AUDIO_CHANNELS = 1;
 const AUDIO_ENCODING = 'audio/wav';
 
-// VAD (Voice Activity Detection) — Stille-Erkennung
+// VAD (Voice Activity Detection) — Stille-Erkennung.
-const VAD_SILENCE_THRESHOLD_DB = -45;  // dB unter dem als "Stille" gilt
+// Fallback-Werte falls die adaptive Baseline-Messung fehlschlaegt (z.B. weil
-const VAD_SPEECH_THRESHOLD_DB = -28;   // dB ueber dem als "Sprache" gilt (Sprach-Gate) — hoeher = weniger Umgebungsgeraeusche
+// 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
 
+// Override fuer die Stille-Schwelle — wenn gesetzt, wird die adaptive Baseline
+// ignoriert. Nuetzlich wenn die adaptive Logik in spezifischen Umgebungen
+// nicht zuverlaessig greift. Range -55..-15 dB. Speech-Schwelle wird auf
+// override+10 dB gesetzt (Speech muss klar lauter als Stille sein).
+export const VAD_SILENCE_DB_DEFAULT = -38;  // wenn User Manuell-Modus waehlt
+export const VAD_SILENCE_DB_MIN = -55;      // sehr empfindlich, fast jeder Pegel ist "Sprache"
+export const VAD_SILENCE_DB_MAX = -15;      // sehr unempfindlich, nur lautes Reden gilt
+export const VAD_SILENCE_DB_OVERRIDE_KEY = 'aria_vad_silence_db_override';
+
+/** Liefert den manuellen Override-Wert oder null wenn "automatisch". */
+export async function loadVadSilenceDbOverride(): Promise<number | null> {
+  try {
+    const raw = await AsyncStorage.getItem(VAD_SILENCE_DB_OVERRIDE_KEY);
+    if (raw == null || raw === '') return null;
+    const n = parseFloat(raw);
+    if (!isFinite(n)) return null;
+    if (n < VAD_SILENCE_DB_MIN || n > VAD_SILENCE_DB_MAX) return null;
+    return n;
+  } catch {
+    return null;
+  }
+}
+
 // VAD-Stille (in Sekunden) — wie lange Sprechpause toleriert wird, bevor
 // die Aufnahme automatisch beendet wird. Einstellbar in den App-Settings.
 export const VAD_SILENCE_DEFAULT_SEC = 2.8;
@@ -138,7 +169,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).
@@ -212,6 +260,14 @@ 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();
@@ -270,6 +326,14 @@ class AudioService {
     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> {
@@ -327,6 +391,12 @@ class AudioService {
 
       this.recordingPath = `${RNFS.CachesDirectoryPath}/aria_recording_${Date.now()}.mp4`;
 
+      // Foreground-Service VOR dem AudioRecord starten — sonst blockt Android
+      // den Background-Mic-Zugriff (foregroundServiceType=microphone muss zum
+      // Zeitpunkt des startRecorder() schon aktiv sein, sonst greifen die
+      // Background-Mic-Restrictions ab Android 11+).
+      await acquireBackgroundAudio('rec');
+
       // Aufnahme mit Metering starten
       await this.recorder.startRecorder(this.recordingPath, {
         AudioEncoderAndroid: AudioEncoderAndroidType.AAC,
@@ -341,8 +411,36 @@ 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) {
+              // Minimum statt Mittelwert: robust gegen Spike-Samples (z.B. wenn
+              // der User direkt nach Wake-Word sofort spricht oder das Wake-Word-
+              // Echo noch im Mikro ist). Min ist der ruhigste Moment.
+              const lowest = Math.min(...this.vadBaselineSamples);
+              const rawSilence = lowest + VAD_SILENCE_OFFSET_DB;
+              const rawSpeech = lowest + VAD_SPEECH_OFFSET_DB;
+              // Cap auf einen vernuenftigen Bereich:
+              // - Silence-Schwelle nicht ueber -28dB (sonst zaehlt Hintergrund-
+              //   geraeusch dauerhaft als "Sprache" → VAD feuert nie)
+              // - Silence-Schwelle nicht unter -50dB (sonst zu strikt)
+              this.vadAdaptiveSilenceDb = Math.max(-50, Math.min(rawSilence, -28));
+              this.vadAdaptiveSpeechDb = Math.max(-40, Math.min(rawSpeech, -18));
+              const msg = `VAD: ambient=${lowest.toFixed(0)}dB stille>${this.vadAdaptiveSilenceDb.toFixed(0)}dB`;
+              console.log('[Audio] %s speech>%s (raw silence=%s speech=%s)',
+                          msg, this.vadAdaptiveSpeechDb.toFixed(1),
+                          rawSilence.toFixed(1), rawSpeech.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();
           }
@@ -357,7 +455,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();
           }
         }
@@ -367,6 +465,23 @@ 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.
+      this.vadBaselineSamples = [];
+      this.vadAdaptiveSilenceDb = VAD_SILENCE_FALLBACK_DB;
+      this.vadAdaptiveSpeechDb = VAD_SPEECH_FALLBACK_DB;
+
+      // Manueller Override aus Settings — wenn gesetzt, wird die adaptive
+      // Baseline-Messung uebersteuert. User-Wahl gewinnt vor Auto-Magic.
+      const dbOverride = await loadVadSilenceDbOverride();
+      if (dbOverride != null) {
+        this.vadAdaptiveSilenceDb = dbOverride;
+        this.vadAdaptiveSpeechDb = dbOverride + 10;  // Speech klar ueber Stille
+        this.vadBaselineSamples = new Array(VAD_BASELINE_SAMPLES).fill(0);  // Baseline-Sammeln deaktivieren
+        const msg = `VAD: manuell stille>${dbOverride}dB`;
+        console.log('[Audio] %s', msg);
+        try { ToastAndroid.show(msg, ToastAndroid.SHORT); } catch {}
+      }
       this.setState('recording');
 
       // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
@@ -394,18 +509,19 @@ class AudioService {
       };
       if (autoStop) {
         const vadSilenceMs = await loadVadSilenceMs();
+        const maxRecordingMs = await loadMaxRecordingMs();
         console.log('[Audio] startRecording: autoStop=true, VAD-Stille=%dms, MAX=%dms',
-                    vadSilenceMs, MAX_RECORDING_MS);
+                    vadSilenceMs, maxRecordingMs);
         this.vadTimer = setInterval(() => {
           const silenceDuration = Date.now() - this.lastSpeechTime;
           if (silenceDuration >= vadSilenceMs) {
             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`);
+          fireSilenceOnce(`Max-Dauer ${maxRecordingMs}ms`);
-        }, MAX_RECORDING_MS);
+        }, maxRecordingMs);
       }
 
       // Conversation-Window: Wenn der User innerhalb noSpeechTimeoutMs nicht
@@ -604,6 +720,7 @@ class AudioService {
         }
         this._cancelDeferredFocusRelease();
         AudioFocus?.requestDuck().catch(() => {});
+        this._firePlaybackStarted();
       }
     }
 
@@ -718,6 +835,7 @@ class AudioService {
 
   // Callback wenn alle Audio-Teile abgespielt sind
   private playbackFinishedListeners: (() => void)[] = [];
+  private playbackStartedListeners: (() => void)[] = [];
 
   onPlaybackFinished(callback: () => void): () => void {
     this.playbackFinishedListeners.push(callback);
@@ -726,6 +844,21 @@ 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) {
@@ -738,10 +871,11 @@ class AudioService {
       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;
 
@@ -805,6 +939,9 @@ class AudioService {
 
   /** Laufende Wiedergabe stoppen + Queue leeren */
   stopPlayback(): void {
+    // Foreground-Service auch stoppen — sonst bleibt die Notification haengen
+    // wenn Wiedergabe abgebrochen wird (Anruf, Cancel, Barge-In).
+    stopBackgroundAudio().catch(() => {});
     this.audioQueue = [];
     this.isPlaying = false;
     if (this.currentSound) {

android/src/services/backgroundAudio.ts

@@ -0,0 +1,76 @@
+/**
+ * Background-Audio: ARIAs TTS, Mic-Aufnahme und Wake-Word-Lauschen sollen
+ * auch bei minimierter App weiterlaufen. Wir starten dafuer einen Foreground-
+ * Service mit foregroundServiceType=mediaPlayback|microphone, der eine
+ * persistente Notification zeigt waehrend irgendein Audio-Slot aktiv ist.
+ *
+ * Mehrere Komponenten koennen den Service unabhaengig "halten":
+ *   - 'tts'  : ARIA spricht
+ *   - 'rec'  : Aufnahme laeuft
+ *   - 'wake' : Wake-Word lauscht passiv (Ohr aktiv)
+ *
+ * Solange mindestens ein Slot aktiv ist, laeuft der Service. Wenn alle
+ * Slots leer sind, wird er gestoppt. Der Notification-Text passt sich an
+ * den hoechstprioren Slot an (tts > rec > wake).
+ */
+
+import { NativeModules } from 'react-native';
+
+interface BackgroundAudioNative {
+  start(reason: string): Promise<boolean>;
+  stop(): Promise<boolean>;
+}
+
+const { BackgroundAudio } = NativeModules as { BackgroundAudio?: BackgroundAudioNative };
+
+type Slot = 'tts' | 'rec' | 'wake';
+
+const slots = new Set<Slot>();
+
+// Prioritaet fuer den Notification-Text — hoechste zuerst.
+const PRIORITY: Slot[] = ['tts', 'rec', 'wake'];
+
+function topReason(): string {
+  for (const s of PRIORITY) {
+    if (slots.has(s)) return s;
+  }
+  return '';
+}
+
+async function applyState(): Promise<void> {
+  if (!BackgroundAudio) return;
+  if (slots.size === 0) {
+    try { await BackgroundAudio.stop(); } catch {}
+    console.log('[BackgroundAudio] Service gestoppt (keine Slots)');
+    return;
+  }
+  const reason = topReason();
+  try {
+    await BackgroundAudio.start(reason);
+    console.log('[BackgroundAudio] Service aktiv (slot=%s, slots=%s)',
+                reason, [...slots].join('+'));
+  } catch (err: any) {
+    console.warn('[BackgroundAudio] start fehlgeschlagen:', err?.message || err);
+  }
+}
+
+export async function acquireBackgroundAudio(slot: Slot): Promise<void> {
+  if (slots.has(slot)) return;
+  slots.add(slot);
+  await applyState();
+}
+
+export async function releaseBackgroundAudio(slot: Slot): Promise<void> {
+  if (!slots.has(slot)) return;
+  slots.delete(slot);
+  await applyState();
+}
+
+export function backgroundAudioActive(): boolean {
+  return slots.size > 0;
+}
+
+// --- Legacy API (nur tts-Slot) — fuer Aufruf-Sites die noch nichts vom Slot-
+// system wissen. Mappt auf den 'tts'-Slot. ---
+export const startBackgroundAudio = () => acquireBackgroundAudio('tts');
+export const stopBackgroundAudio = () => releaseBackgroundAudio('tts');

android/src/services/phoneCall.ts

@@ -19,6 +19,7 @@ import {
   ToastAndroid,
 } from 'react-native';
 import audioService from './audio';
+import wakeWordService from './wakeword';
 
 interface PhoneCallNative {
   start(): Promise<boolean>;
@@ -91,16 +92,25 @@ class PhoneCallService {
 
   private _onStateChanged(state: PhoneState): void {
     if (state === this.lastState) return;
-    console.log('[PhoneCall] State: %s → %s', this.lastState, state);
+    const prev = this.lastState;
+    console.log('[PhoneCall] State: %s → %s', prev, state);
     this.lastState = state;
     if (state === 'ringing' || state === 'offhook') {
       audioService.haltAllPlayback(`Telefon-State: ${state}`);
+      // Wake-Word + Aufnahme pausieren: Telefonie-App belegt das Mikro
+      // waehrend des Anrufs, plus ARIA soll nicht im Telefonat zuhoeren.
+      wakeWordService.pauseForCall().catch(() => {});
       ToastAndroid.show(
         state === 'ringing' ? 'Anruf — ARIA pausiert' : 'Im Gespraech — ARIA pausiert',
         ToastAndroid.SHORT,
       );
+    } else if (state === 'idle' && prev !== 'idle') {
+      // Auflegen: Wake-Word reaktivieren wenn vor dem Anruf aktiv war.
+      // TTS kommt nicht automatisch zurueck (Stream weg) — User kann
+      // ARIAs letzte Antwort per Play-Button nochmal hoeren.
+      wakeWordService.resumeFromCall().catch(() => {});
+      ToastAndroid.show('Anruf beendet — ARIA wieder aktiv', ToastAndroid.SHORT);
     }
-    // idle: nichts automatisch — User soll nichts unbeabsichtigt re-triggern
   }
 }
 

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

@@ -22,6 +22,7 @@
 
 import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { acquireBackgroundAudio } from './backgroundAudio';
 
 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;
@@ -72,6 +73,19 @@ 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;
+  /** Anruf-Pause: state wird gemerkt damit nach Auflegen wiederhergestellt wird. */
+  private callPaused: boolean = false;
+  private preCallState: WakeWordState = 'off';
+  /** Cooldown nach App-Resume: kurze Phase in der Wake-Word-Detections
+   *  ignoriert werden. Beim Wechsel von Background nach Vordergrund gibt's
+   *  oft einen Audio-Pegel-Spike (AudioFocus-Switch, AudioTrack re-route),
+   *  der openWakeWord faelschlich triggern kann. */
+  private cooldownUntilMs: number = 0;
 
   private keyword: WakeKeyword = DEFAULT_KEYWORD;
   private nativeReady: boolean = false;
@@ -152,6 +166,10 @@ class WakeWordService {
   /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
   async start(): Promise<boolean> {
     if (this.state !== 'off') return true;
+    // Foreground-Service VOR dem Mic-Zugriff hochziehen damit Background-
+    // Lauschen funktioniert (Android braucht foregroundServiceType=microphone
+    // aktiv zum Zeitpunkt des AudioRecord.startRecording).
+    await acquireBackgroundAudio('wake');
     if (this.nativeReady && OpenWakeWord) {
       try {
         await OpenWakeWord.start();
@@ -191,16 +209,42 @@ class WakeWordService {
     if (this.nativeReady && OpenWakeWord) {
       try { await OpenWakeWord.stop(); } catch {}
     }
+    this.bargeListening = false;
     this.setState('off');
   }
 
+  /** Cooldown setzen — alle Wake-Word-Detections in den naechsten ms ignorieren.
+   *  Wird beim App-Resume gerufen weil AppState-Wechsel Audio-Spikes erzeugen
+   *  die openWakeWord faelschlich als Trigger interpretiert. */
+  setResumeCooldown(ms: number = 1500): void {
+    this.cooldownUntilMs = Date.now() + ms;
+    console.log('[WakeWord] Cooldown aktiv fuer %dms', ms);
+  }
+
   /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
   private async onWakeDetected(): Promise<void> {
-    console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
+    const now = Date.now();
-    ToastAndroid.show(`Wake-Word "${KEYWORD_LABELS[this.keyword]}" erkannt — sprich jetzt`, ToastAndroid.SHORT);
+    if (now < this.cooldownUntilMs) {
+      const left = this.cooldownUntilMs - now;
+      console.log('[WakeWord] Trigger ignoriert (Cooldown noch %dms aktiv — wahrscheinlich App-Resume-Spike)', left);
+      return;
+    }
+    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');
     setTimeout(() => {
       if (this.state === 'conversing') {
@@ -209,6 +253,72 @@ 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');
+  }
+
+  /** Bei eingehendem Anruf: Wake-Word + Aufnahme stoppen, Pre-Call-State
+   *  merken. Telefonie-App belegt das Mikro waehrend des Anrufs, plus ARIA
+   *  soll nicht in laufende Telefonate reinhoeren. */
+  async pauseForCall(): Promise<void> {
+    if (this.callPaused) return;
+    this.preCallState = this.state;
+    if (this.state === 'off') {
+      this.callPaused = true;  // merken dass wir pausiert wurden
+      return;
+    }
+    this.callPaused = true;
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.bargeListening = false;
+    console.log('[WakeWord] Anruf — Wake-Word pausiert (war: %s)', this.preCallState);
+  }
+
+  /** Nach Auflegen: Pre-Call-State wiederherstellen. Aktive Konversation
+   *  geht zu armed zurueck (User soll nicht in einen halben Dialog springen). */
+  async resumeFromCall(): Promise<void> {
+    if (!this.callPaused) return;
+    const restoreTo = this.preCallState;
+    this.callPaused = false;
+    this.preCallState = 'off';
+    console.log('[WakeWord] Anruf zu Ende — restore state=%s', restoreTo);
+    if (restoreTo === 'off') return;
+    // Aktive Konversation war wahrscheinlich durch haltAllPlayback eh abgebrochen,
+    // sicher zu armed degraden.
+    if (restoreTo === 'conversing') this.setState('armed');
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.start(); } catch (err) {
+        console.warn('[WakeWord] Restore-Start fehlgeschlagen:', err);
+      }
+    }
+  }
+
   /** Konversation beenden — User hat im Window nichts gesagt.
    *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
    *  Ohne: zurueck zu 'off'.
@@ -268,6 +378,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 () => {

aria-data/config/AGENT.md

@@ -54,13 +54,6 @@ Fuer Web-Anfragen: **WebFetch** oder **Bash mit curl**. Niemals sagen "ich habe
 
 ## Stimme
 
-| Stimme | Modell | Wann |
+TTS laeuft ueber F5-TTS (Voice Cloning, Gaming-PC). Stefan kann eigene
-|--------|--------|------|
+Stimmen aus Audio-Samples klonen (Diagnostic → Stimmen → Stimme klonen)
-| **Ramona** (weiblich) | `de_DE-ramona-low` | Alltag, Antworten, Gespraeche (Standard) |
+und in App + Diagnostic auswaehlen.
-| **Thorsten** (maennlich, tief) | `de_DE-thorsten-high` | Epische Momente, Alarme, besondere Ereignisse |
-
-**Thorsten spricht bei:**
-- Build erfolgreich deployed
-- Ticket geloest / Aufgabe abgeschlossen
-- Kritischer Alarm (Server down, Sicherheitswarnung)
-- Wenn Stefan sagt "So soll es sein"

aria-data/config/BOOTSTRAP.md

@@ -80,10 +80,8 @@ Wenn ein Tool nicht klappt, probiere die Alternative. Niemals sagen "ich habe ke
 
 ## Stimme
 
-| Stimme | Modell | Wann |
+TTS laeuft ueber F5-TTS auf der Gamebox (Voice Cloning). Stefan kann
-|--------|--------|------|
+eigene Stimmen aus Audio-Samples klonen und in App/Diagnostic auswaehlen.
-| **Ramona** (weiblich) | `de_DE-ramona-low` | Alltag, Antworten, Gespraeche (Standard) |
-| **Thorsten** (maennlich, tief) | `de_DE-thorsten-high` | Epische Momente, Alarme, besondere Ereignisse |
 
 ## Gedaechtnis (Memory)
 
@@ -147,4 +145,4 @@ Danach den Eintrag in `memory/MEMORY.md` (Index) verlinken.
 ### Netzwerk
 - **aria-net:** Internes Docker-Netz (proxy, aria-core)
 - **RVS:** Rendezvous-Server im Rechenzentrum — Relay fuer die Android-App
-- **Bridge:** Voice Bridge (Whisper STT + Piper TTS) — teilt Netzwerk mit aria-core
+- **Bridge:** Voice Bridge (orchestriert STT/TTS via Gamebox-Bridges) — teilt Netzwerk mit aria-core

bridge/aria_bridge.py

@@ -1,17 +1,13 @@
 """
 ARIA Voice Bridge — Hauptmodul.
 
-Verbindet die Android App (via RVS) mit ARIA-Core und bietet
+Verbindet die Android App (via RVS) mit ARIA-Core. Spracheingabe laeuft
-lokale Spracheingabe (Wake-Word + Whisper STT) und Sprachausgabe (Piper TTS).
+ueber die whisper-bridge (Gamebox, faster-whisper auf CUDA), Sprachausgabe
+ueber die f5tts-bridge (Voice Cloning, satzweises PCM-Streaming).
 
 Nachrichtenfluss:
   App  → RVS → Bridge → aria-core
-  aria-core → Bridge → RVS → App
+  aria-core → Bridge → f5tts-bridge → PCM → RVS → App
-                     → Lautsprecher (TTS)
-
-Stimmen:
-  - Ramona (de_DE-ramona-low)  — Alltag, Gespraeche
-  - Thorsten (de_DE-thorsten-high) — epische Momente, Alarme
 """
 
 from __future__ import annotations
@@ -493,7 +489,7 @@ class ARIABridge:
         self.current_mode = self._load_persisted_mode()
         self.running = False
 
-        # Komponenten (TTS: immer XTTS remote, Piper wurde entfernt)
+        # Komponenten (TTS: F5-TTS remote auf der Gamebox, lokales TTS wurde entfernt)
         self.tts_enabled = True
         self.xtts_voice = ""
         self._f5tts_config: dict = {}
@@ -1028,6 +1024,31 @@ class ARIABridge:
         except Exception as e:
             logger.debug("[session] Diagnostic nicht erreichbar (%s) — nutze '%s'", e, self._session_key)
 
+    def _build_core_text(self, text: str, interrupted: bool = False,
+                          location: Optional[dict] = None) -> str:
+        """Baut den Text fuer aria-core mit allen relevanten Hints (Barge-In,
+        GPS-Position). Hints sind in eckigen Klammern, der eigentliche User-
+        Text folgt unverandert."""
+        parts: list[str] = []
+        if interrupted:
+            parts.append(
+                "[Hinweis: Stefan hat dich gerade unterbrochen waehrend du noch "
+                "gesprochen oder gearbeitet hast. Folgendes ist eine Korrektur, "
+                "Ergaenzung oder ein Themenwechsel zu deiner letzten Antwort.]"
+            )
+        if location and isinstance(location, dict):
+            lat = location.get("lat")
+            lon = location.get("lon") or location.get("lng")
+            if lat is not None and lon is not None:
+                parts.append(
+                    f"[Stefans aktuelle GPS-Position: {float(lat):.6f}, {float(lon):.6f}. "
+                    f"Nutze die nur wenn die Frage sich auf seinen Standort bezieht. "
+                    f"Erwaehne sie nicht von dir aus, ausser er fragt explizit danach.]"
+                )
+        if parts:
+            return " ".join(parts) + " " + text
+        return text
+
     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."""
@@ -1235,6 +1256,8 @@ class ARIABridge:
                 except (TypeError, ValueError):
                     self._next_speed_override = None
             if text:
+                interrupted = bool(payload.get("interrupted", False))
+                location = payload.get("location") or None
                 # Wenn Files gerade gepuffert sind (Bild + Text gleichzeitig
                 # gesendet), mergen wir sie zu einer einzigen Anfrage statt
                 # zwei separater send_to_core-Calls.
@@ -1242,8 +1265,12 @@ class ARIABridge:
                 if merged:
                     logger.info("[rvs] App-Chat (mit Anhaengen): '%s'", text[:80])
                 else:
-                    logger.info("[rvs] App-Chat: '%s'", text[:80])
+                    core_text = self._build_core_text(text, interrupted, location)
-                    await self.send_to_core(text, source="app")
+                    logger.info("[rvs] App-Chat%s%s: '%s'",
+                                " [BARGE-IN]" if interrupted else "",
+                                " [GPS]" if location else "",
+                                text[:80])
+                    await self.send_to_core(core_text, source="app" + (" [barge-in]" if interrupted else ""))
             return
 
         if msg_type == "cancel_request":
@@ -1500,9 +1527,16 @@ class ARIABridge:
                     self._next_speed_override = speed if 0.1 <= speed <= 5.0 else None
                 except (TypeError, ValueError):
                     self._next_speed_override = None
-            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB",
+            interrupted = bool(payload.get("interrupted", False))
-                        mime_type, duration_ms, len(audio_b64) // 1365)
+            audio_request_id = payload.get("audioRequestId", "") or ""
-            asyncio.create_task(self._process_app_audio(audio_b64, mime_type))
+            location = payload.get("location") or None
+            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB%s%s%s",
+                        mime_type, duration_ms, len(audio_b64) // 1365,
+                        " [BARGE-IN]" if interrupted else "",
+                        " [GPS]" if location 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, location))
 
         elif msg_type == "stt_response":
             # Antwort der whisper-bridge auf unseren stt_request
@@ -1558,8 +1592,23 @@ 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:
+    async def _process_app_audio(self, audio_b64: str, mime_type: str,
-        """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal."""
+                                  interrupted: bool = False,
+                                  audio_request_id: str = "",
+                                  location: Optional[dict] = None) -> 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).
+
+        location: Optional GPS-Position {lat, lon} — wird als Hinweis-Praefix mitgegeben
+        damit ARIA bei standortbezogenen Fragen sie nutzen kann."""
         # Erst Remote versuchen
         text = await self._stt_remote(audio_b64, mime_type)
         if text is None:
@@ -1571,19 +1620,29 @@ class ARIABridge:
 
         if text.strip():
             logger.info("[rvs] STT Ergebnis: '%s'", text[:80])
+            # Hints (Barge-In, GPS) als Praefix vorschalten — gemeinsamer Helper
+            # mit dem chat-Pfad damit das Verhalten konsistent ist.
+            core_text = self._build_core_text(text, interrupted, location)
             # 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": {
+                    "payload": stt_payload,
-                        "text": text,
-                        "sender": "stt",
-                    },
                     "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; }
+                min-height: 120px; max-height: 250px; overflow-y: auto;
-    .chat-msg { margin-bottom: 6px; padding: 6px 10px; border-radius: 6px; font-size: 13px; line-height: 1.5; word-wrap: break-word; }
+                padding: 12px; margin-bottom: 8px; display: flex; flex-direction: column; gap: 8px; }
-    .chat-msg.sent { background: #0096FF; color: #fff; margin-left: 20%; text-align: right; }
+    .chat-msg { padding: 10px 14px; border-radius: 14px; font-size: 14px; line-height: 1.5;
-    .chat-msg.received { background: #1E1E2E; margin-right: 20%; }
+                word-wrap: break-word; max-width: 80%; white-space: pre-wrap;
-    .chat-msg.error { background: #3B1010; color: #FF6B6B; }
+                box-shadow: 0 1px 2px rgba(0,0,0,0.4); }
-    .chat-msg .meta { font-size: 10px; color: rgba(255,255,255,0.4); margin-top: 2px; }
+    .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 { display: flex; gap: 6px; align-items: flex-end; }
-    .input-row input { flex: 1; background: #1E1E2E; border: 1px solid #333; border-radius: 6px;
+    .input-row input, .input-row textarea {
-                       padding: 8px 12px; color: #E0E0F0; font-family: inherit; font-size: 13px; }
+        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>
@@ -654,24 +665,6 @@
       </div>
     </div>
 
-    <!-- Highlight-Trigger -->
-    <div class="settings-section">
-      <h2>Highlight-Trigger</h2>
-      <div style="font-size:11px;color:#8888AA;margin-bottom:8px;">
-        Woerter die automatisch die Highlight-Stimme (Thorsten) ausloesen.
-        Eines pro Zeile. Aenderungen werden in der Bridge gespeichert.
-      </div>
-      <div class="card" style="max-width:500px;">
-        <textarea id="highlight-triggers" rows="8" style="width:100%;box-sizing:border-box;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:6px;padding:8px;color:#fff;font-size:13px;font-family:monospace;resize:vertical;"
-          placeholder="Lade..."></textarea>
-        <div style="display:flex;gap:8px;margin-top:8px;">
-          <button class="btn" onclick="saveHighlightTriggers()" style="flex:1;">Speichern</button>
-          <button class="btn secondary" onclick="loadHighlightTriggers()" style="flex:1;">Neu laden</button>
-        </div>
-        <div id="trigger-status" style="font-size:11px;color:#555570;margin-top:6px;"></div>
-      </div>
-    </div>
-
     <!-- Tool-Berechtigungen -->
     <div class="settings-section">
       <h2>Tool-Berechtigungen</h2>
@@ -945,14 +938,6 @@
           return;
         }
 
-        if (msg.type === 'trigger_list') {
-          const textarea = document.getElementById('highlight-triggers');
-          textarea.value = (msg.triggers || []).join('\n');
-          document.getElementById('trigger-status').textContent = msg.triggers.length + ' Trigger geladen';
-          document.getElementById('trigger-status').style.color = '#8888AA';
-          return;
-        }
-
         if (msg.type === 'service_status') {
           updateServiceStatus(msg.payload || {});
           return;
@@ -1947,20 +1932,6 @@
       }
     }
 
-    // ── Highlight-Trigger ────────────────────────
-    function loadHighlightTriggers() {
-      send({ action: 'get_triggers' });
-    }
-    function saveHighlightTriggers() {
-      const text = document.getElementById('highlight-triggers').value;
-      const triggers = text.split('\n').map(t => t.trim()).filter(t => t.length > 0);
-      send({ action: 'save_triggers', triggers });
-      document.getElementById('trigger-status').textContent = 'Gespeichert (' + triggers.length + ' Trigger)';
-      document.getElementById('trigger-status').style.color = '#34C759';
-    }
-    // Beim Tab-Wechsel zu Einstellungen: Trigger laden
-    const origSwitchMainTab = typeof switchMainTab === 'function' ? switchMainTab : null;
-
     // ── Modus-Wechsel ────────────────────────────
     // Kanonische IDs (matchen bridge/modes.py canonical_id + android ModeSelector)
     const MODE_LABELS = { normal: 'Normal', nicht_stoeren: 'Nicht stoeren', fluester: 'Fluestern', hangar: 'Hangar', gaming: 'Gaming' };
@@ -2069,10 +2040,23 @@
       return str.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
     }
 
-    // Enter-Taste sendet via Gateway
+    // Auto-Resize fuer Textarea — wuchst mit dem Inhalt bis zum max-height
-    document.getElementById('chat-input').addEventListener('keydown', (e) => {
+    function autoResizeTextarea(el) {
-      if (e.key === 'Enter') testRVS();
+      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) => {
@@ -2432,9 +2416,8 @@
       document.querySelectorAll('.main-nav-btn').forEach(b => {
         if (b.textContent.trim().toLowerCase().includes(tab === 'main' ? 'main' : 'einstellung')) b.classList.add('active');
       });
-      // Einstellungen: Config + Trigger + QR laden
+      // Einstellungen: Config + QR laden
       if (tab === 'settings') {
-        loadHighlightTriggers();
         send({ action: 'get_voice_config' });
         loadRuntimeConfig();
         loadOnboardingQR();

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", () => {});
@@ -1462,10 +1475,6 @@ wss.on("connection", (ws) => {
         } catch {}
         sendToRVS_raw({ type: "config", payload: voiceConfig, timestamp: Date.now() });
         log("info", "server", `Voice-Config gespeichert: xttsVoice=${voiceConfig.xttsVoice || "default"}, whisper=${voiceConfig.whisperModel || "-"}`);
-      } else if (msg.action === "get_triggers") {
-        handleGetTriggers(ws);
-      } else if (msg.action === "save_triggers") {
-        handleSaveTriggers(ws, msg.triggers || []);
       } else if (msg.action === "test_tts") {
         handleTestTTS(ws, msg.text || "Test");
       } else if (msg.action === "preview_voice") {
@@ -1616,31 +1625,6 @@ function handleGetVoiceConfig(clientWs) {
   }
 }
 
-// ── Highlight-Trigger (legacy UI — wird nicht mehr ausgewertet seit Piper raus) ─
-const TRIGGERS_FILE = "/shared/config/highlight_triggers.json";
-
-async function handleGetTriggers(clientWs) {
-  try {
-    const triggers = fs.existsSync(TRIGGERS_FILE)
-      ? JSON.parse(fs.readFileSync(TRIGGERS_FILE, "utf-8"))
-      : [];
-    clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
-  } catch (err) {
-    clientWs.send(JSON.stringify({ type: "trigger_list", triggers: [], error: err.message }));
-  }
-}
-
-async function handleSaveTriggers(clientWs, triggers) {
-  try {
-    fs.mkdirSync("/shared/config", { recursive: true });
-    fs.writeFileSync(TRIGGERS_FILE, JSON.stringify(triggers, null, 2));
-    log("info", "server", `${triggers.length} Highlight-Trigger gespeichert`);
-    clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
-  } catch (err) {
-    log("error", "server", `Trigger speichern fehlgeschlagen: ${err.message}`);
-  }
-}
-
 // ── TTS Diagnose (XTTS) ───────────────────────────────
 // ── Voice Preview ────────────────────────────────────────
 // Sammelt audio_pcm Chunks einer Preview-Anfrage, baut am Ende eine WAV

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

@@ -2,6 +2,41 @@
 
 ## Erledigt
 
+### Bugs / Fixes
+
+- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen
+- [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
+- [x] Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
+- [x] Voice-Auswahl funktioniert wieder: speaker_wav als Basename statt Pfad fuer daswer123 local-Mode
+- [x] Diagnostic-Voice-Wechsel resettet alle App-lokalen Voice-Overrides via type "config"
+- [x] Streaming TTS Stop-Race: Writer wartet auf playbackHeadPosition vor stop()/release() — keine abgeschnittenen Saetze mehr
+- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
+- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
+- [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
+- [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
+- [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
+- [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
+- [x] Wake-Word Embedding rank-4 Fix (Pipeline-Bug der das Triggern verhinderte) + Frame-Count aus Modell-Metadaten lesen
+- [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] 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→App: persistente RVS-Connection statt frische pro Send (Race-Probleme mit Zombie-WS geloest)
+- [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
+- [x] Mikro-Offen-Toast "🎤 sprich jetzt" erscheint erst wenn audioService.startRecording wirklich erfolgreich war (statt ~400ms vorher beim Wake-Word-Detect)
+- [x] Sprachnachrichten ohne STT-Result werden nach 60s+Aufnahmedauer automatisch entfernt (sicher genug fuer 5-30min-Aufnahmen, schnell genug fuer leere Wake-Word-Echos)
+- [x] VAD adaptive Baseline robuster: minimum statt avg + Cap auf -50dB bis -28dB (Stille) / -40dB bis -18dB (Speech) — keine "tote" VAD-Konfiguration mehr bei lauter Umgebung oder Wake-Word-Echo
+- [x] Push-to-Talk raus, nur noch Tap-to-Talk (verhinderte Touch-Race-Probleme)
+- [x] Manueller Mikro-Stop beendet Wake-Word-Konversation: Tap auf Mikro-Knopf waehrend conversing → audio raus + zurueck zu armed (= Wake-Word lauscht wieder, kein Auto-Mikro nach ARIAs Antwort). VAD-Auto-Stop bleibt bei Multi-Turn
+- [x] **Wake-Word pausiert bei Anruf**: phoneCall ruft pauseForCall (openWakeWord.stop) bei RINGING/OFFHOOK, resumeFromCall bei IDLE. Pre-Call-State wird gemerkt — armed bleibt armed, conversing degraded zu armed (User soll nicht in halbem Dialog landen)
+- [x] **App-Resume-Cooldown**: Wechsel von Background → Foreground triggert keinen falschen Wake-Word-Trigger mehr. AppState-Listener setzt 1.5s Cooldown in dem onWakeDetected-Events ignoriert werden (Audio-Pegel-Spike beim AudioFocus-Switch sonst als Wake-Word interpretiert)
+- [x] Background-Mikro robust: acquireBackgroundAudio('rec'/'wake') wird jetzt VOR AudioRecord.startRecording gerufen — Foreground-Service mit foregroundServiceType=microphone muss aktiv sein bevor das Mikro greift, sonst blockiert Android ab 11+ den Background-Zugriff
+- [x] **Stille-Pegel manuell setzbar** (Settings → Spracheingabe): Override-Wert in dB von -55 bis -15, default "automatisch". Info-Button mit Modal erklaert die Skala (niedriger = sensibler, hoeher = robuster gegen Hintergrundlaerm). Bei manuell gesetztem Wert wird die adaptive Baseline ignoriert
+
+### App Features
+
 - [x] Bildupload funktioniert (Shared Volume /shared/uploads/)
 - [x] Sprachnachrichten werden als Text angezeigt (STT → Chat-Bubble)
 - [x] Cache leeren + Auto-Download von Anhaengen
@@ -11,13 +46,9 @@
 - [x] Ohr-Button → Gespraechsmodus (Auto-Aufnahme nach ARIA-Antwort)
 - [x] Play-Button in ARIA-Nachrichten fuer Sprachwiedergabe
 - [x] Chat-Suche in der App (Lupe in Statusleiste)
-- [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
 - [x] Abbrechen-Button im Diagnostic Chat
-- [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
-- [x] Grosse Nachrichten satzweise aufteilen fuer TTS
-- [x] RVS Nachrichten vom Smartphone gehen durch
 - [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed pro Stimme — durch XTTS/F5-TTS ersetzt)
-- [x] Highlight-Trigger konfigurierbar in Diagnostic
+- [x] Highlight-Trigger konfigurierbar in Diagnostic (spaeter komplett entfernt — war Piper-Relikt)
 - [x] XTTS v2 Integration (Gaming-PC, GPU, Voice Cloning) — durch F5-TTS ersetzt
 - [x] XTTS Voice Cloning (Audio-Samples hochladen, eigene Stimme)
 - [x] TTS Engine waehlbar (Piper/XTTS) — Piper raus, XTTS raus, jetzt nur F5-TTS
@@ -25,16 +56,12 @@
 - [x] Auto-Update: APK-Installation via FileProvider
 - [x] Auto-Update: "Auf Updates pruefen" Button in App-Einstellungen
 - [x] Audio-Queue (sequentielle Wiedergabe, kein Ueberlappen)
-- [x] Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
 - [x] Mehrere Anhaenge + Text vor dem Senden (Pending-Vorschau)
 - [x] Paste-Support fuer Bilder in Diagnostic Chat
 - [x] Markdown-Bereinigung fuer TTS (fett, kursiv, code, links, etc.)
-- [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
 - [x] Diagnostic: Sessions als Markdown exportieren (Download-Button)
 - [x] Speech Gate: Aufnahme wird verworfen wenn keine Sprache erkannt
 - [x] Session-Persistenz: Gewaehlte Session bleibt ueber Container-Restarts erhalten
-- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen
-- [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
 - [x] Whisper STT: Model-Auswahl in Diagnostic (tiny/base/small/medium/large-v3), Hot-Reload
 - [x] App: Audio-Aufnahme explizit 16kHz mono (spart Resample, optimal fuer Whisper)
 - [x] Streaming TTS: PCM-Stream → AudioTrack MODE_STREAM, keine WAV-Gaps
@@ -51,14 +78,11 @@
 - [x] Disk-Voll Banner in Diagnostic: rotes Overlay + copy-baren Cleanup-Befehlen (safe + aggressiv)
 - [x] cleanup.sh: kombinierter Docker-Aufraeum-Befehl (safe / --full)
 - [x] Streaming TTS Pre-Roll: AudioTrack play() startet erst wenn 2.5s gepuffert sind
-- [x] Streaming TTS Stop-Race: Writer wartet auf playbackHeadPosition vor stop()/release() — keine abgeschnittenen Saetze mehr
 - [x] Leading-Silence (200ms) am Stream-Anfang — AudioTrack faehrt sauber an
 - [x] Pre-Roll-Buffer einstellbar in App-Settings (1.0-6.0s, Default 3.5s)
 - [x] Fade-In auf erstem PCM-Chunk (120ms) — versteckt XTTS/F5-TTS Warmup-Glitches
 - [x] Decimal-zu-Worte fuer TTS (0.1 → null komma eins, mit IP-Schutz-Lookahead)
 - [x] Generic Acronym-Buchstabieren (XTTS → X T T S, USB → U S B, ueber expliziter Liste)
-- [x] Voice-Auswahl funktioniert wieder: speaker_wav als Basename statt Pfad fuer daswer123 local-Mode
-- [x] Diagnostic-Voice-Wechsel resettet alle App-lokalen Voice-Overrides via type "config"
 - [x] voice_preload/voice_ready: Stille Mini-Render bei Voice-Wechsel + Toast/Status "bereit"
 - [x] Whisper STT auf die Gamebox ausgelagert (faster-whisper CUDA, float16) — neuer aria-whisper-bridge Container
 - [x] aria-bridge: STT primaer remote (Gamebox), Fallback lokal nach 45s Timeout
@@ -66,37 +90,49 @@
 - [x] **F5-TTS ersetzt XTTS komplett** — neuer aria-f5tts-bridge Container, Voice Cloning, satzweises Streaming
 - [x] Voice-Upload mit Whisper-Auto-Transkription — User muss keinen Referenz-Text eintippen
 - [x] Audio-Pause statt Ducking: Spotify/YouTube pausieren komplett waehrend TTS (TRANSIENT statt MAY_DUCK)
-- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
 - [x] VAD-Stille einstellbar in App-Settings (1.0-8.0s, Default 2.8s)
 - [x] MAX_RECORDING auf 120s — laengere Erklaerungen moeglich
-- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
 - [x] F5-TTS: Referenz-WAV-Preprocessing — Loudness-Normalisierung -16 LUFS + Silence-Trim + 10s Clip fuer konsistente Cloning-Quali
 - [x] F5-TTS: deutsches Fine-Tune (aihpi/F5-TTS-German, Vocos-Variante) via hf:// Pfad in Diagnostic konfigurierbar
-- [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
-- [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
 - [x] Dynamischer STT-Timeout in aria-bridge: 300s waehrend whisper-bridge 'loading', 45s wenn 'ready'
 - [x] service_status Broadcasts: f5tts/whisper melden Lade-Status, Banner in Diagnostic (unten rechts) + App (oben)
 - [x] config_request Pattern: Bridges fragen beim Connect die aktuelle Voice-Config an, aria-bridge antwortet
 - [x] F5-TTS Tuning via Diagnostic (Modell-ID, Checkpoint, cfg_strength, nfe_step) statt ENV-Vars — Hot-Reload bei Modell-Wechsel
 - [x] Conversation-Window: Gespraechsmodus endet nach X Sekunden Stille (1.0-20.0s, Default 8s, einstellbar in Settings)
-- [x] Porcupine Wake-Word-Integration in der App (Built-In Keywords + Custom spaeter, per Geraet einstellbar)
+- [x] Porcupine Wake-Word-Integration in der App (durch openWakeWord ersetzt)
 - [x] HF-Cache als Bind-Mount statt Docker Volume — kein .vhdx-Bloat auf Docker Desktop / Windows
 - [x] cleanup-windows.ps1 / .bat: VHDX-Cleanup via diskpart (ohne Hyper-V) mit Self-Elevation
-- [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
-- [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
 - [x] App Text-Rendering: Nachrichten selektierbar + Autolink fuer URLs/E-Mails/Telefonnummern (Browser/Mail/Dialer)
 - [x] TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings → 0.5-2.0x in 0.1-Schritten, Default 1.0)
 - [x] Diagnostic: Voice-Preview-Modal (Play-Icon vor Delete-X, Textfeld mit Default, WAV im Browser abspielen)
+- [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] APK ABI-Split auf arm64-v8a — von ~136 MB auf ~35 MB, Auto-Update-Downloads aufs Phone deutlich kleiner
+- [x] PhoneStateListener: TTS pausiert bei eingehendem Anruf (READ_PHONE_STATE Permission)
+- [x] Diagnostic-Chat: bubblige Formatierung, mehrzeiliges Eingabefeld (textarea, Enter sendet, Shift+Enter neue Zeile)
+- [x] Adaptive VAD-Schwelle: Baseline aus den ersten 500ms Mic-Pegel, Stille = baseline+6dB / Sprache = baseline+12dB
+- [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] Settings-Sub-Screens: 8 Kategorien (Verbindung, Allgemein, Spracheingabe, Wake-Word, Sprachausgabe, Speicher, Protokoll, Ueber) statt langer Liste
+- [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
+- [x] **GPS-Position mitsenden**: Toggle in Settings → Allgemein → Standort, persistiert in AsyncStorage. Wenn aktiv wird lat/lon mit jeder chat/audio-Message mitgegeben. Bridge prefixed den Text fuer aria-core mit GPS-Hint (mit Anweisung dass die Position nur bei Bedarf erwaehnt wird)
+- [x] **Background Audio Service**: TTS, Wake-Word-Lauschen UND Aufnahme laufen auch bei minimierter App weiter. Foreground-Service mit foregroundServiceType=mediaPlayback|microphone, persistente Notification mit dynamischem Text ("ARIA spricht" / "ARIA hoert zu" / "ARIA bereit")
+
+### Infrastruktur
+
+- [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
+- [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
+- [x] RVS Nachrichten vom Smartphone gehen durch
+- [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
 
 ## 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)