fix: WebSocket max_size hochgedreht — voice_upload sprengte Default 1MB

Symptom: aria-whisper-bridge bekam beim ersten internen stt_request
(via voice_upload mit WAV als base64, ~2.4MB) den Frame zu Gesicht,
default ws-max ist 1MB → mit Close-Code 1009 abgewiesen → Verbindung
tot → naechster stt_request lief in Timeout → lokales Fallback.

Fixes:
- whisper-bridge: max_size=50*1024*1024 in websockets.connect()
  (gleicher Wert wie f5tts-bridge schon hat)
- RVS-Server: maxPayload=50*1024*1024 in WebSocketServer-Optionen,
  damit der Server die Frames nicht selbst auf 1MB cappt bevor er
  sie an die Bridge weiterleitet.

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

.env.example

@@ -15,7 +15,7 @@ ARIA_AUTH_TOKEN=change-me-to-a-long-random-string
 # App, Bridge, Diagnostic und XTTS-Bridge verbinden sich hierueber.
 # Alle muessen den gleichen Host, Port und Token nutzen.
 
-# Hostname des RVS-Servers (z.B. rvs.example.de oder example.com)
+# Hostname des RVS-Servers (z.B. rvs.example.de oder mobil.hacker-net.de)
 RVS_HOST=rvs.example.de
 
 # Port auf dem der RVS laeuft (muss mit rvs/docker-compose.yml uebereinstimmen)

.gitignore

@@ -13,10 +13,6 @@ aria-data/config/*.env
 !aria-data/config/*.env.example
 !aria-data/config/openclaw.env
 
-# Privater User-Profile-Snippet (Tool-Stack, interne URLs)
-aria-data/config/USER.md
-!aria-data/config/USER.md.example
-
 # ── ARIAs Gedächtnis (nur per tar gesichert) ────
 aria-data/brain/
 

README.md

@@ -378,13 +378,9 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 ### Features
 
 - Text-Chat mit ARIA
-- **Sprachaufnahme**: Tap-to-Talk (tippen startet, tippen stoppt, Auto-Stop bei Stille via VAD)
+- **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
 - **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
-- **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
-- **VAD (Voice Activity Detection)**: 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 + Auto-Resume**: TTS verstummt bei klassischem Anruf oder VoIP-Call (WhatsApp/Signal/Discord). Nach dem Auflegen geht ARIA von der **genauen Stelle** weiter wo sie unterbrochen wurde — die App misst die Position vom Wiedergabe-Anfang und nutzt den WAV-Cache der Antwort
+- **VAD (Voice Activity Detection)**: Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme 120s.
 - **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
 - **STT (Speech-to-Text)**: 16kHz mono → Bridge → Gamebox-Whisper (CUDA) → Text im Chat. Fast in Echtzeit.
 - **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
@@ -402,45 +398,6 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 - GPS-Position (optional)
 - QR-Code Scanner fuer Token-Pairing
 
-### Wake-Word (openWakeWord, on-device)
-
-Wake-Word-Erkennung laeuft komplett **on-device** ueber [openWakeWord](https://github.com/dscripka/openWakeWord)
-mit ONNX Runtime — kein API-Key, kein Cloud-Roundtrip, kein Cent Lizenzgebuehren,
-und das Audio verlaesst das Geraet nie.
-
-**Mitgelieferte Wake-Words** (ONNX-Dateien in `android/android/app/src/main/assets/openwakeword/`):
-- `Hey Jarvis` (Default, openWakeWord-Original)
-- `Computer` (Star-Trek-Style, Community-Modell)
-- `Alexa`, `Hey Mycroft`, `Hey Rhasspy` (openWakeWord-Originale)
-
-Community-Modelle stammen aus [fwartner/home-assistant-wakewords-collection](https://github.com/fwartner/home-assistant-wakewords-collection).
-
-**Bedienung:**
-- App → **Einstellungen** → **Wake-Word** → gewuenschtes Keyword waehlen → **Speichern + Aktivieren**
-- **Ohr-Button (👂)** in der Statusleiste tippen → Wake-Word ist scharf, App hoert passiv mit
-- Wake-Word sagen → Symbol wechselt auf 🎙️, **Bereit-Sound** (Ding-Dong, optional in Settings) + Toast "🎤 sprich jetzt" sobald das Mikro wirklich offen ist
-- Nach jeder ARIA-Antwort oeffnet sich das Mikro nochmal — Stille → zurueck zu 👂
-- Erneut tippen → Ohr aus (🔇)
-
-**Eigene Wake-Words trainieren** (gratis, ~30 Min):
-
-1. openWakeWord Trainings-Notebook auf Colab oeffnen (Link im
-   [openWakeWord Repo](https://github.com/dscripka/openWakeWord) unter "Training Custom Models")
-2. Wake-Word-Phrase eingeben (z.B. "ARIA", "Hey Stefan"), Notebook ausfuehren —
-   das Notebook generiert synthetische Trainings-Beispiele und trainiert das Modell.
-3. Resultierende `.onnx`-Datei runterladen
-4. Datei in `android/android/app/src/main/assets/openwakeword/` ablegen
-5. In `android/src/services/wakeword.ts` den Dateinamen (ohne `.onnx`) zur
-   `WAKE_KEYWORDS`-Liste hinzufuegen
-6. APK neu bauen
-
-*(Diagnostic-Upload fuer Custom-`.onnx` ohne Rebuild kommt spaeter.)*
-
-**Tuning** (in [wakeword.ts](android/src/services/wakeword.ts)):
-- `DEFAULT_THRESHOLD = 0.5` — Score-Schwelle (raise auf 0.6–0.7 bei False-Positives)
-- `DEFAULT_PATIENCE = 2` — wie viele Frames ueber Threshold noetig
-- `DEFAULT_DEBOUNCE_MS = 1500` — Mindestabstand zwischen zwei Triggern
-
 ### Ersteinrichtung (Dev-Maschine, einmalig)
 
 ```bash
@@ -510,36 +467,10 @@ Der Update-Flow:
 App (Mikrofon) → AAC/MP4 Aufnahme → Base64 → RVS → Bridge
 Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-core
 Bridge: STT-Ergebnis → RVS → App (Placeholder wird durch transkribierten Text ersetzt)
-aria-core → Antwort → Bridge → F5-TTS (Gaming-PC) → PCM-Stream → RVS → App
+aria-core → Antwort → Bridge → XTTS (Gaming-PC) → PCM-Stream → RVS → App
 App: AudioTrack MODE_STREAM (nahtlos), Cache als WAV pro Message
 ```
 
-### Audio-Verhalten in der App
-
-| Phase                        | Andere App (Spotify) | ARIA-Mikro              |
-|------------------------------|----------------------|-------------------------|
-| Idle / Ohr aus               | spielt frei          | aus                     |
-| Wake-Word lauscht (armed)    | spielt frei          | passiv (openWakeWord)   |
-| User-Aufnahme laeuft         | pausiert (EXCLUSIVE) | Recording               |
-| Aufnahme zu Ende             | resumed              | aus                     |
-| ARIA denkt/schreibt (~20s)   | spielt frei          | aus                     |
-| TTS startet                  | pausiert (DUCK)      | aus (oder barge)        |
-| TTS spielt (auch GPU-Pausen) | bleibt pausiert      | barge wenn Wake-Word    |
-| TTS zu Ende                  | nach 800ms resumed   | (Conversation-Window)   |
-| Eingehender Anruf (auch VoIP)| —                    | Mikro pausiert          |
-| Anruf vorbei (Auto-Resume)   | pausiert wieder       | aus                     |
-| Neue Frage waehrend Anruf    | —                    | (Resume verworfen)      |
-
-Mechanismen: Underrun-Schutz im PcmStreamPlayer (Stille-Fill in Render-
-Pausen), Conversation-Focus bei Wake-Word, Foreground-Service mit
-mediaPlayback|microphone, Anruf-Erkennung ueber TelephonyManager +
-AudioFocus-Loss-Listener mit Polling-Fallback (VoIP). Bei Anruf wird
-die Wiedergabe-Position gemerkt — nach dem Auflegen spielt ARIA ab
-der genauen Stelle weiter (oder verwirft das wenn der User waehrend
-des Telefonats per Text eine neue Frage gestellt hat). PcmPlayback-
-Finished-Event vom Native sorgt dafuer dass Spotify erst pausiert
-bleibt bis ARIA wirklich verstummt ist.
-
 ### Datei-Pipeline (Bilder & Anhaenge)
 
 ```
@@ -594,7 +525,8 @@ aria-data/
 │   └── diag-state/                 ← Diagnostic persistenter State
 │
 │   (im Shared Volume /shared/config/):
-│   ├── voice_config.json           ← TTS-Einstellungen (Stimme, Speed, F5-TTS-Tuning)
+│   ├── voice_config.json           ← TTS-Einstellungen (Stimme, Speed, Engine)
+│   ├── highlight_triggers.json     ← Highlight-Trigger Woerter
 │   └── chat_backup.jsonl           ← Nachrichten-Backup (on-the-fly)
 │
 └── ssh/                            ← SSH Keys fuer VM-Zugriff
@@ -718,33 +650,6 @@ In der Diagnostic unter Einstellungen → Sprachausgabe:
 > **Tipp:** Fuer beste Ergebnisse: saubere Aufnahme, eine Stimme, kein Hintergrund,
 > 10-30 Sekunden Gesamtlaenge. Mehrere kurze Dateien werden zusammengefuegt.
 
-### Deutsches Fine-Tune (bessere Qualitaet auf Deutsch)
-
-Das Default-Modell `F5TTS_v1_Base` ist primaer auf Englisch + Chinesisch trainiert
-und liefert auf Deutsch merklich schwaechere Voice-Cloning-Qualitaet als XTTS es
-tat. Community-Fine-Tune von [aihpi](https://huggingface.co/aihpi/F5-TTS-German)
-auf dem Emilia-Dataset + Common Voice 19.0 funktioniert deutlich besser.
-
-**Konfiguration ueber Diagnostic → "F5-TTS Modell-Tuning (advanced)":**
-
-| Feld | Wert |
-|------|------|
-| Modell-Architektur | `F5TTS_Base` *(nicht v1_Base! Fine-Tune basiert auf der alten Architektur)* |
-| Custom Checkpoint | `hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors` |
-| Custom Vocab | `hf://aihpi/F5-TTS-German/vocab.txt` |
-| cfg_strength | `2.0` |
-| nfe_step | `32` |
-
-→ "Anwenden" klicken. Die `hf://`-Pfade werden einmalig automatisch runter-
-geladen (~3-5GB, landet im `xtts/hf-cache/`) und bei Container-Restart aus
-dem Cache wiederverwendet.
-
-> **Warnung zur BigVGAN-Variante** (`F5TTS_Base_bigvgan/model_295000.safetensors`):
-> funktioniert AKTUELL NICHT mit dieser Bridge. Die f5-tts Library laedt
-> per Default den Vocos-Vocoder, die BigVGAN-Weights sind damit inkompatibel
-> → Modell produziert NaN, App bleibt stumm. Nur die **Vocos-Variante
-> (F5TTS_Base/model_365000.safetensors)** nutzen.
-
 ---
 
 ## Docker Volumes
@@ -812,10 +717,8 @@ docker exec aria-core ssh aria-wohnung hostname
 - **Proxy Cold Start**: Jede Nachricht spawnt einen neuen `claude --print` Prozess.
   Dadurch ist ARIA langsamer als die direkte Claude CLI. Timeout ist auf 900s (15 Min).
 - **Kein Streaming zur App**: Die App zeigt erst die fertige Antwort, keine Streaming-Tokens.
-- **Wake-Word in der App nur eingebaute Keywords**: `Hey Jarvis`, `Alexa`, `Hey Mycroft`,
-  `Hey Rhasspy` funktionieren sofort, eigene Wake-Words muessen aktuell noch als
-  `.onnx`-Datei ins App-Bundle gelegt + zur Liste in `wakeword.ts` hinzugefuegt werden.
-  Die Diagnostic-Upload-UI ist Phase 2.
+- **Wake Word nur auf VM**: Die Bridge hoert auf "ARIA" ueber das lokale Mikrofon der VM.
+  In der App gibt es Energy-basierte Erkennung (Phase 1). On-device "ARIA"-Keyword (Porcupine) ist Phase 2.
 - **Audio-Format**: App nimmt AAC/MP4 auf, Bridge konvertiert via FFmpeg zu 16kHz PCM.
 - **RVS Zombie-Connections**: WebSocket-Verbindungen sterben gelegentlich ohne Fehlermeldung.
   Bridge hat Ping-Check (5s), Diagnostic nutzt frische Verbindungen pro Request.
@@ -841,7 +744,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 (frueher Piper Ramona/Thorsten, Highlight-Trigger) — durch XTTS, dann F5-TTS Voice Cloning ersetzt
+- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed, Highlight-Trigger) — durch XTTS v2 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
@@ -868,21 +771,8 @@ 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 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 + Auto-Resume: TTS verstummt bei Anruf, faehrt nach Auflegen ab der gemerkten Position fort (Date.now()-Tracking + WAV-Cache der Antwort)
-- [x] PcmPlaybackFinished-Event: AudioFocus wird erst released wenn AudioTrack wirklich durch ist — kein Spotify-mid-TTS mehr
-- [x] Edge-Case: neue Frage waehrend Telefonat verwirft pending Auto-Resume, neueste Antwort gewinnt
-- [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] VAD-Stille-Toleranz und Max-Aufnahme einstellbar (1-8s, 120s)
 - [x] Disk-Voll Banner in Diagnostic mit copy-baren Cleanup-Befehlen
-- [x] Wake-Word on-device via openWakeWord (ONNX Runtime, kein API-Key) + State-Icon
 
 ### Phase 2 — ARIA wird produktiv
 
@@ -898,5 +788,5 @@ docker exec aria-core ssh aria-wohnung hostname
 - [ ] STARFACE Telefonie-Skill
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
-- [ ] Custom-`.onnx`-Upload fuer Wake-Word ueber Diagnostic (ohne App-Rebuild)
+- [ ] Porcupine Wake Word (on-device "ARIA" in der App)
 - [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)

android/App.tsx

@@ -13,7 +13,6 @@ import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
 import ChatScreen from './src/screens/ChatScreen';
 import SettingsScreen from './src/screens/SettingsScreen';
 import rvs from './src/services/rvs';
-import { initLogger } from './src/services/logger';
 
 // --- Navigation ---
 
@@ -45,10 +44,6 @@ const TAB_ICONS: Record<string, { active: string; inactive: string }> = {
 const App: React.FC = () => {
   // Beim Start: gespeicherte RVS-Konfiguration laden und verbinden
   useEffect(() => {
-    // Verbose-Logging-Setting laden BEVOR andere Module loslegen.
-    // initLogger ist async aber blockt nichts — solange er noch laueft,
-    // loggen wir normal (Default an), danach respektiert console.log das Setting.
-    initLogger().catch(() => {});
     const initConnection = async () => {
       const config = await rvs.loadConfig();
       if (config) {

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 10106
-        versionName "0.1.1.6"
+        versionCode 506
+        versionName "0.0.5.6"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }
@@ -104,19 +104,6 @@ android {
             proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
         }
     }
-
-    // ABI-Split: nur arm64-v8a (jedes Android-Phone seit ~2017). Bringt die
-    // APK von ~136 MB auf ~35 MB — relevant weil ONNX Runtime + die anderen
-    // Native-Libs sonst pro Architektur dazukommen. Wer 32-bit oder Emulator
-    // braucht, kann hier "armeabi-v7a", "x86_64" etc. ergaenzen.
-    splits {
-        abi {
-            enable true
-            reset()
-            include "arm64-v8a"
-            universalApk false
-        }
-    }
 }
 
 dependencies {
@@ -124,9 +111,6 @@ dependencies {
     implementation("com.facebook.react:react-android")
     implementation("com.facebook.react:flipper-integration")
 
-    // ONNX Runtime fuer on-device Wake-Word (openWakeWord ONNX-Modelle in assets/openwakeword/)
-    implementation("com.microsoft.onnxruntime:onnxruntime-android:1.17.1")
-
     if (hermesEnabled.toBoolean()) {
         implementation("com.facebook.react:hermes-android")
     } else {

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

@@ -4,19 +4,6 @@
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
-    <!-- Anruf-State lesen damit TTS bei klingelndem Telefon pausiert -->
-    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
-    <!-- Optional: GPS-Position der Frage anhaengen (nur wenn User in Settings aktiviert) -->
-    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
-    <!-- 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"
@@ -48,10 +35,5 @@
           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/ApkInstallerPackage.kt

@@ -7,7 +7,7 @@ import com.facebook.react.uimanager.ViewManager
 
 class ApkInstallerPackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(ApkInstallerModule(reactContext), FileOpenerModule(reactContext))
+        return listOf(ApkInstallerModule(reactContext))
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

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

@@ -1,108 +0,0 @@
-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/AudioFocusModule.kt

@@ -5,71 +5,26 @@ import android.media.AudioAttributes
 import android.media.AudioFocusRequest
 import android.media.AudioManager
 import android.os.Build
-import android.util.Log
-import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.modules.core.DeviceEventManagerModule
 
 /**
- * Steuert Audio-Focus fuer Ducking/Muten anderer Apps + emittiert Loss-Events
- * an JS damit ARIA bei VoIP-Anrufen (WhatsApp/Signal/Discord/...) aufhoert
- * zu sprechen — diese Anrufe gehen nicht ueber TelephonyManager, sondern
- * requestn AudioFocus_GAIN_TRANSIENT_EXCLUSIVE was wir hier mitbekommen.
+ * Steuert Audio-Focus fuer Ducking/Muten anderer Apps.
  *
  * - requestDuck()      → andere Apps werden leiser (ARIA spricht TTS)
  * - requestExclusive() → andere Apps werden pausiert (Mikrofon-Aufnahme)
  * - release()          → Focus abgeben, andere Apps duerfen wieder
- *
- * Events:
- * - "AudioFocusChanged" mit type:
- *     "loss"           — endgueltiger Verlust (Anruf, andere App permanent)
- *     "loss_transient" — vorruebergehender Verlust (kurze Unterbrechung)
- *     "gain"           — Fokus zurueck
  */
 class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
     override fun getName() = "AudioFocus"
 
-    companion object { private const val TAG = "AudioFocus" }
-
     private var currentRequest: AudioFocusRequest? = null
 
     private fun audioManager(): AudioManager? =
         reactApplicationContext.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
 
-    private fun emitFocusChange(type: String) {
-        try {
-            val params = Arguments.createMap().apply { putString("type", type) }
-            reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("AudioFocusChanged", params)
-        } catch (e: Exception) {
-            Log.w(TAG, "emit failed: ${e.message}")
-        }
-    }
-
-    private val focusListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
-        when (focusChange) {
-            AudioManager.AUDIOFOCUS_LOSS -> {
-                Log.i(TAG, "AUDIOFOCUS_LOSS (z.B. Anruf, anderer Player permanent)")
-                emitFocusChange("loss")
-            }
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-                Log.i(TAG, "AUDIOFOCUS_LOSS_TRANSIENT (kurze Unterbrechung)")
-                emitFocusChange("loss_transient")
-            }
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
-                // Notification-Sound o.ae. — wir ignorieren das, ARIA macht weiter
-                Log.d(TAG, "AUDIOFOCUS_LOSS_CAN_DUCK ignoriert")
-            }
-            AudioManager.AUDIOFOCUS_GAIN -> {
-                Log.i(TAG, "AUDIOFOCUS_GAIN")
-                emitFocusChange("gain")
-            }
-        }
-    }
-
     private fun requestFocus(durationHint: Int, usage: Int, promise: Promise) {
         val am = audioManager()
         if (am == null) {
@@ -86,13 +41,13 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
                 .build()
             val req = AudioFocusRequest.Builder(durationHint)
                 .setAudioAttributes(attrs)
-                .setOnAudioFocusChangeListener(focusListener)
+                .setOnAudioFocusChangeListener { /* kein Callback noetig */ }
                 .build()
             currentRequest = req
             am.requestAudioFocus(req)
         } else {
             @Suppress("DEPRECATION")
-            am.requestAudioFocus(focusListener, AudioManager.STREAM_MUSIC, durationHint)
+            am.requestAudioFocus(null, AudioManager.STREAM_MUSIC, durationHint)
         }
 
         promise.resolve(result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
@@ -131,82 +86,14 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
         promise.resolve(true)
     }
 
-    /** Den USAGE_MEDIA-Focus-Stack im System aufmischen, damit Spotify/YouTube
-     *  resumen wenn ein anderer Player (z.B. react-native-sound) seinen Focus
-     *  nicht ordnungsgemaess released hat. Strategie: kurz selbst USAGE_MEDIA
-     *  GAIN beanspruchen — das System invalidiert dabei den haengenden Stack-
-     *  Eintrag des anderen Players — und sofort wieder abandonen. Spotify
-     *  bekommt den Focus-Gain und resumed.
-     *
-     *  Workaround fuer das react-native-sound-Bug: Sound.stop()/release()
-     *  laesst den AudioFocusRequest haengen.
-     */
-    @ReactMethod
-    fun kickReleaseMedia(promise: Promise) {
-        val am = audioManager()
-        if (am == null) {
-            promise.resolve(false)
-            return
-        }
-        // Async laufen lassen — wir wollen einen request, Pause, dann abandon.
-        // Ohne Pause merkt das System (und damit Spotify) die kurze Owner-
-        // Wechsel oft gar nicht. 250ms reicht erfahrungsgemaess fuer den
-        // Focus-Stack-Refresh.
-        Thread {
-            try {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    val attrs = AudioAttributes.Builder()
-                        .setUsage(AudioAttributes.USAGE_MEDIA)
-                        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
-                        .build()
-                    val kickListener = AudioManager.OnAudioFocusChangeListener { /* ignorieren */ }
-                    val kickReq = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
-                        .setAudioAttributes(attrs)
-                        .setOnAudioFocusChangeListener(kickListener)
-                        .build()
-                    am.requestAudioFocus(kickReq)
-                    Thread.sleep(250)
-                    am.abandonAudioFocusRequest(kickReq)
-                } else {
-                    val kickListener = AudioManager.OnAudioFocusChangeListener { /* ignorieren */ }
-                    @Suppress("DEPRECATION")
-                    am.requestAudioFocus(kickListener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
-                    Thread.sleep(250)
-                    @Suppress("DEPRECATION")
-                    am.abandonAudioFocus(kickListener)
-                }
-                Log.i(TAG, "kickReleaseMedia: USAGE_MEDIA-Stack aufgemischt (250ms Pause)")
-            } catch (e: Exception) {
-                Log.w(TAG, "kickReleaseMedia failed: ${e.message}")
-            }
-        }.start()
-        promise.resolve(true)
-    }
-
     private fun release() {
         val am = audioManager() ?: return
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             currentRequest?.let { am.abandonAudioFocusRequest(it) }
         } else {
             @Suppress("DEPRECATION")
-            am.abandonAudioFocus(focusListener)
+            am.abandonAudioFocus(null)
         }
         currentRequest = null
     }
-
-    /** Aktueller Audio-Mode: NORMAL=0, IN_CALL=2, IN_COMMUNICATION=3, CALL_SCREENING=4.
-     *  IN_COMMUNICATION ist der typische VoIP-Anruf-Mode (WhatsApp, Signal, etc.) —
-     *  kann gepollt werden um zu erkennen wann der Anruf vorbei ist (zurueck NORMAL). */
-    @ReactMethod
-    fun getMode(promise: Promise) {
-        val am = audioManager()
-        if (am == null) {
-            promise.resolve(0)
-            return
-        }
-        promise.resolve(am.mode)
-    }
-
-    @ReactMethod fun addListener(eventName: String) {}
-    @ReactMethod fun removeListeners(count: Int) {}
 }

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

@@ -1,59 +0,0 @@
-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

@@ -1,16 +0,0 @@
-package com.ariacockpit
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-class 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/FileOpenerModule.kt

@@ -1,55 +0,0 @@
-package com.ariacockpit
-
-import android.content.Intent
-import android.net.Uri
-import android.os.Build
-import androidx.core.content.FileProvider
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import java.io.File
-
-/**
- * Oeffnet eine beliebige Datei (PDF, Bild, Office-Doc, ...) mit der vom User
- * gewaehlten App via Android-Intent-Picker. Nutzt FileProvider damit auch
- * Android 7+ (content:// statt file://) das URI lesen darf.
- *
- * MIME-Type wird vom Caller bestimmt — App-Auswahl ist davon abhaengig (PDF
- * geht an PDF-Viewer, image/jpeg an Galerie, etc.).
- */
-class FileOpenerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    override fun getName() = "FileOpener"
-
-    @ReactMethod
-    fun open(filePath: String, mimeType: String, promise: Promise) {
-        try {
-            val cleanPath = filePath.removePrefix("file://")
-            val file = File(cleanPath)
-            if (!file.exists()) {
-                promise.reject("FILE_NOT_FOUND", "Datei nicht gefunden: $cleanPath")
-                return
-            }
-            val context = reactApplicationContext
-            val uri: Uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
-            } else {
-                Uri.fromFile(file)
-            }
-            val safeMime = if (mimeType.isBlank()) "application/octet-stream" else mimeType
-            val intent = Intent(Intent.ACTION_VIEW).apply {
-                setDataAndType(uri, safeMime)
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-            }
-            // Chooser zeigt Android-Auswahl falls mehrere Apps das MIME oeffnen koennen.
-            val chooser = Intent.createChooser(intent, "Oeffnen mit").apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            }
-            context.startActivity(chooser)
-            promise.resolve(true)
-        } catch (e: Exception) {
-            promise.reject("OPEN_ERROR", e.message, e)
-        }
-    }
-}

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

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

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

@@ -1,413 +0,0 @@
-package com.ariacockpit
-
-import ai.onnxruntime.OnnxTensor
-import ai.onnxruntime.OrtEnvironment
-import ai.onnxruntime.OrtSession
-import android.Manifest
-import android.content.pm.PackageManager
-import android.media.AudioFormat
-import android.media.AudioRecord
-import android.media.MediaRecorder
-import android.media.audiofx.AcousticEchoCanceler
-import android.media.audiofx.AutomaticGainControl
-import android.media.audiofx.NoiseSuppressor
-import android.util.Log
-import androidx.core.content.ContextCompat
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import java.nio.FloatBuffer
-import java.util.concurrent.atomic.AtomicBoolean
-
-/**
- * Wake-Word Erkennung on-device via openWakeWord (https://github.com/dscripka/openWakeWord).
- *
- * Drei-stufige ONNX Pipeline:
- *   1. Audio (16kHz mono int16, 1280-Sample-Chunks) → Melspectrogram → 32-mel Frames
- *   2. 76 Mel-Frames Sliding Window (stride 8) → Speech-Embedding → 96-dim Vektor
- *   3. Letzte 16 Embeddings (~1.28s Kontext) → Wake-Word-Klassifikator → Sigmoid-Score
- *
- *  Modelle liegen in assets/openwakeword/ (mel + embedding shared, plus pro Keyword
- *  ein eigenes .onnx). Erkennung feuert nach `patience` aufeinanderfolgenden
- *  Frames ueber `threshold` und unterdrueckt Wiederholungen fuer `debounceMs`.
- *
- *  Emittiert "WakeWordDetected" als RN-Event wenn ein Trigger erkannt wurde.
- */
-class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    override fun getName() = "OpenWakeWord"
-
-    companion object {
-        private const val TAG = "OpenWakeWord"
-        private const val SAMPLE_RATE = 16000
-        private const val CHUNK_SAMPLES = 1280               // 80ms @ 16kHz
-        private const val MEL_FRAMES_PER_EMBEDDING = 76      // Embedding-Fenster
-        private const val EMBEDDING_STRIDE = 8               // Slide um 8 Mel-Frames
-        private const val EMBEDDING_DIM = 96
-        private const val MEL_BINS = 32
-        private const val DEFAULT_WW_INPUT_FRAMES = 16       // Fallback wenn Modell-Metadata fehlt
-    }
-
-    private val env: OrtEnvironment = OrtEnvironment.getEnvironment()
-    private var melSession: OrtSession? = null
-    private var embSession: OrtSession? = null
-    private var wwSession: OrtSession? = null
-
-    private var melInputName: String = "input"
-    private var embInputName: String = "input_1"
-    private var wwInputName: String = "input"
-    // Anzahl Embedding-Frames die der Wake-Word-Klassifikator pro Inferenz erwartet —
-    // hey_jarvis hat 16, andere Community-Modelle koennen abweichen (z.B. 28).
-    // Wird beim init() aus den Modell-Metadaten gelesen.
-    private var wwInputFrames: Int = DEFAULT_WW_INPUT_FRAMES
-
-    // Konfiguration
-    private var threshold: Float = 0.5f
-    private var patience: Int = 2
-    private var debounceMs: Long = 1500
-    private var modelName: String = "hey_jarvis"
-
-    // Audio-Capture-Thread
-    private var audioRecord: AudioRecord? = null
-    private val running = AtomicBoolean(false)
-    private var captureThread: Thread? = null
-
-    // Audio-Effects: Echo-Cancellation (gegen ARIAs eigene TTS-Stimme die sonst
-    // das Wake-Word triggern wuerde) + Noise-Suppression. Per VOICE_COMMUNICATION
-    // Audio-Source schon vorhanden, aber explizites Aktivieren ist robuster.
-    private var aec: AcousticEchoCanceler? = null
-    private var ns: NoiseSuppressor? = null
-    private var agc: AutomaticGainControl? = null
-
-    // Inferenz-State
-    private val melBuffer: ArrayList<FloatArray> = ArrayList(256)   // Liste von 32-dim Frames
-    private var melProcessedIdx: Int = 0
-    private val embBuffer: ArrayDeque<FloatArray> = ArrayDeque(32)  // Ringpuffer letzter Embeddings
-    private var consecutiveAboveThreshold: Int = 0
-    private var lastDetectionMs: Long = 0L
-
-    /**
-     *  Initialisiert die ONNX-Sessions fuer ein bestimmtes Wake-Word.
-     *  modelName: dateiname ohne Suffix (z.B. "hey_jarvis", "alexa", "hey_mycroft", "hey_rhasspy")
-     */
-    @ReactMethod
-    fun init(modelName: String, threshold: Double, patience: Int, debounceMs: Int, promise: Promise) {
-        try {
-            disposeSessions()
-            this.modelName = modelName
-            this.threshold = threshold.toFloat()
-            this.patience = patience.coerceAtLeast(1)
-            this.debounceMs = debounceMs.toLong()
-
-            val ctx = reactApplicationContext
-            val melBytes = ctx.assets.open("openwakeword/melspectrogram.onnx").use { it.readBytes() }
-            val embBytes = ctx.assets.open("openwakeword/embedding_model.onnx").use { it.readBytes() }
-            val wwBytes = ctx.assets.open("openwakeword/$modelName.onnx").use { it.readBytes() }
-
-            val opts = OrtSession.SessionOptions()
-            melSession = env.createSession(melBytes, opts)
-            embSession = env.createSession(embBytes, opts)
-            wwSession = env.createSession(wwBytes, opts)
-
-            melInputName = melSession!!.inputNames.first()
-            embInputName = embSession!!.inputNames.first()
-            wwInputName = wwSession!!.inputNames.first()
-
-            // WW-Input-Frame-Count aus dem Modell lesen — variiert pro Keyword.
-            // Erwartete Form: (1, N, 96), N steht in der Modell-Metadaten.
-            val wwInputInfo = wwSession!!.inputInfo[wwInputName]
-            val wwShape = (wwInputInfo?.info as? ai.onnxruntime.TensorInfo)?.shape
-            wwInputFrames = wwShape?.getOrNull(1)?.toInt()?.takeIf { it > 0 } ?: DEFAULT_WW_INPUT_FRAMES
-
-            Log.i(TAG, "Init OK: model=$modelName wwFrames=$wwInputFrames threshold=$threshold patience=$patience " +
-                    "debounce=${debounceMs}ms (inputs: mel=$melInputName emb=$embInputName ww=$wwInputName)")
-            promise.resolve(true)
-        } catch (e: Exception) {
-            Log.e(TAG, "Init fehlgeschlagen: ${e.message}", e)
-            disposeSessions()
-            promise.reject("INIT_FAILED", e.message ?: "Unbekannter Fehler", e)
-        }
-    }
-
-    @ReactMethod
-    fun start(promise: Promise) {
-        if (running.get()) {
-            promise.resolve(true)
-            return
-        }
-        if (melSession == null || embSession == null || wwSession == null) {
-            promise.reject("NOT_INITIALIZED", "init() muss vor start() aufgerufen werden")
-            return
-        }
-        // Berechtigung pruefen — der App-Code holt die ueblicherweise schon vorher,
-        // aber wir bestehen hier explizit darauf damit AudioRecord nicht stumm
-        // failt.
-        val perm = ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.RECORD_AUDIO)
-        if (perm != PackageManager.PERMISSION_GRANTED) {
-            promise.reject("NO_MIC_PERMISSION", "RECORD_AUDIO Permission fehlt")
-            return
-        }
-
-        try {
-            val minBuf = AudioRecord.getMinBufferSize(
-                SAMPLE_RATE,
-                AudioFormat.CHANNEL_IN_MONO,
-                AudioFormat.ENCODING_PCM_16BIT,
-            ).coerceAtLeast(CHUNK_SAMPLES * 2 * 4)
-
-            // VOICE_COMMUNICATION-Source: aktiviert auf den meisten Android-Geraeten
-            // automatisch Echo-Cancellation + Noise-Suppression. Wichtig damit
-            // ARIAs eigene Stimme nicht das Wake-Word triggert wenn parallel
-            // zur TTS-Wiedergabe gelauscht wird.
-            val record = AudioRecord(
-                MediaRecorder.AudioSource.VOICE_COMMUNICATION,
-                SAMPLE_RATE,
-                AudioFormat.CHANNEL_IN_MONO,
-                AudioFormat.ENCODING_PCM_16BIT,
-                minBuf,
-            )
-            if (record.state != AudioRecord.STATE_INITIALIZED) {
-                record.release()
-                promise.reject("AUDIO_INIT", "AudioRecord nicht initialisiert (Mikro belegt?)")
-                return
-            }
-            audioRecord = record
-
-            // Audio-Effects ZUSAETZLICH explizit aktivieren — manche Geraete
-            // benoetigen das, obwohl VOICE_COMMUNICATION es eigentlich schon
-            // mitbringt. Failure ist nicht kritisch (continue ohne Effects).
-            try {
-                if (AcousticEchoCanceler.isAvailable()) {
-                    aec = AcousticEchoCanceler.create(record.audioSessionId)?.apply { enabled = true }
-                    Log.i(TAG, "AEC aktiviert (enabled=${aec?.enabled})")
-                }
-            } catch (e: Exception) { Log.w(TAG, "AEC failed: ${e.message}") }
-            try {
-                if (NoiseSuppressor.isAvailable()) {
-                    ns = NoiseSuppressor.create(record.audioSessionId)?.apply { enabled = true }
-                }
-            } catch (e: Exception) { Log.w(TAG, "NS failed: ${e.message}") }
-            try {
-                if (AutomaticGainControl.isAvailable()) {
-                    agc = AutomaticGainControl.create(record.audioSessionId)?.apply { enabled = true }
-                }
-            } catch (e: Exception) { Log.w(TAG, "AGC failed: ${e.message}") }
-
-            resetInferenceState()
-            running.set(true)
-            record.startRecording()
-
-            captureThread = Thread({ captureLoop() }, "OpenWakeWordCapture").apply {
-                isDaemon = true
-                start()
-            }
-
-            Log.i(TAG, "Lauschen gestartet (model=$modelName)")
-            promise.resolve(true)
-        } catch (e: Exception) {
-            Log.e(TAG, "start fehlgeschlagen", e)
-            running.set(false)
-            audioRecord?.release()
-            audioRecord = null
-            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
-        }
-    }
-
-    private fun releaseAudioEffects() {
-        try { aec?.release() } catch (_: Exception) {}
-        try { ns?.release() } catch (_: Exception) {}
-        try { agc?.release() } catch (_: Exception) {}
-        aec = null; ns = null; agc = null
-    }
-
-    @ReactMethod
-    fun stop(promise: Promise) {
-        running.set(false)
-        try {
-            captureThread?.join(1500)
-        } catch (_: InterruptedException) {}
-        captureThread = null
-        try { audioRecord?.stop() } catch (_: Exception) {}
-        try { audioRecord?.release() } catch (_: Exception) {}
-        audioRecord = null
-        releaseAudioEffects()
-        Log.i(TAG, "Lauschen gestoppt")
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun dispose(promise: Promise) {
-        running.set(false)
-        try { captureThread?.join(1000) } catch (_: InterruptedException) {}
-        captureThread = null
-        try { audioRecord?.stop() } catch (_: Exception) {}
-        try { audioRecord?.release() } catch (_: Exception) {}
-        audioRecord = null
-        releaseAudioEffects()
-        disposeSessions()
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun isAvailable(promise: Promise) {
-        // Wake-Word ist immer verfuegbar (kein API-Key, alles on-device)
-        promise.resolve(true)
-    }
-
-    // RN-Event-Subscriptions — RN-Konvention, sonst Warnung im Debug-Build
-    @ReactMethod fun addListener(eventName: String) {}
-    @ReactMethod fun removeListeners(count: Int) {}
-
-    private fun disposeSessions() {
-        try { melSession?.close() } catch (_: Exception) {}
-        try { embSession?.close() } catch (_: Exception) {}
-        try { wwSession?.close() } catch (_: Exception) {}
-        melSession = null
-        embSession = null
-        wwSession = null
-    }
-
-    private fun resetInferenceState() {
-        melBuffer.clear()
-        melProcessedIdx = 0
-        embBuffer.clear()
-        consecutiveAboveThreshold = 0
-        lastDetectionMs = 0L
-    }
-
-    private fun emitDetected() {
-        val params = com.facebook.react.bridge.Arguments.createMap().apply {
-            putString("model", modelName)
-        }
-        try {
-            reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("WakeWordDetected", params)
-        } catch (e: Exception) {
-            Log.w(TAG, "emit fehlgeschlagen: ${e.message}")
-        }
-    }
-
-    private fun captureLoop() {
-        val buf = ShortArray(CHUNK_SAMPLES)
-        val record = audioRecord ?: return
-        Log.i(TAG, "Capture-Loop gestartet")
-        while (running.get()) {
-            var read = 0
-            while (read < CHUNK_SAMPLES && running.get()) {
-                val n = record.read(buf, read, CHUNK_SAMPLES - read)
-                if (n <= 0) {
-                    Log.w(TAG, "AudioRecord.read returned $n — Loop ende")
-                    running.set(false)
-                    return
-                }
-                read += n
-            }
-            if (!running.get()) break
-            try {
-                processChunk(buf)
-            } catch (e: Exception) {
-                Log.w(TAG, "processChunk: ${e.message}")
-            }
-        }
-        Log.i(TAG, "Capture-Loop beendet")
-    }
-
-    /** Verarbeitet einen 1280-Sample int16 Audio-Chunk. */
-    private fun processChunk(audio: ShortArray) {
-        // 1) Audio → mel (output (1, 1, frames, 32))
-        val floats = FloatArray(audio.size) { audio[it].toFloat() }
-        val melTensor = OnnxTensor.createTensor(
-            env,
-            FloatBuffer.wrap(floats),
-            longArrayOf(1L, audio.size.toLong()),
-        )
-        val melResult = melSession!!.run(mapOf(melInputName to melTensor))
-        val melOut = melResult.get(0).value
-        melTensor.close()
-        @Suppress("UNCHECKED_CAST")
-        val mel4 = melOut as Array<Array<Array<FloatArray>>>
-        val frames = mel4[0][0]
-        // openWakeWord wendet `mel/10 + 2` an, bevor es ans Embedding-Modell geht
-        for (frame in frames) {
-            val scaled = FloatArray(frame.size) { frame[it] / 10f + 2f }
-            melBuffer.add(scaled)
-        }
-        melResult.close()
-
-        // 2) Sliding window: alle vollstaendigen 76-Frame-Fenster verarbeiten
-        while (melBuffer.size >= melProcessedIdx + MEL_FRAMES_PER_EMBEDDING) {
-            val flat = FloatArray(MEL_FRAMES_PER_EMBEDDING * MEL_BINS)
-            var pos = 0
-            for (i in 0 until MEL_FRAMES_PER_EMBEDDING) {
-                val src = melBuffer[melProcessedIdx + i]
-                System.arraycopy(src, 0, flat, pos, MEL_BINS)
-                pos += MEL_BINS
-            }
-            val embIn = OnnxTensor.createTensor(
-                env,
-                FloatBuffer.wrap(flat),
-                longArrayOf(1L, MEL_FRAMES_PER_EMBEDDING.toLong(), MEL_BINS.toLong(), 1L),
-            )
-            val embRes = embSession!!.run(mapOf(embInputName to embIn))
-            val embOut = embRes.get(0).value
-            embIn.close()
-            // Erwartete Output-Form: (1, 1, 1, 96) — rank-4, NICHT (1, 96).
-            // Die Google-Embedding-Pipeline behaelt extra Dimensionen.
-            @Suppress("UNCHECKED_CAST")
-            val embArr = embOut as Array<Array<Array<FloatArray>>>
-            embBuffer.addLast(embArr[0][0][0].copyOf())
-            while (embBuffer.size > wwInputFrames) embBuffer.removeFirst()
-            embRes.close()
-
-            melProcessedIdx += EMBEDDING_STRIDE
-        }
-        // Mel-Buffer trimmen — verhindert Memory-Wachstum
-        if (melProcessedIdx > MEL_FRAMES_PER_EMBEDDING) {
-            val keepFrom = melProcessedIdx - MEL_FRAMES_PER_EMBEDDING
-            val newList = ArrayList<FloatArray>(melBuffer.size - keepFrom)
-            for (i in keepFrom until melBuffer.size) newList.add(melBuffer[i])
-            melBuffer.clear()
-            melBuffer.addAll(newList)
-            melProcessedIdx = MEL_FRAMES_PER_EMBEDDING
-        }
-
-        // 3) Klassifikation — sobald wir 16 Embeddings haben
-        if (embBuffer.size < wwInputFrames) return
-        val flatEmb = FloatArray(wwInputFrames * EMBEDDING_DIM)
-        var p = 0
-        // Letzte wwInputFrames Embeddings nehmen (embBuffer ist auf wwInputFrames begrenzt)
-        for (e in embBuffer) {
-            System.arraycopy(e, 0, flatEmb, p, EMBEDDING_DIM)
-            p += EMBEDDING_DIM
-        }
-        val wwIn = OnnxTensor.createTensor(
-            env,
-            FloatBuffer.wrap(flatEmb),
-            longArrayOf(1L, wwInputFrames.toLong(), EMBEDDING_DIM.toLong()),
-        )
-        val wwRes = wwSession!!.run(mapOf(wwInputName to wwIn))
-        val wwOut = wwRes.get(0).value
-        wwIn.close()
-        // Erwartete Output-Form: (1, 1) → Array<FloatArray>
-        @Suppress("UNCHECKED_CAST")
-        val score = (wwOut as Array<FloatArray>)[0][0]
-        wwRes.close()
-
-        if (score >= threshold) {
-            consecutiveAboveThreshold++
-            if (consecutiveAboveThreshold >= patience) {
-                val now = System.currentTimeMillis()
-                if (now - lastDetectionMs >= debounceMs) {
-                    lastDetectionMs = now
-                    consecutiveAboveThreshold = 0
-                    Log.i(TAG, "Wake-Word erkannt! score=$score model=$modelName")
-                    emitDetected()
-                }
-            }
-        } else {
-            consecutiveAboveThreshold = 0
-        }
-    }
-}

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

@@ -1,16 +0,0 @@
-package com.ariacockpit
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-class OpenWakeWordPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(OpenWakeWordModule(reactContext))
-    }
-
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
-}

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

@@ -4,15 +4,12 @@ import android.media.AudioAttributes
 import android.media.AudioFormat
 import android.media.AudioManager
 import android.media.AudioTrack
-import android.os.Build
 import android.util.Base64
 import android.util.Log
-import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import java.util.concurrent.LinkedBlockingQueue
 
 /**
@@ -35,17 +32,11 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
         private const val TAG = "PcmStreamPlayer"
         // Fallback wenn JS keinen Wert uebergibt.
         private const val DEFAULT_PREROLL_SECONDS = 3.5
-        // 0.0 = sofortige Wiedergabe — play() direkt beim ersten Chunk.
-        // Macht Sinn fuer F5-TTS weil Render so schnell ist dass ein Puffer
-        // unnoetig ist und bei kurzen Saetzen sogar stoeren kann.
-        private const val MIN_PREROLL_SECONDS = 0.0
+        private const val MIN_PREROLL_SECONDS = 0.5
         private const val MAX_PREROLL_SECONDS = 10.0
         // Stille am Stream-Anfang, damit AudioTrack sauber anfaehrt und die
         // ersten Samples nicht abgeschnitten werden (XTTS-Warmup + play()-Latenz).
-        private const val LEADING_SILENCE_SECONDS = 0.3
-        // Stille am Ende — puffert das Hardware-Flushen damit die letzten
-        // echten Samples garantiert ausgespielt werden bevor stop() kommt.
-        private const val TRAILING_SILENCE_SECONDS = 0.3
+        private const val LEADING_SILENCE_SECONDS = 0.2
     }
 
     override fun getName() = "PcmStreamPlayer"
@@ -68,23 +59,17 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
             // Alte Session beenden falls vorhanden
             stopInternal()
 
-            // Nur NaN/Inf → Default. 0.0 ist gueltig (= sofortige Wiedergabe).
-            val prerollSec = if (prerollSeconds.isFinite() && prerollSeconds >= 0.0) {
-                prerollSeconds.coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
-            } else {
-                DEFAULT_PREROLL_SECONDS
-            }
+            val prerollSec = prerollSeconds
+                .coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
+                .let { if (it.isFinite() && it > 0) it else DEFAULT_PREROLL_SECONDS }
 
             val channelConfig = if (channels == 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
             val encoding = AudioFormat.ENCODING_PCM_16BIT
             val minBuf = AudioTrack.getMinBufferSize(sampleRate, channelConfig, encoding)
             val bytesPerSecond = sampleRate * channels * 2 // 16-bit = 2 bytes
+            // Buffer muss mindestens PREROLL + etwas Spielraum fassen.
             val prerollTarget = (bytesPerSecond * prerollSec).toInt()
-            // Buffer entkoppelt von Preroll — fester ~4s-Buffer. OnePlus A12
-            // mit USAGE_ASSISTANT laeuft AudioTrack erst ab ~3s gepufferter
-            // Daten an. Wir padden Kurztexte vor play() auf 3s (siehe Block
-            // nach mainLoop), Buffer braucht ~1s Headroom weil write() blockt.
-            val bufferSize = (bytesPerSecond * 4).coerceAtLeast(minBuf * 8)
+            val bufferSize = (minBuf * 32).coerceAtLeast(prerollTarget * 2)
             prerollBytes = prerollTarget
             bytesBuffered = 0
             playbackStarted = false
@@ -108,20 +93,7 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                 .setTransferMode(AudioTrack.MODE_STREAM)
                 .build()
 
-            // Start-Threshold runterdrehen: Default ist bufferSize/2 (= 2s bei 4s
-            // Buffer). AudioTrack startet sonst nicht bevor 2s im Puffer sind —
-            // bei kurzen TTS-Antworten (3 Worte ~ 1.4s) bleibt pos auf 0 stehen.
-            // 0.1s reicht damit AudioTrack sofort mit dem ersten Chunk anlaeuft.
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                try {
-                    val startFrames = (sampleRate / 10).coerceAtLeast(1)  // 100ms
-                    newTrack.setStartThresholdInFrames(startFrames)
-                    Log.i(TAG, "Start-Threshold gesetzt: ${startFrames} frames (~100ms)")
-                } catch (e: Exception) {
-                    Log.w(TAG, "setStartThresholdInFrames failed: ${e.message}")
-                }
-            }
-
+            // AudioTrack erstellen — play() wird erst aufgerufen wenn Pre-Roll erreicht.
             track = newTrack
             queue.clear()
             writerShouldStop = false
@@ -131,9 +103,9 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                 val t = track ?: return@Thread
                 try {
                     // Leading-Silence in den Buffer — gibt AudioTrack Zeit anzufahren.
-                    val leadingBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
-                    if (leadingBytes > 0) {
-                        val silence = ByteArray(leadingBytes)
+                    val silenceBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
+                    if (silenceBytes > 0) {
+                        val silence = ByteArray(silenceBytes)
                         var silOff = 0
                         while (silOff < silence.size && !writerShouldStop) {
                             val w = t.write(silence, silOff, silence.size - silOff)
@@ -142,83 +114,25 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         }
                         bytesBuffered += silence.size
                     }
-                    // Bei preroll=0: play() SOFORT nach Leading-Silence aufrufen,
-                    // nicht erst bei Ankunft des ersten echten Chunks. Android's
-                    // AudioTrack haelt den Play-State und wartet auf neue Samples.
-                    // So verschluckt es keine Worte wenn der erste Chunk erst
-                    // nach play()-Startup-Latenz eintrifft.
-                    if (prerollBytes == 0 && !playbackStarted) {
-                        try {
-                            t.play()
-                            playbackStarted = true
-                            Log.i(TAG, "Playback sofort gestartet (preroll=0, ${bytesBuffered}B silence)")
-                        } catch (e: Exception) {
-                            Log.w(TAG, "play() sofort failed: ${e.message}")
-                        }
-                    }
-                    // Idle-Cutoff: wenn endRequested NICHT kam aber lange nichts mehr
-                    // reinkommt, brechen wir ab (Bridge-Crash, verlorener final).
-                    // 120s damit lange F5-TTS-Render-Pausen zwischen Saetzen (z.B. bei
-                    // Modell-Wechsel oder kalter GPU) nicht den Stream abreissen.
-                    var idleMs = 0L
-                    val maxIdleMs = 120_000L
-                    // Zielpufferfuellung — unter diesem Wasserstand fuettern wir
-                    // Stille rein damit AudioTrack nicht underrunt waehrend die
-                    // Bridge den naechsten Satz rendert. Spotify/YouTube reagieren
-                    // sonst mit eigenmaechtiger Wiederaufnahme nach ~10s Stille.
-                    val underrunGuardFrames = sampleRate / 10  // ~100ms
-                    val silenceFillFrames = sampleRate / 20    // ~50ms pro Refill
-
-                    mainLoop@ while (!writerShouldStop) {
-                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS)
-                        if (data == null) {
+                    while (!writerShouldStop) {
+                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS) ?: run {
                             if (endRequested) {
-                                // Falls play() noch gar nicht lief (Stream ohne data
-                                // ueberhaupt — sehr seltene Edge-Case): jetzt anstossen
-                                // damit das finally{}-Wait nicht endlos blockt.
+                                // Falls wir vor Pre-Roll enden (kurzer Text): trotzdem abspielen
                                 if (!playbackStarted) {
-                                    try { t.play(); playbackStarted = true } catch (_: Exception) {}
+                                    try { t.play() } catch (_: Exception) {}
+                                    playbackStarted = true
                                 }
-                                break@mainLoop
+                                return@Thread
                             }
-                            // Underrun-Schutz: Stille reinfuettern wenn der AudioTrack-
-                            // Puffer leerzulaufen droht. Spotify resumed sonst nach
-                            // ~10s Pause auf eigene Faust, obwohl wir den Fokus halten.
-                            if (playbackStarted) {
-                                val framesWritten = bytesBuffered / streamBytesPerFrame
-                                val framesPlayed = t.playbackHeadPosition.toLong()
-                                val framesInBuffer = framesWritten - framesPlayed
-                                if (framesInBuffer < underrunGuardFrames) {
-                                    val fillBytes = silenceFillFrames * streamBytesPerFrame
-                                    val silence = ByteArray(fillBytes)
-                                    var silOff = 0
-                                    while (silOff < silence.size && !writerShouldStop) {
-                                        val w = t.write(silence, silOff, silence.size - silOff)
-                                        if (w <= 0) break
-                                        silOff += w
-                                    }
-                                    bytesBuffered += silence.size
-                                }
-                            }
-                            idleMs += 50L
-                            if (idleMs >= maxIdleMs) {
-                                Log.w(TAG, "Idle-Cutoff: ${maxIdleMs}ms keine Daten — Stream wird beendet")
-                                break@mainLoop
-                            }
-                            continue@mainLoop
-                        }
-                        idleMs = 0L
+                            null
+                        } ?: continue
 
-                        // play() beim ALLERERSTEN data-chunk aufrufen — egal wie wenig
-                        // Daten da sind. Sonst stallt AudioTrack auf OnePlus A12 wenn
-                        // play() erst gerufen wird nachdem der Buffer komplett gefuellt
-                        // ist. Pre-Roll als "Vorrat aufbauen" passiert dann waehrend
-                        // der Track schon spielt — Underrun-Schutz fuettert ggf. Stille.
-                        if (!playbackStarted) {
+                        // Pre-Roll Check: play() erst wenn genug gepuffert
+                        if (!playbackStarted && bytesBuffered + data.size >= prerollBytes) {
                             try {
                                 t.play()
                                 playbackStarted = true
-                                Log.i(TAG, "Playback gestartet beim 1. Chunk (${bytesBuffered}B leading + ${data.size}B data)")
+                                Log.i(TAG, "Playback gestartet nach Pre-Roll ${bytesBuffered + data.size} Bytes")
                             } catch (e: Exception) {
                                 Log.w(TAG, "play() failed: ${e.message}")
                             }
@@ -232,19 +146,6 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         }
                         bytesBuffered += data.size
                     }
-                    // Trailing-Silence damit die letzten echten Samples garantiert
-                    // durch das Hardware-Buffering kommen bevor stop() sie abschneidet
-                    val trailingBytes = ((sampleRate * channels * 2) * TRAILING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
-                    if (trailingBytes > 0 && !writerShouldStop) {
-                        val silence = ByteArray(trailingBytes)
-                        var silOff = 0
-                        while (silOff < silence.size && !writerShouldStop) {
-                            val w = t.write(silence, silOff, silence.size - silOff)
-                            if (w <= 0) break
-                            silOff += w
-                        }
-                        bytesBuffered += silence.size
-                    }
                 } catch (e: Exception) {
                     Log.w(TAG, "Writer-Thread Fehler: ${e.message}")
                 } finally {
@@ -254,21 +155,12 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         val totalFrames = (bytesBuffered / streamBytesPerFrame).toInt()
                         var lastPos = -1
                         var stalledCount = 0
-                        var retried = false
                         while (!writerShouldStop) {
                             val pos = t.playbackHeadPosition
                             if (pos >= totalFrames) break
+                            // Safety: wenn Position 2s nicht mehr vorwaerts → AudioTrack hing
                             if (pos == lastPos) {
                                 stalledCount++
-                                // Nach 500ms Stillstand: AudioTrack-Quirk auf manchen
-                                // Geraeten (OnePlus A12) — play() nochmal anstossen.
-                                if (stalledCount == 10 && pos == 0 && !retried) {
-                                    retried = true
-                                    Log.w(TAG, "playback nicht angefahren — retry play()")
-                                    try { t.play() } catch (e: Exception) {
-                                        Log.w(TAG, "retry play() failed: ${e.message}")
-                                    }
-                                }
                                 if (stalledCount > 40) {
                                     Log.w(TAG, "playback stalled at $pos/$totalFrames — give up")
                                     break
@@ -283,17 +175,6 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                     } catch (_: Exception) {}
                     try { t.stop() } catch (_: Exception) {}
                     try { t.release() } catch (_: Exception) {}
-                    // RN-Event: AudioTrack ist wirklich durch (alle Samples gespielt).
-                    // JS released erst JETZT den AudioFocus — sonst spielt Spotify
-                    // beim end()-Cap waehrend ARIA noch redet (15s+ je nach Buffer).
-                    try {
-                        val params = Arguments.createMap()
-                        reactApplicationContext
-                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                            .emit("PcmPlaybackFinished", params)
-                    } catch (e: Exception) {
-                        Log.w(TAG, "PlaybackFinished emit failed: ${e.message}")
-                    }
                 }
             }, "PcmStreamWriter").apply { start() }
 
@@ -350,9 +231,6 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
         promise.resolve(true)
     }
 
-    @ReactMethod fun addListener(eventName: String) {}
-    @ReactMethod fun removeListeners(count: Int) {}
-
     private fun stopInternal() {
         writerShouldStop = true
         endRequested = true

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

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

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

@@ -1,16 +0,0 @@
-package com.ariacockpit
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-class PhoneCallPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(PhoneCallModule(reactContext))
-    }
-
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
-}

android/android/app/src/main/res/xml/file_paths.xml

@@ -1,8 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <paths>
     <cache-path name="cache" path="." />
-    <files-path name="files" path="." />
-    <external-path name="external" path="." />
-    <external-files-path name="external_files" path="." />
-    <external-cache-path name="external_cache" path="." />
 </paths>

android/build.sh

@@ -167,23 +167,10 @@ export CI=true
 
 if [ "$MODE" = "debug" ]; then
     ./gradlew assembleDebug
-    OUT_DIR="app/build/outputs/apk/debug"
+    APK_PATH="app/build/outputs/apk/debug/app-debug.apk"
 else
     ./gradlew assembleRelease
-    OUT_DIR="app/build/outputs/apk/release"
-fi
-
-# Mit ABI-Splits heisst die APK z.B. app-arm64-v8a-release.apk statt
-# app-release.apk. arm64-v8a-Variante zuerst probieren (das ist unser
-# Standard), Universal-APK als Fallback falls Splits deaktiviert sind.
-if [ -f "$OUT_DIR/app-arm64-v8a-${MODE}.apk" ]; then
-    APK_PATH="$OUT_DIR/app-arm64-v8a-${MODE}.apk"
-elif [ -f "$OUT_DIR/app-${MODE}.apk" ]; then
-    APK_PATH="$OUT_DIR/app-${MODE}.apk"
-else
-    echo -e "${RED}Keine passende APK in $OUT_DIR gefunden${NC}"
-    cd ..
-    exit 1
+    APK_PATH="app/build/outputs/apk/release/app-release.apk"
 fi
 
 cd ..

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.1.1.6",
+  "version": "0.0.5.6",
   "private": true,
   "scripts": {
     "android": "react-native run-android",
@@ -10,32 +10,33 @@
     "build:apk": "cd android && ./gradlew assembleRelease"
   },
   "dependencies": {
-    "@react-native-async-storage/async-storage": "^1.21.0",
-    "@react-native-community/geolocation": "^3.2.1",
-    "@react-navigation/bottom-tabs": "^6.5.11",
-    "@react-navigation/native": "^6.1.9",
     "react": "18.2.0",
     "react-native": "0.73.4",
-    "react-native-audio-recorder-player": "^3.6.7",
-    "react-native-camera-kit": "^13.0.0",
+    "@react-navigation/native": "^6.1.9",
+    "@react-navigation/bottom-tabs": "^6.5.11",
+    "react-native-screens": "3.27.0",
+    "react-native-safe-area-context": "^4.8.2",
     "react-native-document-picker": "^9.1.1",
-    "react-native-fs": "^2.20.0",
+    "react-native-sound": "^0.11.2",
+    "@react-native-community/geolocation": "^3.2.1",
     "react-native-image-picker": "^7.1.0",
     "react-native-permissions": "^4.1.4",
-    "react-native-safe-area-context": "^4.8.2",
-    "react-native-screens": "3.27.0",
-    "react-native-sound": "^0.11.2",
-    "react-native-svg": "^14.1.0"
+    "react-native-camera-kit": "^13.0.0",
+    "@react-native-async-storage/async-storage": "^1.21.0",
+    "react-native-fs": "^2.20.0",
+    "react-native-audio-recorder-player": "^3.6.7",
+    "@picovoice/porcupine-react-native": "3.0.5",
+    "@picovoice/react-native-voice-processor": "1.2.3"
   },
   "devDependencies": {
-    "@react-native/eslint-config": "^0.73.2",
-    "@react-native/metro-config": "^0.73.5",
-    "@react-native/typescript-config": "^0.73.1",
-    "@types/jest": "^29.5.11",
+    "typescript": "^5.3.3",
     "@types/react": "^18.2.48",
     "@types/react-native": "^0.73.0",
-    "jest": "^29.7.0",
+    "@react-native/eslint-config": "^0.73.2",
+    "@react-native/typescript-config": "^0.73.1",
+    "@react-native/metro-config": "^0.73.5",
     "metro-react-native-babel-preset": "^0.77.0",
-    "typescript": "^5.3.3"
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.11"
   }
 }

android/src/components/MessageText.tsx

@@ -1,88 +0,0 @@
-/**
- * MessageText — selektierbarer Chat-Text mit Android-Auto-Linkifizierung,
- * plus Inline-Image-Rendering wenn der Text Bild-URLs enthaelt.
- *
- * - Markdown-Syntax `![alt](url)` und plain `https://...image.png` werden
- *   erkannt — die URL bleibt im Text sichtbar (klickbar via Linkify),
- *   zusaetzlich wird das Bild als <Image> oder <SvgUri> drunter gerendert.
- * - 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 fing die Long-Press-
- *   Geste ab, damit war Markieren+Kopieren defekt.
- */
-
-import React, { useEffect, useState } from 'react';
-import { View, Text, Image, TextStyle, StyleProp } from 'react-native';
-import { SvgUri } from 'react-native-svg';
-
-interface Props {
-  text: string;
-  style?: StyleProp<TextStyle>;
-}
-
-// Bild-URL-Pattern: http(s)://... endend auf gaengige Bild-Endungen.
-const IMG_URL_RE = /https?:\/\/[^\s)<"']+\.(?:jpe?g|png|gif|webp|bmp|ico|svg)(?:\?[^\s)<"']*)?/gi;
-
-function extractImageUrls(text: string): string[] {
-  const urls = new Set<string>();
-  const matches = text.match(IMG_URL_RE);
-  if (matches) matches.forEach(u => urls.add(u));
-  return Array.from(urls);
-}
-
-const SVG_RE = /\.svg(?:\?|$)/i;
-
-/** Image mit dynamischer Aspect-Ratio aus echten Bilddimensionen.
- *  SVGs werden ueber react-native-svg gerendert (kein Image.getSize). */
-const InlineImage: React.FC<{ uri: string }> = ({ uri }) => {
-  const isSvg = SVG_RE.test(uri);
-  const [aspectRatio, setAspectRatio] = useState<number>(1);
-  const [failed, setFailed] = useState(false);
-  useEffect(() => {
-    if (isSvg) return; // Image.getSize geht fuer SVG nicht
-    let cancelled = false;
-    Image.getSize(
-      uri,
-      (w, h) => { if (!cancelled && w > 0 && h > 0) setAspectRatio(Math.max(0.5, Math.min(2.5, w / h))); },
-      () => { if (!cancelled) setFailed(true); },
-    );
-    return () => { cancelled = true; };
-  }, [uri, isSvg]);
-  if (failed) return null;
-  if (isSvg) {
-    return (
-      <View style={{ marginTop: 8, width: 260, height: 260, backgroundColor: '#0D0D1A', borderRadius: 8, alignItems: 'center', justifyContent: 'center' }}>
-        <SvgUri uri={uri} width="100%" height="100%" onError={() => setFailed(true)} />
-      </View>
-    );
-  }
-  return (
-    <Image
-      source={{ uri }}
-      style={{ width: 260, aspectRatio, borderRadius: 8, marginTop: 8, backgroundColor: '#0D0D1A' }}
-      resizeMode="cover"
-      onError={() => setFailed(true)}
-    />
-  );
-};
-
-const MessageText: React.FC<Props> = ({ text, style }) => {
-  const imageUrls = extractImageUrls(text || '');
-  if (imageUrls.length === 0) {
-    return (
-      <Text style={style} selectable dataDetectorType="all">
-        {text}
-      </Text>
-    );
-  }
-  return (
-    <View>
-      <Text style={style} selectable dataDetectorType="all">
-        {text}
-      </Text>
-      {imageUrls.map(u => <InlineImage key={u} uri={u} />)}
-    </View>
-  );
-};
-
-export default MessageText;

android/src/components/VoiceButton.tsx

@@ -44,6 +44,7 @@ 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(() => {
@@ -92,62 +93,66 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     }
   }, [isRecording]);
 
-  // VAD Silence Callback — Auto-Stop.
-  // WICHTIG: NICHT auf isRecording prüfen (Closure ist stale) — stattdessen
-  // audioService selber fragen. Empty deps → Listener wird EINMAL registriert.
-  // audioService garantiert jetzt dass der Callback pro Aufnahme nur einmal
-  // feuert (silenceFired-Latch).
-  const onCompleteRef = useRef(onRecordingComplete);
-  useEffect(() => { onCompleteRef.current = onRecordingComplete; }, [onRecordingComplete]);
+  // VAD Silence Callback — Auto-Stop
   useEffect(() => {
     const unsubSilence = audioService.onSilenceDetected(async () => {
-      if (audioService.getRecordingState() !== 'recording') return;
-      const result = await audioService.stopRecording();
+      if (!isRecording) return;
       setIsRecording(false);
+      const result = await audioService.stopRecording();
       if (result && result.durationMs > 500) {
-        onCompleteRef.current(result);
+        onRecordingComplete(result);
       }
     });
     return unsubSilence;
-  }, []);
+  }, [isRecording, onRecordingComplete]);
 
   // Auto-Start fuer Wake Word (extern getriggert)
   const startAutoRecording = useCallback(async () => {
     if (disabled || isRecording) return;
     const started = await audioService.startRecording(true); // autoStop = true
     if (started) {
+      isLongPress.current = false;
       setIsRecording(true);
     }
   }, [disabled, isRecording]);
 
-  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop.
-  // Guard gegen Doppel-Tap während asyncer Start/Stop.
-  const tapBusy = useRef(false);
+  // 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
   const handleTap = async () => {
-    if (disabled || tapBusy.current) return;
-    tapBusy.current = true;
-    try {
-      // Fragen WIR den Service, nicht den React-State (Closure kann stale sein)
-      const svcState = audioService.getRecordingState();
-      if (svcState === 'recording') {
-        // Aufnahme manuell stoppen
-        const result = await audioService.stopRecording();
-        setIsRecording(false);
-        if (result && result.durationMs > 300) {
-          onRecordingComplete(result);
-        }
-      } else if (svcState === 'idle') {
-        // Aufnahme mit Auto-Stop starten
-        const started = await audioService.startRecording(true);
-        if (started) {
-          setIsRecording(true);
-        }
+    if (disabled) return;
+    if (isRecording) {
+      // Aufnahme manuell stoppen
+      setIsRecording(false);
+      const result = await audioService.stopRecording();
+      if (result && result.durationMs > 300) {
+        onRecordingComplete(result);
+      }
+    } else {
+      // Aufnahme mit Auto-Stop starten
+      const started = await audioService.startRecording(true);
+      if (started) {
+        isLongPress.current = false;
+        setIsRecording(true);
       }
-      // svcState === 'processing': Stopp in progress — nichts tun, User
-      // muss nochmal tippen wenn fertig. Aber wir blockieren mit tapBusy
-      // kurz damit der User's UI-Feedback synchron bleibt.
-    } finally {
-      tapBusy.current = false;
     }
   };
 
@@ -178,6 +183,10 @@ 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,28 +19,17 @@ import {
   ScrollView,
   Modal,
   ToastAndroid,
-  AppState,
-  NativeModules,
-  Alert,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
-import { SvgUri } from 'react-native-svg';
 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';
 import CameraUpload, { PhotoData } from '../components/CameraUpload';
-import MessageText from '../components/MessageText';
-import { RecordingResult, loadConvWindowMs, loadTtsSpeed, TTS_SPEED_DEFAULT } from '../services/audio';
+import { RecordingResult, loadConvWindowMs } from '../services/audio';
 import Geolocation from '@react-native-community/geolocation';
 
 // --- Typen ---
@@ -64,10 +53,6 @@ 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 ---
@@ -83,73 +68,6 @@ const capMessages = (msgs: ChatMessage[]): ChatMessage[] =>
 const DEFAULT_ATTACHMENT_DIR = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
 const STORAGE_PATH_KEY = 'aria_attachment_storage_path';
 
-const { FileOpener } = NativeModules as {
-  FileOpener?: { open: (filePath: string, mimeType: string) => Promise<boolean> };
-};
-
-/** Datei mit Android-Intent-Picker oeffnen (System waehlt App nach MIME). */
-async function openFileWithIntent(filePath: string, mimeType: string): Promise<void> {
-  if (!FileOpener) {
-    ToastAndroid.show('FileOpener Native Module fehlt', ToastAndroid.SHORT);
-    return;
-  }
-  try {
-    await FileOpener.open(filePath, mimeType || 'application/octet-stream');
-  } catch (err: any) {
-    ToastAndroid.show(`Oeffnen fehlgeschlagen: ${err?.message || err}`, ToastAndroid.LONG);
-  }
-}
-
-/** Image-Vorschau in der Chat-Bubble. Misst die echte Bild-Dimension via
- *  Image.getSize + setzt aspectRatio dynamisch — dadurch passt sich die
- *  Bubble ans Bild an (kein "Strich" mehr bei breiten oder hohen Bildern). */
-const CHAT_IMAGE_STYLE = {
-  width: 260,
-  borderRadius: 8,
-  marginBottom: 6,
-  backgroundColor: '#0D0D1A',
-} as const;
-const ChatImage: React.FC<{
-  uri: string;
-  onPress: () => void;
-  onError: () => void;
-}> = ({ uri, onPress, onError }) => {
-  const [aspectRatio, setAspectRatio] = useState<number>(4 / 3);
-  const isSvg = /\.svg(?:\?|$)/i.test(uri);
-  useEffect(() => {
-    if (isSvg) return; // SvgUri hat kein getSize
-    let cancelled = false;
-    Image.getSize(uri, (w, h) => {
-      if (!cancelled && w > 0 && h > 0) {
-        // Aspect-Ratio capen damit sehr lange Panorama-Bilder oder hohe
-        // Screenshot-Streifen die Bubble nicht sprengen
-        const r = Math.max(0.5, Math.min(2.5, w / h));
-        setAspectRatio(r);
-      }
-    }, () => {});
-    return () => { cancelled = true; };
-  }, [uri, isSvg]);
-  if (isSvg) {
-    return (
-      <TouchableOpacity onPress={onPress} activeOpacity={0.8}>
-        <View style={[CHAT_IMAGE_STYLE, { height: 260, alignItems: 'center', justifyContent: 'center' }]}>
-          <SvgUri uri={uri} width="100%" height="100%" onError={onError} />
-        </View>
-      </TouchableOpacity>
-    );
-  }
-  return (
-    <TouchableOpacity onPress={onPress} activeOpacity={0.8}>
-      <Image
-        source={{ uri }}
-        style={[CHAT_IMAGE_STYLE, { aspectRatio }]}
-        resizeMode="cover"
-        onError={onError}
-      />
-    </TouchableOpacity>
-  );
-};
-
 async function getAttachmentDir(): Promise<string> {
   try {
     const saved = await AsyncStorage.getItem(STORAGE_PATH_KEY);
@@ -185,8 +103,6 @@ const ChatScreen: React.FC = () => {
   const [showCameraUpload, setShowCameraUpload] = useState(false);
   const [gpsEnabled, setGpsEnabled] = useState(false);
   const [wakeWordActive, setWakeWordActive] = useState(false);
-  // Genauer State (off/armed/conversing) fuer UI-Feedback am Button
-  const [wakeWordState, setWakeWordState] = useState<'off' | 'armed' | 'conversing'>('off');
   const [fullscreenImage, setFullscreenImage] = useState<string | null>(null);
   const [searchQuery, setSearchQuery] = useState('');
   const [searchVisible, setSearchVisible] = useState(false);
@@ -200,20 +116,9 @@ const ChatScreen: React.FC = () => {
   const [ttsMuted, setTtsMuted] = useState(false);
   // Gerätelokale XTTS-Voice-Wahl (bevorzugt gegenueber dem globalen Default)
   const localXttsVoiceRef = useRef<string>('');
-  // Geraetelokale TTS-Wiedergabegeschwindigkeit (speed-Param an F5-TTS)
-  const ttsSpeedRef = useRef<number>(TTS_SPEED_DEFAULT);
-  // Spiegelung der TTS-Settings in einer Ref — damit die onMessage-Closure
-  // (useEffect mit []-deps) IMMER die aktuellen Werte sieht. Ohne Ref
-  // bliebe canPlay auf dem Mount-Initial-Wert haengen (mute ignoriert,
-  // oder AsyncStorage-Load nicht beruecksichtigt).
-  const ttsCanPlayRef = useRef<boolean>(true);
 
   const flatListRef = useRef<FlatList>(null);
   const messageIdCounter = useRef(0);
-  // ServerPaths fuer die der User auf "oeffnen" geklickt hat — beim
-  // file_response wird die Datei nach dem Speichern direkt mit dem System-
-  // Intent geoeffnet (PDF-Viewer, Galerie, etc.).
-  const autoOpenPaths = useRef<Set<string>>(new Set());
 
   // Eindeutige Message-ID generieren
   const nextId = (): string => {
@@ -221,99 +126,36 @@ const ChatScreen: React.FC = () => {
     return `msg_${Date.now()}_${messageIdCounter.current}`;
   };
 
-  // TTS- + GPS-Settings beim Mount + alle 2s neu laden (damit Settings-Toggle
-  // sofort greift, ohne Context- oder Event-System)
+  // TTS-Settings beim Mount + bei Screen-Fokus neu laden (damit Settings-Toggle sofort greift)
   useEffect(() => {
-    const loadSettings = async () => {
+    const loadTtsSettings = async () => {
       const enabled = await AsyncStorage.getItem('aria_tts_enabled');
       setTtsDeviceEnabled(enabled !== 'false'); // default true
       const muted = await AsyncStorage.getItem('aria_tts_muted');
-      const isMuted = muted === 'true';
-      setTtsMuted(isMuted); // default false
-      audioService.setMuted(isMuted);  // service-internen Flag synchronisieren
+      setTtsMuted(muted === 'true'); // default false
       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');
     };
-    loadSettings();
-    const interval = setInterval(loadSettings, 2000);
+    loadTtsSettings();
+    // Poll alle 2s um Settings-Aenderung mitzubekommen (einfache Loesung ohne Context)
+    const interval = setInterval(loadTtsSettings, 2000);
     return () => clearInterval(interval);
   }, []);
 
   // Wake Word: einmalig laden + Porcupine vorbereiten (wenn Access Key gesetzt)
   useEffect(() => {
     wakeWordService.loadFromStorage().catch(() => {});
-    const unsub = wakeWordService.onStateChange((s) => {
-      setWakeWordState(s);
-      setWakeWordActive(s !== 'off');
-      // Conversation-Focus an Wake-Word-State koppeln: solange wir aktiv im
-      // Dialog sind, soll Spotify dauerhaft gepaust bleiben (auch ueber
-      // Render-Pausen + zwischen Antworten hinweg). Sobald wir zurueck nach
-      // 'armed' oder 'off' fallen, darf Spotify wieder.
-      if (s === 'conversing') audioService.acquireConversationFocus();
-      else audioService.releaseConversationFocus();
-      // 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();
   }, []);
 
-  // Anruf-Erkennung: TTS pausieren wenn das Telefon klingelt
-  useEffect(() => {
-    phoneCallService.start().catch(err =>
-      console.warn('[Chat] phoneCall.start fehlgeschlagen', err));
-    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(() => {
-    ttsCanPlayRef.current = ttsDeviceEnabled && !ttsMuted;
-  }, [ttsDeviceEnabled, ttsMuted]);
-
   const toggleMute = useCallback(() => {
     setTtsMuted(prev => {
       const next = !prev;
       AsyncStorage.setItem('aria_tts_muted', String(next));
-      // Ref synchron updaten — sonst kommen noch Chunks im selben Tick
-      // mit canPlay=true durch (Race vor dem useEffect-Update).
-      ttsCanPlayRef.current = ttsDeviceEnabled && !next;
-      // Globalen Mute-Flag im audioService setzen — uebersteuert auch
-      // payload.silent in handlePcmChunk und stoppt laufende Wiedergabe.
-      audioService.setMuted(next);
+      // Bei Muten sofort laufende Wiedergabe stoppen
+      if (next) audioService.stopPlayback();
       return next;
     });
-  }, [ttsDeviceEnabled]);
+  }, []);
 
   // Chat-Verlauf aus AsyncStorage laden
   const isInitialLoad = useRef(true);
@@ -384,32 +226,11 @@ const ChatScreen: React.FC = () => {
         return;
       }
 
-      // file_from_aria: ARIA hat eine Datei rausgegeben → als ARIA-Bubble anzeigen
-      if (message.type === 'file_from_aria') {
-        const p = message.payload || {};
-        const ariaMsg: ChatMessage = {
-          id: nextId(),
-          sender: 'aria',
-          text: '',
-          timestamp: Date.now(),
-          attachments: [{
-            type: (typeof p.mimeType === 'string' && p.mimeType.startsWith('image/')) ? 'image' : 'file',
-            name: (p.name as string) || 'datei',
-            size: (p.size as number) || 0,
-            mimeType: (p.mimeType as string) || '',
-            serverPath: (p.serverPath as string) || '',
-          }],
-        };
-        setMessages(prev => capMessages([...prev, ariaMsg]));
-        return;
-      }
-
       // file_response: Re-Download von Server — lokal speichern
       if (message.type === 'file_response') {
         const reqId = (message.payload.requestId as string) || '';
         const b64 = (message.payload.base64 as string) || '';
         const serverPath = (message.payload.serverPath as string) || '';
-        const mimeType = (message.payload.mimeType as string) || '';
         if (b64 && reqId) {
           const fileName = (message.payload.name as string) || 'download';
           persistAttachment(b64, reqId, fileName).then(filePath => {
@@ -419,11 +240,6 @@ const ChatScreen: React.FC = () => {
                 a.serverPath === serverPath ? { ...a, uri: filePath } : a
               ),
             })));
-            // Wenn der User dieses File explizit oeffnen wollte → Intent-Picker
-            if (serverPath && autoOpenPaths.current.has(serverPath)) {
-              autoOpenPaths.current.delete(serverPath);
-              openFileWithIntent(filePath.replace(/^file:\/\//, ''), mimeType);
-            }
           }).catch(() => {});
         }
         return;
@@ -431,51 +247,17 @@ 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
-        // wuerde bei zwei kurz hintereinander gesendeten Audios beide Bubbles
-        // den gleichen Text bekommen (Bug: zweite Antwort ueberschreibt erste).
+        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben
         if (sender === 'stt') {
           const sttText = (message.payload.text as string) || '';
-          const sttAudioReqId = (message.payload.audioRequestId as string) || '';
-          if (!sttText) {
-            return;
-          }
-          setMessages(prev => {
-            const newText = `\uD83C\uDFA4 ${sttText}`;
-            // Primaer: matche per audioRequestId (eindeutig pro Aufnahme).
-            // So gibt's keine Verwechslung wenn zwei Audios kurz hintereinander
-            // gesendet wurden und ihre STT-Results ueberlappen.
-            if (sttAudioReqId) {
-              const idxById = prev.findIndex(m => m.audioRequestId === sttAudioReqId);
-              if (idxById >= 0) {
-                const next = prev.slice();
-                next[idxById] = { ...next[idxById], text: newText };
-                return next;
-              }
-            }
-            // Fallback: alte Bridge-Version ohne audioRequestId \u2014 match per Substring,
-            // nimmt die ERSTE noch unaufgeloeste Placeholder.
-            const idx = prev.findIndex(m =>
+          if (sttText) {
+            setMessages(prev => prev.map(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' }],
-            }]);
-          });
+                ? { ...m, text: `\uD83C\uDFA4 ${sttText}` }
+                : m
+            ));
+          }
           return;
         }
 
@@ -517,12 +299,7 @@ const ChatScreen: React.FC = () => {
       }
 
       // TTS-Audio abspielen wenn vorhanden — respektiert geraetelokalen Mute/Disable
-      // WICHTIG: via Ref statt direkt state lesen, sonst ist's stale (Closure-Bug).
-      const canPlay = ttsCanPlayRef.current;
-      if (message.type === 'audio_pcm' || (message.type === 'audio' && message.payload.base64)) {
-        console.log('[Chat] audio-msg canPlay=%s (enabled=%s muted=%s)',
-                    canPlay, ttsDeviceEnabled, ttsMuted);
-      }
+      const canPlay = ttsDeviceEnabled && !ttsMuted;
       if (message.type === 'audio' && message.payload.base64) {
         const b64 = message.payload.base64 as string;
         const refId = (message.payload.messageId as string) || '';
@@ -556,8 +333,6 @@ const ChatScreen: React.FC = () => {
         const activity = (message.payload.activity as string) || 'idle';
         const tool = (message.payload.tool as string) || '';
         setAgentActivity({ activity, tool });
-        // Spotify darf waehrend "ARIA denkt/schreibt" weiterspielen — pausiert
-        // nur wenn TTS startet (dann acquired _firePlaybackStarted den Focus).
       }
 
       // Voice-Config aus Diagnostic — setzt die lokale App-Stimme auf den
@@ -639,14 +414,7 @@ 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) {
-        // 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 {
+      if (!started) {
         // Mikrofon nicht verfuegbar, naechsten Versuch
         wakeWordService.resume();
       }
@@ -657,17 +425,13 @@ 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', {
@@ -675,12 +439,8 @@ const ChatScreen: React.FC = () => {
           durationMs: result.durationMs,
           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
@@ -691,59 +451,16 @@ 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]);
 
   // Wake Word Toggle Handler
   const toggleWakeWord = useCallback(async () => {
     if (wakeWordActive) {
-      // Vor Porcupine-Stop: eventuelle laufende Aufnahme abbrechen. Sonst
-      // bleibt audioService.recordingState=='recording' haengen und der
-      // normale Aufnahme-Button wirkt nicht mehr (startRecording lehnt
-      // ab weil "Aufnahme laeuft bereits").
-      try { await audioService.stopRecording(); } catch {}
-      await wakeWordService.stop();
+      wakeWordService.stop();
       setWakeWordActive(false);
     } else {
       const started = await wakeWordService.start();
@@ -786,23 +503,17 @@ const ChatScreen: React.FC = () => {
 
   // GPS-Position holen (optional)
   const getCurrentLocation = useCallback((): Promise<{ lat: number; lon: number } | null> => {
-    if (!gpsEnabled) {
-      console.log('[GPS] gpsEnabled=false → kein Standort');
-      return Promise.resolve(null);
-    }
+    if (!gpsEnabled) return Promise.resolve(null);
 
     return new Promise((resolve) => {
       Geolocation.getCurrentPosition(
         (position) => {
-          const loc = {
+          resolve({
             lat: position.coords.latitude,
             lon: position.coords.longitude,
-          };
-          console.log('[GPS] Position: lat=%s lon=%s', loc.lat, loc.lon);
-          resolve(loc);
+          });
         },
-        (error) => {
-          console.warn('[GPS] getCurrentPosition Fehler:', error?.code, error?.message);
+        (_error) => {
           resolve(null);
         },
         { enableHighAccuracy: false, timeout: 5000 },
@@ -812,29 +523,6 @@ 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();
 
@@ -848,8 +536,6 @@ 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 = {
@@ -860,17 +546,13 @@ const ChatScreen: React.FC = () => {
     };
     setMessages(prev => capMessages([...prev, userMsg]));
 
-    console.log('[Chat] sende mit voice=%s speed=%s interrupted=%s',
-                localXttsVoiceRef.current || '(default)', ttsSpeedRef.current, wasInterrupted);
     // An RVS senden — mit geraetelokaler Voice (Bridge nutzt sie fuer die Antwort)
     rvs.send('chat', {
       text,
       voice: localXttsVoiceRef.current,
-      speed: ttsSpeedRef.current,
-      interrupted: wasInterrupted,
       ...(location && { location }),
     });
-  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments, interruptAriaIfBusy]);
+  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments]);
 
   // Anfrage abbrechen — sofort lokalen Indicator weg, Bridge triggert doctor --fix
   const cancelRequest = useCallback(() => {
@@ -878,37 +560,15 @@ 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]));
 
@@ -916,25 +576,9 @@ const ChatScreen: React.FC = () => {
       base64: result.base64,
       durationMs: result.durationMs,
       mimeType: result.mimeType,
-      voice: localXttsVoiceRef.current,
-      speed: ttsSpeedRef.current,
-      interrupted: wasInterrupted,
-      audioRequestId,
       ...(location && { location }),
     });
-    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]);
+  }, [getCurrentLocation]);
 
   // Datei auswaehlen → zur Pending-Liste hinzufuegen
   const handleFileSelected = useCallback(async (file: FileData) => {
@@ -951,7 +595,6 @@ const ChatScreen: React.FC = () => {
   // Alle Pending Anhaenge + Text senden
   const sendPendingAttachments = useCallback(async (messageText: string) => {
     if (pendingAttachments.length === 0) return;
-    console.log('[Chat] sendPendingAttachments: %d Anhang/Anhaenge', pendingAttachments.length);
     const location = await getCurrentLocation();
     const msgId = nextId();
 
@@ -1001,8 +644,6 @@ const ChatScreen: React.FC = () => {
       }
 
       // An RVS senden
-      console.log('[Chat] sende file: name=%s mime=%s size=%s b64Bytes=%s',
-                  name, mimeType, file.size, base64.length);
       rvs.send('file', {
         name,
         type: mimeType,
@@ -1018,7 +659,6 @@ const ChatScreen: React.FC = () => {
       rvs.send('chat', {
         text: messageText,
         voice: localXttsVoiceRef.current,
-        speed: ttsSpeedRef.current,
         ...(location && { location }),
       });
     }
@@ -1042,9 +682,11 @@ const ChatScreen: React.FC = () => {
         {item.attachments?.map((att, idx) => (
           <View key={idx}>
             {att.type === 'image' && att.uri ? (
-              <ChatImage
-                uri={att.uri}
-                onPress={() => setFullscreenImage(att.uri || null)}
+              <TouchableOpacity onPress={() => setFullscreenImage(att.uri || null)} activeOpacity={0.8}>
+              <Image
+                source={{ uri: att.uri }}
+                style={styles.attachmentImage}
+                resizeMode="cover"
                 onError={() => {
                   setMessages(prev => prev.map(m =>
                     m.id === item.id ? { ...m, attachments: m.attachments?.map((a, i) =>
@@ -1053,6 +695,7 @@ const ChatScreen: React.FC = () => {
                   ));
                 }}
               />
+              </TouchableOpacity>
             ) : att.type === 'image' && !att.uri ? (
               <TouchableOpacity
                 style={styles.attachmentFile}
@@ -1069,22 +712,7 @@ const ChatScreen: React.FC = () => {
                 </Text>
               </TouchableOpacity>
             ) : (
-              <TouchableOpacity
-                style={styles.attachmentFile}
-                onPress={() => {
-                  // Lokal vorhanden \u2192 direkt mit System-Intent oeffnen
-                  if (att.uri) {
-                    openFileWithIntent(att.uri.replace(/^file:\/\//, ''), att.mimeType || '');
-                    return;
-                  }
-                  // Sonst: file_request \u2192 bei file_response wird die Datei
-                  // gespeichert UND geoeffnet (autoOpenPaths-Tracking).
-                  if (att.serverPath) {
-                    autoOpenPaths.current.add(att.serverPath);
-                    rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: item.id });
-                  }
-                }}
-              >
+              <View style={styles.attachmentFile}>
                 <Text style={styles.attachmentFileIcon}>
                   {att.mimeType?.includes('pdf') ? '\uD83D\uDCC4' :
                    att.mimeType?.includes('word') || att.mimeType?.includes('document') ? '\uD83D\uDCC3' :
@@ -1094,42 +722,37 @@ const ChatScreen: React.FC = () => {
                 <Text style={styles.attachmentFileName} numberOfLines={1}>{att.name}</Text>
                 {att.size ? <Text style={styles.attachmentFileSize}>{Math.round(att.size / 1024)}KB</Text> : null}
                 {!att.uri && att.serverPath && (
-                  <Text style={[styles.attachmentFileSize, {color: '#0096FF'}]}>(tippen zum oeffnen)</Text>
+                  <TouchableOpacity onPress={() => rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: item.id })}>
+                    <Text style={[styles.attachmentFileSize, {color: '#0096FF'}]}>(laden)</Text>
+                  </TouchableOpacity>
                 )}
                 {!att.uri && !att.serverPath && <Text style={styles.attachmentFileSize}>(nicht verfuegbar)</Text>}
-              </TouchableOpacity>
+              </View>
             )}
           </View>
         ))}
         {/* Text (nicht anzeigen wenn nur "Anhang empfangen" und ein Bild da ist) */}
         {!(item.text === 'Anhang empfangen' && item.attachments?.some(a => a.type === 'image' && a.uri)) && (
-          <MessageText
-            text={item.text}
-            style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}
-          />
+          <Text style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}>
+            {item.text}
+          </Text>
         )}
         {/* Play-Button fuer ARIA-Nachrichten — Cache bevorzugt, sonst Bridge-TTS mit aktueller Engine */}
         {!isUser && item.text.length > 0 && (
           <TouchableOpacity
             style={styles.playButton}
-            onPress={async () => {
-              // Erst lokalen Cache pruefen — audioPath kann auf eine geloeschte
-              // Datei zeigen (TTS-Cache geleert oder Auto-Cleanup). In dem Fall
-              // ueber RVS neu rendern lassen statt stumm zu bleiben.
-              const cachePath = item.audioPath?.replace(/^file:\/\//, '') || '';
-              const cached = cachePath ? await RNFS.exists(cachePath).catch(() => false) : false;
-              if (cached) {
-                audioService.playFromPath(item.audioPath!);
-                return;
+            onPress={() => {
+              if (item.audioPath) {
+                audioService.playFromPath(item.audioPath);
+              } else {
+                // messageId mitschicken damit die Bridge das generierte Audio
+                // wieder mit der Nachricht verknuepft (fuer den naechsten Replay aus Cache)
+                rvs.send('tts_request' as any, {
+                  text: item.text,
+                  voice: localXttsVoiceRef.current,
+                  messageId: item.messageId || '',
+                });
               }
-              // messageId mitschicken damit die Bridge das generierte Audio
-              // wieder mit der Nachricht verknuepft (fuer den naechsten Replay aus Cache)
-              rvs.send('tts_request' as any, {
-                text: item.text,
-                voice: localXttsVoiceRef.current,
-                speed: ttsSpeedRef.current,
-                messageId: item.messageId || '',
-              });
             }}
           >
             <Text style={styles.playButtonText}>{'\uD83D\uDD0A'}</Text>
@@ -1250,29 +873,9 @@ const ChatScreen: React.FC = () => {
               ? '\u270D\uFE0F ARIA schreibt...'
               : '\uD83D\uDCAD ARIA denkt...'}
           </Text>
-          <View style={{flexDirection: 'row', gap: 6}}>
-            <TouchableOpacity style={[styles.thinkingCancel, {borderColor: '#FF9500'}]} onPress={() => rvs.send('doctor_fix' as any, {})}>
-              <Text style={[styles.thinkingCancelText, {color: '#FF9500'}]}>{'🔧'}</Text>
-            </TouchableOpacity>
-            <TouchableOpacity
-              style={[styles.thinkingCancel, {borderColor: '#FF3B30'}]}
-              onPress={() => {
-                Alert.alert(
-                  'ARIA hart neu starten?',
-                  'Container-Restart (~15s). Laufende Anfragen gehen verloren.',
-                  [
-                    { text: 'Abbrechen', style: 'cancel' },
-                    { text: 'Neu starten', style: 'destructive', onPress: () => rvs.send('aria_restart' as any, {}) },
-                  ],
-                );
-              }}
-            >
-              <Text style={[styles.thinkingCancelText, {color: '#FF3B30'}]}>{'🚨'}</Text>
-            </TouchableOpacity>
-            <TouchableOpacity style={styles.thinkingCancel} onPress={cancelRequest}>
-              <Text style={styles.thinkingCancelText}>Abbrechen</Text>
-            </TouchableOpacity>
-          </View>
+          <TouchableOpacity style={styles.thinkingCancel} onPress={cancelRequest}>
+            <Text style={styles.thinkingCancelText}>Abbrechen</Text>
+          </TouchableOpacity>
         </View>
       )}
 
@@ -1367,10 +970,7 @@ const ChatScreen: React.FC = () => {
               style={[styles.wakeWordBtn, wakeWordActive && styles.wakeWordBtnActive]}
               onPress={toggleWakeWord}
             >
-              <Text style={styles.wakeWordIcon}>
-                {wakeWordState === 'conversing' ? '🎙️' :
-                 wakeWordState === 'armed' ? '👂' : '🔇'}
-              </Text>
+              <Text style={styles.wakeWordIcon}>{wakeWordActive ? '👂' : '🔇'}</Text>
             </TouchableOpacity>
           </>
         )}
@@ -1384,17 +984,11 @@ const ChatScreen: React.FC = () => {
           onPress={() => setFullscreenImage(null)}
         >
           {fullscreenImage && (
-            /\.svg(?:\?|$)/i.test(fullscreenImage) ? (
-              <View style={styles.fullscreenImage}>
-                <SvgUri uri={fullscreenImage} width="100%" height="100%" preserveAspectRatio="xMidYMid meet" />
-              </View>
-            ) : (
-              <Image
-                source={{ uri: fullscreenImage }}
-                style={styles.fullscreenImage}
-                resizeMode="contain"
-              />
-            )
+            <Image
+              source={{ uri: fullscreenImage }}
+              style={styles.fullscreenImage}
+              resizeMode="contain"
+            />
           )}
         </TouchableOpacity>
       </Modal>
@@ -1499,11 +1093,9 @@ const styles = StyleSheet.create({
     color: '#E0E0F0',
   },
   attachmentImage: {
-    // Feste Breite + dynamische aspectRatio (in ChatImage gesetzt) damit die
-    // Bubble sich ans Bild anpasst. Mit width: '100%' ohne explizite Parent-
-    // Breite wuerde RN das Bild auf 0px schrumpfen → "Strich".
-    width: 260,
-    aspectRatio: 4 / 3,
+    width: '100%',
+    minHeight: 200,
+    maxHeight: 400,
     borderRadius: 8,
     marginBottom: 6,
     backgroundColor: '#0D0D1A',

android/src/screens/SettingsScreen.tsx

@@ -17,8 +17,6 @@ import {
   Platform,
   ToastAndroid,
   ActivityIndicator,
-  Modal,
-  PermissionsAndroid,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
@@ -37,36 +35,16 @@ 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 audioService from '../services/audio';
-import { isVerboseLogging, setVerboseLogging } from '../services/logger';
-import {
-  isWakeReadySoundEnabled,
-  setWakeReadySoundEnabled,
-  playWakeReadySound,
-} from '../services/wakeReadySound';
 import wakeWordService, {
-  WAKE_KEYWORDS,
-  KEYWORD_LABELS,
+  BUILTIN_KEYWORDS,
   DEFAULT_KEYWORD,
+  WAKE_ACCESS_KEY_STORAGE,
   WAKE_KEYWORD_STORAGE,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
 import VoiceCloneModal from '../components/VoiceCloneModal';
-import updateService from '../services/updater';
 
 const STORAGE_PATH_KEY = 'aria_attachment_storage_path';
 const DEFAULT_STORAGE_PATH = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
@@ -90,18 +68,6 @@ 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
@@ -132,27 +98,16 @@ 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 [apkCacheInfo, setApkCacheInfo] = useState<{count: number, totalMB: number} | null>(null);
-  const [ttsCacheInfo, setTtsCacheInfo] = useState<{count: number, totalMB: number} | null>(null);
-  const [verboseLogging, setVerboseLoggingState] = useState<boolean>(isVerboseLogging());
-  const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
+  const [wakeAccessKey, setWakeAccessKey] = useState<string>('');
+  const [wakeAccessKeyVisible, setWakeAccessKeyVisible] = useState(false);
   const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
   const [wakeStatus, setWakeStatus] = useState<string>('');
-  const [wakeReadySound, setWakeReadySound] = useState<boolean>(true);
   const [editingPath, setEditingPath] = useState(false);
   const [xttsVoice, setXttsVoice] = useState('');
   const [loadingVoice, setLoadingVoice] = useState<string | null>(null);
   const [availableVoices, setAvailableVoices] = useState<Array<{name: string, size: number}>>([]);
   const [voiceCloneVisible, setVoiceCloneVisible] = useState(false);
   const [tempPath, setTempPath] = useState('');
-  // Sub-Screen Navigation: null = Hauptmenue, sonst eine der Section-IDs.
-  // So bleibt aller geteilte State im selben Component-Closure und wir
-  // brauchen keine react-navigation-Stack-Setup.
-  const [currentSection, setCurrentSection] = useState<string | null>(null);
 
   let logIdCounter = 0;
 
@@ -174,9 +129,6 @@ 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);
@@ -201,34 +153,12 @@ 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);
-        if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) setTtsSpeed(n);
-      }
+    AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE).then(saved => {
+      if (saved) setWakeAccessKey(saved);
     });
     AsyncStorage.getItem(WAKE_KEYWORD_STORAGE).then(saved => {
-      if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
+      if (saved) setWakeKeyword(saved);
     });
-    isWakeReadySoundEnabled().then(setWakeReadySound);
-    updateService.getApkCacheSize().then(setApkCacheInfo).catch(() => {});
-    audioService.getTtsCacheSize().then(setTtsCacheInfo).catch(() => {});
     AsyncStorage.getItem('aria_xtts_voice').then(saved => {
       if (saved) setXttsVoice(saved);
     });
@@ -463,31 +393,9 @@ const SettingsScreen: React.FC = () => {
 
   // --- GPS Toggle ---
 
-  const handleGPSToggle = useCallback(async (value: boolean) => {
-    if (value && Platform.OS === 'android') {
-      try {
-        const granted = await PermissionsAndroid.request(
-          PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
-          {
-            title: 'ARIA — Standort an Anfragen anhaengen',
-            message: 'Damit ARIA bei Anfragen wie "Wo ist der naechste...?" den '
-              + 'Standort kennt, darf die App den ungefaehren Standort lesen. '
-              + 'Wird nur bei jeder Anfrage einmal abgerufen, nicht im Hintergrund.',
-            buttonPositive: 'Erlauben',
-            buttonNegative: 'Abbrechen',
-          },
-        );
-        if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
-          ToastAndroid.show('Standort-Berechtigung abgelehnt', ToastAndroid.SHORT);
-          return;
-        }
-      } catch (err) {
-        console.warn('[Settings] GPS-Permission Request gescheitert:', err);
-        return;
-      }
-    }
+  const handleGPSToggle = useCallback((value: boolean) => {
     setGpsEnabled(value);
-    AsyncStorage.setItem('aria_gps_enabled', String(value)).catch(() => {});
+    // In Produktion: Wert in AsyncStorage persistieren
   }, []);
 
   // --- XTTS Voice ---
@@ -566,39 +474,7 @@ 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 */}
@@ -695,10 +571,8 @@ 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} />
@@ -711,11 +585,7 @@ const SettingsScreen: React.FC = () => {
           <View style={styles.toggleInfo}>
             <Text style={styles.toggleLabel}>GPS-Position mitsenden</Text>
             <Text style={styles.toggleHint}>
-              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.
+              Standort wird automatisch an Nachrichten angehaengt
             </Text>
           </View>
           <Switch
@@ -726,10 +596,8 @@ 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>
@@ -797,146 +665,46 @@ 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' && (<>
+      {/* === Wake-Word (geraetelokal) === */}
       <Text style={styles.sectionTitle}>Wake-Word</Text>
       <View style={styles.card}>
         <Text style={styles.toggleHint}>
-          Lokale Erkennung via openWakeWord (ONNX, on-device). Kein API-Key,
-          kein Cloud-Roundtrip — Audio verlaesst das Geraet nicht. Wenn das Ohr
-          aktiv ist, hoerst du normal mit; sagst du das Wake-Word, startet eine
-          Konversation mit ARIA.
+          Wenn ein Picovoice-Access-Key eingetragen ist, hoert die App passiv
+          auf das gewaehlte Wake-Word — du kannst dich mit anderen unterhalten,
+          Musik laufen lassen und mit "{wakeKeyword}" eine Konversation mit
+          ARIA starten. Ohne Key oder bei Fehlschlag startet das Ohr direkt
+          eine Konversation (klassischer Modus).
         </Text>
 
+        <Text style={[styles.toggleLabel, {marginTop: 16}]}>Picovoice Access Key</Text>
+        <View style={{flexDirection: 'row', alignItems: 'center', gap: 8, marginTop: 6}}>
+          <TextInput
+            style={[styles.input, {flex: 1}]}
+            value={wakeAccessKey}
+            onChangeText={setWakeAccessKey}
+            placeholder="kostenlos auf console.picovoice.ai"
+            placeholderTextColor="#666680"
+            secureTextEntry={!wakeAccessKeyVisible}
+            autoCapitalize="none"
+            autoCorrect={false}
+          />
+          <TouchableOpacity
+            onPress={() => setWakeAccessKeyVisible(v => !v)}
+            style={{padding: 8}}
+          >
+            <Text style={{fontSize: 18}}>{wakeAccessKeyVisible ? '🙈' : '👁'}</Text>
+          </TouchableOpacity>
+        </View>
+
         <Text style={[styles.toggleLabel, {marginTop: 16}]}>Wake-Word</Text>
         <Text style={styles.toggleHint}>
-          Eigene Wake-Words via openWakeWord-Notebook trainierbar (gratis).
-          Custom-Upload ueber Diagnostic kommt in einer spaeteren Version.
+          Built-In: sofort verwendbar. "ARIA" als Custom-Keyword kommt spaeter
+          ueber Diagnostic-Upload.
         </Text>
         <View style={{flexDirection: 'row', flexWrap: 'wrap', gap: 6, marginTop: 8}}>
-          {WAKE_KEYWORDS.map(kw => (
+          {BUILTIN_KEYWORDS.map(kw => (
             <TouchableOpacity
               key={kw}
               style={[
@@ -949,7 +717,7 @@ const SettingsScreen: React.FC = () => {
                 styles.keywordChipText,
                 wakeKeyword === kw && styles.keywordChipTextActive,
               ]}>
-                {KEYWORD_LABELS[kw]}
+                {kw}
               </Text>
             </TouchableOpacity>
           ))}
@@ -961,8 +729,8 @@ const SettingsScreen: React.FC = () => {
             onPress={async () => {
               setWakeStatus('Initialisiere...');
               try {
-                const ok = await wakeWordService.configure(wakeKeyword);
-                setWakeStatus(ok ? `✅ "${KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS]}" bereit` : '❌ Init-Fehler — Logs pruefen');
+                const ok = await wakeWordService.configure(wakeAccessKey, wakeKeyword);
+                setWakeStatus(ok ? `✅ "${wakeKeyword}" bereit` : '❌ Fehlgeschlagen — Access Key pruefen');
               } catch (err: any) {
                 setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
               }
@@ -975,36 +743,9 @@ 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}>
@@ -1059,38 +800,6 @@ const SettingsScreen: React.FC = () => {
                 <Text style={styles.prerollButtonText}>+0.5</Text>
               </TouchableOpacity>
             </View>
-
-            <Text style={[styles.toggleLabel, {marginTop: 24}]}>Sprechgeschwindigkeit</Text>
-            <Text style={styles.toggleHint}>
-              Wie schnell ARIA spricht. 1.0 = Normal. Niedriger = langsamer, hoeher = schneller.
-              Wird an F5-TTS als speed-Param uebergeben und pro Geraet gespeichert.
-              Default: {TTS_SPEED_DEFAULT.toFixed(1)}x.
-            </Text>
-            <View style={styles.prerollRow}>
-              <TouchableOpacity
-                style={styles.prerollButton}
-                onPress={() => {
-                  const next = Math.max(TTS_SPEED_MIN, Math.round((ttsSpeed - 0.1) * 10) / 10);
-                  setTtsSpeed(next);
-                  AsyncStorage.setItem(TTS_SPEED_STORAGE_KEY, String(next));
-                }}
-                disabled={ttsSpeed <= TTS_SPEED_MIN}
-              >
-                <Text style={styles.prerollButtonText}>−0.1</Text>
-              </TouchableOpacity>
-              <Text style={styles.prerollValue}>{ttsSpeed.toFixed(1)} x</Text>
-              <TouchableOpacity
-                style={styles.prerollButton}
-                onPress={() => {
-                  const next = Math.min(TTS_SPEED_MAX, Math.round((ttsSpeed + 0.1) * 10) / 10);
-                  setTtsSpeed(next);
-                  AsyncStorage.setItem(TTS_SPEED_STORAGE_KEY, String(next));
-                }}
-                disabled={ttsSpeed >= TTS_SPEED_MAX}
-              >
-                <Text style={styles.prerollButtonText}>+0.1</Text>
-              </TouchableOpacity>
-            </View>
           </View>
         )}
 
@@ -1147,10 +856,7 @@ const SettingsScreen: React.FC = () => {
         )}
       </View>
 
-      </>)}
-
       {/* === Speicher === */}
-      {currentSection === 'storage' && (<>
       <Text style={styles.sectionTitle}>Anhang-Speicher</Text>
       <View style={styles.card}>
         <View style={styles.toggleRow}>
@@ -1225,164 +931,8 @@ const SettingsScreen: React.FC = () => {
         )}
       </View>
 
-      {/* === Update-Cache === */}
-      <Text style={[styles.sectionTitle, {marginTop: 16}]}>Update-Cache</Text>
-      <View style={styles.card}>
-        <Text style={styles.toggleHint}>
-          Heruntergeladene APK-Dateien fuer App-Updates. Werden automatisch
-          beim App-Start und vor jedem neuen Download geloescht — der Button
-          ist fuer den Notfall (z.B. wenn ein Download haengen geblieben ist).
-        </Text>
-        <Text style={[styles.storageSizeText, {marginTop: 8}]}>
-          {apkCacheInfo === null ? '...' :
-           apkCacheInfo.count === 0 ? 'leer' :
-           `${apkCacheInfo.count} APK${apkCacheInfo.count === 1 ? '' : 's'} · ${apkCacheInfo.totalMB.toFixed(1)}MB`}
-        </Text>
-        <TouchableOpacity
-          style={[styles.clearButton, {marginTop: 8, backgroundColor: 'rgba(255,59,48,0.15)'}]}
-          onPress={async () => {
-            const res = await updateService.cleanupOldApks();
-            ToastAndroid.show(
-              res.removed === 0
-                ? 'Update-Cache war schon leer'
-                : `${res.removed} APK${res.removed === 1 ? '' : 's'} geloescht (${res.freedMB.toFixed(1)}MB frei)`,
-              ToastAndroid.SHORT,
-            );
-            const info = await updateService.getApkCacheSize();
-            setApkCacheInfo(info);
-          }}
-        >
-          <Text style={[styles.clearButtonText, {color: '#FF3B30'}]}>Update-Cache leeren</Text>
-        </TouchableOpacity>
-      </View>
-
-      {/* === TTS-Cache === */}
-      <Text style={[styles.sectionTitle, {marginTop: 16}]}>TTS-Cache</Text>
-      <View style={styles.card}>
-        <Text style={styles.toggleHint}>
-          Gespeicherte Sprachausgaben (WAV pro Antwort) — werden fuer den
-          Play-Button und Auto-Resume nach Anrufen genutzt. Loeschen
-          unterbricht keine laufende Wiedergabe, alte Antworten lassen sich
-          danach nur nicht mehr abspielen.
-        </Text>
-        <Text style={[styles.storageSizeText, {marginTop: 8}]}>
-          {ttsCacheInfo === null ? '...' :
-           ttsCacheInfo.count === 0 ? 'leer' :
-           `${ttsCacheInfo.count} WAV${ttsCacheInfo.count === 1 ? '' : 's'} · ${ttsCacheInfo.totalMB.toFixed(1)}MB`}
-        </Text>
-        <TouchableOpacity
-          style={[styles.clearButton, {marginTop: 8, backgroundColor: 'rgba(255,59,48,0.15)'}]}
-          onPress={async () => {
-            const res = await audioService.clearTtsCache();
-            ToastAndroid.show(
-              res.removed === 0
-                ? 'TTS-Cache war schon leer'
-                : `${res.removed} WAV${res.removed === 1 ? '' : 's'} geloescht (${res.freedMB.toFixed(1)}MB frei)`,
-              ToastAndroid.SHORT,
-            );
-            const info = await audioService.getTtsCacheSize();
-            setTtsCacheInfo(info);
-          }}
-        >
-          <Text style={[styles.clearButtonText, {color: '#FF3B30'}]}>TTS-Cache leeren</Text>
-        </TouchableOpacity>
-      </View>
-
-      {/* === ARIA Reparatur === */}
-      <Text style={[styles.sectionTitle, {marginTop: 16}]}>Reparatur</Text>
-      <View style={styles.card}>
-        <Text style={styles.toggleHint}>
-          Wenn ARIA gar nicht mehr antwortet oder auf jede Anfrage mit
-          "Antwort ohne Text" zurueckkommt — meistens ein steckengebliebener
-          Run im aria-core. Dieser Button fuehrt {'“'}openclaw doctor --fix{'”'}
-          aus und macht ARIA wieder ansprechbar.
-        </Text>
-        <TouchableOpacity
-          style={[styles.clearButton, {marginTop: 8, backgroundColor: 'rgba(255,149,0,0.15)'}]}
-          onPress={() => {
-            rvs.send('doctor_fix' as any, {});
-            ToastAndroid.show('Reparatur-Befehl gesendet — Antwort kommt gleich', ToastAndroid.SHORT);
-          }}
-        >
-          <Text style={[styles.clearButtonText, {color: '#FF9500'}]}>{'🔧 ARIA reparieren'}</Text>
-        </TouchableOpacity>
-        <Text style={[styles.toggleHint, {marginTop: 12}]}>
-          Wenn auch Reparieren nicht hilft — Container hart neu starten.
-          ARIA ist dann ~15 Sekunden weg und kommt mit frischem State zurueck.
-          Laufende Anfragen gehen verloren.
-        </Text>
-        <TouchableOpacity
-          style={[styles.clearButton, {marginTop: 8, backgroundColor: 'rgba(255,59,48,0.15)'}]}
-          onPress={() => {
-            Alert.alert(
-              'ARIA hart neu starten?',
-              'Container-Restart (~15s). Laufende Anfragen gehen verloren.',
-              [
-                { text: 'Abbrechen', style: 'cancel' },
-                { text: 'Neu starten', style: 'destructive', onPress: () => {
-                  rvs.send('aria_restart' as any, {});
-                  ToastAndroid.show('Container-Restart angestossen…', ToastAndroid.LONG);
-                }},
-              ],
-            );
-          }}
-        >
-          <Text style={[styles.clearButtonText, {color: '#FF3B30'}]}>{'🚨 ARIA hart neu starten'}</Text>
-        </TouchableOpacity>
-        <Text style={[styles.toggleHint, {marginTop: 12}]}>
-          Konversation komplett zuruecksetzen — alle bisherigen Nachrichten
-          aus ARIA's Session loeschen + Container neu. Anders als der harte
-          Restart wird hier auch ARIA's Erinnerung an die laufende
-          Konversation gewipt. Geschieht automatisch alle 140 Nachrichten
-          (Bridge-Setting COMPACT_AFTER_MESSAGES).
-        </Text>
-        <TouchableOpacity
-          style={[styles.clearButton, {marginTop: 8, backgroundColor: 'rgba(255,149,0,0.15)'}]}
-          onPress={() => {
-            Alert.alert(
-              'Konversation komprimieren?',
-              'Alle Nachrichten in ARIAs aktueller Session werden geloescht und der Container neu gestartet. ARIA vergisst den bisherigen Gespraechsverlauf.',
-              [
-                { text: 'Abbrechen', style: 'cancel' },
-                { text: 'Komprimieren', style: 'destructive', onPress: () => {
-                  rvs.send('aria_session_reset' as any, {});
-                  ToastAndroid.show('Session wird zurueckgesetzt…', ToastAndroid.LONG);
-                }},
-              ],
-            );
-          }}
-        >
-          <Text style={[styles.clearButtonText, {color: '#FF9500'}]}>{'🧹 Konversation komprimieren'}</Text>
-        </TouchableOpacity>
-      </View>
-
-      </>)}
-
       {/* === Logs === */}
-      {currentSection === 'protocol' && (<>
       <Text style={styles.sectionTitle}>Protokoll</Text>
-
-      {/* Verbose-Logging-Toggle */}
-      <View style={styles.card}>
-        <View style={styles.toggleRow}>
-          <Text style={styles.toggleLabel}>Verbose Logging</Text>
-          <Switch
-            value={verboseLogging}
-            onValueChange={(v) => {
-              setVerboseLogging(v);
-              setVerboseLoggingState(v);
-            }}
-            trackColor={{ false: '#3A3A52', true: '#0096FF' }}
-            thumbColor={verboseLogging ? '#FFFFFF' : '#666680'}
-          />
-        </View>
-        <Text style={styles.toggleHint}>
-          Wenn aus: console.log wird global stummgeschaltet (Speicher schonen).
-          Warnungen und Fehler bleiben immer aktiv. Bei Bedarf einschalten zum
-          Debuggen via adb logcat.
-        </Text>
-      </View>
-
       <View style={styles.card}>
         {/* Tab-Umschalter */}
         <View style={styles.tabRow}>
@@ -1460,10 +1010,8 @@ 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>
@@ -1483,7 +1031,6 @@ const SettingsScreen: React.FC = () => {
           <Text style={styles.connectButtonText}>Auf Updates pr{'\u00FC'}fen</Text>
         </TouchableOpacity>
       </View>
-      </>)}
 
       {/* Platz am Ende */}
       <View style={styles.bottomSpacer} />
@@ -1512,58 +1059,6 @@ 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,
@@ -1921,48 +1416,6 @@ 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,11 +6,10 @@
  * Nutzt react-native-audio-recorder-player fuer Aufnahme.
  */
 
-import { Platform, PermissionsAndroid, NativeModules, ToastAndroid, NativeEventEmitter } from 'react-native';
+import { Platform, PermissionsAndroid, NativeModules } from 'react-native';
 import Sound from 'react-native-sound';
 import RNFS from 'react-native-fs';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { acquireBackgroundAudio, releaseBackgroundAudio, stopBackgroundAudio } from './backgroundAudio';
 import AudioRecorderPlayer, {
   AudioEncoderAndroidType,
   AudioSourceAndroidType,
@@ -41,8 +40,6 @@ const { AudioFocus, PcmStreamPlayer } = NativeModules as {
     requestDuck: () => Promise<boolean>;
     requestExclusive: () => Promise<boolean>;
     release: () => Promise<boolean>;
-    kickReleaseMedia: () => Promise<boolean>;
-    getMode?: () => Promise<number>;
   };
   PcmStreamPlayer?: {
     start: (sampleRate: number, channels: number, prerollSeconds: number) => Promise<boolean>;
@@ -75,41 +72,11 @@ const AUDIO_SAMPLE_RATE = 16000;
 const AUDIO_CHANNELS = 1;
 const AUDIO_ENCODING = 'audio/wav';
 
-// VAD (Voice Activity Detection) — Stille-Erkennung.
-// Fallback-Werte falls die adaptive Baseline-Messung fehlschlaegt (z.B. weil
-// das Mikro keine metering-Updates liefert). Adaptive Werte werden zur
-// Laufzeit aus den ersten BASELINE_SAMPLES gemessen und auf baseline+offset
-// gesetzt — funktioniert in lauten wie leisen Umgebungen.
-const VAD_SILENCE_FALLBACK_DB = -38;   // Fallback Stille-Schwelle
-const VAD_SPEECH_FALLBACK_DB = -22;    // Fallback Sprach-Schwelle
-const VAD_SILENCE_OFFSET_DB = 6;       // Sprache = Baseline + 6dB
-const VAD_SPEECH_OFFSET_DB = 12;       // sicheres Speech = Baseline + 12dB
-const VAD_BASELINE_SAMPLES = 5;        // 5 × 100ms = 500ms Baseline
+// VAD (Voice Activity Detection) — Stille-Erkennung
+const VAD_SILENCE_THRESHOLD_DB = -45;  // dB unter dem als "Stille" gilt
+const VAD_SPEECH_THRESHOLD_DB = -28;   // dB ueber dem als "Sprache" gilt (Sprach-Gate) — hoeher = weniger Umgebungsgeraeusche
 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 = -85;      // extrem empfindlich, praktisch alles gilt als 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;
@@ -125,24 +92,6 @@ export const CONV_WINDOW_MIN_SEC = 3.0;
 export const CONV_WINDOW_MAX_SEC = 20.0;
 export const CONV_WINDOW_STORAGE_KEY = 'aria_conv_window_sec';
 
-// TTS-Wiedergabegeschwindigkeit — wird pro Geraet gespeichert und an die
-// Bridge mitgegeben (speed-Param im F5-TTS infer()). 1.0 = normal.
-export const TTS_SPEED_DEFAULT = 1.0;
-export const TTS_SPEED_MIN = 0.1;
-export const TTS_SPEED_MAX = 5.0;
-export const TTS_SPEED_STORAGE_KEY = 'aria_tts_speed';
-
-export async function loadTtsSpeed(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY);
-    if (raw != null) {
-      const n = parseFloat(raw);
-      if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) return n;
-    }
-  } catch {}
-  return TTS_SPEED_DEFAULT;
-}
-
 export async function loadConvWindowMs(): Promise<number> {
   try {
     const raw = await AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY);
@@ -171,29 +120,12 @@ async function loadVadSilenceMs(): Promise<number> {
 
 // Max-Dauer einer Aufnahme (Notbremse gegen Runaway-Loops). Auf 2 Minuten
 // hochgezogen damit auch laengere Erklaerungen durchgehen.
-// 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;
-}
+const MAX_RECORDING_MS = 120000;
 
 // Pre-Roll: Wie lange Audio im AudioTrack-Buffer liegt bevor play() startet.
 // Einstellbar via Diagnostic/Settings (Key: aria_tts_preroll_sec).
 export const TTS_PREROLL_DEFAULT_SEC = 3.5;
-export const TTS_PREROLL_MIN_SEC = 0;     // 0 = sofort abspielen (F5-TTS ist schnell genug)
+export const TTS_PREROLL_MIN_SEC = 1.0;
 export const TTS_PREROLL_MAX_SEC = 6.0;
 export const TTS_PREROLL_STORAGE_KEY = 'aria_tts_preroll_sec';
 
@@ -241,281 +173,16 @@ class AudioService {
   private pcmBytesCollected: number = 0;
   private readonly PCM_MAX_CACHE_BYTES = 30 * 1024 * 1024; // 30MB
 
-  // AudioFocus wird verzoegert freigegeben — wenn ARIA eine zweite Antwort
-  // direkt hinterherschickt (oder ein neuer Stream startet), bleibt Spotify
-  // pausiert. Ohne diese Verzoegerung springt Spotify im Mikro-Sekunden-Gap
-  // zwischen zwei Streams kurz wieder an.
-  private focusReleaseTimer: ReturnType<typeof setTimeout> | null = null;
-  private readonly FOCUS_RELEASE_DELAY_MS = 800;
-
-  // Conversation-Mode: solange aktiv (Wake-Word Status 'conversing' ODER
-  // wir wissen "ARIA spricht gerade in einem Multi-Turn-Dialog"), halten wir
-  // den AudioFocus DAUERHAFT. Der per-Stream-Release wird unterdrueckt,
-  // damit Spotify nicht in Render-Pausen oder zwischen Antworten zurueckkehrt.
-  private _conversationFocusActive: boolean = false;
-
   // VAD State
   private vadEnabled: boolean = false;
   private lastSpeechTime: number = 0;
   private vadTimer: ReturnType<typeof setInterval> | null = null;
   private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
-  // Latch damit der Silence-Callback pro Aufnahme genau einmal feuert
-  private silenceFired: boolean = false;
   private noSpeechTimer: ReturnType<typeof setTimeout> | null = null;
-  // 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;
-
-  // Interruption-Tracking fuer Auto-Resume nach Anruf:
-  // - playbackStartTime: ms-Timestamp wenn AudioTrack tatsaechlich anfing
-  //   abzuspielen (= _firePlaybackStarted)
-  // - currentPlaybackMsgId: welche Antwort lief gerade
-  // - pausedPosition / pausedMessageId: bei captureInterruption gemerkt
-  private playbackStartTime: number = 0;
-  private currentPlaybackMsgId: string = '';
-  private pausedPosition: number = 0;       // Sekunden in der Audio-Datei
-  private pausedMessageId: string = '';
-  private resumeSound: Sound | null = null;  // halten damit GC nicht zuschlaegt
-  // Leading-Silence wird im Native vor den Chunks geschrieben — beim
-  // Position-Berechnen vom playbackStarted abziehen
-  private readonly LEADING_SILENCE_SEC = 0.3;
 
   constructor() {
     this.recorder = new AudioRecorderPlayer();
     this.recorder.setSubscriptionDuration(0.1); // 100ms Metering-Updates
-    // Native Event: AudioTrack hat alle Samples wirklich durchgespielt (nach
-    // dem finally{}-Block im Writer-Thread). ERST jetzt darf AudioFocus
-    // freigegeben werden — sonst spielt Spotify schon waehrend ARIA noch
-    // redet (PcmStreamPlayer.end() returnt mit 15s-Cap viel zu frueh).
-    if (PcmStreamPlayer) {
-      try {
-        const emitter = new NativeEventEmitter(NativeModules.PcmStreamPlayer as any);
-        emitter.addListener('PcmPlaybackFinished', () => {
-          console.log('[Audio] PcmPlaybackFinished — Focus jetzt freigeben');
-          this._releaseFocusDeferred();
-        });
-      } catch (err) {
-        console.warn('[Audio] PcmPlaybackFinished-Subscription fehlgeschlagen:', err);
-      }
-    }
-    // App-Start: orphaned aria_tts_*.wav / aria_recording_*.mp4 aus dem Cache
-    // wegraeumen. Sammeln sich an wenn Sound mid-playback gestoppt wird (Anruf,
-    // Mute, Barge-In) — der completion-callback feuert dann nicht und die Datei
-    // bleibt liegen. 5min-Threshold damit gerade aktiv geschriebene Files sicher
-    // sind. cleanupOnStartup ist async, blockt den Constructor nicht.
-    this._cleanupStaleCacheFiles(5 * 60 * 1000).catch(() => {});
-  }
-
-  /** AudioFocus mit kleiner Verzoegerung freigeben — Spotify/YouTube
-   *  springen sonst im Gap zwischen zwei TTS-Streams (oder wenn ARIA
-   *  eine zweite Antwort direkt hinterherschickt) kurz wieder an.
-   *  Im Conversation-Mode (Wake-Word conversing) wird das Release komplett
-   *  unterdrueckt — der Focus bleibt fuer die ganze Konversation gehalten. */
-  private _releaseFocusDeferred(): void {
-    if (this._conversationFocusActive) {
-      console.log('[Audio] _releaseFocusDeferred: Conversation aktiv → kein Release');
-      this._cancelDeferredFocusRelease();
-      return;
-    }
-    this._cancelDeferredFocusRelease();
-    console.log('[Audio] _releaseFocusDeferred: in %dms', this.FOCUS_RELEASE_DELAY_MS);
-    this.focusReleaseTimer = setTimeout(() => {
-      this.focusReleaseTimer = null;
-      if (this._conversationFocusActive) {
-        console.log('[Audio] Focus-Release abgebrochen (Conversation jetzt aktiv)');
-        return;
-      }
-      console.log('[Audio] AudioFocus jetzt released');
-      AudioFocus?.release().catch(() => {});
-    }, this.FOCUS_RELEASE_DELAY_MS);
-  }
-
-  private _cancelDeferredFocusRelease(): void {
-    if (this.focusReleaseTimer) {
-      clearTimeout(this.focusReleaseTimer);
-      this.focusReleaseTimer = null;
-    }
-  }
-
-  /** Conversation-Mode beginnt → AudioFocus dauerhaft halten (Spotify bleibt
-   *  pausiert). Idempotent: mehrfaches Aufrufen ist sicher. */
-  acquireConversationFocus(): void {
-    if (this._conversationFocusActive) return;
-    this._conversationFocusActive = true;
-    this._cancelDeferredFocusRelease();
-    console.log('[Audio] Conversation-Focus aktiv (Spotify bleibt gepaust)');
-    AudioFocus?.requestDuck().catch(() => {});
-  }
-
-  /** Conversation-Mode endet → Focus darf wieder freigegeben werden
-   *  (verzoegert, damit eine direkt folgende Antwort nichts kaputtmacht). */
-  releaseConversationFocus(): void {
-    if (!this._conversationFocusActive) return;
-    this._conversationFocusActive = false;
-    console.log('[Audio] Conversation-Focus inaktiv');
-    this._releaseFocusDeferred();
-  }
-
-  /** TTS-Wiedergabe haart stoppen — z.B. fuer Barge-In. Buffer wird geleert,
-   *  kein Auto-Resume. Released auch sofort den AudioFocus. */
-  haltAllPlayback(reason: string = ''): void {
-    console.log('[Audio] haltAllPlayback: %s', reason || '(no reason)');
-    this._conversationFocusActive = false;
-    this.stopPlayback();
-  }
-
-  /** Speziell fuer Anrufe: AudioTrack stoppen + Focus releasen, ABER pcm-
-   *  Buffer + messageId behalten damit weitere Chunks der unterbrochenen
-   *  Antwort weiter gesammelt werden. isFinal schreibt dann die WAV trotz
-   *  Anruf — und resumeFromInterruption findet sie. */
-  pauseForCall(reason: string = ''): void {
-    console.log('[Audio] pauseForCall: %s', reason || '(no reason)');
-    this._conversationFocusActive = false;
-    this._pausedForCall = true;
-    // Queue + isPlaying ruecksetzen — sonst klemmt der naechste Play-Button
-    // (playAudio sieht isPlaying=true und ruft _playNext nicht mehr auf).
-    this.audioQueue = [];
-    this.isPlaying = false;
-    // Foreground-Service stoppen — Notification waere sonst irrefuehrend
-    stopBackgroundAudio().catch(() => {});
-    // SoundPool/RNSound (Resume-Sound, Play-Button) stoppen — nicht relevant fuer Auto-Resume
-    if (this.currentSound) {
-      try { this.currentSound.stop(); this.currentSound.release(); } catch {}
-      this.currentSound = null;
-    }
-    if (this.resumeSound) {
-      try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
-      this.resumeSound = null;
-    }
-    // AudioTrack hart stoppen damit nichts mehr aus dem Lautsprecher kommt.
-    // pcmStreamActive bleibt true, pcmBuffer/pcmMessageId BLEIBEN — damit
-    // weitere Chunks gesammelt werden und isFinal die WAV schreiben kann.
-    PcmStreamPlayer?.stop().catch(() => {});
-    this._cancelDeferredFocusRelease();
-    AudioFocus?.release().catch(() => {});
-  }
-
-  /** Anruf vorbei → weitere Chunks duerfen wieder abgespielt werden.
-   *  resumeFromInterruption uebernimmt die Wiedergabe ab gemerkter Position. */
-  endCallPause(): void {
-    if (!this._pausedForCall) return;
-    this._pausedForCall = false;
-    console.log('[Audio] endCallPause');
-  }
-
-  /** Bei Anruf: aktuelle Wiedergabe-Position merken damit wir nach dem
-   *  Auflegen von dort weitermachen koennen. Returnt Position in Sekunden
-   *  oder 0 wenn nichts spielte.
-   *
-   *  Idempotent: bei mehrfachem Aufruf (ringing → offhook) wird die Position
-   *  vom ersten Mal NICHT ueberschrieben. playbackStartTime laeuft stumpf
-   *  weiter obwohl das Audio gestoppt ist — der erste Halt ist der echte. */
-  captureInterruption(): number {
-    if (this.pausedMessageId) {
-      console.log('[Audio] captureInterruption: bereits erfasst (msgId=%s pos=%ss) — skip',
-                  this.pausedMessageId, this.pausedPosition.toFixed(2));
-      return this.pausedPosition;
-    }
-    if (!this.playbackStartTime || !this.currentPlaybackMsgId) {
-      console.log('[Audio] captureInterruption: nichts spielte (startTime=%s, msgId=%s)',
-                  this.playbackStartTime, this.currentPlaybackMsgId || '(leer)');
-      this.pausedPosition = 0;
-      this.pausedMessageId = '';
-      return 0;
-    }
-    const elapsedMs = Date.now() - this.playbackStartTime;
-    const positionSec = Math.max(0, elapsedMs / 1000 - this.LEADING_SILENCE_SEC);
-    this.pausedPosition = positionSec;
-    this.pausedMessageId = this.currentPlaybackMsgId;
-    console.log('[Audio] captureInterruption: msgId=%s pos=%ss',
-                this.pausedMessageId, positionSec.toFixed(2));
-    return positionSec;
-  }
-
-  /** Nach Anruf-Ende: ab gemerkter Position weiterspielen. Wenn Cache noch
-   *  nicht geschrieben (final kam waehrend Anruf vielleicht doch nicht),
-   *  warten bis maxWaitMs und dann probieren. Returnt true wenn gestartet. */
-  async resumeFromInterruption(maxWaitMs: number = 30000): Promise<boolean> {
-    const msgId = this.pausedMessageId;
-    const position = this.pausedPosition;
-    if (!msgId) {
-      console.log('[Audio] resumeFromInterruption: kein gemerkter Stand — skip');
-      return false;
-    }
-    console.log('[Audio] resumeFromInterruption: starte fuer msgId=%s pos=%ss',
-                msgId, position.toFixed(2));
-    this.pausedMessageId = '';  // konsumieren
-    const cachePath = `${RNFS.DocumentDirectoryPath}/tts_cache/${msgId}.wav`;
-    const startTime = Date.now();
-    while (Date.now() - startTime < maxWaitMs) {
-      try {
-        if (await RNFS.exists(cachePath)) {
-          return await this._playFromPathAtPosition(cachePath, position);
-        }
-      } catch {}
-      await new Promise(r => setTimeout(r, 500));
-    }
-    console.warn('[Audio] resumeFromInterruption: WAV %s nicht binnen %dms verfuegbar',
-                  msgId, maxWaitMs);
-    return false;
-  }
-
-  private async _playFromPathAtPosition(path: string, positionSec: number): Promise<boolean> {
-    try {
-      // Bestehende laufende Wiedergabe abbrechen damit wir sauber starten
-      if (this.resumeSound) {
-        try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
-        this.resumeSound = null;
-      }
-      const sound = await new Promise<Sound>((resolve, reject) => {
-        const s = new Sound(path.replace(/^file:\/\//, ''), '', (err) =>
-          err ? reject(err) : resolve(s));
-      });
-      // Audio-Focus anfordern damit Spotify pausiert
-      this._cancelDeferredFocusRelease();
-      AudioFocus?.requestDuck().catch(() => {});
-      this._firePlaybackStarted();
-      this.isPlaying = true;
-      this.resumeSound = sound;
-      // Tracking auch fuer den Resume-Sound aktualisieren — sonst kann
-      // captureInterruption bei einem zweiten Anruf die Position nicht
-      // mehr ermitteln (playbackStartTime waere von der ersten Wiedergabe).
-      const msgIdMatch = path.match(/([^/\\]+)\.wav$/i);
-      if (msgIdMatch) this.currentPlaybackMsgId = msgIdMatch[1];
-      // Virtuelle Start-Zeit so setzen, dass captureInterruption (das den
-      // Leading-Silence-Offset wieder abzieht) die korrekte Position liefert.
-      this.playbackStartTime = Date.now() - (positionSec + this.LEADING_SILENCE_SEC) * 1000;
-      console.log('[Audio] Resume von Position %ss aus %s',
-                  positionSec.toFixed(2), path);
-      sound.setCurrentTime(Math.max(0, positionSec));
-      sound.play((success) => {
-        if (!success) console.warn('[Audio] Resume-Wiedergabe fehlgeschlagen');
-        try { sound.release(); } catch {}
-        if (this.resumeSound === sound) this.resumeSound = null;
-        this.isPlaying = false;
-        this.playbackFinishedListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] cb err:', e); }
-        });
-        this._releaseFocusDeferred();
-      });
-      return true;
-    } catch (err: any) {
-      console.warn('[Audio] _playFromPathAtPosition fehlgeschlagen:', err?.message || err);
-      return false;
-    }
-  }
-
-  /** 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 ---
@@ -575,12 +242,6 @@ 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,
@@ -595,36 +256,8 @@ 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 > this.vadAdaptiveSpeechDb) {
+        if (db > VAD_SPEECH_THRESHOLD_DB) {
           if (!this.speechDetected && this.speechStartTime === 0) {
             this.speechStartTime = Date.now();
           }
@@ -639,7 +272,7 @@ class AudioService {
 
         // VAD: Stille erkennen (nur wenn Sprache erkannt wurde)
         if (this.vadEnabled) {
-          if (db > this.vadAdaptiveSilenceDb) {
+          if (db > VAD_SILENCE_THRESHOLD_DB) {
             this.lastSpeechTime = Date.now();
           }
         }
@@ -649,71 +282,38 @@ 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.)
-      this._cancelDeferredFocusRelease();
       AudioFocus?.requestExclusive().catch(() => {});
 
-      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar).
-      // WICHTIG: jeder Trigger (VAD-Stille / Max-Dauer / No-Speech-Window)
-      // disable SOFORT den VAD-Flag und clear den Timer, BEVOR die Listener
-      // gefeuert werden. Sonst feuert das setInterval weiter alle 200ms und
-      // ruft stopRecording parallel auf → audio-recorder-player crasht.
+      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar)
       this.vadEnabled = autoStop;
-      this.silenceFired = false;
-      const fireSilenceOnce = (reason: string) => {
-        if (this.silenceFired) return;
-        this.silenceFired = true;
-        this.vadEnabled = false;
-        if (this.vadTimer) { clearInterval(this.vadTimer); this.vadTimer = null; }
-        if (this.maxDurationTimer) { clearTimeout(this.maxDurationTimer); this.maxDurationTimer = null; }
-        if (this.noSpeechTimer) { clearTimeout(this.noSpeechTimer); this.noSpeechTimer = null; }
-        console.log('[Audio] Silence-Fire: %s', reason);
-        this.silenceListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] silence listener err:', e); }
-        });
-      };
       if (autoStop) {
         const vadSilenceMs = await loadVadSilenceMs();
-        const maxRecordingMs = await loadMaxRecordingMs();
-        console.log('[Audio] startRecording: autoStop=true, VAD-Stille=%dms, MAX=%dms',
-                    vadSilenceMs, maxRecordingMs);
+        console.log('[Audio] VAD-Stille:', vadSilenceMs, 'ms');
         this.vadTimer = setInterval(() => {
           const silenceDuration = Date.now() - this.lastSpeechTime;
           if (silenceDuration >= vadSilenceMs) {
-            fireSilenceOnce(`VAD ${silenceDuration}ms Stille (Schwelle=${vadSilenceMs}ms)`);
+            console.log(`[Audio] VAD: ${silenceDuration}ms Stille — Auto-Stop`);
+            this.silenceListeners.forEach(cb => cb());
           }
         }, 200);
-        // Notbremse: Nach maxRecordingMs zwangsweise stoppen
+        // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
         this.maxDurationTimer = setTimeout(() => {
-          fireSilenceOnce(`Max-Dauer ${maxRecordingMs}ms`);
-        }, maxRecordingMs);
+          console.warn(`[Audio] Max-Dauer ${MAX_RECORDING_MS}ms erreicht — Zwangs-Stop`);
+          this.silenceListeners.forEach(cb => cb());
+        }, MAX_RECORDING_MS);
       }
 
       // Conversation-Window: Wenn der User innerhalb noSpeechTimeoutMs nicht
-      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie).
+      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie),
+      // ChatScreen erkennt das und beendet die Konversation.
       if (noSpeechTimeoutMs > 0) {
         this.noSpeechTimer = setTimeout(() => {
           if (!this.speechDetected && this.recordingState === 'recording') {
-            fireSilenceOnce(`Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache`);
+            console.log(`[Audio] Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache — Stop`);
+            this.silenceListeners.forEach(cb => cb());
           }
         }, noSpeechTimeoutMs);
       }
@@ -753,9 +353,8 @@ class AudioService {
       await this.recorder.stopRecorder();
       this.recorder.removeRecordBackListener();
 
-      // Audio-Focus verzoegert freigeben — gleich kommt die TTS-Antwort,
-      // im Gap soll Spotify nicht hochkommen.
-      this._releaseFocusDeferred();
+      // Audio-Focus freigeben — andere Apps duerfen wieder
+      AudioFocus?.release().catch(() => {});
 
       const durationMs = Date.now() - this.recordingStartTime;
       const hadSpeech = this.speechDetected;
@@ -794,15 +393,8 @@ class AudioService {
   /** Base64-kodiertes Audio in die Queue stellen und abspielen */
   async playAudio(base64Data: string): Promise<void> {
     if (!base64Data) return;
-    // Mute-Flag respektieren — robust gegen Race-Conditions zwischen User-
-    // Klick auf Mute und einem TTS-Chunk der im selben Tick eintrifft.
-    if (this._muted) {
-      console.log('[Audio] playAudio: muted=true → skip');
-      return;
-    }
+
     this.audioQueue.push(base64Data);
-    console.log('[Audio] playAudio: queued (queue=%d isPlaying=%s pausedForCall=%s)',
-                this.audioQueue.length, this.isPlaying, this._pausedForCall);
     if (!this.isPlaying) {
       this._playNext();
     }
@@ -834,13 +426,7 @@ class AudioService {
 
   /** Einen PCM-Chunk aus einer audio_pcm Nachricht empfangen.
    *  silent=true → nur cachen, nicht abspielen (z.B. wenn TTS geraetelokal gemutet).
-   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached.
-   *
-   *  Wrapper serialisiert aufeinanderfolgende Chunk-Calls via Promise-Queue —
-   *  sonst gabs bei kurzen Streams einen Race: final-Chunk konnte `end()` rufen
-   *  BEVOR der vorherige `start()` im Native-Modul fertig war. Der Writer-
-   *  Thread sah dann endRequested=true ohne jemals Chunks zu verarbeiten. */
-  private _pcmChunkQueue: Promise<any> = Promise.resolve();
+   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached. */
   async handlePcmChunk(payload: {
     base64: string;
     sampleRate?: number;
@@ -850,45 +436,11 @@ class AudioService {
     final?: boolean;
     silent?: boolean;
   }): Promise<string> {
-    const p = this._pcmChunkQueue.then(() => this._handlePcmChunkImpl(payload)).catch(err => {
-      console.warn('[Audio] handlePcmChunk queued err:', err);
-      return '';
-    });
-    // Chain only on the side effect — callers still get the per-call result
-    this._pcmChunkQueue = p;
-    return p;
-  }
-
-  private async _handlePcmChunkImpl(payload: {
-    base64: string;
-    sampleRate?: number;
-    channels?: number;
-    messageId?: string;
-    chunk?: number;
-    final?: boolean;
-    silent?: boolean;
-  }): Promise<string> {
-    // _stoppedMessageId: User hat diese Antwort mid-Wiedergabe gestoppt
-    // (Mute geklickt). Auch wenn Mute jetzt wieder aus ist, soll diese
-    // Antwort nicht weiterspielen. Erst eine neue messageId resetted das.
-    const incomingMsgId = payload.messageId || '';
-    const stoppedByUser = !!this._stoppedMessageId && incomingMsgId === this._stoppedMessageId;
-    // Globaler Mute-Flag uebersteuert das per-Call silent — verhindert
-    // Race-Conditions wenn der User zwischen Chunks den Mute-Knopf drueckt.
-    // _pausedForCall: AudioTrack ist gestoppt waehrend Anruf — Chunks weiter
-    // sammeln (fuer WAV-Cache), aber NICHT in den Player schicken.
-    const silent = !!payload.silent || this._muted || this._pausedForCall || stoppedByUser;
+    const silent = !!payload.silent;
     if (!silent && !PcmStreamPlayer) {
       console.warn('[Audio] PcmStreamPlayer Native Module nicht verfuegbar');
       return '';
     }
-    // Debug-Log bei Chunk 0 eines neuen Streams — damit man im adb logcat
-    // sieht warum der Auto-Playback greift oder nicht.
-    if ((payload.chunk ?? 0) === 0 && !this.pcmStreamActive) {
-      console.log('[Audio] PCM-Stream start: silent=%s messageId=%s sr=%s ch=%s',
-                  silent, payload.messageId || '(none)',
-                  payload.sampleRate, payload.channels);
-    }
 
     const messageId = payload.messageId || '';
     const sampleRate = payload.sampleRate || 24000;
@@ -903,28 +455,6 @@ class AudioService {
         this.pcmBuffer = [];
         this.pcmBytesCollected = 0;
       }
-      // Resume-Sound stoppen falls noch aktiv (User hat nach Anruf eine
-      // neue Frage gestellt — die alte interruptierte Antwort ist obsolet).
-      if (this.resumeSound) {
-        try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
-        this.resumeSound = null;
-      }
-      // Pending Auto-Resume verwerfen wenn die neue Antwort eine andere
-      // messageId hat. Sonst spielt nach 30s-Wartezeit der Resume die
-      // ueberholte Antwort ab.
-      if (this.pausedMessageId && this.pausedMessageId !== messageId) {
-        console.log('[Audio] Neue TTS-Antwort (msgId=%s) — Auto-Resume fuer %s verworfen',
-                    messageId, this.pausedMessageId);
-        this.pausedMessageId = '';
-        this.pausedPosition = 0;
-      }
-      // Stop-Marker zuruecksetzen wenn neue messageId — neue Antwort darf
-      // wieder normal abspielen, egal ob Mute zwischendurch aktiv war.
-      if (this._stoppedMessageId && this._stoppedMessageId !== messageId) {
-        console.log('[Audio] Neue Antwort (msgId=%s) — Stop-Marker fuer %s zurueckgesetzt',
-                    messageId, this._stoppedMessageId);
-        this._stoppedMessageId = '';
-      }
       this.pcmStreamActive = true;
       this.pcmMessageId = messageId;
       this.pcmSampleRate = sampleRate;
@@ -940,9 +470,7 @@ class AudioService {
           this.pcmStreamActive = false;
           return '';
         }
-        this._cancelDeferredFocusRelease();
         AudioFocus?.requestDuck().catch(() => {});
-        this._firePlaybackStarted();
       }
     }
 
@@ -959,16 +487,12 @@ class AudioService {
 
     if (isFinal) {
       if (!silent) {
-        // end() signalisiert dem Writer "keine weiteren Chunks". Aber WIR
-        // releasen den AudioFocus NICHT hier — der writer braucht u.U. noch
-        // 30+ Sekunden bis der Buffer wirklich abgespielt ist. Den release
-        // triggert das native Event "PcmPlaybackFinished" wenn AudioTrack
-        // wirklich am Ende ist (siehe ensurePlaybackFinishedListener).
+        // end() resolved jetzt erst wenn der native Writer-Thread fertig
+        // ist (alle Samples ausgespielt) — danach erst AudioFocus freigeben,
+        // damit Spotify/YouTube nicht waehrend des Pre-Roll-Ausklangs
+        // wieder aufdrehen.
         try { await PcmStreamPlayer!.end(); } catch {}
-        // playbackFinished-Listener informieren (UI-Logik)
-        this.playbackFinishedListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] playbackFinished cb err:', e); }
-        });
+        AudioFocus?.release().catch(() => {});
       }
       this.pcmStreamActive = false;
 
@@ -1042,10 +566,7 @@ class AudioService {
     }
   }
 
-  /** Audio aus lokaler Datei (file:// Pfad) in die Queue und abspielen.
-   *  Setzt zusaetzlich playbackStartTime + currentPlaybackMsgId damit ein
-   *  Anruf waehrend dieses Playbacks korrekt erfasst wird (ohne dieses
-   *  Tracking liefert captureInterruption nichts → kein Auto-Resume). */
+  /** Audio aus lokaler Datei (file:// Pfad) in die Queue und abspielen. */
   async playFromPath(filePath: string): Promise<void> {
     if (!filePath) return;
     try {
@@ -1054,14 +575,6 @@ class AudioService {
         console.warn('[Audio] Cache-Datei existiert nicht mehr:', cleanPath);
         return;
       }
-      // Dateiname ohne .wav als messageId nehmen (egal ob UUID oder andere ID)
-      const fileMatch = cleanPath.match(/([^/\\]+)\.wav$/i);
-      const msgId = fileMatch ? fileMatch[1] : '';
-      console.log('[Audio] playFromPath: cleanPath=%s → msgId=%s', cleanPath, msgId || '(leer)');
-      if (msgId) {
-        this.currentPlaybackMsgId = msgId;
-        this.playbackStartTime = Date.now() - this.LEADING_SILENCE_SEC * 1000;
-      }
       const b64 = await RNFS.readFile(cleanPath, 'base64');
       this.playAudio(b64);
     } catch (err) {
@@ -1071,7 +584,6 @@ class AudioService {
 
   // Callback wenn alle Audio-Teile abgespielt sind
   private playbackFinishedListeners: (() => void)[] = [];
-  private playbackStartedListeners: (() => void)[] = [];
 
   onPlaybackFinished(callback: () => void): () => void {
     this.playbackFinishedListeners.push(callback);
@@ -1080,47 +592,20 @@ 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 {
-    // Tracking fuer Auto-Resume nach Anruf-Pause: NUR setzen wenn ein
-    // PCM-Stream laeuft (Live-TTS). Bei Play-Button / Resume-Sound hat der
-    // Caller (playFromPath / _playFromPathAtPosition) das Tracking schon
-    // korrekt mit der msgId aus dem Pfad gesetzt — sonst wuerden wir hier
-    // mit leerem pcmMessageId ueberschreiben.
-    if (this.pcmMessageId) {
-      this.playbackStartTime = Date.now();
-      this.currentPlaybackMsgId = this.pcmMessageId;
-    }
-    this.playbackStartedListeners.forEach(cb => {
-      try { cb(); } catch (e) { console.warn('[Audio] playbackStarted listener err:', e); }
-    });
-  }
-
   /** Naechstes Audio aus der Queue abspielen */
   private async _playNext(): Promise<void> {
     if (this.audioQueue.length === 0) {
       this.isPlaying = false;
-      // Audio-Focus verzoegert abgeben → wenn gleich noch eine Antwort kommt,
-      // bleibt Spotify pausiert.
-      this._releaseFocusDeferred();
+      // Audio-Focus abgeben → andere Apps volle Lautstaerke
+      AudioFocus?.release().catch(() => {});
       // Alle Audio-Teile abgespielt → Listener benachrichtigen
       this.playbackFinishedListeners.forEach(cb => cb());
       return;
     }
 
-    // Beim ersten Playback-Start: andere Apps ducken + Listener informieren
+    // Beim ersten Playback-Start: andere Apps ducken
     if (!this.isPlaying) {
-      this._cancelDeferredFocusRelease();
       AudioFocus?.requestDuck().catch(() => {});
-      this._firePlaybackStarted();
     }
     this.isPlaying = true;
 
@@ -1151,13 +636,11 @@ class AudioService {
     }
 
     this.currentSound = sound;
-    console.log('[Audio] Sound.play startet (path=%s)', soundPath);
 
     // Naechstes Audio schon vorbereiten waehrend dieses abspielt
     this._preloadNext();
 
     sound.play((success) => {
-      console.log('[Audio] Sound.play callback: success=%s queue=%d', success, this.audioQueue.length);
       if (!success) console.warn('[Audio] Wiedergabe fehlgeschlagen');
       sound.release();
       this.currentSound = null;
@@ -1184,51 +667,8 @@ class AudioService {
     }
   }
 
-  /** Mute: alle eingehenden TTS-Chunks/WAVs werden ignoriert bis wieder
-   *  unmuted. Robuster als ein React-Ref weil hier kein Re-Render-Race ist
-   *  — die Bridge kann einen Chunk im selben JS-Tick liefern in dem der
-   *  User Mute geklickt hat. */
-  private _muted: boolean = false;
-  /** Anruf laeuft → Chunks werden nur in den Cache-Buffer gepusht, nicht
-   *  abgespielt. Wird in pauseForCall gesetzt, in endCallPause/resumeFrom-
-   *  Interruption zurueckgenommen. */
-  private _pausedForCall: boolean = false;
-  /** Wenn der User mid-Wiedergabe Mute drueckt: messageId der ABGEBROCHENEN
-   *  Antwort merken. Folge-Chunks dieser msgId werden silent ignoriert, auch
-   *  wenn der User Mute wieder ausschaltet — kein "Resume mid-Antwort". Eine
-   *  NEUE messageId resetted das, dann spielt's wieder normal. */
-  private _stoppedMessageId: string = '';
-  setMuted(muted: boolean): void {
-    console.log('[Audio] setMuted: %s (currentSound=%s pcmStreamActive=%s)',
-                muted, this.currentSound ? 'aktiv' : 'null', this.pcmStreamActive);
-    this._muted = muted;
-    if (muted) {
-      // Aktuell laufende Antwort als "verworfen" markieren — nachfolgende
-      // chunks dieser msgId werden silent gehalten auch wenn der User Mute
-      // gleich wieder ausschaltet. Erst eine NEUE Antwort darf wieder reden.
-      const activeMsgId = this.pcmMessageId || this.currentPlaybackMsgId;
-      if (activeMsgId) {
-        this._stoppedMessageId = activeMsgId;
-        console.log('[Audio] Antwort %s als gestoppt markiert', activeMsgId);
-      }
-      this.stopPlayback();
-    }
-  }
-  isMuted(): boolean { return this._muted; }
-
   /** Laufende Wiedergabe stoppen + Queue leeren */
   stopPlayback(): void {
-    // Idempotent: wenn nichts mehr aktiv ist, NICHT noch einen Focus-Release/
-    // Kick-Cycle anstossen — Re-Renders triggern setMuted oft mehrfach hinter-
-    // einander, und jeder weitere Kick lässt Spotify nochmal kurz pausieren.
-    const hasAnything = !!(this.currentSound || this.resumeSound || this.preloadedSound
-                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying);
-    if (!hasAnything) return;
-    console.log('[Audio] stopPlayback: currentSound=%s queue=%d pcm=%s',
-                this.currentSound ? 'aktiv' : 'null', this.audioQueue.length, this.pcmStreamActive);
-    // 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) {
@@ -1236,32 +676,21 @@ class AudioService {
       this.currentSound.release();
       this.currentSound = null;
     }
-    if (this.resumeSound) {
-      this.resumeSound.stop();
-      this.resumeSound.release();
-      this.resumeSound = null;
-    }
     if (this.preloadedSound) {
       this.preloadedSound.release();
       this.preloadedSound = null;
       if (this.preloadedPath) RNFS.unlink(this.preloadedPath).catch(() => {});
       this.preloadedPath = '';
     }
-    // PCM-Stream ebenfalls hart stoppen (Cancel/Abbruch).
-    // pcmStreamActive wird beim isFinal-Chunk schon false gesetzt — der
-    // AudioTrack spielt aber noch sekundenlang aus seinem Buffer ab. Daher
-    // IMMER stop() aufrufen, ohne den Flag zu pruefen (ist idempotent).
-    PcmStreamPlayer?.stop().catch(() => {});
-    this.pcmStreamActive = false;
-    this.pcmBuffer = [];
-    this.pcmBytesCollected = 0;
-    this.pcmMessageId = '';
-    // Audio-Focus sofort freigeben — User hat explizit abgebrochen.
-    // Unser Focus war TRANSIENT, Spotify resumed darum automatisch beim
-    // Abandon. Den frueheren kickReleaseMedia haben wir entfernt: er
-    // requestete USAGE_MEDIA mit GAIN (permanent), was Spotify als
-    // "user-action stopp" interpretierte und Auto-Resume verhinderte.
-    this._cancelDeferredFocusRelease();
+    // PCM-Stream ebenfalls hart stoppen (Cancel/Abbruch)
+    if (this.pcmStreamActive) {
+      PcmStreamPlayer?.stop().catch(() => {});
+      this.pcmStreamActive = false;
+      this.pcmBuffer = [];
+      this.pcmBytesCollected = 0;
+      this.pcmMessageId = '';
+    }
+    // Audio-Focus freigeben
     AudioFocus?.release().catch(() => {});
   }
 
@@ -1302,29 +731,19 @@ class AudioService {
     }
   }
 
-  /** Alte Aufnahme- und TTS-Files aus dem Cache loeschen.
-   *  Default 30s — verwendet beim Mikro-Start (kurze Lebensdauer reicht).
-   *  App-Start nutzt 5min damit gerade aktive Files nicht erwischt werden. */
-  private async _cleanupStaleCacheFiles(maxAgeMs: number = 30000): Promise<void> {
+  /** Alte Aufnahme- und TTS-Files aus dem Cache loeschen (>30s alt). */
+  private async _cleanupStaleCacheFiles(): Promise<void> {
     try {
       const files = await RNFS.readDir(RNFS.CachesDirectoryPath);
       const now = Date.now();
-      let removed = 0;
-      let freedBytes = 0;
       for (const f of files) {
         if (!f.isFile()) continue;
         if (!f.name.startsWith('aria_recording_') && !f.name.startsWith('aria_tts_')) continue;
         const age = now - (f.mtime ? f.mtime.getTime() : 0);
-        if (age > maxAgeMs) {
-          freedBytes += parseInt(f.size as any, 10) || 0;
+        if (age > 30000) {
           await RNFS.unlink(f.path).catch(() => {});
-          removed += 1;
         }
       }
-      if (removed > 0) {
-        console.log('[Audio] Cache-Cleanup: %d Files entfernt, %.1fMB freigegeben',
-                    removed, freedBytes / 1024 / 1024);
-      }
     } catch {
       // silent — cleanup ist best-effort
     }
@@ -1351,43 +770,6 @@ class AudioService {
       // silent
     }
   }
-
-  /** Aktuelle Groesse des TTS-Caches. */
-  async getTtsCacheSize(): Promise<{ count: number; totalMB: number }> {
-    let count = 0;
-    let total = 0;
-    try {
-      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
-      if (await RNFS.exists(dir)) {
-        const files = await RNFS.readDir(dir);
-        for (const f of files) {
-          if (!f.isFile() || !f.name.endsWith('.wav')) continue;
-          count += 1;
-          total += parseInt(f.size as any, 10) || 0;
-        }
-      }
-    } catch {}
-    return { count, totalMB: total / 1024 / 1024 };
-  }
-
-  /** TTS-Cache komplett leeren (Settings-Button). */
-  async clearTtsCache(): Promise<{ removed: number; freedMB: number }> {
-    let removed = 0;
-    let freed = 0;
-    try {
-      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
-      if (!(await RNFS.exists(dir))) return { removed: 0, freedMB: 0 };
-      const files = await RNFS.readDir(dir);
-      for (const f of files) {
-        if (!f.isFile() || !f.name.endsWith('.wav')) continue;
-        const size = parseInt(f.size as any, 10) || 0;
-        await RNFS.unlink(f.path).catch(() => {});
-        removed += 1;
-        freed += size;
-      }
-    } catch {}
-    return { removed, freedMB: freed / 1024 / 1024 };
-  }
 }
 
 // Singleton

android/src/services/backgroundAudio.ts

@@ -1,76 +0,0 @@
-/**
- * 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/logger.ts

@@ -1,41 +0,0 @@
-/**
- * Verbose-Logging-Toggle: console.log laesst sich global stummschalten.
- * console.warn/console.error bleiben immer an — Fehler will man immer sehen.
- *
- * Default: an (true). Toggle ueber Settings → Protokoll → Verbose Logging.
- * Beim Start wird der gespeicherte Wert geladen, vorher loggen wir normal.
- */
-
-import AsyncStorage from '@react-native-async-storage/async-storage';
-
-export const VERBOSE_LOGGING_KEY = 'aria_verbose_logging';
-
-// Original-console.log retten, damit wir die Wrapper jederzeit wieder
-// "scharf" stellen koennen (sonst waere ein Toggle-an nach -aus tot).
-const originalLog = console.log.bind(console);
-const noop = () => {};
-
-let _verbose = true;
-
-function applyState(): void {
-  console.log = _verbose ? originalLog : noop;
-}
-
-/** Wert aus AsyncStorage laden und anwenden. Beim App-Start aufrufen. */
-export async function initLogger(): Promise<void> {
-  try {
-    const v = await AsyncStorage.getItem(VERBOSE_LOGGING_KEY);
-    _verbose = v !== 'false'; // default: true
-  } catch {}
-  applyState();
-}
-
-export function isVerboseLogging(): boolean {
-  return _verbose;
-}
-
-export function setVerboseLogging(verbose: boolean): void {
-  _verbose = verbose;
-  applyState();
-  AsyncStorage.setItem(VERBOSE_LOGGING_KEY, String(verbose)).catch(() => {});
-}

android/src/services/phoneCall.ts

@@ -1,222 +0,0 @@
-/**
- * PhoneCall-Service — pausiert ARIA bei Telefonaten:
- *
- * 1. Klassischer Mobilfunk-Anruf via TelephonyManager (PhoneCallModule.kt)
- *    Status: idle / ringing / offhook
- *
- * 2. VoIP-Anrufe (WhatsApp, Signal, Discord, Telegram, Teams, ...) via
- *    AudioFocus-Loss-Event (AudioFocusModule.kt). Diese Apps requestn
- *    AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE wenn ein Anruf reinkommt — wir
- *    bekommen ein "loss" Event und reagieren genauso wie auf RINGING.
- *
- * In beiden Faellen wird audioService.haltAllPlayback() + wakeWordService.
- * pauseForCall() gerufen. Bei call-end (idle / focus-gain) → resumeFromCall.
- *
- * Permission READ_PHONE_STATE ist nur fuer Pfad 1 noetig — Pfad 2 braucht
- * keine extra Berechtigung weil unser eigener AudioFocus-Listener feuert.
- */
-
-import {
-  NativeEventEmitter,
-  NativeModules,
-  PermissionsAndroid,
-  Platform,
-  ToastAndroid,
-} from 'react-native';
-import audioService from './audio';
-import wakeWordService from './wakeword';
-
-interface PhoneCallNative {
-  start(): Promise<boolean>;
-  stop(): Promise<boolean>;
-}
-
-const { PhoneCall } = NativeModules as { PhoneCall?: PhoneCallNative };
-
-type PhoneState = 'idle' | 'ringing' | 'offhook';
-
-class PhoneCallService {
-  private started: boolean = false;
-  private subscription: { remove: () => void } | null = null;
-  private focusSubscription: { remove: () => void } | null = null;
-  private lastState: PhoneState = 'idle';
-  /** Damit Resume nach VoIP-Loss nicht doppelt feuert wenn auch
-   *  TelephonyManager-IDLE-Event kommt. */
-  private interruptedByFocus: boolean = false;
-
-  async start(): Promise<boolean> {
-    if (this.started || Platform.OS !== 'android') return false;
-
-    // 1. AudioFocus-Listener IMMER registrieren — fangs VoIP-Calls (WhatsApp,
-    //    Signal, Discord etc.) abdecken, brauchen keine Permission.
-    try {
-      const focusEmitter = new NativeEventEmitter(NativeModules.AudioFocus as any);
-      this.focusSubscription = focusEmitter.addListener(
-        'AudioFocusChanged',
-        (e: { type: 'loss' | 'loss_transient' | 'gain' }) => this._onFocusChanged(e.type),
-      );
-      console.log('[PhoneCall] AudioFocus-Listener aktiv (fuer VoIP-Calls)');
-    } catch (err: any) {
-      console.warn('[PhoneCall] AudioFocus-Subscription gescheitert', err?.message || err);
-    }
-
-    // 2. TelephonyManager-Listener — fuer klassische Mobilfunk-Anrufe
-    if (PhoneCall) {
-      try {
-        const granted = await PermissionsAndroid.request(
-          PermissionsAndroid.PERMISSIONS.READ_PHONE_STATE,
-          {
-            title: 'ARIA Cockpit — Anruf-Erkennung',
-            message: 'Damit ARIA bei einem eingehenden Anruf nicht weiterredet, '
-              + 'darf die App den Anruf-Status sehen (Klingeln/Aktiv/Aufgelegt). '
-              + 'Es werden keine Anrufdaten gelesen oder gespeichert.',
-            buttonPositive: 'Erlauben',
-            buttonNegative: 'Spaeter',
-          },
-        );
-        if (granted === PermissionsAndroid.RESULTS.GRANTED) {
-          const ok = await PhoneCall.start();
-          if (ok) {
-            const emitter = new NativeEventEmitter(NativeModules.PhoneCall as any);
-            this.subscription = emitter.addListener(
-              'PhoneCallStateChanged',
-              (e: { state: PhoneState }) => this._onStateChanged(e.state),
-            );
-            console.log('[PhoneCall] TelephonyManager-Listener aktiv');
-          }
-        } else {
-          console.warn('[PhoneCall] READ_PHONE_STATE abgelehnt — VoIP-Calls werden trotzdem ueber AudioFocus erkannt');
-        }
-      } catch (err: any) {
-        console.warn('[PhoneCall] TelephonyManager-Setup gescheitert:', err?.message || err);
-      }
-    }
-
-    this.started = true;
-    return true;
-  }
-
-  async stop(): Promise<void> {
-    if (!this.started) return;
-    try { this.subscription?.remove(); } catch {}
-    try { this.focusSubscription?.remove(); } catch {}
-    this.subscription = null;
-    this.focusSubscription = null;
-    if (PhoneCall) {
-      try { await PhoneCall.stop(); } catch {}
-    }
-    this.started = false;
-    this.lastState = 'idle';
-    this.interruptedByFocus = false;
-  }
-
-  private _onStateChanged(state: PhoneState): void {
-    if (state === this.lastState) return;
-    const prev = this.lastState;
-    console.log('[PhoneCall] State: %s → %s', prev, state);
-    this.lastState = state;
-    if (state === 'ringing' || state === 'offhook') {
-      this._haltForCall(state === 'ringing' ? 'Anruf — ARIA pausiert' : 'Im Gespraech — ARIA pausiert');
-    } else if (state === 'idle' && prev !== 'idle') {
-      // Wenn schon durch AudioFocus-Loss pausiert wurde, NICHT doppelt resumen.
-      // Der Focus-Gain-Event triggert das Resume.
-      if (!this.interruptedByFocus) {
-        this._resumeAfterCall('Anruf beendet — ARIA wieder aktiv');
-      }
-    }
-  }
-
-  /** AudioFocus-Loss = irgendeine andere App hat den Focus uebernommen.
-   *  Das passiert bei VoIP-Anrufen (was wir wollen) ABER auch bei normalen
-   *  Audio-Playern (anderer Player startet, Notification-Sound, sogar
-   *  unsere eigenen Sound-Calls beim Play-Button). Daher checken wir den
-   *  AudioMode — nur IN_CALL (2) oder IN_COMMUNICATION (3) zaehlt als Anruf. */
-  private async _onFocusChanged(type: 'loss' | 'loss_transient' | 'gain'): Promise<void> {
-    if (type === 'loss' || type === 'loss_transient') {
-      // Schon durch klassischen TelephonyManager pausiert? Dann nichts doppeln.
-      if (this.lastState === 'ringing' || this.lastState === 'offhook') return;
-      // Mode pruefen — nur echte Anrufe behandeln.
-      let mode = -1;
-      try { mode = await (NativeModules.AudioFocus as any)?.getMode?.(); } catch {}
-      if (mode !== 2 && mode !== 3) {
-        // NORMAL-Mode → kein Anruf (Stefan hat z.B. Play-Button gedrueckt
-        // oder Spotify hat sich neu reingedraengelt). Keine Toasts.
-        console.log('[PhoneCall] FOCUS_LOSS ignoriert (AudioMode=%d, kein Call)', mode);
-        return;
-      }
-      this.interruptedByFocus = true;
-      this._haltForCall('Anruf erkannt (VoIP) — ARIA pausiert');
-      // Pollen, weil GAIN nicht zuverlaessig kommt (wir releasen den Focus
-      // selbst beim halt → kein automatischer GAIN). AudioMode != IN_COMMUNICATION
-      // = Call vorbei.
-      this._startVoipResumePoll();
-    } else if (type === 'gain') {
-      if (this.interruptedByFocus) {
-        this.interruptedByFocus = false;
-        this._stopVoipResumePoll();
-        this._resumeAfterCall('Audio frei — ARIA wieder aktiv');
-      }
-    }
-  }
-
-  /** Polling-Fallback: alle 3s checken ob AudioMode wieder NORMAL ist. */
-  private voipPollTimer: ReturnType<typeof setInterval> | null = null;
-  private _startVoipResumePoll(): void {
-    if (this.voipPollTimer) return;
-    this.voipPollTimer = setInterval(async () => {
-      if (!this.interruptedByFocus) {
-        this._stopVoipResumePoll();
-        return;
-      }
-      try {
-        const mode = await (NativeModules.AudioFocus as any)?.getMode?.();
-        // 0 = MODE_NORMAL — Call ist vorbei
-        if (typeof mode === 'number' && mode === 0) {
-          this.interruptedByFocus = false;
-          this._stopVoipResumePoll();
-          this._resumeAfterCall('Anruf beendet — ARIA wieder aktiv');
-        }
-      } catch {}
-    }, 3000);
-  }
-  private _stopVoipResumePoll(): void {
-    if (this.voipPollTimer) {
-      clearInterval(this.voipPollTimer);
-      this.voipPollTimer = null;
-    }
-  }
-
-  private _haltForCall(toast: string): void {
-    // Position merken bevor wir den Stream killen — fuer Auto-Resume.
-    audioService.captureInterruption();
-    // pauseForCall (statt haltAllPlayback): pcmBuffer + messageId bleiben,
-    // weitere Chunks werden weiter gesammelt damit isFinal die WAV schreibt.
-    audioService.pauseForCall(toast);
-    wakeWordService.pauseForCall().catch(() => {});
-    ToastAndroid.show(toast, ToastAndroid.SHORT);
-  }
-
-  private _resumeAfterCall(toast: string): void {
-    // Anruf-Pause aufheben — neue Chunks duerfen wieder direkt abgespielt
-    // werden (falls die Bridge mid-Anruf isFinal noch nicht geschickt hat).
-    audioService.endCallPause();
-    wakeWordService.resumeFromCall().catch(() => {});
-    ToastAndroid.show(toast, ToastAndroid.SHORT);
-    // 800ms warten bevor Auto-Resume — sonst kollidiert ARIA's neuer Focus-
-    // Request mit Spotify's Auto-Resume nach Anruf-Ende. System haengt nach
-    // dem Auflegen noch im IN_CALL-Mode-Uebergang, Spotify schaut auf Focus-
-    // Gain und wuerde sofort wieder LOSS sehen → bleibt pausiert.
-    // Mit Delay: Spotify resumed kurz, dann pausiert ARIA wieder ordnungs-
-    // gemaess. Wenn ARIA nichts pending hat, bleibt Spotify einfach an.
-    setTimeout(() => {
-      audioService.resumeFromInterruption(30000).then(ok => {
-        if (ok) {
-          console.log('[PhoneCall] Auto-Resume von gemerkter Position gestartet');
-        }
-      }).catch(() => {});
-    }, 800);
-  }
-}
-
-const phoneCallService = new PhoneCallService();
-export default phoneCallService;

android/src/services/updater.ts

@@ -29,11 +29,6 @@ class UpdateService {
   private downloading = false;
 
   constructor() {
-    // Beim Start alte APK-Reste aus dem Cache wegraeumen — wenn diese App
-    // laeuft, sind frueher heruntergeladene APKs entweder schon installiert
-    // oder unvollstaendig gewesen. Spart sonst pro Update 20-30MB auf dem Handy.
-    this.cleanupOldApks().catch(() => {});
-
     // Auf update_available Nachrichten lauschen
     rvs.onMessage((msg: RVSMessage) => {
       if (msg.type === 'update_available' as any) {
@@ -50,71 +45,6 @@ class UpdateService {
     });
   }
 
-  /** Sucht ueberall wo .apk-Dateien herumliegen koennten. */
-  private async _apkSearchDirs(): Promise<string[]> {
-    const dirs = [RNFS.CachesDirectoryPath, RNFS.DocumentDirectoryPath];
-    if ((RNFS as any).ExternalCachesDirectoryPath) {
-      dirs.push((RNFS as any).ExternalCachesDirectoryPath);
-    }
-    if (RNFS.ExternalDirectoryPath) {
-      dirs.push(RNFS.ExternalDirectoryPath);
-    }
-    return dirs;
-  }
-
-  /** Raeumt alte heruntergeladene APK-Dateien aus den App-Verzeichnissen auf.
-   *  Public damit Settings den Button "Update-Cache leeren" benutzen kann. */
-  async cleanupOldApks(keepCurrentName?: string): Promise<{ removed: number; freedMB: number }> {
-    const dirs = await this._apkSearchDirs();
-    let removed = 0;
-    let freed = 0;
-    for (const dir of dirs) {
-      try {
-        if (!(await RNFS.exists(dir))) continue;
-        const files = await RNFS.readDir(dir);
-        const apks = files.filter(f => /\.apk$/i.test(f.name));
-        for (const f of apks) {
-          if (keepCurrentName && f.name === keepCurrentName) continue;
-          try {
-            const size = parseInt(f.size as any, 10) || 0;
-            await RNFS.unlink(f.path);
-            removed += 1;
-            freed += size;
-            console.log(`[Update] APK geloescht: ${f.path} (${(size / 1024 / 1024).toFixed(1)}MB)`);
-          } catch (err: any) {
-            console.warn(`[Update] APK-Loeschen fehlgeschlagen: ${f.path} (${err?.message || err})`);
-          }
-        }
-      } catch (err: any) {
-        console.warn(`[Update] Cleanup-Fehler in ${dir}: ${err?.message || err}`);
-      }
-    }
-    const freedMB = freed / 1024 / 1024;
-    if (removed > 0) {
-      console.log(`[Update] Cleanup fertig: ${removed} APK${removed === 1 ? '' : 's'} entfernt, ${freedMB.toFixed(1)}MB freigegeben`);
-    }
-    return { removed, freedMB };
-  }
-
-  /** Aktuelle Groesse aller APK-Dateien in den App-Verzeichnissen (in MB). */
-  async getApkCacheSize(): Promise<{ count: number; totalMB: number }> {
-    const dirs = await this._apkSearchDirs();
-    let count = 0;
-    let total = 0;
-    for (const dir of dirs) {
-      try {
-        if (!(await RNFS.exists(dir))) continue;
-        const files = await RNFS.readDir(dir);
-        for (const f of files) {
-          if (!f.isFile() || !/\.apk$/i.test(f.name)) continue;
-          count += 1;
-          total += parseInt(f.size as any, 10) || 0;
-        }
-      } catch {}
-    }
-    return { count, totalMB: total / 1024 / 1024 };
-  }
-
   /** Bei App-Start Update pruefen */
   checkForUpdate(): void {
     if (this.checking) return;
@@ -181,10 +111,6 @@ class UpdateService {
         });
       });
 
-      // Vor dem Schreiben alte APKs im Cache wegraeumen — falls mehrere
-      // Updates in einer Session gezogen werden
-      await this.cleanupOldApks();
-
       // Base64 als APK-Datei speichern
       const destPath = `${RNFS.CachesDirectoryPath}/${apkData.fileName}`;
       await RNFS.writeFile(destPath, apkData.base64, 'base64');

android/src/services/wakeReadySound.ts

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

android/src/services/wakeword.ts

@@ -1,154 +1,107 @@
 /**
  * Gespraechsmodus / Wake Word Service
  *
- * Wake-Word-Engine: openWakeWord (https://github.com/dscripka/openWakeWord),
- * komplett on-device via ONNX Runtime in Native-Kotlin (siehe
- * OpenWakeWordModule.kt + assets/openwakeword/). Kein API-Key, kein Cloud-
- * Roundtrip, kein Cent Lizenzgebuehren.
- *
  * Drei Zustaende:
  *   off        — Ohr aus, nichts laeuft
- *   armed      — Ohr aktiv, openWakeWord hoert passiv auf das Wake-Word.
- *                Das Mikro ist von OpenWakeWord belegt; AudioRecorder ist aus.
- *   conversing — Wake-Word getriggert (oder Ohr-Tap manuell):
- *                aktive Konversation. OpenWakeWord pausiert (gibt Mikro frei),
+ *   armed      — Ohr aktiv, Porcupine hoert passiv auf das Wake-Word.
+ *                Das Mikro ist von Porcupine belegt; AudioRecorder ist aus.
+ *   conversing — Wake-Word getriggert (oder Ohr-Tap ohne Wake-Word):
+ *                aktive Konversation. Porcupine pausiert (gibt Mikro frei),
  *                AudioRecorder uebernimmt fuer die Aufnahme.
  *                Nach jeder ARIA-Antwort oeffnet das Mikro fuer X Sekunden
  *                (Conversation-Window). Stille im Fenster → zurueck zu armed.
  *
- * Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
- * 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
+ * Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
+ * direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
+ * geht dann nach 'off' statt 'armed'.
  */
 
-import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { acquireBackgroundAudio } from './backgroundAudio';
 
 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;
 
 export type WakeWordState = 'off' | 'armed' | 'conversing';
 
+export const WAKE_ACCESS_KEY_STORAGE = 'aria_wake_access_key';
 export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';
 
-/** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
- *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
- *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
- *  werden — Diagnostic-Upload ist Phase 2. */
-export const WAKE_KEYWORDS = [
-  'hey_jarvis',
+/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
+ *  Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
+ *  Console — wird spaeter ueber Diagnostic uploadbar. */
+export const BUILTIN_KEYWORDS = [
+  'jarvis',
   'computer',
+  'picovoice',
+  'porcupine',
+  'bumblebee',
+  'terminator',
   'alexa',
-  'hey_mycroft',
-  'hey_rhasspy',
+  'hey google',
+  'ok google',
+  'hey siri',
 ] as const;
-export type WakeKeyword = typeof WAKE_KEYWORDS[number];
-export const DEFAULT_KEYWORD: WakeKeyword = 'hey_jarvis';
-
-/** Hilfs-Mapping fuer die Anzeige im UI. */
-export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
-  hey_jarvis: 'Hey Jarvis',
-  computer: 'Computer',
-  alexa: 'Alexa',
-  hey_mycroft: 'Hey Mycroft',
-  hey_rhasspy: 'Hey Rhasspy',
-};
-
-// Detection-Tuning — kann in Settings spaeter konfigurierbar werden.
-const DEFAULT_THRESHOLD = 0.5;
-const DEFAULT_PATIENCE = 2;
-const DEFAULT_DEBOUNCE_MS = 1500;
-
-interface OpenWakeWordModule {
-  init(modelName: string, threshold: number, patience: number, debounceMs: number): Promise<boolean>;
-  start(): Promise<boolean>;
-  stop(): Promise<boolean>;
-  dispose(): Promise<boolean>;
-  isAvailable(): Promise<boolean>;
-}
-
-const { OpenWakeWord } = NativeModules as { OpenWakeWord?: OpenWakeWordModule };
+export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
+export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
 
 class WakeWordService {
   private state: WakeWordState = 'off';
   private wakeCallbacks: WakeWordCallback[] = [];
   private stateCallbacks: StateCallback[] = [];
-  /** 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;
+  // Picovoice Manager (lazy, da Native Module nicht in jedem Build verfuegbar ist)
+  private porcupine: any = null;
+  private accessKey: string = '';
+  private keyword: string = DEFAULT_KEYWORD;
   private initInProgress: Promise<boolean> | null = null;
-  private eventSub: { remove: () => void } | null = null;
 
-  /** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
+  /** Beim App-Start aufrufen — laedt Settings, baut Porcupine wenn Key da ist. */
   async loadFromStorage(): Promise<void> {
     try {
+      const k = await AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE);
       const w = await AsyncStorage.getItem(WAKE_KEYWORD_STORAGE);
-      const wt = (w || DEFAULT_KEYWORD).trim() as WakeKeyword;
-      this.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
-      await this.initNative();
+      this.accessKey = (k || '').trim();
+      this.keyword = (w || DEFAULT_KEYWORD).trim();
+      if (this.accessKey) {
+        // Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
+        await this.initPorcupine();
+      }
     } catch (err) {
       console.warn('[WakeWord] loadFromStorage', err);
     }
   }
 
-  /** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
-  async configure(keyword: string): Promise<boolean> {
-    const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
-      ? (keyword as WakeKeyword)
-      : DEFAULT_KEYWORD;
-    this.keyword = next;
-    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, next);
+  /** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
+  async configure(accessKey: string, keyword: string): Promise<boolean> {
+    this.accessKey = (accessKey || '').trim();
+    this.keyword = (keyword || DEFAULT_KEYWORD).trim();
+    await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
+    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);
 
-    // Laufende Instanz stoppen + neu initialisieren
-    await this.disposeNative();
-    const ok = await this.initNative();
-    if (!ok) {
-      ToastAndroid.show(
-        `Wake-Word "${KEYWORD_LABELS[next]}" konnte nicht initialisiert werden — Logs pruefen`,
-        ToastAndroid.LONG,
-      );
-    }
-    return ok;
+    // Laufende Instanz stoppen
+    await this.disposePorcupine();
+    if (!this.accessKey) return false;
+
+    // Neu initialisieren
+    return this.initPorcupine();
   }
 
-  private async initNative(): Promise<boolean> {
-    if (!OpenWakeWord) {
-      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
-      this.nativeReady = false;
-      return false;
-    }
+  private async initPorcupine(): Promise<boolean> {
     if (this.initInProgress) return this.initInProgress;
     this.initInProgress = (async () => {
       try {
-        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
-        // Subscribe nur einmal
-        if (!this.eventSub) {
-          const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
-          this.eventSub = emitter.addListener('WakeWordDetected', () => {
-            console.log('[WakeWord] Native Detection-Event empfangen');
-            this.onWakeDetected().catch(err =>
-              console.warn('[WakeWord] onWakeDetected crashed:', err));
-          });
-        }
-        this.nativeReady = true;
-        console.log('[WakeWord] Init OK (model=%s)', this.keyword);
+        const { PorcupineManager } = require('@picovoice/porcupine-react-native');
+        // Built-In Keyword-Identifier sind lower-case strings im SDK
+        this.porcupine = await PorcupineManager.fromBuiltInKeywords(
+          this.accessKey,
+          [this.keyword],
+          (_keywordIndex: number) => this.onWakeDetected(),
+        );
+        console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
         return true;
-      } catch (err: any) {
-        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
-        this.nativeReady = false;
+      } catch (err) {
+        console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err);
+        this.porcupine = null;
         return false;
       } finally {
         this.initInProgress = null;
@@ -157,43 +110,30 @@ class WakeWordService {
     return this.initInProgress;
   }
 
-  private async disposeNative(): Promise<void> {
-    if (!OpenWakeWord) return;
-    try { await OpenWakeWord.dispose(); } catch {}
-    this.nativeReady = false;
+  private async disposePorcupine() {
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
+      try { await this.porcupine.delete(); } catch {}
+      this.porcupine = null;
+    }
   }
 
   /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
   async start(): Promise<boolean> {
     if (this.state !== 'off') return true;
-    // 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) {
+    if (this.porcupine) {
+      // Passives Lauschen via Porcupine
       try {
-        await OpenWakeWord.start();
-        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
-        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        await this.porcupine.start();
+        console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
         this.setState('armed');
         return true;
-      } catch (err: any) {
-        console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
-                     err?.message || err);
-        ToastAndroid.show(
-          `Wake-Word-Start failed: ${err?.message || err}`,
-          ToastAndroid.LONG,
-        );
+      } catch (err) {
+        console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:', err);
       }
-    } else {
-      console.warn('[WakeWord] Native-Modul nicht bereit — Direkt-Aufnahme-Fallback');
-      ToastAndroid.show(
-        'Wake-Word nicht aktiv — direkte Aufnahme startet (Mikro hoert mit)',
-        ToastAndroid.LONG,
-      );
     }
-    // Fallback: direkt in Konversation
-    console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
+    // Fallback: direkt in die Konversation
+    console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
     this.setState('conversing');
     setTimeout(() => {
       if (this.state === 'conversing') {
@@ -206,46 +146,20 @@ class WakeWordService {
   /** Komplett ausschalten (Ohr abschalten) */
   async stop(): Promise<void> {
     console.log('[WakeWord] Ohr deaktiviert');
-    if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
     }
-    this.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. */
+  /** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
   private async onWakeDetected(): Promise<void> {
-    const now = Date.now();
-    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;
+    console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
     }
     this.setState('conversing');
+    // kurz warten damit Mikrofon frei ist
     setTimeout(() => {
       if (this.state === 'conversing') {
         this.wakeCallbacks.forEach(cb => cb());
@@ -253,83 +167,16 @@ 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).
+   *  Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
    *  Ohne: zurueck zu 'off'.
    */
   async endConversation(): Promise<void> {
     if (this.state !== 'conversing') return;
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine && this.accessKey) {
       try {
-        await OpenWakeWord.start();
+        await this.porcupine.start();
         console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
-        ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return;
       } catch (err) {
@@ -337,7 +184,6 @@ class WakeWordService {
       }
     }
     console.log('[WakeWord] Konversation zu Ende — Ohr aus');
-    ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
     this.setState('off');
   }
 
@@ -362,10 +208,10 @@ class WakeWordService {
   }
 
   hasWakeWord(): boolean {
-    return this.nativeReady;
+    return !!this.porcupine;
   }
 
-  getKeyword(): WakeKeyword {
+  getKeyword(): string {
     return this.keyword;
   }
 
@@ -378,19 +224,6 @@ 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

@@ -52,61 +52,15 @@ Fuer Web-Anfragen: **WebFetch** oder **Bash mit curl**. Niemals sagen "ich habe
 4. **Regelmaessig committen** — mit sinnvollen Commit-Messages.
 5. **Tageslog fuehren** — was wurde getan, was ist offen.
 
-## Dateien an Stefan zurueckgeben — KRITISCH
-
-**Das ist die EINZIGE Methode wie Stefan an Dateien rankommt. Ohne
-diese Schritte sieht und bekommt er die Datei NICHT.**
-
-### Regel 1 — Speicher-Ort
-
-Dateien fuer Stefan AUSSCHLIESSLICH unter `/shared/uploads/` speichern.
-
-NIEMALS in:
-- `/home/node/.openclaw/workspace/...` (das ist NUR dein Arbeitsverzeichnis,
-  Stefan hat keinen Zugriff darauf)
-- `/tmp/...`, `/root/...`, oder sonst irgendwo
-
-Dateinamen mit `aria_`-Prefix damit Cleanup-Scripts sie zuordnen koennen:
-
-```
-/shared/uploads/aria_<beschreibender_name>.<ext>
-```
-
-Beispiele: `aria_termin_zusage.pdf`, `aria_einkaufsliste.md`,
-`aria_logs_2026-05-10.zip`.
-
-### Regel 2 — Marker im Antworttext
-
-Am Ende deiner Antwort EINMALIG den Marker setzen:
-
-```
-[FILE: /shared/uploads/aria_<name>.<ext>]
-```
-
-OHNE diesen Marker erscheint die Datei NICHT in der App / Diagnostic.
-
-Mehrere Dateien: mehrere `[FILE: ...]`-Marker am Ende, jeder in
-eigener Zeile.
-
-### Beispiel — kompletter Workflow
-
-User: "Schreib mir ein Lasagne-Rezept als md-Datei"
-
-1. Du schreibst die Datei: `Write` Tool mit Pfad `/shared/uploads/aria_lasagne.md`
-2. Antwort an Stefan:
-
-```
-Hier dein Lasagne-Rezept — Ragu am Vortag, echter Parmesan,
-Ruhezeit nicht skippen. Beim Schichten Bechamel auf jede Lage.
-
-[FILE: /shared/uploads/aria_lasagne.md]
-```
-
-Der Marker wird automatisch aus dem sichtbaren Text entfernt und
-als Anhang-Bubble angezeigt. Stefan tippt drauf → oeffnet die Datei.
-
 ## Stimme
 
-TTS laeuft ueber F5-TTS (Voice Cloning, Gaming-PC). Stefan kann eigene
-Stimmen aus Audio-Samples klonen (Diagnostic → Stimmen → Stimme klonen)
-und in App + Diagnostic auswaehlen.
+| Stimme | Modell | Wann |
+|--------|--------|------|
+| **Ramona** (weiblich) | `de_DE-ramona-low` | Alltag, Antworten, Gespraeche (Standard) |
+| **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

@@ -78,93 +78,12 @@ Wenn ein Tool nicht klappt, probiere die Alternative. Niemals sagen "ich habe ke
 - Destruktive Operationen (Dateien loeschen, Datenbanken droppen)
 - Push auf main
 
-## Dateien an Stefan zurueckgeben — KRITISCH
-
-**Das ist die EINZIGE Methode wie Stefan an Dateien rankommt. Ohne diese
-Schritte sieht und bekommt er die Datei NICHT.**
-
-### Regel 1 — Speicher-Ort
-
-Dateien fuer Stefan AUSSCHLIESSLICH unter `/shared/uploads/` speichern.
-
-NIEMALS in:
-- `/home/node/.openclaw/workspace/...` (NUR dein Arbeitsverzeichnis,
-  Stefan hat keinen Zugriff)
-- `/tmp/...`, `/root/...`, oder sonst irgendwo
-
-Dateinamen mit `aria_`-Prefix:
-
-```
-/shared/uploads/aria_<beschreibender_name>.<ext>
-```
-
-Beispiele: `aria_termin_zusage.pdf`, `aria_einkaufsliste.md`,
-`aria_logs_2026-05-10.zip`.
-
-### Regel 2 — Marker im Antworttext
-
-Am Ende deiner Antwort EINMALIG den Marker setzen:
-
-```
-[FILE: /shared/uploads/aria_<name>.<ext>]
-```
-
-OHNE diesen Marker erscheint die Datei NICHT in der App / Diagnostic.
-
-Mehrere Dateien: mehrere `[FILE: ...]`-Marker am Ende, jeder in
-eigener Zeile.
-
-### Beispiel — kompletter Workflow
-
-User: "Schreib mir ein Lasagne-Rezept als md-Datei"
-
-1. Du schreibst: `Write` Tool mit Pfad `/shared/uploads/aria_lasagne.md`
-2. Antwort an Stefan:
-
-```
-Hier dein Lasagne-Rezept — Ragu am Vortag, echter Parmesan,
-Ruhezeit nicht skippen. Beim Schichten Bechamel auf jede Lage.
-
-[FILE: /shared/uploads/aria_lasagne.md]
-```
-
-Der Marker wird automatisch aus dem sichtbaren Text entfernt und
-als Anhang-Bubble angezeigt. Stefan tippt drauf → oeffnet die Datei
-im jeweiligen Standard-Programm.
-
-### Externe Bilder/Dateien — IMMER runterladen, nicht nur verlinken
-
-Wenn Stefan ein Bild oder eine Datei aus dem Netz haben will (Wikipedia,
-Wiki Commons, ein Beispiel-PDF, etc.):
-
-NICHT NUR die URL in die Antwort schreiben — das Bild ist dann nur
-solange sichtbar wie der externe Server lebt.
-
-STATTDESSEN:
-1. Mit `Bash` + curl/wget herunterladen nach `/shared/uploads/aria_<name>.<ext>`
-2. Mit `[FILE: ...]`-Marker als Anhang ausspielen
-
-Beispiel — User: "Zeig mir ein Bild von Micky Maus"
-
-```bash
-curl -sL "https://upload.wikimedia.org/wikipedia/commons/7/7f/Mickey_Mouse.svg" \
-     -o /shared/uploads/aria_mickey_mouse.svg
-```
-
-Antwort:
-```
-Hier Micky Maus — offizielles SVG von Wikimedia Commons (Public Domain).
-
-[FILE: /shared/uploads/aria_mickey_mouse.svg]
-```
-
-So bleibt das Bild permanent im Chat-Verlauf, auch wenn die Wiki-URL
-spaeter offline geht oder umgezogen wird.
-
 ## Stimme
 
-TTS laeuft ueber F5-TTS auf der Gamebox (Voice Cloning). Stefan kann
-eigene Stimmen aus Audio-Samples klonen und in App/Diagnostic auswaehlen.
+| Stimme | Modell | Wann |
+|--------|--------|------|
+| **Ramona** (weiblich) | `de_DE-ramona-low` | Alltag, Antworten, Gespraeche (Standard) |
+| **Thorsten** (maennlich, tief) | `de_DE-thorsten-high` | Epische Momente, Alarme, besondere Ereignisse |
 
 ## Gedaechtnis (Memory)
 
@@ -228,4 +147,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 (orchestriert STT/TTS via Gamebox-Bridges) — teilt Netzwerk mit aria-core
+- **Bridge:** Voice Bridge (Whisper STT + Piper TTS) — teilt Netzwerk mit aria-core

aria-data/config/USER.md

@@ -1,10 +1,10 @@
-# <Username> — Benutzer-Praeferenzen
+# Stefan — Benutzer-Praeferenzen
 
 ## Allgemein
 
-- **Sprache:** <z.B. Deutsch>
-- **Kommunikation:** <z.B. Direkt, kein Bullshit, Humor willkommen>
-- **Rolle:** <z.B. Chef, Auftraggeber, Entwickler bei XYZ>
+- **Sprache:** Deutsch
+- **Kommunikation:** Direkt, kein Bullshit, Humor willkommen
+- **Rolle:** Chef, Auftraggeber, Entwickler bei HackerSoft Oldenburg
 
 ## Bestaetigung erforderlich fuer
 
@@ -12,6 +12,7 @@
 - Push auf main
 - Aenderungen an Kundensystemen
 - Server-Befehle die nicht rueckgaengig gemacht werden koennen
+- Windows neu installieren (erst Daten sichern!)
 
 ## Autonomes Arbeiten OK fuer
 
@@ -27,10 +28,8 @@
 
 | Tool | Zweck |
 |------|-------|
-| **<Beispiel-Tool>** | <Zweck> |
-
-<!--
-  Diese Datei ist eine Vorlage. Lokal als USER.md kopieren und mit
-  eigenen Praeferenzen + Tool-Stack fuellen. USER.md selbst ist via
-  .gitignore vom Repo ausgeschlossen.
--->
+| **Proxmox** | VM-Infrastruktur (ARIAs Zuhause) |
+| **Gitea** | Code-Hosting (gitea.hackersoft.de) |
+| **OpenCRM** | Kundenverwaltung |
+| **STARFACE** | Telefonie |
+| **RustDesk** | Remote IT-Support bei Kunden |

bridge/aria_bridge.py

@@ -1,13 +1,17 @@
 """
 ARIA Voice Bridge — Hauptmodul.
 
-Verbindet die Android App (via RVS) mit ARIA-Core. Spracheingabe laeuft
-ueber die whisper-bridge (Gamebox, faster-whisper auf CUDA), Sprachausgabe
-ueber die f5tts-bridge (Voice Cloning, satzweises PCM-Streaming).
+Verbindet die Android App (via RVS) mit ARIA-Core und bietet
+lokale Spracheingabe (Wake-Word + Whisper STT) und Sprachausgabe (Piper TTS).
 
 Nachrichtenfluss:
   App  → RVS → Bridge → aria-core
-  aria-core → Bridge → f5tts-bridge → PCM → RVS → App
+  aria-core → Bridge → RVS → App
+                     → Lautsprecher (TTS)
+
+Stimmen:
+  - Ramona (de_DE-ramona-low)  — Alltag, Gespraeche
+  - Thorsten (de_DE-thorsten-high) — epische Momente, Alarme
 """
 
 from __future__ import annotations
@@ -16,9 +20,7 @@ import asyncio
 import base64
 import json
 import logging
-import mimetypes
 import os
-import re
 import signal
 import ssl
 import sys
@@ -491,7 +493,7 @@ class ARIABridge:
         self.current_mode = self._load_persisted_mode()
         self.running = False
 
-        # Komponenten (TTS: F5-TTS remote auf der Gamebox, lokales TTS wurde entfernt)
+        # Komponenten (TTS: immer XTTS remote, Piper wurde entfernt)
         self.tts_enabled = True
         self.xtts_voice = ""
         self._f5tts_config: dict = {}
@@ -539,31 +541,9 @@ class ARIABridge:
         # Wird fuer die direkt folgende ARIA-Antwort genutzt und dann zurueckgesetzt.
         # So kann jedes Geraet seine bevorzugte Stimme bekommen (pro Request).
         self._next_voice_override: Optional[str] = None
-        # Gleiche Logik fuer die Wiedergabegeschwindigkeit (F5-TTS speed-Param,
-        # App-Setting aria_tts_speed, 1.0 = normal).
-        self._next_speed_override: Optional[float] = None
         # STT-Requests die aktuell auf Antwort von der whisper-bridge (Gamebox) warten.
         # requestId → Future mit dem Text (oder None bei Fehler).
         self._pending_stt: dict[str, asyncio.Future] = {}
-        # whisper-bridge service_status: True wenn ready, False/None wenn loading/unbekannt.
-        # Beeinflusst das Timeout fuer stt_request — bei "loading" warten wir laenger,
-        # weil das Modell beim ersten Request noch ~1-2 Min runtergeladen werden kann.
-        self._remote_stt_ready: bool = False
-        # User-Message-Counter fuer Auto-Compact. Bei zu langer Konversation
-        # sprengt die argv-Liste beim Claude-Subprocess-Spawn (E2BIG). Bei
-        # COMPACT_AFTER erreicht → Sessions reset + Container restart.
-        # Counter ueberlebt Bridge-Restart nicht (frischer Zaehler beim Start ok).
-        self._user_message_count: int = 0
-        self._compact_after = int(os.getenv("COMPACT_AFTER_MESSAGES", "140"))
-        # Pending Files: wenn die App ein Bild + Text gleichzeitig schickt, kommen
-        # zwei separate RVS-Events ('file' und 'chat') — wir buffern die Files
-        # kurz und mergen sie mit dem nachfolgenden Chat-Text zu einer einzigen
-        # Anfrage an aria-core. Sonst antwortet ARIA zweimal (einmal "warte auf
-        # Anweisung" beim file, einmal auf den Chat-Text).
-        # Liste von Tuples: (file_path, name, file_type, size_kb, width, height)
-        self._pending_files: list[tuple[str, str, str, int, int, int]] = []
-        self._pending_files_flush_task: Optional[asyncio.Task] = None
-        self._PENDING_FILES_WINDOW_SEC: float = 0.8
 
     def initialize(self) -> None:
         """Initialisiert alle Komponenten.
@@ -685,10 +665,7 @@ class ARIABridge:
         while self.running:
             try:
                 logger.info("[core] Verbinde: %s", self.ws_url)
-                # max_size=50MB damit grosse Bilder/Voice-Uploads durchgehen.
-                # Python-websockets Default ist nur 1 MiB → 5MB JPEG sprengt
-                # das Limit, Connection wird silent gedroppt.
-                async with websockets.connect(self.ws_url, max_size=50 * 1024 * 1024) as ws:
+                async with websockets.connect(self.ws_url) as ws:
                     # OpenClaw Handshake durchfuehren
                     if not await self._openclaw_handshake(ws):
                         logger.error("[core] Handshake fehlgeschlagen — Reconnect")
@@ -794,29 +771,13 @@ class ARIABridge:
                 await self._emit_activity("idle", "")
                 if not text:
                     logger.warning("[core] chat final ohne Text: %s", json.dumps(payload)[:200])
-                    # App+Diagnostic informieren statt stumm — sonst wartet die
-                    # UI ewig auf eine Antwort die nicht kommt. Passiert z.B.
-                    # wenn Claude-Vision das Bild ablehnt (leere Antwort)
-                    # oder die Antwort nur aus Tool-Calls ohne Final-Text bestand.
-                    await self._send_to_rvs({
-                        "type": "chat",
-                        "payload": {
-                            "text": "[Hinweis] Antwort ohne Text — moeglicherweise Bild zu gross fuer Vision-API oder reine Tool-Ausfuehrung.",
-                            "sender": "aria",
-                        },
-                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                    })
                     return
                 logger.info("[core] Antwort: '%s'", text[:80])
                 await self._process_core_response(text, payload)
                 return
 
             if state == "error":
-                # OpenClaw nutzt errorMessage statt error bei state=error.
-                error = (payload.get("error")
-                         or payload.get("errorMessage")
-                         or payload.get("message")
-                         or "Unbekannt")
+                error = payload.get("error", "Unbekannt")
                 logger.error("[core] Chat-Fehler: %s", error)
                 self._last_chat_final_at = asyncio.get_event_loop().time()
                 await self._emit_activity("idle", "")
@@ -852,12 +813,7 @@ class ARIABridge:
             return
 
         if event_name == "chat:error":
-            # OpenClaw legt den echten Text manchmal in errorMessage ab
-            # (state=error). Vorher wurde nur error/message gechecked → "Unbekannt".
-            error = (payload.get("error")
-                     or payload.get("errorMessage")
-                     or payload.get("message")
-                     or "Unbekannt")
+            error = payload.get("error", payload.get("message", "Unbekannt"))
             logger.error("[core] Chat-Fehler (legacy): %s", error)
             await self._send_to_rvs({
                 "type": "chat",
@@ -890,48 +846,6 @@ class ARIABridge:
             pass
         return payload.get("text", "")
 
-    # File-Marker-Pattern: `[FILE: /pfad/zur/datei.ext]` (Pfad kann Spaces
-    # enthalten, Endung beliebig). Mehrfach im Text moeglich.
-    _FILE_MARKER_RE = re.compile(r"\[FILE:\s*(/shared/uploads/[^\]]+?)\s*\]", re.IGNORECASE)
-
-    def _extract_file_markers(self, text: str) -> tuple[str, list[dict]]:
-        """Sucht [FILE: /shared/uploads/...]-Marker, gibt (cleaned_text, file_list) zurueck."""
-        files: list[dict] = []
-        for m in self._FILE_MARKER_RE.finditer(text):
-            path = m.group(1).strip()
-            if not path.startswith("/shared/uploads/"):
-                logger.warning("[core] FILE-Marker mit unerlaubtem Pfad ignoriert: %s", path)
-                continue
-            if not os.path.isfile(path):
-                logger.warning("[core] FILE-Marker zeigt auf nicht existente Datei: %s", path)
-                continue
-            name = os.path.basename(path)
-            mime, _ = mimetypes.guess_type(path)
-            size = os.path.getsize(path)
-            files.append({
-                "serverPath": path,
-                "name": name,
-                "mimeType": mime or "application/octet-stream",
-                "size": size,
-            })
-        cleaned = self._FILE_MARKER_RE.sub("", text).strip()
-        # Zwei aufeinanderfolgende Leerzeilen → eine
-        cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
-        return cleaned, files
-
-    async def _broadcast_aria_file(self, file_info: dict) -> None:
-        """ARIA hat eine Datei fuer den User erstellt — App+Diagnostic informieren."""
-        logger.info("[rvs] ARIA-Datei rausgeben: %s (%s, %dKB)",
-                    file_info["name"], file_info["mimeType"], file_info["size"] // 1024)
-        try:
-            await self._send_to_rvs({
-                "type": "file_from_aria",
-                "payload": file_info,
-                "timestamp": int(asyncio.get_event_loop().time() * 1000),
-            })
-        except Exception as e:
-            logger.warning("[rvs] file_from_aria broadcast fehlgeschlagen: %s", e)
-
     async def _process_core_response(self, text: str, payload: dict) -> None:
         """Verarbeitet eine fertige Antwort von aria-core.
 
@@ -946,14 +860,6 @@ class ARIABridge:
             logger.info("[core] NO_REPLY empfangen — Antwort still verworfen")
             return
 
-        # File-Marker `[FILE: /shared/uploads/aria_xyz.pdf]` extrahieren —
-        # ARIA legt damit Dateien fuer den User bereit (Bilder, PDFs, etc.).
-        # Der Marker wird aus dem Antworttext entfernt (TTS soll ihn nicht
-        # vorlesen) und parallel als file_from_aria-Event geschickt.
-        text, aria_files = self._extract_file_markers(text)
-        for f in aria_files:
-            await self._broadcast_aria_file(f)
-
         metadata = payload.get("metadata", {})
         is_critical = metadata.get("critical", False)
         requested_voice = metadata.get("voice")
@@ -994,13 +900,12 @@ class ARIABridge:
             logger.info("[core] TTS unterdrueckt (Modus: %s)", self.current_mode.config.name)
             return
 
-        # Voice bestimmen: App-Override (gesetzt durch letzten chat-Event) > globale
-        # Default-Voice. Der Override wird NICHT pro Antwort verbraucht — sonst nutzt
-        # eine Multi-Turn-Antwort von ARIA (Tool-Use + finale Antwort) ab dem zweiten
-        # TTS-Call wieder die alte Default-Stimme. Der Override bleibt gueltig bis
-        # zum naechsten chat-Event, wo er entweder ueberschrieben oder geloescht wird.
+        # Voice bestimmen: App-Override fuer diesen Request > globale Default-Voice
         xtts_voice = self._next_voice_override or getattr(self, 'xtts_voice', '')
-        xtts_speed = self._next_speed_override or 1.0
+        # Override verbrauchen (gilt nur fuer genau diese naechste Antwort)
+        if self._next_voice_override:
+            logger.info("[core] Nutze Voice-Override: %s", self._next_voice_override)
+            self._next_voice_override = None
 
         tts_text = tts_text_preview or text
         if not tts_text:
@@ -1017,15 +922,13 @@ class ARIABridge:
                 "payload": {
                     "text": tts_text,
                     "voice": xtts_voice,
-                    "speed": xtts_speed,
                     "language": "de",
                     "requestId": xtts_request_id,
                     "messageId": message_id,
                 },
                 "timestamp": int(asyncio.get_event_loop().time() * 1000),
             })
-            logger.info("[core] XTTS-Request gesendet (voice=%s, speed=%.2fx): '%s'",
-                        xtts_voice or "default", xtts_speed, tts_text[:60])
+            logger.info("[core] XTTS-Request gesendet (%s): '%s'", xtts_voice or "default", tts_text[:60])
         except Exception as e:
             logger.error("[core] XTTS-Request fehlgeschlagen: %s — kein Audio", e)
 
@@ -1106,123 +1009,12 @@ 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."""
-        parts: list[str] = []
-        for fp, name, ftype, kb, w, h in self._pending_files:
-            dim = f" {w}x{h}px" if (w and h) else ""
-            kind = "Bild" if ftype.startswith("image/") else "Datei"
-            parts.append(f"- {kind}: {name}{dim} ({ftype}, {kb}KB) liegt unter {fp}")
-        files_summary = "\n".join(parts)
-        n = len(self._pending_files)
-        anhang = "Anhang" if n == 1 else "Anhaenge"
-        if user_text:
-            return (f"Stefan hat dir {n} {anhang} geschickt:\n{files_summary}\n\n"
-                    f"Er sagt dazu: \"{user_text}\"")
-        return (f"Stefan hat dir {n} {anhang} geschickt:\n{files_summary}\n\n"
-                f"Warte auf seine Anweisung was du damit tun sollst.")
-
-    async def _flush_pending_files_after(self, delay: float) -> None:
-        """Wenn nach `delay`s kein chat-Text gekommen ist: Files alleine an
-        aria-core senden ('warte auf Anweisung'-Variante)."""
-        try:
-            await asyncio.sleep(delay)
-        except asyncio.CancelledError:
-            return
-        if not self._pending_files:
-            return
-        text = self._build_pending_files_message("")
-        self._pending_files = []
-        self._pending_files_flush_task = None
-        await self.send_to_core(text, source="app-file")
-
-    async def _flush_pending_files_with_text(self, user_text: str) -> bool:
-        """Wenn ein chat-Text reinkommt waehrend Files gepuffert sind:
-        Files + Text zu einer einzigen aria-core-Nachricht mergen.
-        Returns True wenn gemerged wurde (Caller soll dann nicht nochmal senden)."""
-        if not self._pending_files:
-            return False
-        if self._pending_files_flush_task and not self._pending_files_flush_task.done():
-            self._pending_files_flush_task.cancel()
-        self._pending_files_flush_task = None
-        text = self._build_pending_files_message(user_text)
-        self._pending_files = []
-        await self.send_to_core(text, source="app-file+chat")
-        return True
-
-    async def _trigger_session_reset(self) -> None:
-        """Sessions loeschen + Container restart via Diagnostic HTTP-API."""
-        try:
-            req = urllib.request.Request(
-                "http://localhost:3001/api/aria-session-reset",
-                data=b"{}",
-                method="POST",
-                headers={"Content-Type": "application/json"},
-            )
-            def _do_reset():
-                try:
-                    with urllib.request.urlopen(req, timeout=45) as resp:
-                        return resp.status
-                except Exception as e:
-                    return f"err:{e}"
-            result = await asyncio.get_event_loop().run_in_executor(None, _do_reset)
-            logger.info("[core] Session-Reset Result: %s", result)
-        except Exception as e:
-            logger.warning("[core] Session-Reset Trigger fehlgeschlagen: %s", e)
-
     async def send_to_core(self, text: str, source: str = "bridge") -> None:
         """Sendet Text an aria-core (OpenClaw chat.send Protokoll)."""
         if self.ws_core is None:
             logger.error("[core] Nicht verbunden — Nachricht verworfen: '%s'", text[:60])
             return
 
-        # Auto-Compact: bei zu vielen User-Messages laeuft argv beim Subprocess-
-        # Spawn ueber (E2BIG). Vor send pruefen, ggf. Sessions resetten.
-        if source.startswith("app") and self._compact_after > 0:
-            self._user_message_count += 1
-            if self._user_message_count >= self._compact_after:
-                logger.warning("[core] Auto-Compact: %d Messages erreicht — Session-Reset",
-                               self._user_message_count)
-                self._user_message_count = 0
-                # Reset triggern via Diagnostic (asynchron, blockiert send nicht)
-                asyncio.create_task(self._trigger_session_reset())
-                # User informieren — der naechste Request kommt erst nach Restart durch
-                await self._send_to_rvs({
-                    "type": "chat",
-                    "payload": {
-                        "text": f"[Compact] Konversation war lang ({self._compact_after} Nachrichten) — Session wurde geleert, ARIA startet frisch. Deine letzte Nachricht bitte gleich nochmal senden.",
-                        "sender": "aria",
-                    },
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                })
-                return
-
         # Aktive Session vom Diagnostic holen
         self._fetch_active_session()
 
@@ -1264,8 +1056,7 @@ class ARIABridge:
             try:
                 url = f"{current_url}?token={self.rvs_token}"
                 logger.info("[rvs] Verbinde: %s", current_url)
-                # max_size=50MB (siehe core-Connect oben — gleicher Grund).
-                async with websockets.connect(url, max_size=50 * 1024 * 1024) as ws:
+                async with websockets.connect(url) as ws:
                     self.ws_rvs = ws
                     retry_delay = 2
                     logger.info("[rvs] Verbunden — warte auf App-Nachrichten")
@@ -1363,38 +1154,14 @@ class ARIABridge:
             if sender in ("aria", "stt"):
                 return
             text = payload.get("text", "")
-            # Voice-Override fuer Folgenachrichten setzen — gilt bis zum naechsten
-            # chat-Event. Leerer String "" = explizit Default-Voice (override loeschen).
-            # Field nicht gesendet = vorherigen Override unveraendert lassen (z.B. wenn
-            # cancel_request oder anderer Service die App umgeht).
-            if "voice" in payload:
-                voice_override = payload.get("voice", "") or ""
-                self._next_voice_override = voice_override or None
-                logger.info("[rvs] Voice fuer Antworten: %s",
-                            self._next_voice_override or "(Default)")
-            # Speed-Override (TTS-Wiedergabegeschwindigkeit, pro Geraet)
-            if "speed" in payload:
-                try:
-                    speed = float(payload.get("speed", 0) or 0)
-                    self._next_speed_override = speed if 0.1 <= speed <= 5.0 else None
-                except (TypeError, ValueError):
-                    self._next_speed_override = None
+            # Voice-Override fuer die naechste ARIA-Antwort merken
+            voice_override = payload.get("voice", "")
+            if voice_override:
+                self._next_voice_override = voice_override
+                logger.info("[rvs] Voice-Override fuer naechste Antwort: %s", voice_override)
             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.
-                merged = await self._flush_pending_files_with_text(text)
-                if merged:
-                    logger.info("[rvs] App-Chat (mit Anhaengen): '%s'", text[:80])
-                else:
-                    core_text = self._build_core_text(text, interrupted, location)
-                    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 ""))
+                logger.info("[rvs] App-Chat: '%s'", text[:80])
+                await self.send_to_core(text, source="app")
             return
 
         if msg_type == "cancel_request":
@@ -1444,14 +1211,8 @@ class ARIABridge:
             if not text:
                 return
             tts_text = clean_text_for_tts(text) or text
-            # Voice + Speed aus App-Payload gewinnen, sonst global/default
+            # Voice aus App-Payload gewinnt, sonst global
             xtts_voice = payload.get("voice", "") or getattr(self, 'xtts_voice', '')
-            try:
-                xtts_speed = float(payload.get("speed", 0) or 0)
-                if not (0.1 <= xtts_speed <= 5.0):
-                    xtts_speed = 1.0
-            except (TypeError, ValueError):
-                xtts_speed = 1.0
             try:
                 xtts_request_id = str(uuid.uuid4())
                 if message_id:
@@ -1461,7 +1222,6 @@ class ARIABridge:
                     "payload": {
                         "text": tts_text,
                         "voice": xtts_voice,
-                        "speed": xtts_speed,
                         "language": "de",
                         "requestId": xtts_request_id,
                         "messageId": message_id,
@@ -1553,149 +1313,70 @@ class ARIABridge:
                 await self.ws_core.send(raw_message)
 
         elif msg_type == "file":
-            # Datei von der App: speichern + zu Pending-Queue hinzufuegen.
-            # Wird mit dem nachfolgenden chat-Event (innerhalb PENDING_FILES_WINDOW)
-            # zu einer einzigen aria-core-Anfrage gemerged. Sonst antwortet ARIA
-            # zweimal: einmal "warte auf Anweisung" beim file, einmal auf den Chat.
+            # Datei von der App → als Text-Nachricht an aria-core
             file_name = payload.get("name", "unbekannt")
             file_type = payload.get("type", "")
             file_b64 = payload.get("base64", "")
+            file_size = payload.get("size", 0)
             width = payload.get("width", 0)
             height = payload.get("height", 0)
             logger.info("[rvs] Datei empfangen: %s (%s, %dKB)",
                         file_name, file_type, len(file_b64) // 1365 if file_b64 else 0)
 
+            # Shared Volume: /shared/ ist in Bridge UND aria-core gemountet
             SHARED_DIR = "/shared/uploads"
             os.makedirs(SHARED_DIR, exist_ok=True)
 
-            if not file_b64:
-                text = f"Stefan hat eine Datei gesendet ({file_name}, {file_type}) aber die Daten sind leer angekommen."
-                await self.send_to_core(text, source="app-file")
-                return
-
-            if file_type.startswith("image/"):
+            if file_b64 and file_type.startswith("image/"):
+                # Bild in Shared Volume speichern
                 ext = ".jpg" if "jpeg" in file_type or "jpg" in file_type else ".png"
                 safe_name = f"img_{int(asyncio.get_event_loop().time())}_{file_name.replace('/', '_')}"
                 file_path = os.path.join(SHARED_DIR, safe_name if safe_name.endswith(ext) else safe_name + ext)
-            else:
+                with open(file_path, "wb") as f:
+                    f.write(base64.b64decode(file_b64))
+                size_kb = len(file_b64) // 1365
+                logger.info("[rvs] Bild gespeichert: %s (%dKB)", file_path, size_kb)
+                # ERST an aria-core senden (wichtigster Schritt)
+                text = (f"Stefan hat dir ein Bild geschickt: {file_name}"
+                        f"{f' ({width}x{height}px)' if width else ''}"
+                        f", {size_kb}KB."
+                        f" Das Bild liegt unter: {file_path}"
+                        f" Warte auf Stefans Anweisung was du damit tun sollst.")
+                await self.send_to_core(text, source="app-file")
+                # Dann App informieren (optional, darf nicht crashen)
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
+            elif file_b64:
+                # Andere Datei in Shared Volume speichern
                 safe_name = f"file_{int(asyncio.get_event_loop().time())}_{file_name.replace('/', '_')}"
                 file_path = os.path.join(SHARED_DIR, safe_name)
-            with open(file_path, "wb") as f:
-                f.write(base64.b64decode(file_b64))
-            size_kb = len(file_b64) // 1365
-            logger.info("[rvs] Datei gespeichert: %s (%dKB)", file_path, size_kb)
-
-            # Pixel-Bilder fuer Claude-Vision shrinken wenn > 2 MB. SVG/PDF/ZIP
-            # bleiben unangetastet (Vision laeuft eh nur auf Raster-Formaten).
-            CLAUDE_VISION_FORMATS = ("image/jpeg", "image/jpg", "image/png", "image/webp", "image/gif")
-            if file_type.lower() in CLAUDE_VISION_FORMATS:
-                file_size_bytes = os.path.getsize(file_path)
-                if file_size_bytes > 2 * 1024 * 1024:
-                    try:
-                        from PIL import Image
-                        with Image.open(file_path) as img:
-                            orig_w, orig_h = img.size
-                            # Anthropic-Empfehlung: max 1568px lange Seite. RGB-Konvertierung
-                            # falls RGBA/Palette (JPEG braucht RGB).
-                            img.thumbnail((1568, 1568), Image.Resampling.LANCZOS)
-                            if img.mode in ("RGBA", "P"):
-                                img = img.convert("RGB")
-                            img.save(file_path, "JPEG", quality=85, optimize=True)
-                        new_size_bytes = os.path.getsize(file_path)
-                        logger.info("[rvs] Bild verkleinert: %dx%d → %dx%d, %.1fMB → %.1fMB",
-                                    orig_w, orig_h, img.size[0], img.size[1],
-                                    file_size_bytes / 1024 / 1024,
-                                    new_size_bytes / 1024 / 1024)
-                    except Exception as e:
-                        logger.warning("[rvs] Bild-Resize fehlgeschlagen (%s) — Original wird genutzt: %s",
-                                       file_name, e)
-
-            # In Pending-Queue + Flush-Timer (anti-spam Buffering)
-            self._pending_files.append((file_path, file_name, file_type, size_kb, int(width or 0), int(height or 0)))
-            if self._pending_files_flush_task and not self._pending_files_flush_task.done():
-                self._pending_files_flush_task.cancel()
-            self._pending_files_flush_task = asyncio.create_task(
-                self._flush_pending_files_after(self._PENDING_FILES_WINDOW_SEC)
-            )
-
-            try:
-                await self._send_to_rvs({
-                    "type": "file_saved",
-                    "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                })
-            except Exception as e:
-                logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
-
-        elif msg_type == "aria_session_reset":
-            # Manueller Compact-Trigger: Sessions weg + Restart
-            logger.warning("[rvs] aria_session_reset Request von App")
-            self._user_message_count = 0
-            asyncio.create_task(self._trigger_session_reset())
-            return
-
-        elif msg_type == "aria_restart":
-            # App-Button "ARIA hart neu starten" → docker restart aria-core
-            # via Diagnostic (der hat den Docker-Socket gemountet).
-            logger.warning("[rvs] aria_restart Request von App — harter Container-Restart")
-            try:
-                req = urllib.request.Request(
-                    "http://localhost:3001/api/aria-restart",
-                    data=b"{}",
-                    method="POST",
-                    headers={"Content-Type": "application/json"},
-                )
-                def _do_restart():
-                    try:
-                        with urllib.request.urlopen(req, timeout=45) as resp:
-                            return resp.status, resp.read().decode("utf-8", errors="ignore")
-                    except Exception as e:
-                        return None, str(e)
-                status, body = await asyncio.get_event_loop().run_in_executor(None, _do_restart)
-                logger.info("[rvs] aria_restart Result: status=%s", status)
-                # Note: bei erfolgreichem Restart ist die RVS-Verbindung sehr
-                # wahrscheinlich kurz weg (aria-bridge ist im service:aria-Network).
-                # Die Antwort kommt evtl. nicht mehr durch — egal.
-            except Exception as e:
-                logger.warning("[rvs] aria_restart Weiterleitung fehlgeschlagen: %s", e)
-            return
-
-        elif msg_type == "doctor_fix":
-            # App-Button "ARIA reparieren" → openclaw doctor --fix anstossen.
-            # Bridge erreicht aria-core nicht via docker (kein docker-socket
-            # gemountet), aber der Diagnostic-Server hat den Socket. HTTP-Call
-            # an http://localhost:3001/api/doctor-fix.
-            logger.info("[rvs] doctor_fix Request von App — leite an Diagnostic weiter")
-            try:
-                req = urllib.request.Request(
-                    "http://localhost:3001/api/doctor-fix",
-                    data=b"{}",
-                    method="POST",
-                    headers={"Content-Type": "application/json"},
-                )
-                # Blocking call ist OK weil openclaw doctor schnell durchlaeuft.
-                # In Executor laufen lassen damit der asyncio-Loop nicht blockt.
-                def _do_fix():
-                    try:
-                        with urllib.request.urlopen(req, timeout=30) as resp:
-                            return resp.status, resp.read().decode("utf-8", errors="ignore")
-                    except Exception as e:
-                        return None, str(e)
-                status, body = await asyncio.get_event_loop().run_in_executor(None, _do_fix)
-                ok = status == 200
-                logger.info("[rvs] doctor_fix Result: status=%s ok=%s", status, ok)
-                await self._send_to_rvs({
-                    "type": "chat",
-                    "payload": {
-                        "text": "[Reparatur] ARIA wurde durchgecheckt — sollte wieder antworten." if ok
-                                else f"[Reparatur] Fehlgeschlagen: {body[:200]}",
-                        "sender": "aria",
-                    },
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                })
-            except Exception as e:
-                logger.warning("[rvs] doctor_fix Weiterleitung fehlgeschlagen: %s", e)
-            return
+                with open(file_path, "wb") as f:
+                    f.write(base64.b64decode(file_b64))
+                size_kb = len(file_b64) // 1365
+                logger.info("[rvs] Datei gespeichert: %s (%dKB)", file_path, size_kb)
+                # ERST an aria-core senden
+                text = (f"Stefan hat dir eine Datei geschickt: {file_name}"
+                        f" ({file_type}, {size_kb}KB)."
+                        f" Die Datei liegt unter: {file_path}"
+                        f" Warte auf Stefans Anweisung was du damit tun sollst.")
+                await self.send_to_core(text, source="app-file")
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
+            else:
+                text = f"Stefan hat eine Datei gesendet ({file_name}, {file_type}) aber die Daten sind leer angekommen."
+                await self.send_to_core(text, source="app-file")
 
         elif msg_type == "file_request":
             # App fordert eine Datei an (Re-Download nach Cache-Leerung)
@@ -1714,7 +1395,6 @@ class ARIABridge:
                 return
             with open(server_path, "rb") as f:
                 file_b64 = base64.b64encode(f.read()).decode("ascii")
-            mime, _ = mimetypes.guess_type(server_path)
             logger.info("[rvs] Re-Download: %s (%dKB)", server_path, len(file_b64) // 1365)
             await self._send_to_rvs({
                 "type": "file_response",
@@ -1723,7 +1403,6 @@ class ARIABridge:
                     "serverPath": server_path,
                     "base64": file_b64,
                     "name": os.path.basename(server_path),
-                    "mimeType": mime or "application/octet-stream",
                 },
                 "timestamp": int(asyncio.get_event_loop().time() * 1000),
             })
@@ -1736,28 +1415,14 @@ class ARIABridge:
             if not audio_b64:
                 logger.warning("[rvs] Audio ohne Daten empfangen")
                 return
-            # Voice-Override fuer Folgenachrichten — gleiche Semantik wie beim chat-Event.
-            if "voice" in payload:
-                voice_override = payload.get("voice", "") or ""
-                self._next_voice_override = voice_override or None
-                logger.info("[rvs] Voice fuer Antworten (via Audio): %s",
-                            self._next_voice_override or "(Default)")
-            if "speed" in payload:
-                try:
-                    speed = float(payload.get("speed", 0) or 0)
-                    self._next_speed_override = speed if 0.1 <= speed <= 5.0 else None
-                except (TypeError, ValueError):
-                    self._next_speed_override = None
-            interrupted = bool(payload.get("interrupted", False))
-            audio_request_id = payload.get("audioRequestId", "") or ""
-            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))
+            # Voice-Override fuer die kommende ARIA-Antwort (App-lokal gewaehlt)
+            voice_override = payload.get("voice", "")
+            if voice_override:
+                self._next_voice_override = voice_override
+                logger.info("[rvs] Voice-Override (via Audio): %s", voice_override)
+            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB",
+                        mime_type, duration_ms, len(audio_b64) // 1365)
+            asyncio.create_task(self._process_app_audio(audio_b64, mime_type))
 
         elif msg_type == "stt_response":
             # Antwort der whisper-bridge auf unseren stt_request
@@ -1777,59 +1442,16 @@ class ARIABridge:
                 future.set_result(text)
             return
 
-        elif msg_type == "service_status":
-            # Gamebox-Bridges (whisper / f5tts) melden ihren Lade-Status.
-            # Wir nutzen das fuer den dynamischen STT-Timeout: solange whisper
-            # im 'loading' steckt, geben wir der Bridge mehr Zeit (Modell-Download
-            # kann 1-2 Min dauern), statt nach 45s lokal zu fallbacken.
-            svc = payload.get("service", "")
-            state = payload.get("state", "")
-            if svc == "whisper":
-                was_ready = self._remote_stt_ready
-                self._remote_stt_ready = (state == "ready")
-                if self._remote_stt_ready != was_ready:
-                    logger.info("[rvs] whisper-bridge -> %s", state)
-            return
-
-        elif msg_type == "config_request":
-            # Eine andere Bridge (whisper/f5tts) bittet um die aktuelle Voice-
-            # Config — passiert wenn sie sich connected, weil sie sonst die
-            # Diagnostic-Settings nicht kennt. Wir broadcasten die persistierte
-            # Config (auch beim normalen Connect von aria-bridge selber, aber
-            # da war eventuell die andere Bridge noch nicht connected).
-            requester = payload.get("service", "?")
-            logger.info("[rvs] config_request von %s — broadcaste Voice-Config", requester)
-            asyncio.create_task(self._broadcast_persisted_config())
-            return
-
         else:
             logger.debug("[rvs] Unbekannter Typ: %s", msg_type)
 
     # STT-Orchestrierung: zuerst Remote (Gamebox), Fallback lokal.
-    # Zwei Timeouts:
-    #   ready=True   → 45s reicht selbst fuer lange Audios
-    #   ready=False  → 300s, weil das Modell evtl. noch heruntergeladen wird
-    #                  (large-v3 ~3GB, kann auf der Gamebox 1-2 Min dauern).
-    _STT_REMOTE_TIMEOUT_READY_S = 45.0
-    _STT_REMOTE_TIMEOUT_LOADING_S = 300.0
+    # Timeout grosszuegig gewaehlt, damit auch ein erstmaliger Modell-Load
+    # auf der Gamebox (bis ~30s bei large-v3) durchgeht.
+    _STT_REMOTE_TIMEOUT_S = 45.0
 
-    async def _process_app_audio(self, audio_b64: str, mime_type: str,
-                                  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."""
+    async def _process_app_audio(self, audio_b64: str, mime_type: str) -> None:
+        """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal."""
         # Erst Remote versuchen
         text = await self._stt_remote(audio_b64, mime_type)
         if text is None:
@@ -1841,34 +1463,19 @@ 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(core_text, source="app-voice" + (" [barge-in]" if interrupted else ""))
+            await self.send_to_core(text, source="app-voice")
             # STT-Text an RVS senden (fuer Anzeige in App + Diagnostic)
             # sender="stt" damit Bridge es ignoriert (kein Loop)
             try:
-                stt_payload = {
-                    "text": text,
-                    "sender": "stt",
-                }
-                if audio_request_id:
-                    stt_payload["audioRequestId"] = audio_request_id
-                # GPS aus dem Original-Audio-Payload mitgeben — Diagnostic
-                # zeigt sie sonst nicht an (App sendet location nur einmal,
-                # die im audio-Payload). Reine Anzeige-Information.
-                if location:
-                    stt_payload["location"] = location
-                ok = await self._send_to_rvs({
+                await self._send_to_rvs({
                     "type": "chat",
-                    "payload": stt_payload,
+                    "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:
@@ -1907,12 +1514,7 @@ class ARIABridge:
             if not ok:
                 logger.warning("[rvs] stt_request konnte nicht gesendet werden — skip Remote")
                 return None
-            timeout_s = (self._STT_REMOTE_TIMEOUT_READY_S
-                         if self._remote_stt_ready
-                         else self._STT_REMOTE_TIMEOUT_LOADING_S)
-            logger.info("[rvs] STT-Timeout %ds (whisper-bridge %s)",
-                        int(timeout_s), "ready" if self._remote_stt_ready else "loading")
-            return await asyncio.wait_for(future, timeout=timeout_s)
+            return await asyncio.wait_for(future, timeout=self._STT_REMOTE_TIMEOUT_S)
         except asyncio.TimeoutError:
             logger.warning("[rvs] Remote-STT Timeout (%.0fs)", self._STT_REMOTE_TIMEOUT_S)
             return None

bridge/requirements.txt

@@ -16,6 +16,3 @@ sounddevice
 
 # Wake-Word Erkennung
 openwakeword
-
-# Bild-Resizing (zu grosse Pixel-Bilder shrinken bevor Claude-Vision sie sieht — 5MB-Limit)
-Pillow

diagnostic/index.html

@@ -63,35 +63,24 @@
     .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: 12px; margin-bottom: 8px; display: flex; flex-direction: column; gap: 8px; }
-    .chat-msg { padding: 10px 14px; border-radius: 14px; font-size: 14px; line-height: 1.5;
-                word-wrap: break-word; max-width: 80%; white-space: pre-wrap;
-                box-shadow: 0 1px 2px rgba(0,0,0,0.4); }
-    .chat-msg.sent { background: #0096FF; color: #fff; align-self: flex-end;
-                     border-bottom-right-radius: 4px; }
-    .chat-msg.received { background: #1E1E2E; color: #E8E8F0; align-self: flex-start;
-                         border-bottom-left-radius: 4px; }
-    .chat-msg.error { background: #3B1010; color: #FF6B6B; align-self: flex-start; }
-    .chat-msg .meta { font-size: 10px; color: rgba(255,255,255,0.4); margin-top: 4px;
-                      display: block; }
+                min-height: 120px; max-height: 250px; overflow-y: auto; padding: 8px; margin-bottom: 8px; }
+    .chat-msg { margin-bottom: 6px; padding: 6px 10px; border-radius: 6px; font-size: 13px; line-height: 1.5; word-wrap: break-word; }
+    .chat-msg.sent { background: #0096FF; color: #fff; margin-left: 20%; text-align: right; }
+    .chat-msg.received { background: #1E1E2E; margin-right: 20%; }
+    .chat-msg.error { background: #3B1010; color: #FF6B6B; }
+    .chat-msg .meta { font-size: 10px; color: rgba(255,255,255,0.4); margin-top: 2px; }
     .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: 8px;
-                            margin-top: 6px; cursor: pointer; display: block; }
+    .chat-msg .chat-media { max-width: 100%; max-height: 200px; border-radius: 4px; margin-top: 4px; 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; align-items: flex-end; }
-    .input-row input, .input-row textarea {
-        flex: 1; background: #1E1E2E; border: 1px solid #333; border-radius: 6px;
-        padding: 8px 12px; color: #E0E0F0; font-family: inherit; font-size: 13px;
-    }
-    .input-row textarea { resize: none; min-height: 38px; max-height: 200px; line-height: 1.4;
-                          overflow-y: auto; }
+    .input-row { display: flex; gap: 6px; }
+    .input-row input { flex: 1; background: #1E1E2E; border: 1px solid #333; border-radius: 6px;
+                       padding: 8px 12px; color: #E0E0F0; font-family: inherit; font-size: 13px; }
 
     /* Terminal Modal */
     .modal-overlay { display:none; position:fixed; top:0; left:0; right:0; bottom:0; background:rgba(0,0,0,0.85);
@@ -147,34 +136,6 @@
     </div>
   </div>
 
-  <!-- Voice-Preview Modal -->
-  <div id="voice-preview-modal" style="display:none;position:fixed;inset:0;z-index:1000;background:rgba(0,0,0,0.7);align-items:center;justify-content:center;">
-    <div style="background:#1A1A2E;border:1px solid #2A2A3E;border-radius:10px;padding:20px;max-width:560px;width:90%;display:flex;flex-direction:column;gap:12px;">
-      <div style="display:flex;align-items:center;justify-content:space-between;">
-        <h3 style="margin:0;color:#fff;">Stimmen-Preview: <span id="voice-preview-name">—</span></h3>
-        <button onclick="closeVoicePreview()" style="background:none;border:none;color:#8888AA;font-size:22px;cursor:pointer;">&times;</button>
-      </div>
-      <textarea id="voice-preview-text" rows="4"
-        style="background:#0D0D1A;border:1px solid #2A2A3E;border-radius:6px;padding:10px;color:#fff;font-size:13px;resize:vertical;"></textarea>
-
-      <div style="display:flex;align-items:center;gap:10px;font-size:12px;color:#8888AA;">
-        <span style="min-width:120px;">Geschwindigkeit:</span>
-        <button onclick="adjustPreviewSpeed(-0.1)" class="btn secondary" style="padding:4px 10px;font-size:12px;">−0.1</button>
-        <span id="voice-preview-speed-value" style="min-width:52px;text-align:center;color:#fff;font-weight:600;">1.0 x</span>
-        <button onclick="adjustPreviewSpeed(0.1)" class="btn secondary" style="padding:4px 10px;font-size:12px;">+0.1</button>
-        <span style="color:#555570;font-size:11px;">(nur fuer dieses Modal, wird nicht gespeichert)</span>
-      </div>
-
-      <div style="display:flex;gap:8px;align-items:center;">
-        <button id="voice-preview-play" onclick="playVoicePreview()" class="btn primary" style="padding:8px 16px;">
-          ▶ Abspielen
-        </button>
-        <span id="voice-preview-status" style="color:#8888AA;font-size:11px;flex:1;"></span>
-      </div>
-      <audio id="voice-preview-audio" controls style="width:100%;display:none;"></audio>
-    </div>
-  </div>
-
   <!-- Disk-Space Warnung (dynamisch gesetzt) -->
   <div id="disk-banner" style="display:none;position:sticky;top:0;z-index:500;padding:10px 14px;border-radius:0;margin:-16px -16px 12px -16px;font-size:13px;">
     <div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap;">
@@ -278,22 +239,13 @@
             <input type="checkbox" id="tts-debug-toggle" onchange="toggleTtsDebug()" style="margin-right:4px;vertical-align:middle;">
             TTS-Text einblenden
           </label>
-          <label style="color:#8888AA;font-size:11px;cursor:pointer;">
-            <input type="checkbox" id="gps-debug-toggle" onchange="toggleGpsDebug()" style="margin-right:4px;vertical-align:middle;">
-            GPS-Position einblenden
-          </label>
           <button class="btn secondary" onclick="toggleChatFullscreen()" id="btn-chat-fs" style="padding:4px 10px;font-size:11px;">Vollbild</button>
         </div>
       </div>
       <div class="chat-box" id="chat-box"></div>
       <div id="thinking-indicator" style="display:none;padding:6px 10px;font-size:12px;color:#FFD60A;background:#1E1E2E;border-radius:0 0 6px 6px;margin-top:-8px;margin-bottom:8px;align-items:center;justify-content:space-between;">
         <span><span style="animation:pulse 1s infinite;">&#x1F4AD;</span> <span id="thinking-text">ARIA denkt...</span></span>
-        <div style="display:flex;gap:6px;">
-          <button class="btn secondary" onclick="doctorFix()" style="padding:2px 10px;font-size:11px;color:#FF9500;border-color:#FF9500;" title="ARIA reparieren — openclaw doctor --fix">&#x1F527; Reparieren</button>
-          <button class="btn secondary" onclick="ariaSessionReset()" style="padding:2px 10px;font-size:11px;color:#FF9500;border-color:#FF9500;" title="Konversation komprimieren — Sessions weg + Restart">&#x1F9F9; Compact</button>
-          <button class="btn secondary" onclick="ariaRestart()" style="padding:2px 10px;font-size:11px;color:#FF3B30;border-color:#FF3B30;" title="Container hart neu starten (~15s)">&#x1F6A8; Hart neu</button>
-          <button class="btn secondary" onclick="cancelRequest()" style="padding:2px 10px;font-size:11px;color:#FF3B30;border-color:#FF3B30;">Abbrechen</button>
-        </div>
+        <button class="btn secondary" onclick="cancelRequest()" style="padding:2px 10px;font-size:11px;color:#FF3B30;border-color:#FF3B30;">Abbrechen</button>
       </div>
       <div id="diag-pending-attachments" style="display:none;padding:6px 10px;background:#1E1E2E;border-radius:6px 6px 0 0;margin-bottom:-4px;display:flex;gap:6px;flex-wrap:wrap;align-items:center;">
       </div>
@@ -302,7 +254,7 @@
           &#x1F4CE;
           <input type="file" id="diag-file-input" multiple accept="image/*,application/pdf,.doc,.docx,.txt" style="display:none;" onchange="handleDiagFileSelect(this.files)">
         </label>
-        <textarea id="chat-input" placeholder="Nachricht an ARIA... (Enter sendet, Shift+Enter neue Zeile)" rows="2" onpaste="handleDiagPaste(event)" oninput="autoResizeTextarea(this)"></textarea>
+        <input type="text" id="chat-input" placeholder="Nachricht an ARIA..." onpaste="handleDiagPaste(event)">
         <button class="btn" id="btn-gw" onclick="testGateway()">Gateway senden</button>
         <button class="btn" id="btn-rvs" onclick="testRVS()">Via RVS senden</button>
       </div>
@@ -320,7 +272,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;">
-      <textarea id="chat-input-fs" placeholder="Nachricht an ARIA... (Enter sendet, Shift+Enter neue Zeile)" rows="2" oninput="autoResizeTextarea(this)"></textarea>
+      <input type="text" id="chat-input-fs" placeholder="Nachricht an ARIA..." onkeydown="if(event.key==='Enter'){testRVSFS();event.preventDefault();}">
       <button class="btn" onclick="testGatewayFS()">Gateway senden</button>
       <button class="btn" onclick="testRVSFS()">Via RVS senden</button>
     </div>
@@ -517,25 +469,23 @@
               Hardcoded Defaults: F5TTS_v1_Base, cfg_strength=2.5, nfe_step=32.
             </div>
 
-            <label style="color:#8888AA;font-size:12px;">
-              Modell-Architektur (F5TTS_v1_Base = Default multilingual, F5TTS_Base = fuer die meisten Fine-Tunes):
-            </label>
+            <label style="color:#8888AA;font-size:12px;">Modell-ID:</label>
             <input type="text" id="diag-f5tts-model"
               placeholder="F5TTS_v1_Base"
               style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
 
             <label style="color:#8888AA;font-size:12px;">
-              Custom Checkpoint — HF-Pfad (hf://user/repo/file) oder lokaler Container-Pfad. Leer = Default.
+              Custom Checkpoint (HF-Repo "user/repo" oder Container-Pfad, leer = Default):
             </label>
             <input type="text" id="diag-f5tts-ckpt"
-              placeholder="z.B. hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors"
+              placeholder="z.B. aoxo/F5-TTS-German"
               style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
 
             <label style="color:#8888AA;font-size:12px;">
-              Custom Vocab — muss zum Checkpoint passen. Leer = Default.
+              Custom Vocab (passend zum Checkpoint, optional):
             </label>
             <input type="text" id="diag-f5tts-vocab"
-              placeholder="z.B. hf://aihpi/F5-TTS-German/vocab.txt"
+              placeholder="leer = Default"
               style="background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
 
             <div style="display:flex;gap:12px;">
@@ -674,6 +624,24 @@
       </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>
@@ -947,26 +915,16 @@
           return;
         }
 
-        if (msg.type === 'service_status') {
-          updateServiceStatus(msg.payload || {});
+        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 === 'voice_preview_audio') {
-          const statusEl = document.getElementById('voice-preview-status');
-          const audio = document.getElementById('voice-preview-audio');
-          const playBtn = document.getElementById('voice-preview-play');
-          if (playBtn) playBtn.disabled = false;
-          if (msg.error) {
-            if (statusEl) statusEl.textContent = '❌ Fehler: ' + msg.error;
-            return;
-          }
-          if (msg.base64 && audio) {
-            audio.src = 'data:audio/wav;base64,' + msg.base64;
-            audio.style.display = 'block';
-            audio.play().catch(() => {});
-            if (statusEl) statusEl.textContent = '✅ fertig';
-          }
+        if (msg.type === 'service_status') {
+          updateServiceStatus(msg.payload || {});
           return;
         }
 
@@ -998,17 +956,7 @@
         }
 
         if (msg.type === 'chat_final') {
-          // [FILE: /shared/uploads/aria_xxx.ext]-Marker aus dem Antworttext
-          // entfernen — die Datei kommt separat via file_from_aria.
-          // (Diagnostic empfaengt chat_final direkt vom Gateway, Bridge
-          // hat darum nicht filtern koennen.)
-          const cleaned = (msg.text || '').replace(/\[FILE:\s*\/shared\/uploads\/[^\]]+\]/gi, '').replace(/\n{3,}/g, '\n\n').trim();
-          addChat('received', cleaned, 'chat:final');
-          return;
-        }
-        if (msg.type === 'file_from_aria') {
-          const p = msg.payload || {};
-          addAriaFile(p);
+          addChat('received', msg.text, 'chat:final');
           return;
         }
         if (msg.type === 'chat_delta') { return; }
@@ -1023,7 +971,7 @@
           if (sender === 'aria') return;
           const chatType = 'sent';
           const label = sender === 'stt' ? '\uD83C\uDFA4 Spracheingabe' : `via RVS (${sender})`;
-          addChat(chatType, p.text || '?', label, { location: p.location });
+          addChat(chatType, p.text || '?', label);
           return;
         }
         if (msg.type === 'proxy_result') {
@@ -1414,16 +1362,6 @@
       if (el) el.checked = showTtsDebug;
     }
 
-    // Debug-Toggle: GPS-Position unter User-Nachrichten einblenden (nur Diagnostic).
-    // App zeigt's bewusst nicht — die Position geht nur an aria-core.
-    let showGpsDebug = localStorage.getItem('aria-show-gps-debug') === '1';
-    function toggleGpsDebug() {
-      showGpsDebug = !showGpsDebug;
-      localStorage.setItem('aria-show-gps-debug', showGpsDebug ? '1' : '0');
-      const el = document.getElementById('gps-debug-toggle');
-      if (el) el.checked = showGpsDebug;
-    }
-
     // Minimal-JS-Port von clean_text_for_tts() (Bridge) — reine Anzeige
     function previewTtsText(text) {
       if (!text) return '';
@@ -1463,18 +1401,7 @@
           ttsBlock = `<div style="margin-top:6px;padding:4px 8px;background:rgba(0,150,255,0.08);border-left:2px solid #0096FF;font-size:11px;color:#88AACC;"><span style="color:#0096FF;font-weight:bold;">TTS:</span> ${escapeHtml(ttsText)}</div>`;
         }
       }
-      // Optional: GPS-Position als Block unter User-Nachrichten (nur Diagnostic)
-      let gpsBlock = '';
-      if (showGpsDebug && options && options.location) {
-        const loc = options.location;
-        const lat = typeof loc.lat === 'number' ? loc.lat.toFixed(6) : '?';
-        const lon = typeof loc.lon === 'number' ? loc.lon.toFixed(6) : (typeof loc.lng === 'number' ? loc.lng.toFixed(6) : '?');
-        if (lat !== '?' && lon !== '?') {
-          const mapLink = `https://www.openstreetmap.org/?mlat=${lat}&mlon=${lon}#map=16/${lat}/${lon}`;
-          gpsBlock = `<div style="margin-top:6px;padding:4px 8px;background:rgba(52,199,89,0.08);border-left:2px solid #34C759;font-size:11px;color:#88BB99;"><span style="color:#34C759;font-weight:bold;">📍 GPS:</span> <a href="${mapLink}" target="_blank" rel="noopener" style="color:#88BB99;text-decoration:underline;">${lat}, ${lon}</a></div>`;
-        }
-      }
-      const html = `${linked}${ttsBlock}${gpsBlock}<div class="meta">${escapeHtml(meta)} — ${new Date().toLocaleTimeString('de-DE')}</div>`;
+      const html = `${linked}${ttsBlock}<div class="meta">${escapeHtml(meta)} — ${new Date().toLocaleTimeString('de-DE')}</div>`;
 
       // Thinking-Indikator ausblenden bei neuer Nachricht
       updateThinkingIndicator({ activity: 'idle' });
@@ -1490,41 +1417,6 @@
       }
     }
 
-    /** ARIA hat eine Datei rausgegeben — als eigene Bubble mit Klick-Handler. */
-    function addAriaFile(p) {
-      const name = p.name || 'datei';
-      const serverPath = p.serverPath || '';
-      const mimeType = p.mimeType || '';
-      const sizeKB = p.size ? Math.round(p.size / 1024) : 0;
-      const isImage = mimeType.startsWith('image/');
-      const isPdf = mimeType === 'application/pdf';
-      const url = serverPath; // Diagnostic-Server liefert /shared/* aus
-      const sizeStr = sizeKB > 1024 ? `${(sizeKB/1024).toFixed(1)}MB` : `${sizeKB}KB`;
-      const icon = isImage ? '🖼️' : isPdf ? '📄' : '📎';
-      // PDFs/Bilder: target=_blank → neuer Tab. Andere: download-Attribut.
-      const linkAttrs = (isImage || isPdf)
-        ? `href="${url}" target="_blank" rel="noopener"`
-        : `href="${url}" download="${escapeHtml(name)}"`;
-      let preview = '';
-      if (isImage) {
-        preview = `<img src="${url}" class="chat-media" onclick="openLightbox('image','${url}')" onerror="this.style.display='none'" style="margin-top:6px;">`;
-      }
-      const html = `<div style="font-weight:bold;">${icon} ARIA hat eine Datei erstellt</div>` +
-                   `<a ${linkAttrs} style="color:#0096FF;text-decoration:underline;">${escapeHtml(name)}</a>` +
-                   ` <span style="color:#888;font-size:11px;">(${escapeHtml(mimeType)}, ${sizeStr})</span>` +
-                   preview +
-                   `<div style="margin-top:4px;font-size:10px;color:#666;font-family:monospace;">${escapeHtml(serverPath)}</div>` +
-                   `<div class="meta">ARIA-Datei — ${new Date().toLocaleTimeString('de-DE')}</div>`;
-      for (const box of [chatBox, document.getElementById('chat-box-fs')]) {
-        if (!box) continue;
-        const el = document.createElement('div');
-        el.className = 'chat-msg received';
-        el.innerHTML = html;
-        box.appendChild(el);
-        box.scrollTop = box.scrollHeight;
-      }
-    }
-
     let chatFullscreen = false;
     function toggleChatFullscreen() {
       const modal = document.getElementById('chat-fullscreen');
@@ -1685,75 +1577,16 @@
       html += '<div style="display:flex;flex-direction:column;gap:4px;">';
       for (const v of voices) {
         const esc = (s) => String(s).replace(/[&<>"']/g, c => ({ "&":"&amp;", "<":"&lt;", ">":"&gt;", '"':"&quot;", "'":"&#39;" }[c]));
-        const jsName = esc(v.name).replace(/'/g, "\\'");
         html += `<div style="display:flex;align-items:center;gap:8px;background:#1E1E2E;border-radius:4px;padding:4px 8px;font-size:12px;">`
               + `<span style="flex:1;color:#E0E0F0;">${esc(v.name)}</span>`
               + `<span style="color:#555570;font-size:10px;">${(v.size/1024).toFixed(0)}KB</span>`
-              + `<button class="btn secondary" onclick="openVoicePreview('${jsName}')" style="padding:2px 8px;font-size:12px;" title="Stimme anhoeren">▶</button>`
-              + `<button class="btn secondary" onclick="deleteXttsVoice('${jsName}')" style="padding:2px 8px;font-size:10px;color:#FF6B6B;" title="Stimme loeschen">X</button>`
+              + `<button class="btn secondary" onclick="deleteXttsVoice('${esc(v.name).replace(/'/g, "\\'")}')" style="padding:2px 8px;font-size:10px;color:#FF6B6B;" title="Stimme loeschen">X</button>`
               + `</div>`;
       }
       html += '</div>';
       box.innerHTML = html;
     }
 
-    // ── Voice Preview Modal ─────────────────────────
-    const VOICE_PREVIEW_DEFAULT = 'Hallo, ich bin ARIA. Das hier ist ein kleiner Test damit du meine Stimme beurteilen kannst.';
-    const PREVIEW_SPEED_DEFAULT = 1.0;
-    const PREVIEW_SPEED_MIN = 0.1;
-    const PREVIEW_SPEED_MAX = 5.0;
-    let currentPreviewVoice = '';
-    let currentPreviewSpeed = PREVIEW_SPEED_DEFAULT;
-
-    function _refreshPreviewSpeedLabel() {
-      const el = document.getElementById('voice-preview-speed-value');
-      if (el) el.textContent = currentPreviewSpeed.toFixed(1) + ' x';
-    }
-
-    function adjustPreviewSpeed(delta) {
-      const next = Math.round((currentPreviewSpeed + delta) * 10) / 10;
-      if (next < PREVIEW_SPEED_MIN || next > PREVIEW_SPEED_MAX) return;
-      currentPreviewSpeed = next;
-      _refreshPreviewSpeedLabel();
-    }
-
-    function openVoicePreview(name) {
-      currentPreviewVoice = name;
-      // Speed bei jedem Oeffnen zuruecksetzen — bewusst kein persist
-      currentPreviewSpeed = PREVIEW_SPEED_DEFAULT;
-      _refreshPreviewSpeedLabel();
-      document.getElementById('voice-preview-name').textContent = name;
-      // Text bei jedem Oeffnen zuruecksetzen
-      document.getElementById('voice-preview-text').value = VOICE_PREVIEW_DEFAULT;
-      document.getElementById('voice-preview-status').textContent = '';
-      const audio = document.getElementById('voice-preview-audio');
-      audio.style.display = 'none';
-      audio.src = '';
-      document.getElementById('voice-preview-modal').style.display = 'flex';
-    }
-
-    function closeVoicePreview() {
-      document.getElementById('voice-preview-modal').style.display = 'none';
-      const audio = document.getElementById('voice-preview-audio');
-      try { audio.pause(); } catch {}
-    }
-
-    function playVoicePreview() {
-      const text = (document.getElementById('voice-preview-text').value || '').trim();
-      if (!text) {
-        document.getElementById('voice-preview-status').textContent = 'Text leer';
-        return;
-      }
-      document.getElementById('voice-preview-status').textContent = '⏳ Rendere...';
-      document.getElementById('voice-preview-play').disabled = true;
-      send({
-        action: 'preview_voice',
-        voice: currentPreviewVoice,
-        text,
-        speed: currentPreviewSpeed,
-      });
-    }
-
     function deleteXttsVoice(name) {
       if (!confirm(`Stimme "${name}" endgueltig loeschen?`)) return;
       send({ action: 'xtts_delete_voice', name });
@@ -1863,47 +1696,6 @@
       renderDiagPending();
     }
 
-    // ── Reparieren — openclaw doctor --fix ──────
-    function doctorFix() {
-      fetch('/api/doctor-fix', { method: 'POST' })
-        .then(r => r.json())
-        .then(data => {
-          if (data.ok) {
-            addLog('info', 'server', 'Reparatur ausgefuehrt: ' + (data.output || 'OK').slice(0, 200));
-          } else {
-            addLog('error', 'server', 'Reparatur fehlgeschlagen: ' + (data.error || ''));
-          }
-        })
-        .catch(err => addLog('error', 'server', 'Reparatur Request fehlgeschlagen: ' + err.message));
-    }
-
-    // ── Hard-Restart — docker restart aria-core ──────
-    function ariaRestart() {
-      if (!confirm('ARIA wird hart neu gestartet (Container-Restart, ~15s).\n\nLaufende Anfragen gehen verloren. Sicher?')) return;
-      fetch('/api/aria-restart', { method: 'POST' })
-        .then(r => r.json())
-        .then(data => {
-          if (data.ok) {
-            addLog('info', 'server', 'ARIA neu gestartet — wartet auf Reconnect');
-          } else {
-            addLog('error', 'server', 'Restart fehlgeschlagen: ' + (data.error || ''));
-          }
-        })
-        .catch(err => addLog('error', 'server', 'Restart Request fehlgeschlagen: ' + err.message));
-    }
-
-    // ── Compact / Session-Reset ──────
-    function ariaSessionReset() {
-      if (!confirm('Konversation komprimieren: alle Nachrichten in ARIAs aktueller Session werden geloescht und der Container neu gestartet. ARIA vergisst den bisherigen Gespraechsverlauf. Sicher?')) return;
-      fetch('/api/aria-session-reset', { method: 'POST' })
-        .then(r => r.json())
-        .then(data => {
-          if (data.ok) addLog('info', 'server', 'Session geleert, ARIA neu gestartet');
-          else addLog('error', 'server', 'Reset fehlgeschlagen: ' + (data.error || ''));
-        })
-        .catch(err => addLog('error', 'server', 'Reset Request fehlgeschlagen: ' + err.message));
-    }
-
     // ── Abbrechen ──────────────────────────────
     function cancelRequest() {
       send({ action: 'cancel_request' });
@@ -2048,6 +1840,20 @@
       }
     }
 
+    // ── 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' };
@@ -2156,23 +1962,10 @@
       return str.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
     }
 
-    // Auto-Resize fuer Textarea — wuchst mit dem Inhalt bis zum max-height
-    function autoResizeTextarea(el) {
-      el.style.height = 'auto';
-      el.style.height = Math.min(el.scrollHeight, 200) + 'px';
-    }
-
-    // Enter sendet, Shift+Enter macht neue Zeile (chat-Standard).
-    function chatInputKeydown(e, sendFn) {
-      if (e.key === 'Enter' && !e.shiftKey) {
-        e.preventDefault();
-        sendFn();
-        // Textarea zurueck auf 2 rows setzen
-        e.target.style.height = 'auto';
-      }
-    }
-    document.getElementById('chat-input').addEventListener('keydown', (e) => chatInputKeydown(e, testRVS));
-    document.getElementById('chat-input-fs').addEventListener('keydown', (e) => chatInputKeydown(e, testRVSFS));
+    // Enter-Taste sendet via Gateway
+    document.getElementById('chat-input').addEventListener('keydown', (e) => {
+      if (e.key === 'Enter') testRVS();
+    });
 
     // Escape schliesst Lightbox
     document.addEventListener('keydown', (e) => {
@@ -2532,8 +2325,9 @@
       document.querySelectorAll('.main-nav-btn').forEach(b => {
         if (b.textContent.trim().toLowerCase().includes(tab === 'main' ? 'main' : 'einstellung')) b.classList.add('active');
       });
-      // Einstellungen: Config + QR laden
+      // Einstellungen: Config + Trigger + QR laden
       if (tab === 'settings') {
+        loadHighlightTriggers();
         send({ action: 'get_voice_config' });
         loadRuntimeConfig();
         loadOnboardingQR();
@@ -2567,8 +2361,6 @@
     // Toggle-Checkbox initial korrekt setzen
     const ttsToggleEl = document.getElementById('tts-debug-toggle');
     if (ttsToggleEl) ttsToggleEl.checked = showTtsDebug;
-    const gpsToggleEl = document.getElementById('gps-debug-toggle');
-    if (gpsToggleEl) gpsToggleEl.checked = showGpsDebug;
 
     // Disk-Space Banner aktualisieren (wird vom Server via disk_status gepusht)
     function updateDiskBanner(status) {

diagnostic/server.js

@@ -620,11 +620,6 @@ function connectRVS(forcePlain) {
           type: "chat",
           payload: { text: `Anhang: ${name}\n${serverPath}`, sender: "user" }
         }});
-      } else if (msg.type === "file_from_aria" && msg.payload) {
-        // ARIA hat eine Datei fuer den User erstellt — im Chat als Anhang anzeigen
-        const p = msg.payload;
-        log("info", "rvs", `ARIA-Datei: ${p.name} (${p.mimeType}, ${(p.size||0)/1024|0}KB)`);
-        broadcast({ type: "file_from_aria", payload: p });
       } else if (msg.type === "heartbeat") {
         // ignorieren
       } else if (msg.type === "mode") {
@@ -658,9 +653,6 @@ function connectRVS(forcePlain) {
           log("info", "rvs", `service_status ${svc} ${state}${model ? ` (${model})` : ""}`);
         }
         broadcast({ type: "service_status", payload: msg.payload });
-      } else if (msg.type === "audio_pcm" && msg.payload && _previewPending.size > 0) {
-        // PCM-Chunks einer laufenden Voice-Preview — sammeln + WAV bauen
-        _handlePreviewChunk(msg.payload);
       } else {
         log("debug", "rvs", `Nachricht: ${JSON.stringify(msg).slice(0, 150)}`);
       }
@@ -721,24 +713,11 @@ 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(payload);
+    freshWs.send(JSON.stringify(msgObj));
     setTimeout(() => { try { freshWs.close(); } catch (_) {} }, 5000);
   });
   freshWs.on("error", () => {});
@@ -1342,97 +1321,6 @@ const server = http.createServer((req, res) => {
     dockerExec("aria-core", "openclaw doctor --fix 2>/dev/null || true").catch(() => {});
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ ok: true }));
-  } else if (req.url === "/api/doctor-fix" && req.method === "POST") {
-    // Manueller "ARIA reparieren"-Button — stuck OpenClaw-Runs aufloesen.
-    log("info", "server", "HTTP /api/doctor-fix — manueller Reparatur-Trigger");
-    dockerExec("aria-core", "openclaw doctor --fix 2>&1")
-      .then(out => {
-        const summary = (out || "").split("\n").filter(l => l.trim()).slice(-3).join(" | ");
-        broadcast({ type: "watchdog", status: "fixed", message: `Reparatur ausgefuehrt: ${summary || "OK"}` });
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: true, output: out }));
-      })
-      .catch(err => {
-        broadcast({ type: "watchdog", status: "error", message: `Reparatur fehlgeschlagen: ${err.message}` });
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: false, error: err.message }));
-      });
-    return;
-  } else if (req.url === "/api/aria-session-reset" && req.method === "POST") {
-    // Sessions weg + Container neu — fuer Compact-After-N-Messages.
-    // E2BIG bei zu langen Sessions: argv beim Subprocess-spawn ueberschritten.
-    log("warn", "server", "HTTP /api/aria-session-reset — Sessions loeschen + Restart");
-    broadcast({ type: "watchdog", status: "fixing", message: "Sessions werden geleert — ARIA bekommt frischen Start" });
-    dockerExec("aria-core", "rm -f /home/node/.openclaw/agents/main/sessions/*.jsonl /home/node/.openclaw/agents/main/sessions/*.lock 2>&1 && echo '{}' > /home/node/.openclaw/agents/main/sessions/sessions.json")
-      .then(() => {
-        // Restart via Docker-API (gleicher Pfad wie /api/aria-restart)
-        const restartReq = http.request({
-          socketPath: "/var/run/docker.sock",
-          path: "/containers/aria-core/restart?t=10",
-          method: "POST",
-          headers: { "Content-Length": 0 },
-          timeout: 30000,
-        }, (dRes) => {
-          if (dRes.statusCode === 204) {
-            log("info", "server", "aria-session-reset OK");
-            broadcast({ type: "watchdog", status: "fixed", message: "Sessions geleert, ARIA neu gestartet" });
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: true }));
-          } else {
-            res.writeHead(500, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: false, error: `Docker-API ${dRes.statusCode}` }));
-          }
-        });
-        restartReq.on("error", (err) => {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: false, error: err.message }));
-        });
-        restartReq.end();
-      })
-      .catch((err) => {
-        log("error", "server", `aria-session-reset Cleanup fehlgeschlagen: ${err.message}`);
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: false, error: err.message }));
-      });
-    return;
-  } else if (req.url === "/api/aria-restart" && req.method === "POST") {
-    // Harter Restart — fuer Faelle wo doctor --fix nicht reicht (alive aber
-    // haengender Run). Geht ueber Docker-API (Socket), kein CLI noetig.
-    // POST /containers/aria-core/restart?t=10 → SIGTERM, dann nach 10s SIGKILL.
-    log("warn", "server", "HTTP /api/aria-restart — harter Container-Restart");
-    broadcast({ type: "watchdog", status: "fixing", message: "ARIA wird hart neu gestartet (~15s)" });
-    const restartReq = http.request({
-      socketPath: "/var/run/docker.sock",
-      path: "/containers/aria-core/restart?t=10",
-      method: "POST",
-      headers: { "Content-Length": 0 },
-      timeout: 30000,
-    }, (dRes) => {
-      let body = "";
-      dRes.on("data", (c) => body += c);
-      dRes.on("end", () => {
-        // Docker-API: 204 = OK, 404 = container nicht da, 500 = anderer Fehler
-        if (dRes.statusCode === 204) {
-          log("info", "server", "aria-restart OK (Docker-API)");
-          broadcast({ type: "watchdog", status: "fixed", message: "ARIA wurde neu gestartet — sollte gleich antworten" });
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: true }));
-        } else {
-          log("error", "server", `aria-restart Docker-API ${dRes.statusCode}: ${body.slice(0, 200)}`);
-          broadcast({ type: "watchdog", status: "error", message: `Restart fehlgeschlagen: HTTP ${dRes.statusCode}` });
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: false, error: `Docker-API ${dRes.statusCode}: ${body}` }));
-        }
-      });
-    });
-    restartReq.on("error", (err) => {
-      log("error", "server", `aria-restart Socket-Fehler: ${err.message}`);
-      broadcast({ type: "watchdog", status: "error", message: `Restart fehlgeschlagen: ${err.message}` });
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: false, error: err.message }));
-    });
-    restartReq.end();
-    return;
   } else if (req.url.startsWith("/shared/")) {
     // Dateien aus Shared Volume ausliefern (Bilder, Uploads)
     const filePath = decodeURIComponent(req.url);
@@ -1551,14 +1439,19 @@ wss.on("connection", (ws) => {
           xttsVoice: msg.xttsVoice || "",
         };
         if (msg.whisperModel !== undefined) voiceConfig.whisperModel = msg.whisperModel;
-        // F5-TTS Tuning-Felder — immer mit dem vom User gesendeten Wert setzen,
-        // auch leeren String. Leer = "reset auf Hard-Default". Sonst merkt die
-        // Bridge nicht dass der User den Wert loeschen wollte (absent key war
-        // vorher 'keep current' semantik → BigVGAN blieb drin obwohl User
-        // leer eingetragen hatte).
-        if (msg.f5ttsModel !== undefined)     voiceConfig.f5ttsModel = msg.f5ttsModel || "";
-        if (msg.f5ttsCkptFile !== undefined)  voiceConfig.f5ttsCkptFile = msg.f5ttsCkptFile || "";
-        if (msg.f5ttsVocabFile !== undefined) voiceConfig.f5ttsVocabFile = msg.f5ttsVocabFile || "";
+        // F5-TTS Tuning-Felder — leere Strings entfernen damit der Default greift
+        if (msg.f5ttsModel !== undefined) {
+          if (msg.f5ttsModel) voiceConfig.f5ttsModel = msg.f5ttsModel;
+          else delete voiceConfig.f5ttsModel;
+        }
+        if (msg.f5ttsCkptFile !== undefined) {
+          if (msg.f5ttsCkptFile) voiceConfig.f5ttsCkptFile = msg.f5ttsCkptFile;
+          else delete voiceConfig.f5ttsCkptFile;
+        }
+        if (msg.f5ttsVocabFile !== undefined) {
+          if (msg.f5ttsVocabFile) voiceConfig.f5ttsVocabFile = msg.f5ttsVocabFile;
+          else delete voiceConfig.f5ttsVocabFile;
+        }
         if (msg.f5ttsCfgStrength !== undefined && !isNaN(msg.f5ttsCfgStrength)) {
           voiceConfig.f5ttsCfgStrength = msg.f5ttsCfgStrength;
         }
@@ -1571,10 +1464,12 @@ 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") {
-        handleVoicePreview(ws, msg.voice || "", msg.text || "Hallo.", msg.speed);
       } else if (msg.action === "check_tts") {
         handleCheckTTS(ws);
       } else if (msg.action === "check_desktop") {
@@ -1721,99 +1616,32 @@ function handleGetVoiceConfig(clientWs) {
   }
 }
 
-// ── TTS Diagnose (XTTS) ───────────────────────────────
-// ── Voice Preview ────────────────────────────────────────
-// Sammelt audio_pcm Chunks einer Preview-Anfrage, baut am Ende eine WAV
-// und schickt sie base64-kodiert an den Browser-Client.
-//
-// Map requestId → { clientWs, chunks: [Buffer], sampleRate, channels }
-const _previewPending = new Map();
+// ── Highlight-Trigger (legacy UI — wird nicht mehr ausgewertet seit Piper raus) ─
+const TRIGGERS_FILE = "/shared/config/highlight_triggers.json";
 
-function _buildWavFromPcm(pcmBuf, sampleRate, channels) {
-  const bitsPerSample = 16;
-  const byteRate = sampleRate * channels * bitsPerSample / 8;
-  const blockAlign = channels * bitsPerSample / 8;
-  const dataSize = pcmBuf.length;
-  const header = Buffer.alloc(44);
-  header.write("RIFF", 0);
-  header.writeUInt32LE(36 + dataSize, 4);
-  header.write("WAVE", 8);
-  header.write("fmt ", 12);
-  header.writeUInt32LE(16, 16);            // subchunk1 size
-  header.writeUInt16LE(1, 20);             // PCM
-  header.writeUInt16LE(channels, 22);
-  header.writeUInt32LE(sampleRate, 24);
-  header.writeUInt32LE(byteRate, 28);
-  header.writeUInt16LE(blockAlign, 32);
-  header.writeUInt16LE(bitsPerSample, 34);
-  header.write("data", 36);
-  header.writeUInt32LE(dataSize, 40);
-  return Buffer.concat([header, pcmBuf]);
-}
-
-function _handlePreviewChunk(payload) {
-  const reqId = payload?.requestId || "";
-  const entry = _previewPending.get(reqId);
-  if (!entry) return;
-  if (payload.base64) {
-    try { entry.chunks.push(Buffer.from(payload.base64, "base64")); } catch {}
-  }
-  if (!entry.sampleRate && payload.sampleRate) entry.sampleRate = payload.sampleRate;
-  if (!entry.channels && payload.channels) entry.channels = payload.channels;
-  if (payload.final) {
-    _previewPending.delete(reqId);
-    try {
-      const pcm = Buffer.concat(entry.chunks);
-      const wav = _buildWavFromPcm(pcm, entry.sampleRate || 24000, entry.channels || 1);
-      const b64 = wav.toString("base64");
-      if (entry.clientWs && entry.clientWs.readyState === 1) {
-        entry.clientWs.send(JSON.stringify({
-          type: "voice_preview_audio",
-          base64: b64,
-          size: wav.length,
-        }));
-      }
-    } catch (err) {
-      if (entry.clientWs && entry.clientWs.readyState === 1) {
-        entry.clientWs.send(JSON.stringify({
-          type: "voice_preview_audio",
-          error: err.message,
-        }));
-      }
-    }
-  }
-}
-
-async function handleVoicePreview(clientWs, voice, text, speed) {
+async function handleGetTriggers(clientWs) {
   try {
-    // Speed clampen — Browser-Slider ist 0.1-5.0
-    let spd = parseFloat(speed);
-    if (!isFinite(spd) || spd < 0.1 || spd > 5.0) spd = 1.0;
-    const requestId = crypto.randomUUID();
-    _previewPending.set(requestId, { clientWs, chunks: [], sampleRate: 0, channels: 0 });
-    // Timeout safety net
-    setTimeout(() => {
-      if (_previewPending.has(requestId)) {
-        _previewPending.delete(requestId);
-        if (clientWs && clientWs.readyState === 1) {
-          clientWs.send(JSON.stringify({
-            type: "voice_preview_audio",
-            error: "Timeout (60s) — keine Antwort vom f5tts-bridge",
-          }));
-        }
-      }
-    }, 60000);
-    log("info", "server", `Voice-Preview: voice="${voice}" speed=${spd.toFixed(1)}x text="${text.slice(0, 60)}"`);
-    sendToRVS_raw({
-      type: "xtts_request",
-      payload: { text, language: "de", requestId, voice, speed: spd },
-      timestamp: Date.now(),
-    });
+    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: "voice_preview_audio", error: err.message }));
+    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) ───────────────────────────────
 async function handleTestTTS(clientWs, text) {
   try {
     log("info", "server", `TTS-Test via XTTS: "${text}"`);

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 &&
@@ -87,7 +87,6 @@ services:
       - RVS_TLS=${RVS_TLS:-true}
       - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
       - RVS_TOKEN=${RVS_TOKEN:-}
-      - COMPACT_AFTER_MESSAGES=${COMPACT_AFTER_MESSAGES:-140}
     restart: unless-stopped
 
   # ─── Diagnostic (Selbstcheck-UI und Einstellungen) ────

init.sh

@@ -1,43 +0,0 @@
-#!/bin/bash
-# ════════════════════════════════════════════════════════════
-#  ARIA — Setup-Script
-#
-#  Materialisiert Config-Dateien aus *.example-Vorlagen wenn
-#  das Original fehlt. Wird einmalig nach git clone und nach
-#  jedem git pull empfohlen — schadet auch sonst nichts (idempotent,
-#  ueberschreibt nichts Bestehendes).
-#
-#  Beispiele:
-#    aria-data/config/USER.md.example → USER.md (wenn nicht vorhanden)
-#    aria-data/config/aria.env.example → aria.env (wenn nicht vorhanden)
-#
-#  Diese Files sind via .gitignore vom Repo ausgeschlossen — die
-#  Vorlagen liegen aber im Repo damit ein frisches Setup ohne lange
-#  Anleitung lauffaehig ist.
-# ════════════════════════════════════════════════════════════
-
-set -e
-cd "$(dirname "$0")"
-
-created=0
-skipped=0
-
-for example in aria-data/config/*.example; do
-    [ -f "$example" ] || continue
-    target="${example%.example}"
-    if [ -e "$target" ]; then
-        skipped=$((skipped + 1))
-    else
-        cp "$example" "$target"
-        echo "✓ $target erstellt aus $(basename "$example")"
-        created=$((created + 1))
-    fi
-done
-
-if [ $created -eq 0 ]; then
-    echo "Alle Config-Dateien vorhanden ($skipped uebersprungen)."
-else
-    echo ""
-    echo "$created Datei(en) angelegt, $skipped uebersprungen."
-    echo "Falls noetig anpassen: aria-data/config/"
-fi

issue.md

@@ -1,109 +1,7 @@
 # ARIA Issues & Features
 
-## Audio-Verhalten in der App
-
-So sollte die App in den verschiedenen Phasen mit fremden Audio-Apps
-(Spotify, YouTube, Podcasts etc.) und dem eigenen Mikro umgehen.
-Wenn was anders ist, ist's ein Bug.
-
-| Phase                        | Andere App (Spotify) | ARIA-Mikro          | Hintergrund-Service |
-|------------------------------|----------------------|---------------------|---------------------|
-| Idle / Ohr aus               | spielt frei          | aus                 | aus                 |
-| Wake-Word lauscht (armed)    | spielt frei          | passiv (openWakeWord) | aktiv ('wake')    |
-| User-Aufnahme laeuft         | pausiert (EXCLUSIVE) | Recording           | aktiv ('rec')       |
-| Aufnahme zu Ende             | resumed              | aus                 | (rec released)      |
-| ARIA denkt/schreibt (~20s)   | spielt frei          | aus                 | (kein Slot)         |
-| TTS startet                  | pausiert (DUCK)      | aus (oder barge)    | aktiv ('tts')       |
-| TTS spielt (auch GPU-Pausen) | bleibt pausiert      | barge wenn Wake-Word| aktiv               |
-| TTS zu Ende                  | nach 800ms resumed   | (Conversation-Window)| (tts released)     |
-| Eingehender Anruf (auch VoIP)| —                    | Mikro pausiert      | aus                 |
-| Anruf vorbei                 | —                    | Mikro wieder armed  | aktiv ('wake')      |
-| Anruf vorbei (Auto-Resume)   | pausiert wieder       | aus                 | aktiv ('tts')       |
-| Neue Frage waehrend Anruf    | —                    | Mikro pausiert      | (rec waehrend Anruf nicht) |
-| Anruf vorbei nach neuer Frage | (siehe TTS-Phasen)   | (siehe TTS-Phasen)  | (tts gewinnt, alter Resume verworfen) |
-
-Wichtige Mechanismen:
-- **Underrun-Schutz** im PcmStreamPlayer fuettert Stille rein wenn die
-  Bridge in Render-Pausen liefert — Spotify bleibt durchgehend pausiert,
-  auch zwischen den Saetzen einer langen Antwort.
-- **Conversation-Focus** (nur bei Wake-Word 'conversing') haelt den
-  AudioFocus dauerhaft. Bei reinem Tap-to-Talk oder Text-Chat greift's
-  nicht — Spotify darf in der Denk-Phase ruhig weiterspielen.
-- **Foreground-Service** (mediaPlayback|microphone) haelt App-Prozess
-  am Leben damit TTS/Mikro/Wake-Word auch bei minimierter App weiter-
-  laufen. Notification zeigt aktuellen Status ("ARIA spricht/hoert
-  zu/bereit").
-- **Anruf-Erkennung** ueber TelephonyManager (klassisch) + AudioFocus-
-  Loss-Listener mit Polling-Fallback (VoIP wie WhatsApp/Signal/Discord).
-- **Auto-Resume nach Anruf**: beim Halt wird die Wiedergabe-Position
-  gemerkt (Date.now() - playbackStart - leadingSilence). Nach Auflegen
-  wartet die App bis zu 30s auf den WAV-Cache und spielt dann ab der
-  gemerkten Position weiter. Wenn das Telefonat länger als die Antwort
-  dauerte, ist der Cache schon fertig — instant Resume.
-- **Neue Frage waehrend Anruf** (Text-Chat geht trotz Telefonat): die
-  neue Antwort ueberschreibt den pending Resume. _handlePcmChunkImpl
-  stoppt einen ggf. laufenden resumeSound und setzt pausedMessageId
-  zurueck wenn die neue Stream-messageId abweicht. Die letzte Antwort
-  gewinnt immer.
-- **Audio-Ausgabe trotz aktivem Telefonat**: ARIA antwortet auch waehrend
-  eines Telefonats per Lautsprecher (Telefon-Audio geht ueber separaten
-  Stream zur Gegenseite). haltAllPlayback wird nur beim STATE-WECHSEL
-  ringing/offhook gerufen — wenn der Anruf schon laeuft (offhook→offhook),
-  triggert eine neue Frage keinen Halt mehr.
-
 ## 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
-- [x] **Kurze TTS-Texte (1-3 Worte) spielen jetzt ab** — auf OnePlus A12 stallte AudioTrack mit `pos=0` weil der Default-Start-Threshold `bufferSize/2` (= 2s) bei kurzen Streams nie ueberschritten wurde. Fix: `setStartThresholdInFrames(100ms)` direkt nach dem Track-Build (API 31+). Buffer auf 4s entkoppelt von Pre-Roll, `play()` wird beim allerersten data-chunk gerufen
-- [x] **Mute-Button stoppt jetzt auch laufenden PCM-Stream** — `pcmStreamActive` wurde beim isFinal-Chunk schon false gesetzt, der AudioTrack spielte aber noch sekundenlang aus seinem Buffer. `stopPlayback()` uebersprang darum `PcmStreamPlayer.stop()`. Fix: stop() immer rufen (ist idempotent), kein Flag-Check mehr
-- [x] **GPS-Permission im Manifest + Runtime-Request** beim Settings-Toggle — vorher fehlten ACCESS_COARSE_LOCATION / ACCESS_FINE_LOCATION komplett. `Geolocation.getCurrentPosition` schlug lautlos fehl, App sendete nie ein location-Feld
-- [x] **GPS-Position auch im STT-Payload an Diagnostic** — die App sendet location einmal im audio-Payload. Die Bridge nutzte sie zwar (ging in aria-core's Kontext rein), reichte sie aber nicht im STT-broadcast an Diagnostic durch. Diagnostic zeigte darum bei Spracheingaben nie den GPS-Block, obwohl der "GPS einblenden"-Toggle aktiv war
-- [x] **Auto-Resume nach Anruf — pcmBuffer bleibt erhalten**: `haltAllPlayback` leerte den pcmBuffer mid-Anruf, isFinal schrieb dann eine leere WAV. Neue `pauseForCall`-Methode statt `haltAllPlayback`: AudioTrack stoppt + Focus released, `pcmBuffer` und `pcmMessageId` bleiben — chunks werden weiter gesammelt damit isFinal die WAV schreibt und resumeFromInterruption sie findet. Plus `captureInterruption` idempotent gemacht (ringing → offhook ueberschreibt nicht)
-- [x] **Replay-Resume nach Anruf**: `_firePlaybackStarted` ueberschrieb `currentPlaybackMsgId` mit leerem pcmMessageId — captureInterruption hatte nichts zu merken. Plus Regex `[0-9a-f-]+\.wav` matchte nicht alle Dateinamen. Plus `_playFromPathAtPosition` aktualisiert jetzt das Tracking damit ein zweiter Anruf in derselben Antwort auch funktioniert
-- [x] **`pauseForCall` setzt `isPlaying` zurueck**: vorher haengten weitere Play-Button-Klicks nach Anruf, weil `playAudio` bei `isPlaying=true` den `_playNext`-Pfad ueberspringt
-- [x] **Play-Button rendert neu wenn Cache-Datei weg ist**: vorher checkte der Button nur `if (item.audioPath)` — auf eine geloeschte Cache-Datei zeigte das aber stillschweigend ins Leere. Jetzt RNFS.exists-Check mit Fallback auf `tts_request` an die Bridge → F5-TTS rendert neu, WAV wandert zurueck in den Cache
-- [x] **Bridge WebSocket max_size 50 MB**: Python `websockets.connect` hat 1 MiB Default — Stefan's 4MB JPEG (5.78 MB Base64) sprengte das, Bridge-Connection wurde silent gedroppt. f5tts/whisper-bridges hatten max_size schon, nur aria_bridge war vergessen
-- [x] **Bridge resized Bilder >2 MB serverseitig auf 1568px**: Claude-Vision-API hat ~5 MB Base64-Limit. Galerie-Bilder via `react-native-image-picker` sind clientseitig schon klein, Buroklammer/DocumentPicker reichte das rohe File durch — Claude lieferte leere Antwort. Pillow im Bridge-Container, nur fuer JPEG/PNG/WebP/GIF (PDFs/ZIPs/SVGs unangetastet)
-- [x] **Bridge `chat:error` liest auch `errorMessage`**: OpenClaw legt bei state=error den Text dort statt in `error` ab → Bridge meldete generisches "[Fehler] Unbekannt", echter Fehler nur in Container-Logs. Plus: `chat:final` ohne text wird jetzt mit Hinweis-Bubble an die App gemeldet (statt stumm), z.B. wenn Vision das Bild silent ablehnt
-- [x] **Cache-Cleanup beim App-Start** — orphane `aria_tts_*.wav` Files (>5 min) im CachesDirectoryPath werden weggeraeumt, sammeln sich sonst an wenn Sound mid-playback gestoppt wird (Anruf, Mute, Barge-In) und der completion-Callback nicht feuert. Plus neuer Settings-Button "TTS-Cache leeren" mit Live-Groessenanzeige
-- [x] **Verbose-Logging-Toggle in Settings → Protokoll**: `console.log` global stummschaltbar (warn/error bleiben aktiv) — spart adb-logcat-Speicher wenn alles laeuft
-- [x] **800 ms-Delay vor Anruf-Auto-Resume**: ARIA's neuer Focus-Request kollidierte sonst mit Spotify's Auto-Resume nach Anruf-Ende. System haengt noch im IN_CALL→NORMAL-Mode-Uebergang, Spotify sieht Loss → Loss und bleibt pausiert. Mit Delay schafft Spotify den Resume-Schritt, dann pausiert ARIA wieder ordnungsgemaess
-- [x] **Mute-Button = Stop fuer aktuelle Antwort**: vorher startete eine NEUE PCM-Chunk-Sequenz nach Mute-aus die alte Antwort weiter wo sie war (funktionierte 2x, dann nicht mehr weil isFinal schon kam). Jetzt mit `_stoppedMessageId`-Tracking: bei Mute wird die aktive msgId gemerkt, alle weiteren chunks dieser msgId bleiben silent — auch wenn Mute zurueckgenommen wird. Reset bei neuer msgId, neue Antworten spielen normal
-- [x] **Spotify resumed nach Mute-Stop**: `stopPlayback` released seinen TRANSIENT-Focus (USAGE_ASSISTANT) sauber → Spotify bekommt GAIN-Event und resumed automatisch. Ein zwischenzeitlich eingebauter `kickReleaseMedia` (USAGE_MEDIA + GAIN) verhinderte das Auto-Resume sogar (Spotify interpretierte es als "user-action stopp") — wieder rausgenommen
-
-### 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
@@ -113,9 +11,13 @@ Wichtige Mechanismen:
 - [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 (spaeter komplett entfernt — war Piper-Relikt)
+- [x] Highlight-Trigger konfigurierbar in Diagnostic
 - [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
@@ -123,12 +25,16 @@ Wichtige Mechanismen:
 - [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
@@ -145,11 +51,14 @@ Wichtige Mechanismen:
 - [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
@@ -157,54 +66,25 @@ Wichtige Mechanismen:
 - [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] 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] 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 (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 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] **VoIP-Anrufe** (WhatsApp/Signal/Discord/Teams) erkannt via AudioFocus-Loss-Listener + getMode-Polling-Fallback (alle 3s)
-- [x] **Auto-Resume nach Anruf**: ARIAs unterbrochene Antwort spielt nach dem Auflegen ab der gemerkten Position weiter (Date.now()-Tracking + WAV-Cache, 30s-Wartezeit auf final-Marker bei kurzem Telefonat)
-- [x] **Neue Frage waehrend Telefonat** ueberschreibt pending Auto-Resume — letzte Antwort gewinnt, alter resumeSound wird gestoppt
-- [x] **Audio-Ausgabe waehrend aktivem Telefonat** funktioniert (haltAllPlayback nur bei state-Wechsel idle→ringing/offhook, nicht bei offhook→offhook)
-- [x] **PcmPlaybackFinished-Event** im Native: AudioFocus wird erst released wenn AudioTrack wirklich durch ist (vorher: end()-Cap nach 0.5s → Spotify spielte 32s parallel zu ARIA)
-- [x] **APK-Cache-Cleanup robuster**: durchsucht jetzt CachesDirectoryPath + DocumentDirectoryPath + ExternalCachesDirectoryPath + ExternalDirectoryPath statt nur Caches. Plus manueller Button "Update-Cache leeren" in Settings → Speicher mit Live-Anzeige der aktuellen Groesse
-- [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)
+- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
 
 ## Offen
 
 ### Bugs
+- [ ] NO_REPLY wird als "NO" im Chat angezeigt — sollte still verworfen werden (Token nicht gesaeubert)
 
 ### App Features
+- [ ] Wake Word on-device (Porcupine "ARIA" Keyword, Phase 2 — passives Lauschen)
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
-- [ ] Custom-Wake-Word-Upload via Diagnostic (eigene .onnx-Files ohne App-Rebuild)
+- [ ] Background Audio Service (TTS auch bei minimierter App)
+
+### TTS / Audio
+- [ ] Audio-Normalisierung (Lautstaerke zwischen Saetzen/Chunks angleichen)
+- [ ] F5-TTS: Streaming-Inferenz testen (nativ statt satzweise) wenn ein passendes Backend kommt
+- [ ] F5-TTS: Optional Deepspeed-Beschleunigung pruefen
 
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)

rvs/server.js

@@ -18,15 +18,10 @@ const ALLOWED_TYPES = new Set([
   "update_check", "update_available", "update_download", "update_data",
   "agent_activity", "cancel_request",
   "audio_pcm",
-  "file_from_aria",
-  "doctor_fix",
-  "aria_restart",
-  "aria_session_reset",
   "xtts_delete_voice",
   "voice_preload", "voice_ready",
   "stt_request", "stt_response",
   "service_status",
-  "config_request",
 ]);
 
 // Token-Raum: token -> { clients: Set<ws> }

xtts/.env.example

@@ -4,7 +4,7 @@
 # ════════════════════════════════════════════════
 
 # RVS Verbindung (gleiche Daten wie auf der ARIA-VM)
-RVS_HOST=example.com
+RVS_HOST=mobil.hacker-net.de
 RVS_PORT=444
 RVS_TLS=true
 RVS_TLS_FALLBACK=true

xtts/.gitignore

@@ -1,7 +1,3 @@
-# HuggingFace Model-Cache (Whisper + F5-TTS, geteilt zwischen den
-# beiden Bridges via Bind-Mount, kann mehrere GB werden)
-hf-cache/
-
 # Voice-Samples (lokal, gehoert nicht ins Repo)
 voices/
 

xtts/docker-compose.yml

@@ -31,11 +31,11 @@ services:
               capabilities: [gpu]
     volumes:
       - ./voices:/voices                         # WAV + TXT Referenz
-      - ./hf-cache:/root/.cache/huggingface      # HF-Cache als Bind-Mount.
-                                                 # Direkt sichtbar im xtts/hf-cache/,
-                                                 # einfach manuell zu loeschen, kein
-                                                 # Docker-Desktop .vhdx Bloat.
-                                                 # Wird mit whisper-bridge geteilt.
+                                                 # KEIN HF-Cache-Mount mehr —
+                                                 # Modell wird beim Start neu
+                                                 # gezogen. Diagnostic zeigt
+                                                 # "TTS laedt..." Banner bis
+                                                 # service_status: ready kommt.
     environment:
       # Bootstrap-only — alle anderen F5-TTS-Settings (Modell, cfg_strength,
       # nfe_step, Custom-Checkpoint) kommen ueber Diagnostic via RVS-config.
@@ -77,9 +77,6 @@ services:
       - WHISPER_DEVICE=${WHISPER_DEVICE:-cuda}
       - WHISPER_COMPUTE_TYPE=${WHISPER_COMPUTE_TYPE:-float16}
       - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-de}
-    volumes:
-      - ./hf-cache:/root/.cache/huggingface      # gleicher Cache wie f5tts-bridge —
-                                                 # ein Modell muss nur einmal pro
-                                                 # Maschine geladen werden, kein
-                                                 # Re-Download bei Container-Restart.
+    # KEIN HF-Cache-Mount — Whisper-Modell wird beim Start neu gezogen.
+    # Wechsel via Diagnostic triggert ebenso Re-Download.
     restart: unless-stopped

xtts/f5tts/bridge.py

@@ -73,12 +73,6 @@ VOICES_DIR = Path(os.getenv("VOICES_DIR", "/voices"))
 
 PCM_CHUNK_BYTES = 8192   # ~170ms @ 24kHz mono s16
 TARGET_SR = 24000        # F5-TTS native
-# F5-TTS hat ein 12s Hard-Limit fuer Referenz-Audio. Laengere WAVs werden
-# vom Modell stumm abgeschnitten — aber unser ref_text bleibt lang und passt
-# dann nicht mehr zum gekuerzten Audio (Quali leidet, warmup-Render ist
-# unnoetig lange). Wir clippen explizit auf 10s + re-transkribieren den Text
-# damit beide synchron bleiben.
-REF_MAX_SECONDS = 10.0
 
 # Wird in einer Uebergangsphase als "ungueltige Referenz" erkannt (alte voices,
 # die hochgeladen wurden bevor die whisper-bridge online war). Bei Erkennung
@@ -99,33 +93,6 @@ def _get_f5tts_cls():
     return _F5TTS_cls
 
 
-def _resolve_hf_path(p: str) -> str:
-    """Wenn p mit 'hf://' anfaengt → aus HuggingFace Hub runterladen,
-    lokalen Pfad zurueckgeben. Sonst unveraendert.
-
-    Format: hf://user/repo/path/to/file.ext
-    Beispiel: hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors
-    """
-    if not p or not p.startswith("hf://"):
-        return p
-    try:
-        from huggingface_hub import hf_hub_download
-        rest = p[5:]
-        parts = rest.split("/", 2)
-        if len(parts) < 3:
-            logger.warning("Ungueltiges hf:// Format: %s (erwarte hf://user/repo/path)", p)
-            return p
-        repo_id = f"{parts[0]}/{parts[1]}"
-        filename = parts[2]
-        logger.info("HF-Download: %s aus %s", filename, repo_id)
-        local = hf_hub_download(repo_id=repo_id, filename=filename)
-        logger.info("HF-Download fertig: %s", local)
-        return local
-    except Exception as e:
-        logger.exception("HF-Download fehlgeschlagen fuer %s: %s", p, e)
-        return p
-
-
 class F5Runner:
     """Haelt das F5-TTS-Modell. Synthese laeuft im Executor (blocking).
 
@@ -149,16 +116,14 @@ class F5Runner:
 
     def _load_blocking(self) -> None:
         cls = _get_f5tts_cls()
-        ckpt_resolved = _resolve_hf_path(self.ckpt_file) if self.ckpt_file else ""
-        vocab_resolved = _resolve_hf_path(self.vocab_file) if self.vocab_file else ""
         logger.info("Lade F5-TTS '%s' (device=%s, ckpt=%s)...",
-                    self.model_id, F5TTS_DEVICE, ckpt_resolved or "default")
+                    self.model_id, F5TTS_DEVICE, self.ckpt_file or "default")
         self._load_started_at = time.time()
         kwargs = {"model": self.model_id, "device": F5TTS_DEVICE}
-        if ckpt_resolved:
-            kwargs["ckpt_file"] = ckpt_resolved
-        if vocab_resolved:
-            kwargs["vocab_file"] = vocab_resolved
+        if self.ckpt_file:
+            kwargs["ckpt_file"] = self.ckpt_file
+        if self.vocab_file:
+            kwargs["vocab_file"] = self.vocab_file
         self.model = cls(**kwargs)
         elapsed = time.time() - self._load_started_at
         logger.info("F5-TTS geladen in %.1fs (cfg_strength=%.1f, nfe=%d)",
@@ -175,31 +140,10 @@ class F5Runner:
 
     async def update_config(self, payload: dict) -> None:
         """Liest f5tts*-Felder aus einem config-Broadcast.
-        Bei Modell-relevantem Wechsel wird neu geladen.
-
-        Semantik:
-          - key fehlt in payload     → aktuellen Wert behalten
-          - key da, nicht-leerer str → diesen Wert nehmen
-          - key da, leerer string    → RESET auf Hard-Default (User hat Feld
-                                       in Diagnostic geleert und Apply geklickt)
-        """
-        if "f5ttsModel" in payload:
-            v = (payload.get("f5ttsModel") or "").strip()
-            new_model = v if v else DEFAULT_F5TTS_MODEL
-        else:
-            new_model = self.model_id
-
-        if "f5ttsCkptFile" in payload:
-            v = payload.get("f5ttsCkptFile") or ""
-            new_ckpt = v.strip() if isinstance(v, str) else ""
-        else:
-            new_ckpt = self.ckpt_file
-
-        if "f5ttsVocabFile" in payload:
-            v = payload.get("f5ttsVocabFile") or ""
-            new_vocab = v.strip() if isinstance(v, str) else ""
-        else:
-            new_vocab = self.vocab_file
+        Bei Modell-relevantem Wechsel wird neu geladen."""
+        new_model = (payload.get("f5ttsModel") or "").strip() or self.model_id
+        new_ckpt = payload.get("f5ttsCkptFile", self.ckpt_file) or ""
+        new_vocab = payload.get("f5ttsVocabFile", self.vocab_file) or ""
         try:
             new_cfg = float(payload.get("f5ttsCfgStrength", self.cfg_strength))
         except (TypeError, ValueError):
@@ -237,10 +181,7 @@ class F5Runner:
         else:
             logger.info("F5-TTS Live-Config: cfg_strength=%.2f nfe=%d", new_cfg, new_nfe)
 
-    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str,
-                        speed: float = 1.0) -> tuple[np.ndarray, int]:
-        logger.info("infer() text=%d chars, speed=%.2f, cfg=%.2f, nfe=%d",
-                    len(gen_text), speed, self.cfg_strength, self.nfe_step)
+    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
         wav, sr, _ = self.model.infer(
             ref_file=ref_wav,
             ref_text=ref_text,
@@ -249,7 +190,6 @@ class F5Runner:
             seed=-1,
             cfg_strength=self.cfg_strength,
             nfe_step=self.nfe_step,
-            speed=speed,
         )
         # F5-TTS gibt float32 1D-Array — auf 24kHz sample-rate standard
         if not isinstance(wav, np.ndarray):
@@ -258,11 +198,10 @@ class F5Runner:
             wav = wav.squeeze()
         return wav.astype(np.float32), int(sr)
 
-    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str,
-                         speed: float = 1.0) -> tuple[np.ndarray, int]:
+    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
         await self.ensure_loaded()
         loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text, speed)
+        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text)
 
 
 # ── Helpers ─────────────────────────────────────────────────
@@ -294,15 +233,7 @@ def split_sentences(text: str, max_len: int = 350) -> list[str]:
 
 
 def float_to_pcm16(wav: np.ndarray) -> bytes:
-    """Float32 (-1..+1) → int16 little-endian bytes.
-
-    F5-TTS generiert gelegentlich NaN/Inf bei Instabilitaeten — ohne sanitize
-    waere der Cast zu int16 undefiniert (RuntimeWarning + kaputter Sound).
-    """
-    nan_count = int(np.isnan(wav).sum() + np.isinf(wav).sum())
-    if nan_count > 0:
-        logger.warning("F5-TTS Output enthaelt %d NaN/Inf samples — ersetze mit 0", nan_count)
-        wav = np.nan_to_num(wav, nan=0.0, posinf=1.0, neginf=-1.0)
+    """Float32 (-1..+1) → int16 little-endian bytes."""
     wav = np.clip(wav, -1.0, 1.0)
     pcm = (wav * 32767.0).astype(np.int16)
     return pcm.tobytes()
@@ -317,51 +248,32 @@ def voice_paths(name: str) -> tuple[Path, Path]:
     return VOICES_DIR / f"{safe}.wav", VOICES_DIR / f"{safe}.txt"
 
 
-def normalize_ref_wav(src_wav: Path, max_seconds: float = REF_MAX_SECONDS) -> tuple[Path, bool]:
-    """Bringt die Referenz-WAV in F5-TTS-freundliche Form:
+def ensure_24k_mono_wav(src_wav: Path) -> Path:
+    """F5-TTS moechte 24kHz mono als Referenz — ffmpeg konvertiert inplace.
 
-      * 24kHz mono
-      * max max_seconds Dauer
-      * Stille am Anfang + Ende abgeschnitten (silenceremove-Filter)
-      * Lautheit auf -16 LUFS normalisiert (loudnorm-Filter) damit
-        das Modell konsistente Amplituden sieht
-
-    F5-TTS reagiert empfindlich auf leise / verrauschte / zerhackte
-    Referenzen. Konsistente, saubere Input-Lautheit hilft der Quali.
-
-    Returns:
-        (path, was_modified) — was_modified=True wenn die Datei wirklich
-        geaendert wurde (Caller sollte dann den passenden .txt invalidieren).
+    Wenn das File schon passt, wird nichts geaendert. Sonst wird es
+    reingeschrieben (Original wird ueberschrieben).
     """
+    try:
+        info = sf.info(str(src_wav))
+        if info.samplerate == TARGET_SR and info.channels == 1:
+            return src_wav
+    except Exception:
+        pass
     tmp_out = src_wav.with_suffix(".conv.wav")
-    # silenceremove am Anfang: bis -50dB gesprochen wird
-    # silenceremove am Ende: ueber -50dB rein, dann 0.5s stille als Cutoff
-    # loudnorm: EBU R128, Ziel -16 LUFS
-    af = ("silenceremove=start_periods=1:start_duration=0.05:start_threshold=-50dB,"
-          "silenceremove=stop_periods=1:stop_duration=0.5:stop_threshold=-50dB,"
-          "loudnorm=I=-16:TP=-1.5:LRA=11")
     cmd = ["ffmpeg", "-y", "-i", str(src_wav),
-           "-af", af,
-           "-ar", str(TARGET_SR), "-ac", "1",
-           "-t", str(max_seconds),
-           "-f", "wav", str(tmp_out)]
+           "-ar", str(TARGET_SR), "-ac", "1", "-f", "wav", str(tmp_out)]
     r = subprocess.run(cmd, capture_output=True, timeout=30)
     if r.returncode != 0:
-        logger.warning("ffmpeg-Normalisierung von %s fehlgeschlagen: %s",
-                       src_wav, r.stderr.decode(errors="replace")[:300])
+        logger.warning("ffmpeg-Konvertierung von %s fehlgeschlagen: %s",
+                       src_wav, r.stderr.decode(errors="replace")[:200])
         try:
             tmp_out.unlink()
         except OSError:
             pass
-        return src_wav, False
+        return src_wav
     os.replace(tmp_out, src_wav)
-    try:
-        info = sf.info(str(src_wav))
-        logger.info("Referenz-WAV normalisiert: %s (%.1fs, %dHz mono, -16 LUFS, silence getrimmt)",
-                    src_wav.name, info.duration, info.samplerate)
-    except Exception:
-        logger.info("Referenz-WAV normalisiert: %s", src_wav.name)
-    return src_wav, True
+    return src_wav
 
 
 async def _send(ws, mtype: str, payload: dict) -> None:
@@ -400,10 +312,7 @@ async def request_transcription(ws, wav_path: Path, language: str = "de") -> Opt
             "requestId": request_id,
             "audio": audio_b64,
             "mimeType": "audio/wav",
-            # KEIN hardcoded model — whisper-bridge nimmt das bereits
-            # geladene. Sonst wuerde hier ein Swap auf 'small' passieren und
-            # danach muesste das in Diagnostic konfigurierte Modell (z.B.
-            # large-v3) wieder geladen werden → doppelter Download.
+            "model": "small",  # klein reicht fuer Voice-Referenz
             "language": language,
         })
         return await asyncio.wait_for(fut, timeout=_STT_TIMEOUT_S)
@@ -426,9 +335,9 @@ _tts_queue: asyncio.Queue[tuple] = asyncio.Queue()
 async def _tts_worker(ws, runner: F5Runner) -> None:
     """Serialisiert Synthesen — GPU kann sonst OOM gehen."""
     while True:
-        text, voice, request_id, message_id, language, speed = await _tts_queue.get()
+        text, voice, request_id, message_id, language = await _tts_queue.get()
         try:
-            await _do_tts(ws, runner, text, voice, request_id, message_id, language, speed)
+            await _do_tts(ws, runner, text, voice, request_id, message_id, language)
         except Exception:
             logger.exception("TTS-Worker Fehler")
         finally:
@@ -436,26 +345,10 @@ async def _tts_worker(ws, runner: F5Runner) -> None:
 
 
 async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
-                  request_id: str, message_id: str, language: str,
-                  speed: float = 1.0) -> None:
+                  request_id: str, message_id: str, language: str) -> None:
     t0 = time.time()
     ref_wav_path, ref_txt_path = voice_paths(voice) if voice else (None, None)
 
-    # WAV zu lang? F5-TTS limitiert intern auf 12s, dann passt der txt nicht
-    # mehr zum Audio. Wir clippen explizit auf 10s und invalidieren den txt,
-    # damit er on-the-fly passend zum gekuerzten Audio neu transkribiert wird.
-    if voice and ref_wav_path and ref_wav_path.exists():
-        try:
-            info = sf.info(str(ref_wav_path))
-            if info.duration > REF_MAX_SECONDS + 0.5:
-                logger.info("Voice '%s' WAV ist %.1fs (>%.0fs) → clippen + txt neu",
-                            voice, info.duration, REF_MAX_SECONDS)
-                _, modified = normalize_ref_wav(ref_wav_path)
-                if modified and ref_txt_path and ref_txt_path.exists():
-                    ref_txt_path.unlink()
-        except Exception as e:
-            logger.warning("Konnte WAV-Dauer nicht pruefen: %s", e)
-
     # Legacy-Platzhalter erkennen → behandeln als "kein txt" und neu transkribieren
     if voice and ref_txt_path and ref_txt_path.exists():
         try:
@@ -509,14 +402,13 @@ async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
             ref_wav_str, ref_text = str(pair[0]), pair[1].read_text(encoding="utf-8").strip()
 
     sentences = split_sentences(text)
-    logger.info("F5-TTS: %d Satz(e), voice=%s, speed=%.2fx (%s)",
-                len(sentences), voice or "default", speed, ref_wav_str)
+    logger.info("F5-TTS: %d Satz(e), voice=%s (%s)", len(sentences), voice or "default", ref_wav_str)
 
     chunk_index = 0
     pcm_sr = TARGET_SR
     for i, sent in enumerate(sentences):
         try:
-            wav, sr = await runner.synthesize(sent, ref_wav_str, ref_text, speed)
+            wav, sr = await runner.synthesize(sent, ref_wav_str, ref_text)
             pcm_sr = sr
             pcm_bytes = float_to_pcm16(wav)
             # Erste PCM-Chunk des allerersten Satzes bekommt Fade-In (maskiert
@@ -599,9 +491,8 @@ async def handle_voice_upload(ws, payload: dict) -> None:
         size_kb = wav_path.stat().st_size / 1024
         logger.info("Voice WAV gespeichert: %s (%.0fKB)", wav_path, size_kb)
 
-        # Auf 24kHz mono clippen auf 10s (F5-TTS Hard-Limit ist 12s,
-        # kuerzer = schnellerer Warmup + Text+Audio bleiben aligned)
-        normalize_ref_wav(wav_path)
+        # Auf 24kHz mono normalisieren (falls App in anderem Format liefert)
+        ensure_24k_mono_wav(wav_path)
 
         # Transkription ueber whisper-bridge anfragen
         logger.info("Transkribiere '%s' via whisper-bridge...", name)
@@ -722,30 +613,22 @@ async def run_loop(runner: F5Runner) -> None:
                 tls_fallback_tried = False
 
                 # Status-Broadcast: erst loading, dann ready nach erfolgreichem Load.
-                # Plus: config_request damit wir die persistierte Diagnostic-Config
-                # bekommen, falls aria-bridge ihre nicht von alleine sendet.
+                # Modell wird hier (nicht ausserhalb der Schleife) gestartet damit
+                # der Loading-Status auch wirklich uebertragen werden kann.
                 async def _load_with_status():
+                    if runner.model is not None:
+                        await _broadcast_status(ws, "ready",
+                                                model=runner.model_id,
+                                                loadSeconds=runner.last_load_seconds)
+                        return
+                    await _broadcast_status(ws, "loading", model=runner.model_id)
                     try:
-                        if runner.model is not None:
-                            logger.info("Initial: broadcaste ready (Modell schon im RAM: %s)", runner.model_id)
-                            await _broadcast_status(ws, "ready",
-                                                    model=runner.model_id,
-                                                    loadSeconds=runner.last_load_seconds)
-                        else:
-                            logger.info("Initial: broadcaste loading + lade Modell '%s'", runner.model_id)
-                            await _broadcast_status(ws, "loading", model=runner.model_id)
-                            await runner.ensure_loaded()
-                            await _broadcast_status(ws, "ready",
-                                                    model=runner.model_id,
-                                                    loadSeconds=runner.last_load_seconds)
-                        logger.info("Initial: sende config_request an aria-bridge")
-                        await _send(ws, "config_request", {"service": "f5tts"})
+                        await runner.ensure_loaded()
+                        await _broadcast_status(ws, "ready",
+                                                model=runner.model_id,
+                                                loadSeconds=runner.last_load_seconds)
                     except Exception as e:
-                        logger.exception("Initial-Load crashed: %s", e)
-                        try:
-                            await _broadcast_status(ws, "error", error=str(e)[:200])
-                        except Exception:
-                            pass
+                        await _broadcast_status(ws, "error", error=str(e)[:200])
                 asyncio.create_task(_load_with_status())
 
                 # TTS-Worker fuer diese Verbindung starten
@@ -761,19 +644,12 @@ async def run_loop(runner: F5Runner) -> None:
                         payload = msg.get("payload", {}) or {}
 
                         if mtype == "xtts_request":
-                            try:
-                                speed = float(payload.get("speed") or 1.0)
-                            except (TypeError, ValueError):
-                                speed = 1.0
-                            if not (0.1 <= speed <= 5.0):
-                                speed = 1.0
                             await _tts_queue.put((
                                 payload.get("text", ""),
                                 payload.get("voice", "") or "",
                                 payload.get("requestId", ""),
                                 payload.get("messageId", ""),
                                 payload.get("language", "de"),
-                                speed,
                             ))
                         elif mtype == "voice_upload":
                             asyncio.create_task(handle_voice_upload(ws, payload))

xtts/whisper/bridge.py

@@ -143,11 +143,7 @@ async def handle_stt_request(ws, payload: dict, runner: WhisperRunner) -> None:
     request_id = payload.get("requestId", "")
     audio_b64 = payload.get("audio", "")
     mime_type = payload.get("mimeType", "audio/mp4")
-    # Modell-Auswahl:
-    #   payload.model gesetzt  → nimm das (aria-bridge sendet's basierend auf Config)
-    #   sonst + Modell geladen → behalt das aktuelle (kein sinnloser Swap)
-    #   sonst                  → fallback auf ENV-Default
-    model = payload.get("model") or (runner.model_size if runner.model is not None else WHISPER_MODEL)
+    model = payload.get("model") or WHISPER_MODEL
     language = payload.get("language") or WHISPER_LANGUAGE
 
     if not audio_b64:
@@ -224,26 +220,15 @@ async def run_loop(runner: WhisperRunner) -> None:
                 retry_s = 2
                 tls_fallback_tried = False
 
-                # Initialer Status-Broadcast — uebertont alten "ready"-State
-                # im App/Diagnostic Banner (sonst denkt der User noch alles ist
-                # gut von vorher). Wenn Modell schon geladen → ready, sonst
-                # loading mit aktuellem (Default-)Namen.
-                # Plus: config_request an aria-bridge — wir wissen nicht ob
-                # sie auch grad reconnected hat oder schon laenger online ist.
-                async def _initial_handshake():
-                    try:
-                        if runner.model is not None:
-                            logger.info("Initial: broadcaste ready (Modell schon im RAM: %s)", runner.model_size)
-                            await _broadcast_status(ws, "ready", model=runner.model_size)
-                        else:
-                            init_model = runner.model_size or WHISPER_MODEL
-                            logger.info("Initial: broadcaste loading (model=%s)", init_model)
-                            await _broadcast_status(ws, "loading", model=init_model)
-                        logger.info("Initial: sende config_request an aria-bridge")
-                        await _send(ws, "config_request", {"service": "whisper"})
-                    except Exception as e:
-                        logger.exception("Initial-Handshake crashed: %s", e)
-                asyncio.create_task(_initial_handshake())
+                # KEIN initialer Preload. Der aria-bridge broadcastet kurz nach
+                # RVS-Connect die persistierte Config (whisperModel) — wir laden
+                # erst wenn der drinsteht, sonst wuerde 2x geladen werden
+                # (small als ENV-Default + dann das echte Modell).
+                # Wenn ein stt_request schneller kommt als die Config: ensure_loaded
+                # im Handler greift dann ein und laedt das angeforderte Modell.
+                if runner.model is not None:
+                    # Wir sind reconnectet — Modell schon im RAM, einfach 'ready'
+                    asyncio.create_task(_broadcast_status(ws, "ready", model=runner.model_size))
 
                 async for raw in ws:
                     try: