release: bump version to 0.0.7.2

fix(compose): $(find ...) muss in compose-command zu $$(find ...) escaped werden
docker-compose interpretiert $( als Variable-Interpolation-Pattern und warf "Invalid interpolation format". Die anderen $$DIST-Stellen waren schon korrekt escaped, nur das command-substitution fehlte. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-05 14:51:18 +02:00 · 2026-05-05 14:24:31 +02:00 · 2026-05-05 14:19:16 +02:00 · 2026-05-03 22:11:08 +02:00 · 2026-05-03 21:59:38 +02:00 · 2026-05-03 21:44:58 +02:00
106 changed files with 9908 additions and 14214 deletions
@@ -1,20 +1,50 @@
-# ARIA Environment Configuration
-# Copy to .env and fill in values
+# ════════════════════════════════════════════════
+#  ARIA — Umgebungsvariablen
+#  Kopieren nach .env und Werte eintragen
+# ════════════════════════════════════════════════

-# Auth token for ARIA Core (generate a long random string)
-# openssl rand -hex 32
+# ── ARIA Auth Token ──────────────────────────────
+# Authentifizierung fuer den OpenClaw Gateway (aria-core).
+# Wird von Diagnostic, Bridge und App genutzt um sich am Gateway anzumelden.
+# Alle Services die mit aria-core kommunizieren brauchen diesen Token.
+# Generieren: openssl rand -hex 32
 ARIA_AUTH_TOKEN=change-me-to-a-long-random-string

-# RVS — Rendezvous-Server (Bridge + App verbinden sich hierüber)
+# ── RVS — Rendezvous-Server ─────────────────────
+# Der RVS ist ein WebSocket-Relay im Rechenzentrum.
+# 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 mobil.hacker-net.de)
 RVS_HOST=rvs.example.de
+
+# Port auf dem der RVS laeuft (muss mit rvs/docker-compose.yml uebereinstimmen)
 RVS_PORT=443
+
+# TLS (wss://) verwenden? true = verschluesselt, false = unverschluesselt (ws://)
 RVS_TLS=true
+
 # Bei TLS-Fehler automatisch auf ws:// (ohne TLS) fallback?
-# true = Fallback erlaubt, false = nur mit TLS verbinden
+# Nuetzlich wenn kein TLS-Zertifikat vorhanden (z.B. Entwicklung)
 RVS_TLS_FALLBACK=true
+
+# Pairing-Token: Wer den gleichen Token hat, landet im gleichen RVS-Room.
+# Wird von generate-token.sh automatisch generiert und hier eingetragen.
+# Die Android App bekommt den Token per QR-Code beim Pairing.
+# WICHTIG: Muss auf ARIA-VM, Gaming-PC (xtts/.env) und App identisch sein!
+# Generieren: ./generate-token.sh (traegt den Token automatisch ein)
 RVS_TOKEN=

-# Gitea (for release.sh — Kennwort wird interaktiv abgefragt)
+# ── Gitea — Release-Verwaltung ───────────────────
+# Wird von release.sh genutzt um APKs auf Gitea zu veroeffentlichen.
+# Kennwort wird beim Release interaktiv abgefragt (nicht in .env!).
 GITEA_URL=https://git.hacker-net.de
 GITEA_REPO=Hacker-Software/ARIA-AGENT
 GITEA_USER=duffyduck
+
+# ── Auto-Update — APK auf RVS-Server kopieren ───
+# SSH-Ziel fuer scp: release.sh kopiert die APK dorthin.
+# Der RVS-Server stellt sie dann per WebSocket an die App bereit.
+# Format: user@host (z.B. root@aria-rvs oder root@rvs.example.de)
+# Leer lassen = Auto-Update ueberspringen, APK manuell auf RVS kopieren.
+RVS_UPDATE_HOST=
@@ -29,9 +29,14 @@ yarn-error.log*
 android/build/
 android/.gradle/
 android/app/build/
+android/android/.gradle/
+android/android/app/build/
+android/android/local.properties
 android/local.properties
+android/package-lock.json
 *.apk
 *.aab
+rvs/updates/*.apk

 # ── Tauri / Desktop Build ───────────────────────
 desktop/src-tauri/target/
@@ -29,11 +29,26 @@ ARIA hat zwei Rollen:
 ┌─────────────────────────────────────────────────────────┐
 │              RVS — Rendezvous-Server                     │
 │         Node.js WebSocket Relay (Docker, Rechenzentrum)  │
-│         Reiner Relay — kennt keine Tokens, leitet durch  │
+│         Relay + Auto-Update (APK-Verteilung)             │
 │                  rvs/docker-compose.yml                  │
-└───────────────────────┬─────────────────────────────────┘
-                        │ WebSocket Tunnel
-                        ▼
+└───────────┬───────────────────────────┬─────────────────┘
+            │ WebSocket Tunnel          │ WebSocket Tunnel
+            ▼                           ▼
+┌─────────────────────────────────┐
+│  Gamebox (Windows + WSL2)        │
+│  RTX 3060, Docker Desktop       │
+│  ┌──────────────────────────┐   │
+│  │ aria-f5tts-bridge        │   │
+│  │  F5-TTS Voice Cloning    │   │
+│  │  PCM-Streaming an die App │   │
+│  ├──────────────────────────┤   │
+│  │ aria-whisper-bridge      │   │
+│  │  Faster-Whisper CUDA     │   │
+│  │  STT in fast-Echtzeit    │   │
+│  └──────────────────────────┘   │
+│  Beide teilen ./voices Volume    │
+│  xtts/docker-compose.yml        │
+└─────────────────────────────────┘
 ┌─────────────────────────────────────────────────────────┐
 │     ARIA-VM (Proxmox, Debian 13) — ARIAs Wohnung        │
 │     Basissystem + Docker. Rest richtet ARIA selbst ein.  │
@@ -50,8 +65,10 @@ ARIA hat zwei Rollen:
 │  │             Liest BOOTSTRAP.md + AGENT.md         │    │
 │  │                                                   │    │
 │  │  [bridge]   ARIA Voice Bridge Container           │    │
-│  │             Whisper STT · Piper TTS · Wake-Word   │    │
-│  │             Ramona (weiblich) + Thorsten (tief)    │    │
+│  │             Wake-Word (lokales Mikro auf VM)       │    │
+│  │             STT primaer remote (Gamebox-Whisper)   │    │
+│  │             Fallback: lokales faster-whisper (CPU) │    │
+│  │             TTS via F5-TTS auf Gamebox             │    │
 │  │             Bruecke: App <> RVS <> Bridge <> ARIA │    │
 │  │                                                   │    │
 │  │  [diagnostic] Selbstcheck-UI + Einstellungen      │    │
@@ -66,13 +83,17 @@ ARIA hat zwei Rollen:
 └─────────────────────────────────────────────────────────┘
 ```

-**Drei separate Deployments:**
+**Vier separate Deployments:**

 | Was | Wo | Wie |
 |-----|----|-----|
 | RVS | Rechenzentrum | `cd rvs && docker compose up -d` |
 | ARIA Core | Debian 13 VM | `docker compose up -d && ./aria-setup.sh` |
-| Android App | Stefans Handy | APK installieren, QR-Code scannen |
+| Gamebox-Stack (F5-TTS + Whisper) | Gamebox (GPU) | `cd xtts && docker compose up -d` |
+| Android App | Stefans Handy | APK installieren (Auto-Update via RVS) |
+
+> Der Gamebox-Stack ist optional: ohne ihn faellt STT auf lokales Whisper (CPU,
+> langsamer) zurueck; TTS bleibt aus (ARIA antwortet dann nur als Text).

 ---

@@ -95,16 +116,31 @@ cd ~/ARIA-AGENT
 cp .env.example .env
 ```

-`.env` Datei editieren:
+`.env` Datei editieren (Details siehe `.env.example`):
 ```bash
+# Gateway-Auth: Alle Services die mit aria-core reden brauchen diesen Token
+# Diagnostic, Bridge, App nutzen ihn fuer den WebSocket-Handshake
 ARIA_AUTH_TOKEN=        # openssl rand -hex 32
+
+# RVS-Verbindung: Hostname + Port deines Rendezvous-Servers
 RVS_HOST=               # z.B. rvs.hackersoft.de
 RVS_PORT=443
 RVS_TLS=true
 RVS_TLS_FALLBACK=true
-RVS_TOKEN=              # wird von generate-token.sh automatisch gesetzt
+
+# Pairing-Token: Verbindet App, Bridge, Diagnostic und XTTS im gleichen RVS-Room
+# MUSS auf allen Geraeten identisch sein (ARIA-VM, Gaming-PC, App)
+# Wird von generate-token.sh automatisch generiert und eingetragen
+RVS_TOKEN=              # ./generate-token.sh
+
+# Optional: SSH-Host des RVS-Servers fuer Auto-Update (z.B. root@aria-rvs)
+RVS_UPDATE_HOST=
 ```

+**Zwei Tokens, zwei Zwecke:**
+- **ARIA_AUTH_TOKEN**: Authentifizierung am OpenClaw Gateway (aria-core). Wer diesen Token hat, kann ARIA Befehle geben.
+- **RVS_TOKEN**: Pairing-Token fuer den Rendezvous-Server. Alle Geraete mit dem gleichen Token landen im gleichen "Room" und koennen kommunizieren. Die App bekommt diesen Token per QR-Code.
+
 ### 2. Claude CLI einloggen (Proxy-Auth)

 Der Proxy-Container nutzt deine Claude Max Subscription. Die Credentials muessen
@@ -120,21 +156,17 @@ claude login
 **Wichtig:** Der Ordner `~/.claude/` (nicht `~/.config/claude/`!) wird als Volume
 in den Proxy gemountet. Die Credentials ueberleben Container-Restarts.

-### 3. Stimmen herunterladen
-
-```bash
-./get-voices.sh
-# Laedt Ramona + Thorsten (Piper TTS) nach aria-data/voices/
-# Ca. 100MB, dauert ein paar Minuten
-```
-
-### 4. Voice Bridge konfigurieren
+### 3. Voice Bridge konfigurieren

 ```bash
 cp aria-data/config/aria.env.example aria-data/config/aria.env
-# Bei Bedarf anpassen (Whisper-Modell, Sprache, Stimmen-Pfade)
+# Bei Bedarf anpassen (Whisper-Modell als Fallback, Sprache, Wake-Word)
 ```

+STT laeuft primaer auf der Gamebox (faster-whisper auf GPU), TTS ausschliesslich
+ueber F5-TTS auf der Gamebox — siehe Abschnitt "Gamebox-Stack — F5-TTS + Whisper"
+weiter unten.
+
 ### 5. RVS-Token generieren & Container starten

 ```bash
@@ -230,7 +262,6 @@ Danach werden per `sed` vier Patches angewendet:
 - Sicherheitsregeln (kein ClawHub, Prompt Injection abwehren)
 - Tool-Freigaben (alle Claude Code Tools: WebFetch, Bash, etc.)
 - SSH-Zugriff auf aria-wohnung (VM)
- Stimmen-Auswahl (Ramona vs Thorsten)
 - Gedaechtnis-System

 ### openclaw.json (via aria-setup.sh)
@@ -267,21 +298,34 @@ braucht ARIA mehrere API-Roundtrips.

 ## Voice Bridge

-Die Bridge verbindet die Android App mit ARIA und bietet lokale Sprachverarbeitung.
+Die Bridge verbindet die Android App mit ARIA und orchestriert die GPU-Services
+auf der Gamebox.

 **Nachrichtenfluss:**
 ```
-App → RVS → Bridge → aria-core
-aria-core → Bridge → RVS → App
-                   → Lautsprecher (TTS)
+Text:   App → RVS → Bridge → chat.send → aria-core
+Audio:  App → RVS → Bridge → stt_request (RVS) → whisper-bridge (Gamebox)
+                          → stt_response → Bridge → chat.send → aria-core
+        Fallback bei Timeout: lokales faster-whisper (CPU)
+Datei:  App → RVS → Bridge → /shared/uploads/ → chat.send (mit Pfad) → aria-core
+
+aria-core → Antwort → Gateway → Diagnostic → RVS → App
+                              → Bridge → xtts_request (RVS) → f5tts-bridge
+                              → audio_pcm Stream → RVS → App AudioTrack
 ```

 ### Features

- **STT**: faster-whisper (lokal, offline, 16kHz mono)
- **TTS**: Piper (Ramona + Thorsten, offline)
- **Wake-Word**: openwakeword (lokales Mikrofon auf der VM)
- **App-Audio**: Base64 Audio von App → FFmpeg → Whisper STT → Text an aria-core
+- **STT primaer remote**: aria-bridge sendet `stt_request` an die Gamebox-Whisper
+  (faster-whisper CUDA, fast Echtzeit). 45s Timeout, dann Fallback auf lokales
+  CPU-Whisper. Modell-Wahl in Diagnostic, Hot-Swap via config-Broadcast.
+- **TTS via F5-TTS**: aria-f5tts-bridge auf der Gamebox. Voice Cloning mit
+  Referenz-Audio + automatisch transkribiertem Referenz-Text.
+- **Text-Cleanup**: `<voice>...</voice>` Tag bevorzugt; Markdown, Code,
+  Einheiten und URLs werden TTS-gerecht aufbereitet. Dezimalzahlen werden
+  ausgeschrieben (`0,1` → "null komma eins"). Acronyme bis 5 Buchstaben werden
+  buchstabiert (`USB` → "U S B", `XTTS` → "X T T S").
+- **Wake-Word**: openwakeword (lokales Mikrofon auf der VM, optional)
 - **Modi**: Normal, Nicht stoeren, Fluestern, Hangar, Gaming

 ### Betriebsmodi
@@ -294,13 +338,6 @@ aria-core → Bridge → RVS → App
 | Hangar | `"ARIA, ich arbeite"` | Nur wichtige Meldungen |
 | Gaming | `"ARIA, Gaming-Modus"` | Nur auf direkte Fragen antworten |

-### Stimmen
-
-| Stimme | Modell | Wann |
-|--------|--------|------|
-| **Ramona** (weiblich) | `de_DE-ramona-low` | Alltag, Antworten, Gespraeche |
-| **Thorsten** (maennlich, tief) | `de_DE-thorsten-high` | Epische Momente, Alarme |
-
 ---

 ## Diagnostic — Selbstcheck-UI und Einstellungen
@@ -310,13 +347,21 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit aria-core.
 ### Features

 - **Status-Karten**: Gateway (Handshake), RVS (TLS-Fallback), Proxy (Auth)
- **Chat-Test**: Nachrichten direkt an ARIA senden (Gateway oder via RVS)
- **Session-Verwaltung**: Sessions auflisten, wechseln, erstellen, loeschen
+- **Disk-Voll Banner**: Rotes Overlay wenn die VM-Disk knapp wird, mit copy-baren Cleanup-Befehlen (safe + aggressiv)
+- **Chat-Test**: Nachrichten direkt an ARIA senden (Gateway oder via RVS), Vollbild-Modus
+- **"ARIA denkt..." Indikator**: Zeigt live was ARIA gerade tut (Denken, Tool, Schreiben)
+- **Abbrechen-Button**: Stoppt laufende Anfragen + doctor --fix
+- **Session-Verwaltung**: Sessions auflisten, wechseln, erstellen, loeschen, als Markdown exportieren (⬇ Button)
 - **Chat-History**: Wird beim Laden und Session-Wechsel angezeigt (read-only aus JSONL)
+- **TTS-Diagnose Tab**: Stimmen testen, Status pruefen, Fehler anzeigen
+- **Einstellungen**: TTS aktiv-Toggle, F5-TTS-Voice (gecloned), Betriebsmodi, Whisper-Modell (tiny…large-v3, Hot-Reload auf der Gamebox)
+- **Voice-Status**: Beim Wechsel der globalen Stimme zeigt ein Status-Text "Lade…" → "bereit (X.Ys)" — getriggert ueber `voice_preload`/`voice_ready`
+- **Voice Cloning**: Audio-Samples hochladen, Referenz-Text wird automatisch via Whisper transkribiert
 - **Claude Login**: Browser-Terminal zum Einloggen in den Proxy
 - **Core Terminal**: Shell in aria-core (openclaw CLI)
- **Container-Logs**: Echtzeit-Logs aller Container (gefiltert nach Tab)
+- **Container-Logs**: Echtzeit-Logs aller Container (gefiltert nach Tab + Pipeline)
 - **SSH Terminal**: Direkter SSH-Zugang zu aria-wohnung
+- **Watchdog**: Erkennt stuck Runs (2min Warnung → 5min doctor --fix → 8min Container-Restart)

 ### Session-Verwaltung

@@ -334,13 +379,65 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`

 - Text-Chat mit ARIA
 - **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
- **VAD (Voice Activity Detection)**: Erkennt 1.8s Stille und stoppt automatisch
- **Wake Word**: Toggle-Button aktiviert kontinuierliches Mikrofon-Monitoring
- **TTS-Wiedergabe**: ARIA antwortet per Lautsprecher (Ramona/Thorsten)
- Datei- und Kamera-Upload
+- **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
+- **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
+- **VAD (Voice Activity Detection)**: Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme 120s.
+- **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
+- **STT (Speech-to-Text)**: 16kHz mono → Bridge → Gamebox-Whisper (CUDA) → Text im Chat. Fast in Echtzeit.
+- **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
+- **TTS-Wiedergabe**: F5-TTS PCM-Streaming direkt in AudioTrack mit konfigurierbarem Pre-Roll-Buffer (1.0–6.0s, Default 3.5s) gegen Gaps bei Render-Pausen
+- **Audio-Pause**: Andere Apps (Spotify, YouTube etc.) pausieren komplett waehrend ARIA spricht und kommen erst wieder nach echtem Wiedergabe-Ende
+- **Lokale Voice-Wahl**: Pro Geraet eigene Stimme moeglich (in Settings). Diagnostic-Wechsel ueberschreibt alle App-Wahlen.
+- **Voice-Ready Toast**: Beim Wechsel zeigt die App "Stimme X bereit (X.Ys)" sobald der Preload durch ist
+- **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden (aus Cache wenn vorhanden, sonst neu rendern)
+- **Chat-Suche**: Lupe in der Statusleiste filtert Nachrichten live
+- **Mehrere Anhaenge**: Bilder + Dateien sammeln, Text hinzufuegen, dann zusammen senden
+- **Paste-Support**: Bilder aus Zwischenablage einfuegen (Diagnostic)
+- **Anhaenge**: Bridge speichert in Shared Volume, ARIA kann darauf zugreifen, Re-Download ueber RVS
+- **Einstellungen**: TTS-aktiv, F5-TTS-Voice, Pre-Roll-Buffer, Stille-Toleranz, Speicherort, Auto-Download, GPS
+- **Auto-Update**: Prueft beim Start + per Button auf neue Version, Download + Installation ueber RVS (FileProvider)
 - GPS-Position (optional)
 - QR-Code Scanner fuer Token-Pairing

+### Wake-Word (openWakeWord, on-device)
+
+Wake-Word-Erkennung laeuft komplett **on-device** ueber [openWakeWord](https://github.com/dscripka/openWakeWord)
+mit ONNX Runtime — kein API-Key, kein Cloud-Roundtrip, kein Cent Lizenzgebuehren,
+und das Audio verlaesst das Geraet nie.
+
+**Mitgelieferte Wake-Words** (ONNX-Dateien in `android/android/app/src/main/assets/openwakeword/`):
+- `Hey Jarvis` (Default, openWakeWord-Original)
+- `Computer` (Star-Trek-Style, Community-Modell)
+- `Alexa`, `Hey Mycroft`, `Hey Rhasspy` (openWakeWord-Originale)
+
+Community-Modelle stammen aus [fwartner/home-assistant-wakewords-collection](https://github.com/fwartner/home-assistant-wakewords-collection).
+
+**Bedienung:**
+- App → **Einstellungen** → **Wake-Word** → gewuenschtes Keyword waehlen → **Speichern + Aktivieren**
+- **Ohr-Button (👂)** in der Statusleiste tippen → Wake-Word ist scharf, App hoert passiv mit
+- Wake-Word sagen → Symbol wechselt auf 🎙️, Konversation laeuft
+- Nach jeder ARIA-Antwort oeffnet sich das Mikro nochmal — Stille → zurueck zu 👂
+- Erneut tippen → Ohr aus (🔇)
+
+**Eigene Wake-Words trainieren** (gratis, ~30 Min):
+
+1. openWakeWord Trainings-Notebook auf Colab oeffnen (Link im
+   [openWakeWord Repo](https://github.com/dscripka/openWakeWord) unter "Training Custom Models")
+2. Wake-Word-Phrase eingeben (z.B. "ARIA", "Hey Stefan"), Notebook ausfuehren —
+   das Notebook generiert synthetische Trainings-Beispiele und trainiert das Modell.
+3. Resultierende `.onnx`-Datei runterladen
+4. Datei in `android/android/app/src/main/assets/openwakeword/` ablegen
+5. In `android/src/services/wakeword.ts` den Dateinamen (ohne `.onnx`) zur
+   `WAKE_KEYWORDS`-Liste hinzufuegen
+6. APK neu bauen
+
+*(Diagnostic-Upload fuer Custom-`.onnx` ohne Rebuild kommt spaeter.)*
+
+**Tuning** (in [wakeword.ts](android/src/services/wakeword.ts)):
+- `DEFAULT_THRESHOLD = 0.5` — Score-Schwelle (raise auf 0.6–0.7 bei False-Positives)
+- `DEFAULT_PATIENCE = 2` — wie viele Frames ueber Threshold noetig
+- `DEFAULT_DEBOUNCE_MS = 1500` — Mindestabstand zwischen zwei Triggern
+
 ### Ersteinrichtung (Dev-Maschine, einmalig)

 ```bash
@@ -361,15 +458,90 @@ cd android
 # APK liegt unter android/app/build/outputs/apk/release/
 ```

-### Audio-Pipeline
+### Release auf Gitea veroeffentlichen
+
+```bash
+./release.sh 1.2.0
+```
+
+Das Script macht alles in einem Schritt:
+1. Setzt Versionsnummern (package.json, build.gradle, SettingsScreen)
+2. Fragt Gitea-Kennwort ab (wird nirgends gespeichert)
+3. Baut die Release-APK
+4. Git Commit + Tag + Push
+5. Erstellt Gitea Release + laedt APK hoch
+6. Kopiert APK auf RVS-Server (Auto-Update, optional)
+
+Voraussetzung in `.env`:
+```bash
+GITEA_URL=https://gitea.hackersoft.de
+GITEA_REPO=stefan/aria-agent
+GITEA_USER=stefan
+RVS_UPDATE_HOST=root@aria-rvs    # Optional: fuer Auto-Update
+```
+
+### Docker-Cleanup
+
+Das Bridge-Image zieht grosse ML-Deps (faster-whisper, ctranslate2, onnxruntime,
+openwakeword) — bei jedem Rebuild waechst der Docker-Build-Cache. Wenn
+die VM voll laeuft:
+
+```bash
+./cleanup.sh           # sicher: Build-Cache + ungenutzte Images
+./cleanup.sh --full    # aggressiv: zusaetzlich ungenutzte Volumes (mit Rueckfrage)
+```
+
+### Auto-Update
+
+Die App prueft beim Start ob eine neuere Version auf dem RVS liegt.
+Der Update-Flow:
+1. `./release.sh 0.0.3.0` → APK wird auf RVS kopiert (via scp)
+2. Alternativ: `git pull` auf dem RVS-Server → APK in `rvs/updates/`
+3. App sendet `update_check` mit aktueller Version
+4. RVS vergleicht → sendet `update_available`
+5. App zeigt Dialog → Download ueber WebSocket → Installation
+
+### Audio-Pipeline (Spracheingabe)

 ```
 App (Mikrofon) → AAC/MP4 Aufnahme → Base64 → RVS → Bridge
 Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-core
-aria-core → Antwort → Bridge → Piper TTS (WAV) → Base64 → RVS → App
-App: Base64 → WAV → Lautsprecher
+Bridge: STT-Ergebnis → RVS → App (Placeholder wird durch transkribierten Text ersetzt)
+aria-core → Antwort → Bridge → XTTS (Gaming-PC) → PCM-Stream → RVS → App
+App: AudioTrack MODE_STREAM (nahtlos), Cache als WAV pro Message
 ```

+### Datei-Pipeline (Bilder & Anhaenge)
+
+```
+App (Kamera/Dateimanager) → Base64 → RVS → Bridge
+Bridge: Speichert in /shared/uploads/ (Shared Volume, fuer aria-core sichtbar)
+Bridge: chat.send → "Stefan hat ein Bild geschickt: foto.jpg — liegt unter /shared/uploads/..."
+ARIA: Kann Datei per Bash/Read-Tool oeffnen und analysieren
+```
+
+**Unterstuetzte Formate:** Bilder (JPG, PNG), Dokumente (PDF, DOCX, TXT), beliebige Dateien.
+Bilder werden in der App inline angezeigt, andere Dateien als Icon + Dateiname.
+
+**Re-Download:** Wird der lokale Cache in der App geleert (Einstellungen → Anhang-Speicher → Cache leeren),
+werden fehlende Anhaenge automatisch ueber RVS vom Server neu geladen. Der Speicherort
+ist in den App-Einstellungen konfigurierbar.
+
+> **Tipp Speicherplatz:** Das Docker Volume `aria-shared` liegt standardmaessig auf ARIAs VM-Disk.
+> Bei vielen Uploads kann das den Speicher der VM belasten (dort laufen auch alle Container).
+> Empfehlung: Das Volume auf ein Netzwerk-Filesystem mounten (CephFS, NFS, GlusterFS):
+> ```yaml
+> # docker-compose.yml
+> volumes:
+>   aria-shared:
+>     driver: local
+>     driver_opts:
+>       type: nfs
+>       o: addr=nas.local,rw
+>       device: ":/exports/aria-uploads"
+> ```
+> So bleibt ARIAs VM-Disk sauber und die Uploads liegen auf dediziertem Storage.
+
 ---

 ## Datenverzeichnis — aria-data/
@@ -384,10 +556,6 @@ aria-data/
 │
 ├── skills/                         ← ARIAs Faehigkeiten (selbst geschrieben!)
 │
-├── voices/                         ← Piper TTS Stimmen (offline)
-│   ├── de_DE-ramona-low.onnx
-│   └── de_DE-thorsten-high.onnx
-│
 ├── config/
 │   ├── BOOTSTRAP.md                ← System-Prompt (Identitaet, Regeln, Tools)
 │   ├── AGENT.md                    ← Persoenlichkeit & Arbeitsprinzipien
@@ -396,6 +564,11 @@ aria-data/
 │   ├── aria.env                    ← Voice Bridge Config
 │   └── diag-state/                 ← Diagnostic persistenter State
 │
+│   (im Shared Volume /shared/config/):
+│   ├── 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
    ├── id_ed25519                  ← Private Key (generiert von aria-setup.sh)
    ├── id_ed25519.pub              ← Public Key (muss in VM authorized_keys!)
@@ -411,7 +584,7 @@ tar -czf aria-backup-$(date +%Y%m%d).tar.gz aria-data/

 ## RVS — Rendezvous-Server

-Laeuft im Rechenzentrum. Reiner Relay — kennt keine Tokens, speichert nichts.
+Laeuft im Rechenzentrum. WebSocket Relay + Auto-Update Server.
 Wer sich mit dem gleichen Token verbindet, landet im gleichen Room.

 ```bash
@@ -419,10 +592,133 @@ cd rvs
 docker compose up -d
 ```

+**Features:**
+- WebSocket Relay (alle Message-Types: chat, audio, file, config, xtts, update, etc.)
+- Auto-Update: APK-Verteilung an Apps ueber WebSocket
+- Heartbeat + tote Verbindungen aufraeumen
+
+**Auto-Update APK bereitstellen:**
+```bash
+# APK in updates/ legen (manuell oder via release.sh)
+cp ARIA-v0.0.3.0.apk ~/ARIA-AGENT/rvs/updates/
+# RVS erkennt die Version aus dem Dateinamen
+```
+
 **Multi-Instanz:** Mehrere ARIA-VMs koennen denselben RVS nutzen — jede mit eigenem Token.

 ---

+## Gamebox-Stack — F5-TTS + Whisper (GPU-Services)
+
+Laeuft auf einem separaten Rechner mit NVIDIA GPU (z.B. Gaming-PC mit RTX 3060).
+Verbindet sich ueber RVS mit der ARIA-Infrastruktur — kein VPN noetig, funktioniert
+ueber verschiedene Netze hinweg.
+
+### Architektur
+
+```
+Gamebox (Windows, RTX 3060, Docker Desktop + WSL2)
+├── aria-f5tts-bridge       F5-TTS Voice Cloning + RVS-Relay
+│                           Hoert auf xtts_request, streamt audio_pcm
+├── aria-whisper-bridge     faster-whisper auf CUDA (float16)
+│                           Hoert auf stt_request, antwortet mit stt_response
+└── ./voices/               Geteilt zwischen beiden:
+                              {name}.wav  — Referenz-Audio (~6-10s)
+                              {name}.txt  — Referenz-Text (auto via Whisper)
+
+         ↕ RVS (Rechenzentrum, WebSocket Relay)
+
+ARIA-VM
+└── aria-bridge: STT primaer remote (45s Timeout, dann lokaler CPU-Fallback)
+                 TTS via xtts_request → audio_pcm Stream
+```
+
+### Voraussetzungen
+
+- Docker Desktop mit WSL2 (Windows) oder Docker mit NVIDIA Runtime (Linux)
+- NVIDIA Container Toolkit
+- GPU mit mindestens 6GB VRAM (Whisper-large + F5-TTS gemeinsam)
+- **Gleicher RVS_TOKEN wie auf der ARIA-VM!**
+
+### Setup
+
+```bash
+cd xtts
+cp .env.example .env
+# .env mit RVS-Verbindungsdaten fuellen (gleicher Token wie ARIA-VM!)
+docker compose up -d
+# Erster Start laedt die Modelle (Whisper ~1-3GB je nach Groesse, F5-TTS ~1GB)
+```
+
+Die Modelle werden in den Volumes `f5tts-models` und `whisper-models` gecacht
+und muessen nur einmal geladen werden.
+
+### Features
+
+**F5-TTS (Sprachausgabe):**
+- Hochqualitatives Voice Cloning auf Basis von 6-10s Referenz-Audio
+- Renderzeit ~0.3x Realtime auf RTX 3060 (RTF ≈ 0.3)
+- Satzweises Streaming, fade-in auf erstem Chunk gegen Warmup-Glitches
+- Sequentielle Queue gegen GPU-OOM bei parallelen Requests
+
+**Whisper (Spracherkennung):**
+- faster-whisper mit CUDA + float16 — fast Echtzeit-Transkription
+- Modelle: tiny / base / small / medium / large-v3 (Hot-Swap via Diagnostic)
+- Wird zusaetzlich von der f5tts-bridge intern genutzt um den Referenz-Text
+  beim Voice-Upload automatisch zu erzeugen
+
+### TTS-Config
+
+In der Diagnostic unter Einstellungen → Sprachausgabe:
+- **TTS aktiv**: Global An/Aus
+- **F5-TTS Stimme**: Default oder gecloned (Maia etc.)
+
+> F5-TTS ist die einzige Engine — wenn die Gamebox offline ist, bleibt ARIA stumm.
+> Chat-Antworten kommen weiter an (nur kein Audio).
+
+### Stimme klonen
+
+1. App oder Diagnostic → "Stimme klonen" → Audio-Dateien hochladen
+   (WAV/MP3, 1-10 Dateien, ~6-10s gesamt)
+2. Name vergeben → "Stimme erstellen"
+3. f5tts-bridge speichert das WAV, schickt einen `stt_request` an die
+   whisper-bridge, legt die Transkription als `.txt` daneben ab und meldet
+   `xtts_voice_saved` zurueck. Der Toast in der App zeigt "Stimme bereit".
+4. Stimme auswaehlen → ein Voice-Preload (stiller Mini-Render) waermt die
+   Latents auf, "voice_ready" Toast bestaetigt es.
+
+> **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

 | Volume | Pfad im Container | Zweck |
@@ -433,6 +729,8 @@ docker compose up -d
 | `./aria-data/ssh` (bind) | `/root/.ssh`, `/home/node/.ssh` | SSH Keys |
 | `./aria-data/brain` (bind) | `/home/node/.openclaw/workspace/memory` | Gedaechtnis |
 | `./aria-data/skills` (bind) | `/home/node/.openclaw/workspace/skills` | Skills |
+| `aria-shared` | `/shared` (Core + Bridge + Proxy + Diag) | Datei-Austausch, Config, Uploads |
+| `./aria-data/config/diag-state` (bind) | `/data` (Diagnostic) | Persistenter State (aktive Session) |

 ---

@@ -486,9 +784,18 @@ docker exec aria-core ssh aria-wohnung hostname
 - **Proxy Cold Start**: Jede Nachricht spawnt einen neuen `claude --print` Prozess.
  Dadurch ist ARIA langsamer als die direkte Claude CLI. Timeout ist auf 900s (15 Min).
 - **Kein Streaming zur App**: Die App zeigt erst die fertige Antwort, keine Streaming-Tokens.
- **Wake Word nur auf VM**: Die Bridge hoert auf "ARIA" ueber das lokale Mikrofon der VM.
-  In der App gibt es Energy-basierte Erkennung (Phase 1).
+- **Wake-Word in der App nur eingebaute Keywords**: `Hey Jarvis`, `Alexa`, `Hey Mycroft`,
+  `Hey Rhasspy` funktionieren sofort, eigene Wake-Words muessen aktuell noch als
+  `.onnx`-Datei ins App-Bundle gelegt + zur Liste in `wakeword.ts` hinzugefuegt werden.
+  Die Diagnostic-Upload-UI ist Phase 2.
 - **Audio-Format**: App nimmt AAC/MP4 auf, Bridge konvertiert via FFmpeg zu 16kHz PCM.
+- **RVS Zombie-Connections**: WebSocket-Verbindungen sterben gelegentlich ohne Fehlermeldung.
+  Bridge hat Ping-Check (5s), Diagnostic nutzt frische Verbindungen pro Request.
+- **Bildanalyse eingeschraenkt**: Bilder werden in `/shared/uploads/` gespeichert. ARIA kann
+  sie per Bash/Read-Tool oeffnen, aber Claude Vision (direkte Bildanalyse) ist ueber den
+  Proxy-Pfad (`claude --print`) noch nicht moeglich. ARIA sieht den Dateipfad, nicht das Bild.
+- **Dateigroesse**: Grosse Dateien (>5MB) koennen WebSocket-Limits ueberschreiten.
+  Bilder werden in der App auf max 1920x1920px @ 80% Qualitaet komprimiert.

 ---

@@ -504,8 +811,38 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] Android App (Chat + Sprache + Uploads)
 - [x] Tool-Permissions (alle Tools freigeschaltet)
 - [x] SSH-Zugriff auf VM (aria-wohnung)
- [x] Diagnostic Web-UI
+- [x] Diagnostic Web-UI + Einstellungen
 - [x] Session-Verwaltung + Chat-History
+- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed, Highlight-Trigger) — durch XTTS v2 Voice Cloning ersetzt
+- [x] 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
+- [x] Datei-/Bild-Upload mit Shared Volume
+- [x] Watchdog (stuck Run Erkennung + Auto-Fix + Container-Restart)
+- [x] Auto-Update System (APK via RVS)
+- [x] Chat-Suche, Play-Button, Abbrechen-Button
+- [x] XTTS v2 Integration (GPU, Voice Cloning, remote ueber RVS)
+- [x] Gespraechsmodus (Ohr-Button, automatische Aufnahme nach ARIA-Antwort)
+- [x] Mehrere Anhaenge + Text vor dem Senden + Paste-Support
+- [x] Markdown-Bereinigung fuer TTS
+- [x] Auto-Update mit FileProvider + Update-Check Button
+- [x] Inverted FlatList (zuverlaessiges Scroll-to-Bottom)
+- [x] Speech Gate (VAD verwirft Aufnahme ohne erkannte Sprache)
+- [x] Session-Persistenz ueber Container-Restarts (sessionFromFile + atomic write)
+- [x] Session-Export als Markdown-Datei (Download-Button pro Session)
+- [x] "ARIA denkt..."-Indicator + Abbrechen-Button in App (via Bridge → RVS)
+- [x] Whisper-Modell waehlbar in Diagnostic (tiny…large-v3, Hot-Reload)
+- [x] App-Aufnahme explizit 16kHz mono (optimal fuer Whisper, kein Resample)
+- [x] Streaming TTS Pre-Roll-Buffer + Wartezeit auf playbackHeadPosition (kein Cutoff mid-Satz mehr)
+- [x] Pre-Roll-Buffer einstellbar in App-Settings
+- [x] Decimal-zu-Worte fuer TTS + generisches Acronym-Buchstabieren
+- [x] voice_preload/voice_ready: visueller Status-Indikator beim Stimmen-Wechsel
+- [x] Whisper STT auf die Gamebox ausgelagert (CUDA float16, fast Echtzeit)
+- [x] **F5-TTS ersetzt XTTS** — bessere Voice-Cloning-Qualitaet, Whisper-auto-transkribierter Referenz-Text
+- [x] Audio-Pause statt Ducking (TRANSIENT statt MAY_DUCK) + release-Timing fix
+- [x] VAD-Stille-Toleranz und Max-Aufnahme einstellbar (1-8s, 120s)
+- [x] 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

@@ -513,11 +850,13 @@ docker exec aria-core ssh aria-wohnung hostname
 - [ ] Gitea-Integration
 - [ ] VM einrichten (Desktop, Browser, Tools)
 - [ ] Heartbeat (periodische Selbst-Checks)
- [ ] Lokales LLM als Wächter (Triage vor Claude-Call)
+- [ ] Lokales LLM als Waechter (Triage vor Claude-Call)
+- [ ] Auto-Compacting / Memory-Verwaltung

 ### Phase 3 — Erweiterungen

 - [ ] STARFACE Telefonie-Skill
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
- [ ] Porcupine Wake Word (on-device "ARIA" in der App)
+- [ ] Custom-`.onnx`-Upload fuer Wake-Word ueber Diagnostic (ohne App-Rebuild)
+- [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)
@@ -1,245 +0,0 @@
-package org.gradle.accessors.dm;
-
-import org.gradle.api.NonNullApi;
-import org.gradle.api.artifacts.MinimalExternalModuleDependency;
-import org.gradle.plugin.use.PluginDependency;
-import org.gradle.api.artifacts.ExternalModuleDependencyBundle;
-import org.gradle.api.artifacts.MutableVersionConstraint;
-import org.gradle.api.provider.Provider;
-import org.gradle.api.model.ObjectFactory;
-import org.gradle.api.provider.ProviderFactory;
-import org.gradle.api.internal.catalog.AbstractExternalDependencyFactory;
-import org.gradle.api.internal.catalog.DefaultVersionCatalog;
-import java.util.Map;
-import org.gradle.api.internal.attributes.ImmutableAttributesFactory;
-import org.gradle.api.internal.artifacts.dsl.CapabilityNotationParser;
-import javax.inject.Inject;
-
-/**
- * A catalog of dependencies accessible via the `libs` extension.
- */
-@NonNullApi
-public class LibrariesForLibs extends AbstractExternalDependencyFactory {
-
-    private final AbstractExternalDependencyFactory owner = this;
-    private final AndroidLibraryAccessors laccForAndroidLibraryAccessors = new AndroidLibraryAccessors(owner);
-    private final KotlinLibraryAccessors laccForKotlinLibraryAccessors = new KotlinLibraryAccessors(owner);
-    private final VersionAccessors vaccForVersionAccessors = new VersionAccessors(providers, config);
-    private final BundleAccessors baccForBundleAccessors = new BundleAccessors(objects, providers, config, attributesFactory, capabilityNotationParser);
-    private final PluginAccessors paccForPluginAccessors = new PluginAccessors(providers, config);
-
-    @Inject
-    public LibrariesForLibs(DefaultVersionCatalog config, ProviderFactory providers, ObjectFactory objects, ImmutableAttributesFactory attributesFactory, CapabilityNotationParser capabilityNotationParser) {
-        super(config, providers, objects, attributesFactory, capabilityNotationParser);
-    }
-
-        /**
-         * Creates a dependency provider for gson (com.google.code.gson:gson)
-         * This dependency was declared in catalog libs.versions.toml
-         */
-        public Provider<MinimalExternalModuleDependency> getGson() {
-            return create("gson");
-    }
-
-        /**
-         * Creates a dependency provider for guava (com.google.guava:guava)
-         * This dependency was declared in catalog libs.versions.toml
-         */
-        public Provider<MinimalExternalModuleDependency> getGuava() {
-            return create("guava");
-    }
-
-        /**
-         * Creates a dependency provider for javapoet (com.squareup:javapoet)
-         * This dependency was declared in catalog libs.versions.toml
-         */
-        public Provider<MinimalExternalModuleDependency> getJavapoet() {
-            return create("javapoet");
-    }
-
-        /**
-         * Creates a dependency provider for junit (junit:junit)
-         * This dependency was declared in catalog libs.versions.toml
-         */
-        public Provider<MinimalExternalModuleDependency> getJunit() {
-            return create("junit");
-    }
-
-    /**
-     * Returns the group of libraries at android
-     */
-    public AndroidLibraryAccessors getAndroid() {
-        return laccForAndroidLibraryAccessors;
-    }
-
-    /**
-     * Returns the group of libraries at kotlin
-     */
-    public KotlinLibraryAccessors getKotlin() {
-        return laccForKotlinLibraryAccessors;
-    }
-
-    /**
-     * Returns the group of versions at versions
-     */
-    public VersionAccessors getVersions() {
-        return vaccForVersionAccessors;
-    }
-
-    /**
-     * Returns the group of bundles at bundles
-     */
-    public BundleAccessors getBundles() {
-        return baccForBundleAccessors;
-    }
-
-    /**
-     * Returns the group of plugins at plugins
-     */
-    public PluginAccessors getPlugins() {
-        return paccForPluginAccessors;
-    }
-
-    public static class AndroidLibraryAccessors extends SubDependencyFactory {
-        private final AndroidGradleLibraryAccessors laccForAndroidGradleLibraryAccessors = new AndroidGradleLibraryAccessors(owner);
-
-        public AndroidLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-        /**
-         * Returns the group of libraries at android.gradle
-         */
-        public AndroidGradleLibraryAccessors getGradle() {
-            return laccForAndroidGradleLibraryAccessors;
-        }
-
-    }
-
-    public static class AndroidGradleLibraryAccessors extends SubDependencyFactory {
-
-        public AndroidGradleLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-            /**
-             * Creates a dependency provider for plugin (com.android.tools.build:gradle)
-             * This dependency was declared in catalog libs.versions.toml
-             */
-            public Provider<MinimalExternalModuleDependency> getPlugin() {
-                return create("android.gradle.plugin");
-        }
-
-    }
-
-    public static class KotlinLibraryAccessors extends SubDependencyFactory {
-        private final KotlinGradleLibraryAccessors laccForKotlinGradleLibraryAccessors = new KotlinGradleLibraryAccessors(owner);
-
-        public KotlinLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-        /**
-         * Returns the group of libraries at kotlin.gradle
-         */
-        public KotlinGradleLibraryAccessors getGradle() {
-            return laccForKotlinGradleLibraryAccessors;
-        }
-
-    }
-
-    public static class KotlinGradleLibraryAccessors extends SubDependencyFactory {
-
-        public KotlinGradleLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-            /**
-             * Creates a dependency provider for plugin (org.jetbrains.kotlin:kotlin-gradle-plugin)
-             * This dependency was declared in catalog libs.versions.toml
-             */
-            public Provider<MinimalExternalModuleDependency> getPlugin() {
-                return create("kotlin.gradle.plugin");
-        }
-
-    }
-
-    public static class VersionAccessors extends VersionFactory  {
-
-        public VersionAccessors(ProviderFactory providers, DefaultVersionCatalog config) { super(providers, config); }
-
-            /**
-             * Returns the version associated to this alias: agp (8.1.1)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getAgp() { return getVersion("agp"); }
-
-            /**
-             * Returns the version associated to this alias: gson (2.8.9)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getGson() { return getVersion("gson"); }
-
-            /**
-             * Returns the version associated to this alias: guava (31.0.1-jre)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getGuava() { return getVersion("guava"); }
-
-            /**
-             * Returns the version associated to this alias: javapoet (1.13.0)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getJavapoet() { return getVersion("javapoet"); }
-
-            /**
-             * Returns the version associated to this alias: junit (4.13.2)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getJunit() { return getVersion("junit"); }
-
-            /**
-             * Returns the version associated to this alias: kotlin (1.8.0)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getKotlin() { return getVersion("kotlin"); }
-
-    }
-
-    public static class BundleAccessors extends BundleFactory {
-
-        public BundleAccessors(ObjectFactory objects, ProviderFactory providers, DefaultVersionCatalog config, ImmutableAttributesFactory attributesFactory, CapabilityNotationParser capabilityNotationParser) { super(objects, providers, config, attributesFactory, capabilityNotationParser); }
-
-    }
-
-    public static class PluginAccessors extends PluginFactory {
-        private final KotlinPluginAccessors paccForKotlinPluginAccessors = new KotlinPluginAccessors(providers, config);
-
-        public PluginAccessors(ProviderFactory providers, DefaultVersionCatalog config) { super(providers, config); }
-
-        /**
-         * Returns the group of plugins at plugins.kotlin
-         */
-        public KotlinPluginAccessors getKotlin() {
-            return paccForKotlinPluginAccessors;
-        }
-
-    }
-
-    public static class KotlinPluginAccessors extends PluginFactory {
-
-        public KotlinPluginAccessors(ProviderFactory providers, DefaultVersionCatalog config) { super(providers, config); }
-
-            /**
-             * Creates a plugin provider for kotlin.jvm to the plugin id 'org.jetbrains.kotlin.jvm'
-             * This plugin was declared in catalog libs.versions.toml
-             */
-            public Provider<PluginDependency> getJvm() { return createPlugin("kotlin.jvm"); }
-
-    }
-
-}
@@ -1,298 +0,0 @@
-package org.gradle.accessors.dm;
-
-import org.gradle.api.NonNullApi;
-import org.gradle.api.artifacts.MinimalExternalModuleDependency;
-import org.gradle.plugin.use.PluginDependency;
-import org.gradle.api.artifacts.ExternalModuleDependencyBundle;
-import org.gradle.api.artifacts.MutableVersionConstraint;
-import org.gradle.api.provider.Provider;
-import org.gradle.api.model.ObjectFactory;
-import org.gradle.api.provider.ProviderFactory;
-import org.gradle.api.internal.catalog.AbstractExternalDependencyFactory;
-import org.gradle.api.internal.catalog.DefaultVersionCatalog;
-import java.util.Map;
-import org.gradle.api.internal.attributes.ImmutableAttributesFactory;
-import org.gradle.api.internal.artifacts.dsl.CapabilityNotationParser;
-import javax.inject.Inject;
-
-/**
- * A catalog of dependencies accessible via the `libs` extension.
- */
-@NonNullApi
-public class LibrariesForLibsInPluginsBlock extends AbstractExternalDependencyFactory {
-
-    private final AbstractExternalDependencyFactory owner = this;
-    private final AndroidLibraryAccessors laccForAndroidLibraryAccessors = new AndroidLibraryAccessors(owner);
-    private final KotlinLibraryAccessors laccForKotlinLibraryAccessors = new KotlinLibraryAccessors(owner);
-    private final VersionAccessors vaccForVersionAccessors = new VersionAccessors(providers, config);
-    private final BundleAccessors baccForBundleAccessors = new BundleAccessors(objects, providers, config, attributesFactory, capabilityNotationParser);
-    private final PluginAccessors paccForPluginAccessors = new PluginAccessors(providers, config);
-
-    @Inject
-    public LibrariesForLibsInPluginsBlock(DefaultVersionCatalog config, ProviderFactory providers, ObjectFactory objects, ImmutableAttributesFactory attributesFactory, CapabilityNotationParser capabilityNotationParser) {
-        super(config, providers, objects, attributesFactory, capabilityNotationParser);
-    }
-
-        /**
-         * Creates a dependency provider for gson (com.google.code.gson:gson)
-         * This dependency was declared in catalog libs.versions.toml
-     * @deprecated Will be removed in Gradle 9.0.
-         */
-    @Deprecated
-        public Provider<MinimalExternalModuleDependency> getGson() {
-        org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-            return create("gson");
-    }
-
-        /**
-         * Creates a dependency provider for guava (com.google.guava:guava)
-         * This dependency was declared in catalog libs.versions.toml
-     * @deprecated Will be removed in Gradle 9.0.
-         */
-    @Deprecated
-        public Provider<MinimalExternalModuleDependency> getGuava() {
-        org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-            return create("guava");
-    }
-
-        /**
-         * Creates a dependency provider for javapoet (com.squareup:javapoet)
-         * This dependency was declared in catalog libs.versions.toml
-     * @deprecated Will be removed in Gradle 9.0.
-         */
-    @Deprecated
-        public Provider<MinimalExternalModuleDependency> getJavapoet() {
-        org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-            return create("javapoet");
-    }
-
-        /**
-         * Creates a dependency provider for junit (junit:junit)
-         * This dependency was declared in catalog libs.versions.toml
-     * @deprecated Will be removed in Gradle 9.0.
-         */
-    @Deprecated
-        public Provider<MinimalExternalModuleDependency> getJunit() {
-        org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-            return create("junit");
-    }
-
-    /**
-     * Returns the group of libraries at android
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public AndroidLibraryAccessors getAndroid() {
-        org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-        return laccForAndroidLibraryAccessors;
-    }
-
-    /**
-     * Returns the group of libraries at kotlin
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public KotlinLibraryAccessors getKotlin() {
-        org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-        return laccForKotlinLibraryAccessors;
-    }
-
-    /**
-     * Returns the group of versions at versions
-     */
-    public VersionAccessors getVersions() {
-        return vaccForVersionAccessors;
-    }
-
-    /**
-     * Returns the group of bundles at bundles
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public BundleAccessors getBundles() {
-        org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-        return baccForBundleAccessors;
-    }
-
-    /**
-     * Returns the group of plugins at plugins
-     */
-    public PluginAccessors getPlugins() {
-        return paccForPluginAccessors;
-    }
-
-    /**
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public static class AndroidLibraryAccessors extends SubDependencyFactory {
-        private final AndroidGradleLibraryAccessors laccForAndroidGradleLibraryAccessors = new AndroidGradleLibraryAccessors(owner);
-
-        public AndroidLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-        /**
-         * Returns the group of libraries at android.gradle
-         * @deprecated Will be removed in Gradle 9.0.
-         */
-        @Deprecated
-        public AndroidGradleLibraryAccessors getGradle() {
-            org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-            return laccForAndroidGradleLibraryAccessors;
-        }
-
-    }
-
-    /**
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public static class AndroidGradleLibraryAccessors extends SubDependencyFactory {
-
-        public AndroidGradleLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-            /**
-             * Creates a dependency provider for plugin (com.android.tools.build:gradle)
-             * This dependency was declared in catalog libs.versions.toml
-         * @deprecated Will be removed in Gradle 9.0.
-             */
-        @Deprecated
-            public Provider<MinimalExternalModuleDependency> getPlugin() {
-            org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-                return create("android.gradle.plugin");
-        }
-
-    }
-
-    /**
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public static class KotlinLibraryAccessors extends SubDependencyFactory {
-        private final KotlinGradleLibraryAccessors laccForKotlinGradleLibraryAccessors = new KotlinGradleLibraryAccessors(owner);
-
-        public KotlinLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-        /**
-         * Returns the group of libraries at kotlin.gradle
-         * @deprecated Will be removed in Gradle 9.0.
-         */
-        @Deprecated
-        public KotlinGradleLibraryAccessors getGradle() {
-            org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-            return laccForKotlinGradleLibraryAccessors;
-        }
-
-    }
-
-    /**
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public static class KotlinGradleLibraryAccessors extends SubDependencyFactory {
-
-        public KotlinGradleLibraryAccessors(AbstractExternalDependencyFactory owner) { super(owner); }
-
-            /**
-             * Creates a dependency provider for plugin (org.jetbrains.kotlin:kotlin-gradle-plugin)
-             * This dependency was declared in catalog libs.versions.toml
-         * @deprecated Will be removed in Gradle 9.0.
-             */
-        @Deprecated
-            public Provider<MinimalExternalModuleDependency> getPlugin() {
-            org.gradle.internal.deprecation.DeprecationLogger.deprecateBehaviour("Accessing libraries or bundles from version catalogs in the plugins block.").withAdvice("Only use versions or plugins from catalogs in the plugins block.").willBeRemovedInGradle9().withUpgradeGuideSection(8, "kotlin_dsl_deprecated_catalogs_plugins_block").nagUser();
-                return create("kotlin.gradle.plugin");
-        }
-
-    }
-
-    public static class VersionAccessors extends VersionFactory  {
-
-        public VersionAccessors(ProviderFactory providers, DefaultVersionCatalog config) { super(providers, config); }
-
-            /**
-             * Returns the version associated to this alias: agp (8.1.1)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getAgp() { return getVersion("agp"); }
-
-            /**
-             * Returns the version associated to this alias: gson (2.8.9)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getGson() { return getVersion("gson"); }
-
-            /**
-             * Returns the version associated to this alias: guava (31.0.1-jre)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getGuava() { return getVersion("guava"); }
-
-            /**
-             * Returns the version associated to this alias: javapoet (1.13.0)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getJavapoet() { return getVersion("javapoet"); }
-
-            /**
-             * Returns the version associated to this alias: junit (4.13.2)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getJunit() { return getVersion("junit"); }
-
-            /**
-             * Returns the version associated to this alias: kotlin (1.8.0)
-             * If the version is a rich version and that its not expressible as a
-             * single version string, then an empty string is returned.
-             * This version was declared in catalog libs.versions.toml
-             */
-            public Provider<String> getKotlin() { return getVersion("kotlin"); }
-
-    }
-
-    /**
-     * @deprecated Will be removed in Gradle 9.0.
-     */
-    @Deprecated
-    public static class BundleAccessors extends BundleFactory {
-
-        public BundleAccessors(ObjectFactory objects, ProviderFactory providers, DefaultVersionCatalog config, ImmutableAttributesFactory attributesFactory, CapabilityNotationParser capabilityNotationParser) { super(objects, providers, config, attributesFactory, capabilityNotationParser); }
-
-    }
-
-    public static class PluginAccessors extends PluginFactory {
-        private final KotlinPluginAccessors paccForKotlinPluginAccessors = new KotlinPluginAccessors(providers, config);
-
-        public PluginAccessors(ProviderFactory providers, DefaultVersionCatalog config) { super(providers, config); }
-
-        /**
-         * Returns the group of plugins at plugins.kotlin
-         */
-        public KotlinPluginAccessors getKotlin() {
-            return paccForKotlinPluginAccessors;
-        }
-
-    }
-
-    public static class KotlinPluginAccessors extends PluginFactory {
-
-        public KotlinPluginAccessors(ProviderFactory providers, DefaultVersionCatalog config) { super(providers, config); }
-
-            /**
-             * Creates a plugin provider for kotlin.jvm to the plugin id 'org.jetbrains.kotlin.jvm'
-             * This plugin was declared in catalog libs.versions.toml
-             */
-            public Provider<PluginDependency> getJvm() { return createPlugin("kotlin.jvm"); }
-
-    }
-
-}
@@ -1,2 +0,0 @@
-#Sun Mar 29 11:32:18 CEST 2026
-gradle.version=8.3
@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 1
-        versionName "1.0"
+        versionCode 702
+        versionName "0.0.7.2"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -104,6 +104,19 @@ android {
            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
        }
    }
+
+    // ABI-Split: nur arm64-v8a (jedes Android-Phone seit ~2017). Bringt die
+    // APK von ~136 MB auf ~35 MB — relevant weil ONNX Runtime + die anderen
+    // Native-Libs sonst pro Architektur dazukommen. Wer 32-bit oder Emulator
+    // braucht, kann hier "armeabi-v7a", "x86_64" etc. ergaenzen.
+    splits {
+        abi {
+            enable true
+            reset()
+            include "arm64-v8a"
+            universalApk false
+        }
+    }
 }

 dependencies {
@@ -111,6 +124,9 @@ dependencies {
    implementation("com.facebook.react:react-android")
    implementation("com.facebook.react:flipper-integration")

+    // ONNX Runtime fuer on-device Wake-Word (openWakeWord ONNX-Modelle in assets/openwakeword/)
+    implementation("com.microsoft.onnxruntime:onnxruntime-android:1.17.1")
+
    if (hermesEnabled.toBoolean()) {
        implementation("com.facebook.react:hermes-android")
    } else {
@@ -1,97 +0,0 @@
-
-package com.facebook.react;
-
-import android.app.Application;
-import android.content.Context;
-import android.content.res.Resources;
-
-import com.facebook.react.ReactPackage;
-import com.facebook.react.shell.MainPackageConfig;
-import com.facebook.react.shell.MainReactPackage;
-import java.util.Arrays;
-import java.util.ArrayList;
-
-// react-native-screens
-import com.swmansion.rnscreens.RNScreensPackage;
-// react-native-safe-area-context
-import com.th3rdwave.safeareacontext.SafeAreaContextPackage;
-// react-native-document-picker
-import com.reactnativedocumentpicker.RNDocumentPickerPackage;
-// react-native-sound
-import com.zmxv.RNSound.RNSoundPackage;
-// @react-native-community/geolocation
-import com.reactnativecommunity.geolocation.GeolocationPackage;
-// react-native-image-picker
-import com.imagepicker.ImagePickerPackage;
-// react-native-permissions
-import com.zoontek.rnpermissions.RNPermissionsPackage;
-// react-native-camera-kit
-import com.rncamerakit.RNCameraKitPackage;
-// @react-native-async-storage/async-storage
-import com.reactnativecommunity.asyncstorage.AsyncStoragePackage;
-// react-native-fs
-import com.rnfs.RNFSPackage;
-// react-native-audio-recorder-player
-import com.dooboolab.audiorecorderplayer.RNAudioRecorderPlayerPackage;
-// react-native-live-audio-stream
-import com.imxiqi.rnliveaudiostream.RNLiveAudioStreamPackage;
-
-public class PackageList {
-  private Application application;
-  private ReactNativeHost reactNativeHost;
-  private MainPackageConfig mConfig;
-
-  public PackageList(ReactNativeHost reactNativeHost) {
-    this(reactNativeHost, null);
-  }
-
-  public PackageList(Application application) {
-    this(application, null);
-  }
-
-  public PackageList(ReactNativeHost reactNativeHost, MainPackageConfig config) {
-    this.reactNativeHost = reactNativeHost;
-    mConfig = config;
-  }
-
-  public PackageList(Application application, MainPackageConfig config) {
-    this.reactNativeHost = null;
-    this.application = application;
-    mConfig = config;
-  }
-
-  private ReactNativeHost getReactNativeHost() {
-    return this.reactNativeHost;
-  }
-
-  private Resources getResources() {
-    return this.getApplication().getResources();
-  }
-
-  private Application getApplication() {
-    if (this.reactNativeHost == null) return this.application;
-    return this.reactNativeHost.getApplication();
-  }
-
-  private Context getApplicationContext() {
-    return this.getApplication().getApplicationContext();
-  }
-
-  public ArrayList<ReactPackage> getPackages() {
-    return new ArrayList<>(Arrays.<ReactPackage>asList(
-      new MainReactPackage(mConfig),
-      new RNScreensPackage(),
-      new SafeAreaContextPackage(),
-      new RNDocumentPickerPackage(),
-      new RNSoundPackage(),
-      new GeolocationPackage(),
-      new ImagePickerPackage(),
-      new RNPermissionsPackage(),
-      new RNCameraKitPackage(),
-      new AsyncStoragePackage(),
-      new RNFSPackage(),
-      new RNAudioRecorderPlayerPackage(),
-      new RNLiveAudioStreamPackage()
-    ));
-  }
-}
@@ -1,16 +0,0 @@
-/**
- * Automatically generated file. DO NOT MODIFY
- */
-package com.ariacockpit;
-
-public final class BuildConfig {
-  public static final boolean DEBUG = false;
-  public static final String APPLICATION_ID = "com.ariacockpit";
-  public static final String BUILD_TYPE = "release";
-  public static final int VERSION_CODE = 1;
-  public static final String VERSION_NAME = "1.0";
-  // Field from default config.
-  public static final boolean IS_HERMES_ENABLED = true;
-  // Field from default config.
-  public static final boolean IS_NEW_ARCHITECTURE_ENABLED = false;
-}
@@ -1,24 +0,0 @@
-{
-  "schemaVersion": "1.1.0",
-  "buildSystem": "Gradle",
-  "buildSystemVersion": "8.3",
-  "buildPlugin": "org.jetbrains.kotlin.gradle.plugin.KotlinAndroidPluginWrapper",
-  "buildPluginVersion": "1.8.0",
-  "projectSettings": {
-    "isHmppEnabled": true,
-    "isCompatibilityMetadataVariantEnabled": false,
-    "isKPMEnabled": false
-  },
-  "projectTargets": [
-    {
-      "target": "org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget",
-      "platformType": "androidJvm",
-      "extras": {
-        "android": {
-          "sourceCompatibility": "17",
-          "targetCompatibility": "17"
-        }
-      }
-    }
-  ]
-}
@@ -3,6 +3,9 @@
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+    <!-- Anruf-State lesen damit TTS bei klingelndem Telefon pausiert -->
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

    <application
      android:name=".MainApplication"
@@ -24,5 +27,15 @@
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
      </activity>
+
+      <provider
+        android:name="androidx.core.content.FileProvider"
+        android:authorities="${applicationId}.fileprovider"
+        android:exported="false"
+        android:grantUriPermissions="true">
+        <meta-data
+          android:name="android.support.FILE_PROVIDER_PATHS"
+          android:resource="@xml/file_paths" />
+      </provider>
    </application>
 </manifest>
@@ -0,0 +1,44 @@
+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.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import java.io.File
+
+class ApkInstallerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "ApkInstaller"
+
+    @ReactMethod
+    fun install(filePath: String, promise: Promise) {
+        try {
+            val file = File(filePath)
+            if (!file.exists()) {
+                promise.reject("FILE_NOT_FOUND", "APK nicht gefunden: $filePath")
+                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 intent = Intent(Intent.ACTION_VIEW).apply {
+                setDataAndType(uri, "application/vnd.android.package-archive")
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            }
+
+            context.startActivity(intent)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("INSTALL_ERROR", e.message, e)
+        }
+    }
+}
@@ -0,0 +1,16 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ApkInstallerPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(ApkInstallerModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
@@ -0,0 +1,99 @@
+package com.ariacockpit
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+/**
+ * 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
+ */
+class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "AudioFocus"
+
+    private var currentRequest: AudioFocusRequest? = null
+
+    private fun audioManager(): AudioManager? =
+        reactApplicationContext.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+
+    private fun requestFocus(durationHint: Int, usage: Int, promise: Promise) {
+        val am = audioManager()
+        if (am == null) {
+            promise.reject("NO_AUDIO_MANAGER", "AudioManager nicht verfuegbar")
+            return
+        }
+
+        release()
+
+        val result: Int = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val attrs = AudioAttributes.Builder()
+                .setUsage(usage)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                .build()
+            val req = AudioFocusRequest.Builder(durationHint)
+                .setAudioAttributes(attrs)
+                .setOnAudioFocusChangeListener { /* kein Callback noetig */ }
+                .build()
+            currentRequest = req
+            am.requestAudioFocus(req)
+        } else {
+            @Suppress("DEPRECATION")
+            am.requestAudioFocus(null, AudioManager.STREAM_MUSIC, durationHint)
+        }
+
+        promise.resolve(result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
+    }
+
+    /** Andere Apps werden pausiert (TTS spricht).
+     *
+     *  TRANSIENT (statt TRANSIENT_MAY_DUCK): Spotify/YouTube pausieren komplett
+     *  statt nur leiser zu werden. Verhindert auch das "kommt-wieder-hoch"-
+     *  Problem mit MAY_DUCK, wo das System nach kurzer Zeit den Duck-Effekt
+     *  wieder aufgehoben hat obwohl wir den Fokus noch hielten.
+     */
+    @ReactMethod
+    fun requestDuck(promise: Promise) {
+        requestFocus(
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT,
+            AudioAttributes.USAGE_ASSISTANT,
+            promise,
+        )
+    }
+
+    /** Andere Apps werden pausiert (Mikrofon-Aufnahme / Gespraech). */
+    @ReactMethod
+    fun requestExclusive(promise: Promise) {
+        requestFocus(
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE,
+            AudioAttributes.USAGE_VOICE_COMMUNICATION,
+            promise,
+        )
+    }
+
+    /** Focus abgeben — andere Apps duerfen wieder volle Lautstaerke. */
+    @ReactMethod
+    fun release(promise: Promise) {
+        release()
+        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(null)
+        }
+        currentRequest = null
+    }
+}
@@ -0,0 +1,16 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class AudioFocusPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(AudioFocusModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
@@ -18,8 +18,11 @@ class MainApplication : Application(), ReactApplication {
      object : DefaultReactNativeHost(this) {
        override fun getPackages(): List<ReactPackage> =
            PackageList(this).packages.apply {
-              // Packages that cannot be autolinked yet can be added manually here, for example:
-              // add(MyReactNativePackage())
+              add(ApkInstallerPackage())
+              add(AudioFocusPackage())
+              add(PcmStreamPlayerPackage())
+              add(OpenWakeWordPackage())
+              add(PhoneCallPackage())
            }

        override fun getJSMainModuleName(): String = "index"
@@ -0,0 +1,369 @@
+package com.ariacockpit
+
+import ai.onnxruntime.OnnxTensor
+import ai.onnxruntime.OrtEnvironment
+import ai.onnxruntime.OrtSession
+import android.Manifest
+import android.content.pm.PackageManager
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaRecorder
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.nio.FloatBuffer
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Wake-Word Erkennung on-device via openWakeWord (https://github.com/dscripka/openWakeWord).
+ *
+ * Drei-stufige ONNX Pipeline:
+ *   1. Audio (16kHz mono int16, 1280-Sample-Chunks) → Melspectrogram → 32-mel Frames
+ *   2. 76 Mel-Frames Sliding Window (stride 8) → Speech-Embedding → 96-dim Vektor
+ *   3. Letzte 16 Embeddings (~1.28s Kontext) → Wake-Word-Klassifikator → Sigmoid-Score
+ *
+ *  Modelle liegen in assets/openwakeword/ (mel + embedding shared, plus pro Keyword
+ *  ein eigenes .onnx). Erkennung feuert nach `patience` aufeinanderfolgenden
+ *  Frames ueber `threshold` und unterdrueckt Wiederholungen fuer `debounceMs`.
+ *
+ *  Emittiert "WakeWordDetected" als RN-Event wenn ein Trigger erkannt wurde.
+ */
+class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "OpenWakeWord"
+
+    companion object {
+        private const val TAG = "OpenWakeWord"
+        private const val SAMPLE_RATE = 16000
+        private const val CHUNK_SAMPLES = 1280               // 80ms @ 16kHz
+        private const val MEL_FRAMES_PER_EMBEDDING = 76      // Embedding-Fenster
+        private const val EMBEDDING_STRIDE = 8               // Slide um 8 Mel-Frames
+        private const val EMBEDDING_DIM = 96
+        private const val MEL_BINS = 32
+        private const val DEFAULT_WW_INPUT_FRAMES = 16       // Fallback wenn Modell-Metadata fehlt
+    }
+
+    private val env: OrtEnvironment = OrtEnvironment.getEnvironment()
+    private var melSession: OrtSession? = null
+    private var embSession: OrtSession? = null
+    private var wwSession: OrtSession? = null
+
+    private var melInputName: String = "input"
+    private var embInputName: String = "input_1"
+    private var wwInputName: String = "input"
+    // Anzahl Embedding-Frames die der Wake-Word-Klassifikator pro Inferenz erwartet —
+    // hey_jarvis hat 16, andere Community-Modelle koennen abweichen (z.B. 28).
+    // Wird beim init() aus den Modell-Metadaten gelesen.
+    private var wwInputFrames: Int = DEFAULT_WW_INPUT_FRAMES
+
+    // Konfiguration
+    private var threshold: Float = 0.5f
+    private var patience: Int = 2
+    private var debounceMs: Long = 1500
+    private var modelName: String = "hey_jarvis"
+
+    // Audio-Capture-Thread
+    private var audioRecord: AudioRecord? = null
+    private val running = AtomicBoolean(false)
+    private var captureThread: Thread? = null
+
+    // Inferenz-State
+    private val melBuffer: ArrayList<FloatArray> = ArrayList(256)   // Liste von 32-dim Frames
+    private var melProcessedIdx: Int = 0
+    private val embBuffer: ArrayDeque<FloatArray> = ArrayDeque(32)  // Ringpuffer letzter Embeddings
+    private var consecutiveAboveThreshold: Int = 0
+    private var lastDetectionMs: Long = 0L
+
+    /**
+     *  Initialisiert die ONNX-Sessions fuer ein bestimmtes Wake-Word.
+     *  modelName: dateiname ohne Suffix (z.B. "hey_jarvis", "alexa", "hey_mycroft", "hey_rhasspy")
+     */
+    @ReactMethod
+    fun init(modelName: String, threshold: Double, patience: Int, debounceMs: Int, promise: Promise) {
+        try {
+            disposeSessions()
+            this.modelName = modelName
+            this.threshold = threshold.toFloat()
+            this.patience = patience.coerceAtLeast(1)
+            this.debounceMs = debounceMs.toLong()
+
+            val ctx = reactApplicationContext
+            val melBytes = ctx.assets.open("openwakeword/melspectrogram.onnx").use { it.readBytes() }
+            val embBytes = ctx.assets.open("openwakeword/embedding_model.onnx").use { it.readBytes() }
+            val wwBytes = ctx.assets.open("openwakeword/$modelName.onnx").use { it.readBytes() }
+
+            val opts = OrtSession.SessionOptions()
+            melSession = env.createSession(melBytes, opts)
+            embSession = env.createSession(embBytes, opts)
+            wwSession = env.createSession(wwBytes, opts)
+
+            melInputName = melSession!!.inputNames.first()
+            embInputName = embSession!!.inputNames.first()
+            wwInputName = wwSession!!.inputNames.first()
+
+            // WW-Input-Frame-Count aus dem Modell lesen — variiert pro Keyword.
+            // Erwartete Form: (1, N, 96), N steht in der Modell-Metadaten.
+            val wwInputInfo = wwSession!!.inputInfo[wwInputName]
+            val wwShape = (wwInputInfo?.info as? ai.onnxruntime.TensorInfo)?.shape
+            wwInputFrames = wwShape?.getOrNull(1)?.toInt()?.takeIf { it > 0 } ?: DEFAULT_WW_INPUT_FRAMES
+
+            Log.i(TAG, "Init OK: model=$modelName wwFrames=$wwInputFrames threshold=$threshold patience=$patience " +
+                    "debounce=${debounceMs}ms (inputs: mel=$melInputName emb=$embInputName ww=$wwInputName)")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "Init fehlgeschlagen: ${e.message}", e)
+            disposeSessions()
+            promise.reject("INIT_FAILED", e.message ?: "Unbekannter Fehler", e)
+        }
+    }
+
+    @ReactMethod
+    fun start(promise: Promise) {
+        if (running.get()) {
+            promise.resolve(true)
+            return
+        }
+        if (melSession == null || embSession == null || wwSession == null) {
+            promise.reject("NOT_INITIALIZED", "init() muss vor start() aufgerufen werden")
+            return
+        }
+        // Berechtigung pruefen — der App-Code holt die ueblicherweise schon vorher,
+        // aber wir bestehen hier explizit darauf damit AudioRecord nicht stumm
+        // failt.
+        val perm = ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.RECORD_AUDIO)
+        if (perm != PackageManager.PERMISSION_GRANTED) {
+            promise.reject("NO_MIC_PERMISSION", "RECORD_AUDIO Permission fehlt")
+            return
+        }
+
+        try {
+            val minBuf = AudioRecord.getMinBufferSize(
+                SAMPLE_RATE,
+                AudioFormat.CHANNEL_IN_MONO,
+                AudioFormat.ENCODING_PCM_16BIT,
+            ).coerceAtLeast(CHUNK_SAMPLES * 2 * 4)
+
+            val record = AudioRecord(
+                MediaRecorder.AudioSource.MIC,
+                SAMPLE_RATE,
+                AudioFormat.CHANNEL_IN_MONO,
+                AudioFormat.ENCODING_PCM_16BIT,
+                minBuf,
+            )
+            if (record.state != AudioRecord.STATE_INITIALIZED) {
+                record.release()
+                promise.reject("AUDIO_INIT", "AudioRecord nicht initialisiert (Mikro belegt?)")
+                return
+            }
+            audioRecord = record
+            resetInferenceState()
+            running.set(true)
+            record.startRecording()
+
+            captureThread = Thread({ captureLoop() }, "OpenWakeWordCapture").apply {
+                isDaemon = true
+                start()
+            }
+
+            Log.i(TAG, "Lauschen gestartet (model=$modelName)")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "start fehlgeschlagen", e)
+            running.set(false)
+            audioRecord?.release()
+            audioRecord = null
+            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
+        }
+    }
+
+    @ReactMethod
+    fun stop(promise: Promise) {
+        running.set(false)
+        try {
+            captureThread?.join(1500)
+        } catch (_: InterruptedException) {}
+        captureThread = null
+        try { audioRecord?.stop() } catch (_: Exception) {}
+        try { audioRecord?.release() } catch (_: Exception) {}
+        audioRecord = null
+        Log.i(TAG, "Lauschen gestoppt")
+        promise.resolve(true)
+    }
+
+    @ReactMethod
+    fun dispose(promise: Promise) {
+        running.set(false)
+        try { captureThread?.join(1000) } catch (_: InterruptedException) {}
+        captureThread = null
+        try { audioRecord?.stop() } catch (_: Exception) {}
+        try { audioRecord?.release() } catch (_: Exception) {}
+        audioRecord = null
+        disposeSessions()
+        promise.resolve(true)
+    }
+
+    @ReactMethod
+    fun isAvailable(promise: Promise) {
+        // Wake-Word ist immer verfuegbar (kein API-Key, alles on-device)
+        promise.resolve(true)
+    }
+
+    // RN-Event-Subscriptions — RN-Konvention, sonst Warnung im Debug-Build
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+
+    private fun disposeSessions() {
+        try { melSession?.close() } catch (_: Exception) {}
+        try { embSession?.close() } catch (_: Exception) {}
+        try { wwSession?.close() } catch (_: Exception) {}
+        melSession = null
+        embSession = null
+        wwSession = null
+    }
+
+    private fun resetInferenceState() {
+        melBuffer.clear()
+        melProcessedIdx = 0
+        embBuffer.clear()
+        consecutiveAboveThreshold = 0
+        lastDetectionMs = 0L
+    }
+
+    private fun emitDetected() {
+        val params = com.facebook.react.bridge.Arguments.createMap().apply {
+            putString("model", modelName)
+        }
+        try {
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("WakeWordDetected", params)
+        } catch (e: Exception) {
+            Log.w(TAG, "emit fehlgeschlagen: ${e.message}")
+        }
+    }
+
+    private fun captureLoop() {
+        val buf = ShortArray(CHUNK_SAMPLES)
+        val record = audioRecord ?: return
+        Log.i(TAG, "Capture-Loop gestartet")
+        while (running.get()) {
+            var read = 0
+            while (read < CHUNK_SAMPLES && running.get()) {
+                val n = record.read(buf, read, CHUNK_SAMPLES - read)
+                if (n <= 0) {
+                    Log.w(TAG, "AudioRecord.read returned $n — Loop ende")
+                    running.set(false)
+                    return
+                }
+                read += n
+            }
+            if (!running.get()) break
+            try {
+                processChunk(buf)
+            } catch (e: Exception) {
+                Log.w(TAG, "processChunk: ${e.message}")
+            }
+        }
+        Log.i(TAG, "Capture-Loop beendet")
+    }
+
+    /** Verarbeitet einen 1280-Sample int16 Audio-Chunk. */
+    private fun processChunk(audio: ShortArray) {
+        // 1) Audio → mel (output (1, 1, frames, 32))
+        val floats = FloatArray(audio.size) { audio[it].toFloat() }
+        val melTensor = OnnxTensor.createTensor(
+            env,
+            FloatBuffer.wrap(floats),
+            longArrayOf(1L, audio.size.toLong()),
+        )
+        val melResult = melSession!!.run(mapOf(melInputName to melTensor))
+        val melOut = melResult.get(0).value
+        melTensor.close()
+        @Suppress("UNCHECKED_CAST")
+        val mel4 = melOut as Array<Array<Array<FloatArray>>>
+        val frames = mel4[0][0]
+        // openWakeWord wendet `mel/10 + 2` an, bevor es ans Embedding-Modell geht
+        for (frame in frames) {
+            val scaled = FloatArray(frame.size) { frame[it] / 10f + 2f }
+            melBuffer.add(scaled)
+        }
+        melResult.close()
+
+        // 2) Sliding window: alle vollstaendigen 76-Frame-Fenster verarbeiten
+        while (melBuffer.size >= melProcessedIdx + MEL_FRAMES_PER_EMBEDDING) {
+            val flat = FloatArray(MEL_FRAMES_PER_EMBEDDING * MEL_BINS)
+            var pos = 0
+            for (i in 0 until MEL_FRAMES_PER_EMBEDDING) {
+                val src = melBuffer[melProcessedIdx + i]
+                System.arraycopy(src, 0, flat, pos, MEL_BINS)
+                pos += MEL_BINS
+            }
+            val embIn = OnnxTensor.createTensor(
+                env,
+                FloatBuffer.wrap(flat),
+                longArrayOf(1L, MEL_FRAMES_PER_EMBEDDING.toLong(), MEL_BINS.toLong(), 1L),
+            )
+            val embRes = embSession!!.run(mapOf(embInputName to embIn))
+            val embOut = embRes.get(0).value
+            embIn.close()
+            // Erwartete Output-Form: (1, 1, 1, 96) — rank-4, NICHT (1, 96).
+            // Die Google-Embedding-Pipeline behaelt extra Dimensionen.
+            @Suppress("UNCHECKED_CAST")
+            val embArr = embOut as Array<Array<Array<FloatArray>>>
+            embBuffer.addLast(embArr[0][0][0].copyOf())
+            while (embBuffer.size > wwInputFrames) embBuffer.removeFirst()
+            embRes.close()
+
+            melProcessedIdx += EMBEDDING_STRIDE
+        }
+        // Mel-Buffer trimmen — verhindert Memory-Wachstum
+        if (melProcessedIdx > MEL_FRAMES_PER_EMBEDDING) {
+            val keepFrom = melProcessedIdx - MEL_FRAMES_PER_EMBEDDING
+            val newList = ArrayList<FloatArray>(melBuffer.size - keepFrom)
+            for (i in keepFrom until melBuffer.size) newList.add(melBuffer[i])
+            melBuffer.clear()
+            melBuffer.addAll(newList)
+            melProcessedIdx = MEL_FRAMES_PER_EMBEDDING
+        }
+
+        // 3) Klassifikation — sobald wir 16 Embeddings haben
+        if (embBuffer.size < wwInputFrames) return
+        val flatEmb = FloatArray(wwInputFrames * EMBEDDING_DIM)
+        var p = 0
+        // Letzte wwInputFrames Embeddings nehmen (embBuffer ist auf wwInputFrames begrenzt)
+        for (e in embBuffer) {
+            System.arraycopy(e, 0, flatEmb, p, EMBEDDING_DIM)
+            p += EMBEDDING_DIM
+        }
+        val wwIn = OnnxTensor.createTensor(
+            env,
+            FloatBuffer.wrap(flatEmb),
+            longArrayOf(1L, wwInputFrames.toLong(), EMBEDDING_DIM.toLong()),
+        )
+        val wwRes = wwSession!!.run(mapOf(wwInputName to wwIn))
+        val wwOut = wwRes.get(0).value
+        wwIn.close()
+        // Erwartete Output-Form: (1, 1) → Array<FloatArray>
+        @Suppress("UNCHECKED_CAST")
+        val score = (wwOut as Array<FloatArray>)[0][0]
+        wwRes.close()
+
+        if (score >= threshold) {
+            consecutiveAboveThreshold++
+            if (consecutiveAboveThreshold >= patience) {
+                val now = System.currentTimeMillis()
+                if (now - lastDetectionMs >= debounceMs) {
+                    lastDetectionMs = now
+                    consecutiveAboveThreshold = 0
+                    Log.i(TAG, "Wake-Word erkannt! score=$score model=$modelName")
+                    emitDetected()
+                }
+            }
+        } else {
+            consecutiveAboveThreshold = 0
+        }
+    }
+}
@@ -0,0 +1,16 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class OpenWakeWordPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(OpenWakeWordModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
@@ -0,0 +1,330 @@
+package com.ariacockpit
+
+import android.media.AudioAttributes
+import android.media.AudioFormat
+import android.media.AudioManager
+import android.media.AudioTrack
+import android.util.Base64
+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
+import java.util.concurrent.LinkedBlockingQueue
+
+/**
+ * Streamt PCM-s16le Audio direkt via AudioTrack MODE_STREAM mit Pre-Roll.
+ *
+ * Pre-Roll: AudioTrack wird zwar direkt gebaut und gefuttert, aber play()
+ * wird erst aufgerufen wenn PREROLL_SECONDS Audio im Buffer ist. So hat
+ * der Stream Zeit einen Vorrat aufzubauen — wenn XTTS mit RTF>1 rendert
+ * (langsamer als Echtzeit), laeuft der Buffer trotzdem nicht leer.
+ *
+ * Flow:
+ *   JS: start(sampleRate, channels) → öffnet AudioTrack (noch nicht play())
+ *   JS: writeChunk(base64)           → dekodiert, queued, Writer schreibt
+ *   Writer: spielt los sobald PREROLL erreicht ist
+ *   JS: end()                         → wartet bis Queue leer, schließt
+ *   JS: stop()                        → Hart stoppen (Cancel)
+ */
+class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    companion object {
+        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 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
+    }
+
+    override fun getName() = "PcmStreamPlayer"
+
+    private var track: AudioTrack? = null
+    private val queue = LinkedBlockingQueue<ByteArray>()
+    private var writerThread: Thread? = null
+    @Volatile private var writerShouldStop = false
+    @Volatile private var endRequested = false
+    @Volatile private var prerollBytes: Int = 0
+    @Volatile private var playbackStarted = false
+    @Volatile private var bytesBuffered: Long = 0
+    @Volatile private var streamBytesPerFrame: Int = 2 // mono s16le default
+
+    // ── Lifecycle ──
+
+    @ReactMethod
+    fun start(sampleRate: Int, channels: Int, prerollSeconds: Double, promise: Promise) {
+        try {
+            // 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 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()
+            val bufferSize = (minBuf * 32).coerceAtLeast(prerollTarget * 2)
+            prerollBytes = prerollTarget
+            bytesBuffered = 0
+            playbackStarted = false
+            streamBytesPerFrame = channels * 2 // s16 = 2 bytes per sample
+
+            val newTrack = AudioTrack.Builder()
+                .setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_ASSISTANT)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                        .build(),
+                )
+                .setAudioFormat(
+                    AudioFormat.Builder()
+                        .setSampleRate(sampleRate)
+                        .setChannelMask(channelConfig)
+                        .setEncoding(encoding)
+                        .build(),
+                )
+                .setBufferSizeInBytes(bufferSize)
+                .setTransferMode(AudioTrack.MODE_STREAM)
+                .build()
+
+            // AudioTrack erstellen — play() wird erst aufgerufen wenn Pre-Roll erreicht.
+            track = newTrack
+            queue.clear()
+            writerShouldStop = false
+            endRequested = false
+
+            writerThread = Thread({
+                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)
+                        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
+                    }
+                    // Bei preroll=0: play() SOFORT nach Leading-Silence aufrufen,
+                    // nicht erst bei Ankunft des ersten echten Chunks. Android's
+                    // AudioTrack haelt den Play-State und wartet auf neue Samples.
+                    // So verschluckt es keine Worte wenn der erste Chunk erst
+                    // nach play()-Startup-Latenz eintrifft.
+                    if (prerollBytes == 0 && !playbackStarted) {
+                        try {
+                            t.play()
+                            playbackStarted = true
+                            Log.i(TAG, "Playback sofort gestartet (preroll=0, ${bytesBuffered}B silence)")
+                        } catch (e: Exception) {
+                            Log.w(TAG, "play() sofort failed: ${e.message}")
+                        }
+                    }
+                    // Idle-Cutoff: wenn endRequested NICHT kam aber 30s nichts mehr
+                    // reinkommt, brechen wir ab (Bridge-Crash, verlorener final).
+                    var idleMs = 0L
+                    val maxIdleMs = 30_000L
+                    // Zielpufferfuellung — unter diesem Wasserstand fuettern wir
+                    // Stille rein damit AudioTrack nicht underrunt waehrend die
+                    // Bridge den naechsten Satz rendert. Spotify/YouTube reagieren
+                    // sonst mit eigenmaechtiger Wiederaufnahme nach ~10s Stille.
+                    val underrunGuardFrames = sampleRate / 10  // ~100ms
+                    val silenceFillFrames = sampleRate / 20    // ~50ms pro Refill
+
+                    mainLoop@ while (!writerShouldStop) {
+                        val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS)
+                        if (data == null) {
+                            if (endRequested) {
+                                // Falls wir vor Pre-Roll enden (kurzer Text): trotzdem abspielen
+                                if (!playbackStarted) {
+                                    try {
+                                        t.play()
+                                        playbackStarted = true
+                                        Log.i(TAG, "Playback gestartet VOR Pre-Roll (kurzer Text, ${bytesBuffered}B gepuffert)")
+                                    } catch (e: Exception) {
+                                        Log.w(TAG, "play() fallback failed: ${e.message}")
+                                    }
+                                }
+                                break@mainLoop
+                            }
+                            // Underrun-Schutz: Stille reinfuettern wenn der AudioTrack-
+                            // Puffer leerzulaufen droht. Spotify resumed sonst nach
+                            // ~10s Pause auf eigene Faust, obwohl wir den Fokus halten.
+                            if (playbackStarted) {
+                                val framesWritten = bytesBuffered / streamBytesPerFrame
+                                val framesPlayed = t.playbackHeadPosition.toLong()
+                                val framesInBuffer = framesWritten - framesPlayed
+                                if (framesInBuffer < underrunGuardFrames) {
+                                    val fillBytes = silenceFillFrames * streamBytesPerFrame
+                                    val silence = ByteArray(fillBytes)
+                                    var silOff = 0
+                                    while (silOff < silence.size && !writerShouldStop) {
+                                        val w = t.write(silence, silOff, silence.size - silOff)
+                                        if (w <= 0) break
+                                        silOff += w
+                                    }
+                                    bytesBuffered += silence.size
+                                }
+                            }
+                            idleMs += 50L
+                            if (idleMs >= maxIdleMs) {
+                                Log.w(TAG, "Idle-Cutoff: ${maxIdleMs}ms keine Daten — Stream wird beendet")
+                                break@mainLoop
+                            }
+                            continue@mainLoop
+                        }
+                        idleMs = 0L
+
+                        // Pre-Roll Check: play() erst wenn genug gepuffert
+                        if (!playbackStarted && bytesBuffered + data.size >= prerollBytes) {
+                            try {
+                                t.play()
+                                playbackStarted = true
+                                Log.i(TAG, "Playback gestartet nach Pre-Roll ${bytesBuffered + data.size} Bytes")
+                            } catch (e: Exception) {
+                                Log.w(TAG, "play() failed: ${e.message}")
+                            }
+                        }
+
+                        var offset = 0
+                        while (offset < data.size && !writerShouldStop) {
+                            val written = t.write(data, offset, data.size - offset)
+                            if (written <= 0) break
+                            offset += written
+                        }
+                        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 {
+                    // Warten bis alle geschriebenen Samples tatsaechlich abgespielt sind,
+                    // sonst cuttet t.release() die letzten Sekunden ab.
+                    try {
+                        val totalFrames = (bytesBuffered / streamBytesPerFrame).toInt()
+                        var lastPos = -1
+                        var stalledCount = 0
+                        while (!writerShouldStop) {
+                            val pos = t.playbackHeadPosition
+                            if (pos >= totalFrames) break
+                            // Safety: wenn Position 2s nicht mehr vorwaerts → AudioTrack hing
+                            if (pos == lastPos) {
+                                stalledCount++
+                                if (stalledCount > 40) {
+                                    Log.w(TAG, "playback stalled at $pos/$totalFrames — give up")
+                                    break
+                                }
+                            } else {
+                                stalledCount = 0
+                                lastPos = pos
+                            }
+                            Thread.sleep(50)
+                        }
+                        Log.i(TAG, "Playback fertig: frames=$totalFrames pos=${t.playbackHeadPosition}")
+                    } catch (_: Exception) {}
+                    try { t.stop() } catch (_: Exception) {}
+                    try { t.release() } catch (_: Exception) {}
+                }
+            }, "PcmStreamWriter").apply { start() }
+
+            Log.i(TAG, "Stream gestartet: ${sampleRate}Hz ch=$channels buf=${bufferSize}B preroll=${prerollBytes}B (${prerollSec}s)")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "start fehlgeschlagen", e)
+            promise.reject("START_FAILED", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun writeChunk(base64Pcm: String, promise: Promise) {
+        try {
+            if (base64Pcm.isEmpty()) {
+                promise.resolve(true)
+                return
+            }
+            val bytes = Base64.decode(base64Pcm, Base64.DEFAULT)
+            queue.put(bytes)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("WRITE_FAILED", e.message, e)
+        }
+    }
+
+    /** Signalisiert: keine weiteren Chunks. Writer spielt aus, dann stoppt.
+     *  Das Promise resolved erst wenn der Writer-Thread fertig ist —
+     *  wichtig damit der Aufrufer den AudioFocus erst NACH dem letzten
+     *  abgespielten Sample wieder freigibt (sonst dreht Spotify hoch
+     *  waehrend das Pre-Roll noch ausspielt).
+     */
+    @ReactMethod
+    fun end(promise: Promise) {
+        endRequested = true
+        val t = writerThread
+        if (t == null || !t.isAlive) {
+            promise.resolve(true)
+            return
+        }
+        // Im Hintergrund auf den Writer warten — kein Threading-Block fuer JS-Bridge
+        Thread({
+            try {
+                t.join(15_000) // hartes Cap, falls Writer haengt
+            } catch (_: InterruptedException) {}
+            promise.resolve(true)
+        }, "PcmStreamEndWaiter").start()
+    }
+
+    /** Harter Stop (Cancel) — Queue verwerfen. */
+    @ReactMethod
+    fun stop(promise: Promise) {
+        stopInternal()
+        promise.resolve(true)
+    }
+
+    private fun stopInternal() {
+        writerShouldStop = true
+        endRequested = true
+        queue.clear()
+        writerThread?.interrupt()
+        writerThread = null
+        val t = track
+        if (t != null) {
+            try { t.stop() } catch (_: Exception) {}
+            try { t.release() } catch (_: Exception) {}
+        }
+        track = null
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        stopInternal()
+        super.onCatalystInstanceDestroy()
+    }
+}
@@ -0,0 +1,16 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PcmStreamPlayerPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(PcmStreamPlayerModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
@@ -0,0 +1,126 @@
+package com.ariacockpit
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.telephony.PhoneStateListener
+import android.telephony.TelephonyCallback
+import android.telephony.TelephonyManager
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * Lauscht auf Anruf-Statusaenderungen — wenn das Telefon klingelt oder ein
+ * Anruf laeuft, sendet das Modul ein "PhoneCallStateChanged"-Event an JS.
+ *
+ * JS-Side stoppt dann die TTS-Wiedergabe damit ARIA nicht mitten ins Gespraech
+ * weiterredet. Ohne READ_PHONE_STATE-Permission failt start() leise — der Rest
+ * der App funktioniert wie bisher.
+ *
+ * State-Strings: "idle" | "ringing" | "offhook"
+ */
+class PhoneCallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "PhoneCall"
+
+    companion object { private const val TAG = "PhoneCall" }
+
+    private var telephonyManager: TelephonyManager? = null
+    private var legacyListener: PhoneStateListener? = null
+    private var modernCallback: Any? = null  // TelephonyCallback ab API 31
+    private var lastState: Int = TelephonyManager.CALL_STATE_IDLE
+
+    @ReactMethod
+    fun start(promise: Promise) {
+        try {
+            val perm = ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.READ_PHONE_STATE)
+            if (perm != PackageManager.PERMISSION_GRANTED) {
+                Log.w(TAG, "READ_PHONE_STATE Permission fehlt — Anruf-Erkennung inaktiv")
+                promise.resolve(false)
+                return
+            }
+            val tm = reactApplicationContext.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
+            if (tm == null) {
+                Log.w(TAG, "TelephonyManager nicht verfuegbar")
+                promise.resolve(false)
+                return
+            }
+            telephonyManager = tm
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                val cb = object : TelephonyCallback(), TelephonyCallback.CallStateListener {
+                    override fun onCallStateChanged(state: Int) {
+                        handleStateChange(state)
+                    }
+                }
+                tm.registerTelephonyCallback(reactApplicationContext.mainExecutor, cb)
+                modernCallback = cb
+            } else {
+                @Suppress("DEPRECATION")
+                val l = object : PhoneStateListener() {
+                    override fun onCallStateChanged(state: Int, phoneNumber: String?) {
+                        handleStateChange(state)
+                    }
+                }
+                @Suppress("DEPRECATION")
+                tm.listen(l, PhoneStateListener.LISTEN_CALL_STATE)
+                legacyListener = l
+            }
+            Log.i(TAG, "PhoneCall-Listener aktiv")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "start fehlgeschlagen", e)
+            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
+        }
+    }
+
+    @ReactMethod
+    fun stop(promise: Promise) {
+        try {
+            val tm = telephonyManager
+            if (tm != null) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    (modernCallback as? TelephonyCallback)?.let { tm.unregisterTelephonyCallback(it) }
+                    modernCallback = null
+                } else {
+                    @Suppress("DEPRECATION")
+                    legacyListener?.let { tm.listen(it, PhoneStateListener.LISTEN_NONE) }
+                    legacyListener = null
+                }
+            }
+            telephonyManager = null
+            lastState = TelephonyManager.CALL_STATE_IDLE
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("STOP_FAILED", e.message ?: "")
+        }
+    }
+
+    private fun handleStateChange(state: Int) {
+        if (state == lastState) return
+        lastState = state
+        val name = when (state) {
+            TelephonyManager.CALL_STATE_RINGING -> "ringing"
+            TelephonyManager.CALL_STATE_OFFHOOK -> "offhook"
+            TelephonyManager.CALL_STATE_IDLE -> "idle"
+            else -> return
+        }
+        Log.i(TAG, "Telefon-State: $name")
+        val params = Arguments.createMap().apply { putString("state", name) }
+        try {
+            reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("PhoneCallStateChanged", params)
+        } catch (e: Exception) {
+            Log.w(TAG, "Event-emit fehlgeschlagen: ${e.message}")
+        }
+    }
+
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+}
@@ -0,0 +1,16 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PhoneCallPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(PhoneCallModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <cache-path name="cache" path="." />
+</paths>
@@ -1,7 +1,9 @@
 buildscript {
    ext {
        buildToolsVersion = "34.0.0"
-        minSdkVersion = 23
+        // 24 = Android 7.0 (Nougat). Verlangt von Porcupine (Picovoice).
+        // Realistisch eh das Minimum: alles unter 7.0 hat <1% Marktanteil.
+        minSdkVersion = 24
        compileSdkVersion = 34
        targetSdkVersion = 34
        ndkVersion = "25.1.8937393"
@@ -167,10 +167,23 @@ export CI=true

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

 cd ..
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.1.0",
+  "version": "0.0.7.2",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -24,8 +24,7 @@
    "react-native-camera-kit": "^13.0.0",
    "@react-native-async-storage/async-storage": "^1.21.0",
    "react-native-fs": "^2.20.0",
-    "react-native-audio-recorder-player": "^3.6.7",
-    "react-native-live-audio-stream": "^1.1.1"
+    "react-native-audio-recorder-player": "^3.6.7"
  },
  "devDependencies": {
    "typescript": "^5.3.3",
@@ -17,6 +17,7 @@ import {
 import DocumentPicker, {
  DocumentPickerResponse,
 } from 'react-native-document-picker';
+import RNFS from 'react-native-fs';

 // --- Typen ---

@@ -74,15 +75,17 @@ const FileUpload: React.FC<FileUploadProps> = ({ onFileSelected, onCancel }) =>

    setLoading(true);
    try {
-      // In Produktion: Datei lesen und zu Base64 konvertieren
-      // const base64 = await RNFS.readFile(selectedFile.fileCopyUri || selectedFile.uri, 'base64');
-      const base64Placeholder = '';
+      // Datei lesen und zu Base64 konvertieren
+      const filePath = selectedFile.fileCopyUri || selectedFile.uri;
+      // URI-Schema entfernen fuer RNFS (file:// → absoluter Pfad)
+      const cleanPath = filePath.replace('file://', '');
+      const base64 = await RNFS.readFile(cleanPath, 'base64');

      const fileData: FileData = {
        name: selectedFile.name || 'unbenannt',
        type: selectedFile.type || 'application/octet-stream',
        size: selectedFile.size || 0,
-        base64: base64Placeholder,
+        base64,
        uri: selectedFile.uri,
      };

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

-  // VAD Silence Callback — Auto-Stop
+  // VAD Silence Callback — Auto-Stop.
+  // WICHTIG: NICHT auf isRecording prüfen (Closure ist stale) — stattdessen
+  // audioService selber fragen. Empty deps → Listener wird EINMAL registriert.
+  // audioService garantiert jetzt dass der Callback pro Aufnahme nur einmal
+  // feuert (silenceFired-Latch).
+  const onCompleteRef = useRef(onRecordingComplete);
+  useEffect(() => { onCompleteRef.current = onRecordingComplete; }, [onRecordingComplete]);
  useEffect(() => {
    const unsubSilence = audioService.onSilenceDetected(async () => {
-      if (!isRecording) return;
-      setIsRecording(false);
+      if (audioService.getRecordingState() !== 'recording') return;
      const result = await audioService.stopRecording();
+      setIsRecording(false);
      if (result && result.durationMs > 500) {
-        onRecordingComplete(result);
+        onCompleteRef.current(result);
      }
    });
    return unsubSilence;
-  }, [isRecording, onRecordingComplete]);
+  }, []);

  // Auto-Start fuer Wake Word (extern getriggert)
  const startAutoRecording = useCallback(async () => {
@@ -136,23 +142,35 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
    }
  };

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

@@ -0,0 +1,362 @@
+/**
+ * VoiceCloneModal — Eigene Stimme aufnehmen und an XTTS uploaden.
+ *
+ * Flow:
+ *   - Modal zeigt Vorlesetext (>30s Lesedauer) + Aufnahme-Button
+ *   - Bei Aufnahme: max 30s, Fortschrittsbalken, Countdown
+ *   - Bei Stop: Name abfragen, dann als voice_upload ueber RVS schicken
+ *   - XTTS-Bridge speichert /voices/<name>.wav, antwortet mit xtts_voice_saved
+ */
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  Modal,
+  View,
+  Text,
+  TouchableOpacity,
+  StyleSheet,
+  Alert,
+  ScrollView,
+  ActivityIndicator,
+  TextInput,
+} from 'react-native';
+import audioService from '../services/audio';
+import rvs from '../services/rvs';
+
+interface Props {
+  visible: boolean;
+  onClose: () => void;
+}
+
+const SAMPLE_TEXT = `Das ist meine eigene Stimme fuer ARIA. Ich lese jetzt einen laengeren Absatz laut vor, damit das Voice-Cloning eine gute Grundlage hat. Guten Tag, ich heisse Stefan und baue gerade mit grosser Begeisterung an meinem persoenlichen KI-Assistenten. Wir automatisieren Infrastruktur, managen Sessions und spielen mit Sprachsynthese. Die letzten Jahre habe ich viel gelernt, vor allem dass Geduld genauso wichtig ist wie Neugier. Hoert sich das jetzt an wie ich selbst? Wenn alles klappt, spricht ARIA bald mit dieser Stimme.`;
+
+const MAX_DURATION_MS = 30000;
+const TARGET_DURATION_MS = 15000;
+
+const VoiceCloneModal: React.FC<Props> = ({ visible, onClose }) => {
+  const [recording, setRecording] = useState(false);
+  const [durationMs, setDurationMs] = useState(0);
+  const [voiceName, setVoiceName] = useState('');
+  const [processing, setProcessing] = useState(false);
+  const [recordingPath, setRecordingPath] = useState('');
+  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const startTimeRef = useRef<number>(0);
+
+  // Zustand zuruecksetzen wenn Modal schliesst/oeffnet
+  useEffect(() => {
+    if (!visible) {
+      setRecording(false);
+      setDurationMs(0);
+      setVoiceName('');
+      setProcessing(false);
+      setRecordingPath('');
+      if (timerRef.current) clearInterval(timerRef.current);
+    }
+  }, [visible]);
+
+  // Cleanup bei Unmount
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current);
+      if (recording) audioService.stopRecording().catch(() => {});
+    };
+  }, [recording]);
+
+  const startRecording = useCallback(async () => {
+    // Frische Aufnahme
+    setDurationMs(0);
+    setRecordingPath('');
+    const ok = await audioService.startRecording(false);
+    if (!ok) {
+      Alert.alert('Fehler', 'Aufnahme konnte nicht gestartet werden (Mikrofon-Berechtigung?)');
+      return;
+    }
+    setRecording(true);
+    startTimeRef.current = Date.now();
+    timerRef.current = setInterval(async () => {
+      const elapsed = Date.now() - startTimeRef.current;
+      setDurationMs(elapsed);
+      if (elapsed >= MAX_DURATION_MS) {
+        await stopRecording();
+      }
+    }, 100);
+  }, []);
+
+  const stopRecording = useCallback(async () => {
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    if (!recording) return;
+    const result = await audioService.stopRecording();
+    setRecording(false);
+    if (!result) {
+      Alert.alert('Keine Sprache erkannt', 'Versuch es bitte nochmal — sprich bis der Timer mindestens 10 Sekunden anzeigt.');
+      setDurationMs(0);
+      return;
+    }
+    // Temp-Datei wurde schon geloescht (stopRecording cleaned up).
+    // Wir brauchen aber base64 aus result direkt fuers Upload.
+    // result.base64 ist bereits da.
+    setRecordingPath(result.base64);
+  }, [recording]);
+
+  const uploadVoice = useCallback(async () => {
+    const name = voiceName.trim();
+    if (!name) {
+      Alert.alert('Name fehlt', 'Bitte gib der Stimme einen Namen (nur Buchstaben, Zahlen, _ und -).');
+      return;
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+      Alert.alert('Ungueltiger Name', 'Nur Buchstaben, Zahlen, _ und - erlaubt.');
+      return;
+    }
+    if (!recordingPath) {
+      Alert.alert('Keine Aufnahme', 'Bitte zuerst aufnehmen.');
+      return;
+    }
+    setProcessing(true);
+    try {
+      // voice_upload erwartet samples als Array mit base64 (aus Diagnostic-Format kopiert)
+      rvs.send('voice_upload' as any, {
+        name,
+        samples: [{ base64: recordingPath }],
+      });
+      Alert.alert('Hochgeladen', `Stimme "${name}" wird vom XTTS-Server verarbeitet. Nach ein paar Sekunden in der Liste verfuegbar.`);
+      onClose();
+    } catch (err: any) {
+      Alert.alert('Fehler', err.message);
+    } finally {
+      setProcessing(false);
+    }
+  }, [voiceName, recordingPath, onClose]);
+
+  const progress = Math.min(durationMs / MAX_DURATION_MS, 1);
+  const sec = Math.floor(durationMs / 1000);
+  const enoughRecorded = durationMs >= TARGET_DURATION_MS;
+
+  return (
+    <Modal visible={visible} animationType="slide" onRequestClose={onClose}>
+      <View style={styles.container}>
+        <View style={styles.header}>
+          <Text style={styles.title}>Eigene Stimme aufnehmen</Text>
+          <TouchableOpacity onPress={onClose}>
+            <Text style={styles.closeX}>{'\u2715'}</Text>
+          </TouchableOpacity>
+        </View>
+
+        <ScrollView style={styles.content} contentContainerStyle={{padding: 16}}>
+          <Text style={styles.hint}>
+            Lies den Text laut und deutlich vor. Maximal 30 Sekunden. Je mehr du sprichst
+            (ziel: bis zum Ende des Textes, ca. 20-30s), desto besser wird die geklonte
+            Stimme.
+          </Text>
+
+          <View style={styles.sampleTextBox}>
+            <Text style={styles.sampleText}>{SAMPLE_TEXT}</Text>
+          </View>
+
+          {/* Timer + Fortschritt */}
+          <View style={{marginTop: 20, alignItems: 'center'}}>
+            <Text style={[styles.timer, recording && styles.timerActive]}>
+              {sec.toString().padStart(2, '0')} / 30 s
+            </Text>
+            <View style={styles.progressBar}>
+              <View style={[styles.progressFill, {width: `${progress * 100}%`, backgroundColor: recording ? '#FF3B30' : '#0096FF'}]} />
+            </View>
+          </View>
+
+          {/* Aufnahme-Button */}
+          {!recordingPath && (
+            <TouchableOpacity
+              style={[styles.recordBtn, recording && styles.recordBtnActive]}
+              onPress={recording ? stopRecording : startRecording}
+            >
+              <Text style={styles.recordIcon}>{recording ? '\u25A0' : '\u25CF'}</Text>
+              <Text style={styles.recordLabel}>{recording ? 'Stop' : 'Aufnahme starten'}</Text>
+            </TouchableOpacity>
+          )}
+
+          {/* Nach Aufnahme: Name + Upload */}
+          {recordingPath && (
+            <View style={{marginTop: 20}}>
+              <Text style={styles.hint}>
+                Aufnahme ({sec}s) fertig. Vergib einen Namen und lade hoch.
+              </Text>
+              <TextInput
+                style={styles.nameInput}
+                value={voiceName}
+                onChangeText={setVoiceName}
+                placeholder="z.B. stefan"
+                placeholderTextColor="#555570"
+                autoCapitalize="none"
+                autoCorrect={false}
+              />
+              <View style={{flexDirection: 'row', gap: 8, marginTop: 12}}>
+                <TouchableOpacity
+                  style={[styles.secondaryBtn, {flex: 1}]}
+                  onPress={() => { setRecordingPath(''); setDurationMs(0); }}
+                >
+                  <Text style={styles.secondaryBtnText}>Nochmal aufnehmen</Text>
+                </TouchableOpacity>
+                <TouchableOpacity
+                  style={[styles.primaryBtn, {flex: 1}]}
+                  onPress={uploadVoice}
+                  disabled={processing}
+                >
+                  {processing
+                    ? <ActivityIndicator color="#fff" />
+                    : <Text style={styles.primaryBtnText}>Hochladen</Text>
+                  }
+                </TouchableOpacity>
+              </View>
+            </View>
+          )}
+
+          {recording && !enoughRecorded && (
+            <Text style={[styles.hint, {marginTop: 12, color: '#FFD60A', textAlign: 'center'}]}>
+              Bitte weiter lesen — mindestens 15 Sekunden
+            </Text>
+          )}
+
+          {recording && enoughRecorded && (
+            <Text style={[styles.hint, {marginTop: 12, color: '#34C759', textAlign: 'center'}]}>
+              Genug Audio fuer eine gute Clonung. Du kannst stoppen.
+            </Text>
+          )}
+        </ScrollView>
+      </View>
+    </Modal>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#0D0D1A',
+  },
+  header: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    paddingHorizontal: 16,
+    paddingTop: 48,
+    paddingBottom: 16,
+    borderBottomWidth: 1,
+    borderBottomColor: '#1E1E2E',
+  },
+  title: {
+    color: '#FFFFFF',
+    fontSize: 18,
+    fontWeight: '700',
+  },
+  closeX: {
+    color: '#8888AA',
+    fontSize: 24,
+    paddingHorizontal: 8,
+  },
+  content: {
+    flex: 1,
+  },
+  hint: {
+    color: '#8888AA',
+    fontSize: 13,
+    lineHeight: 20,
+  },
+  sampleTextBox: {
+    marginTop: 12,
+    padding: 14,
+    backgroundColor: '#12122A',
+    borderRadius: 10,
+    borderWidth: 1,
+    borderColor: '#1E1E2E',
+  },
+  sampleText: {
+    color: '#E0E0F0',
+    fontSize: 15,
+    lineHeight: 24,
+  },
+  timer: {
+    color: '#666680',
+    fontSize: 42,
+    fontWeight: '700',
+    fontVariant: ['tabular-nums'],
+  },
+  timerActive: {
+    color: '#FF3B30',
+  },
+  progressBar: {
+    marginTop: 8,
+    width: '100%',
+    height: 8,
+    backgroundColor: '#1E1E2E',
+    borderRadius: 4,
+    overflow: 'hidden',
+  },
+  progressFill: {
+    height: '100%',
+  },
+  recordBtn: {
+    marginTop: 24,
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: 12,
+    backgroundColor: '#1E1E2E',
+    borderRadius: 12,
+    padding: 18,
+    borderWidth: 2,
+    borderColor: '#34C759',
+  },
+  recordBtnActive: {
+    borderColor: '#FF3B30',
+    backgroundColor: 'rgba(255,59,48,0.15)',
+  },
+  recordIcon: {
+    color: '#FF3B30',
+    fontSize: 24,
+    fontWeight: '700',
+  },
+  recordLabel: {
+    color: '#FFFFFF',
+    fontSize: 17,
+    fontWeight: '600',
+  },
+  nameInput: {
+    marginTop: 10,
+    backgroundColor: '#1E1E2E',
+    borderRadius: 8,
+    paddingHorizontal: 14,
+    paddingVertical: 12,
+    color: '#FFFFFF',
+    fontSize: 15,
+    borderWidth: 1,
+    borderColor: '#2A2A3E',
+  },
+  primaryBtn: {
+    backgroundColor: '#0096FF',
+    borderRadius: 10,
+    padding: 14,
+    alignItems: 'center',
+  },
+  primaryBtnText: {
+    color: '#FFFFFF',
+    fontSize: 15,
+    fontWeight: '700',
+  },
+  secondaryBtn: {
+    backgroundColor: '#1E1E2E',
+    borderRadius: 10,
+    padding: 14,
+    alignItems: 'center',
+    borderWidth: 1,
+    borderColor: '#2A2A3E',
+  },
+  secondaryBtnText: {
+    color: '#8888AA',
+    fontSize: 14,
+    fontWeight: '600',
+  },
+});
+
+export default VoiceCloneModal;
@@ -15,10 +15,43 @@ import {
  StyleSheet,
  Alert,
  Platform,
+  ToastAndroid,
+  ActivityIndicator,
 } from 'react-native';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import RNFS from 'react-native-fs';
+import DocumentPicker from 'react-native-document-picker';
 import rvs, { ConnectionState, RVSMessage, ConnectionConfig, ConnectionLogEntry } from '../services/rvs';
+import {
+  TTS_PREROLL_DEFAULT_SEC,
+  TTS_PREROLL_MIN_SEC,
+  TTS_PREROLL_MAX_SEC,
+  TTS_PREROLL_STORAGE_KEY,
+  VAD_SILENCE_DEFAULT_SEC,
+  VAD_SILENCE_MIN_SEC,
+  VAD_SILENCE_MAX_SEC,
+  VAD_SILENCE_STORAGE_KEY,
+  CONV_WINDOW_DEFAULT_SEC,
+  CONV_WINDOW_MIN_SEC,
+  CONV_WINDOW_MAX_SEC,
+  CONV_WINDOW_STORAGE_KEY,
+  TTS_SPEED_DEFAULT,
+  TTS_SPEED_MIN,
+  TTS_SPEED_MAX,
+  TTS_SPEED_STORAGE_KEY,
+} from '../services/audio';
+import wakeWordService, {
+  WAKE_KEYWORDS,
+  KEYWORD_LABELS,
+  DEFAULT_KEYWORD,
+  WAKE_KEYWORD_STORAGE,
+} from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
+import VoiceCloneModal from '../components/VoiceCloneModal';
+
+const STORAGE_PATH_KEY = 'aria_attachment_storage_path';
+const DEFAULT_STORAGE_PATH = `${RNFS.DocumentDirectoryPath}/chat_attachments`;

 // --- Typen ---

@@ -62,6 +95,22 @@ const SettingsScreen: React.FC = () => {
  const [logs, setLogs] = useState<LogEntry[]>([]);
  const [events, setEvents] = useState<EventEntry[]>([]);
  const [connLog, setConnLog] = useState<ConnectionLogEntry[]>(rvs.getConnectionLog());
+  const [storagePath, setStoragePath] = useState(DEFAULT_STORAGE_PATH);
+  const [autoDownload, setAutoDownload] = useState(true);
+  const [storageSize, setStorageSize] = useState('...');
+  const [ttsEnabled, setTtsEnabled] = useState(true);
+  const [ttsPrerollSec, setTtsPrerollSec] = useState<number>(TTS_PREROLL_DEFAULT_SEC);
+  const [vadSilenceSec, setVadSilenceSec] = useState<number>(VAD_SILENCE_DEFAULT_SEC);
+  const [convWindowSec, setConvWindowSec] = useState<number>(CONV_WINDOW_DEFAULT_SEC);
+  const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
+  const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
+  const [wakeStatus, setWakeStatus] = useState<string>('');
+  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('');

  let logIdCounter = 0;

@@ -73,8 +122,148 @@ const SettingsScreen: React.FC = () => {
      setManualPort(String(config.port));
      setManualToken(config.token);
    }
+    // Speicherpfad + Auto-Download laden
+    AsyncStorage.getItem(STORAGE_PATH_KEY).then(saved => {
+      if (saved) setStoragePath(saved);
+    });
+    AsyncStorage.getItem('aria_auto_download').then(saved => {
+      if (saved !== null) setAutoDownload(saved === 'true');
+    });
+    AsyncStorage.getItem('aria_tts_enabled').then(saved => {
+      if (saved !== null) setTtsEnabled(saved === 'true');
+    });
+    AsyncStorage.getItem(TTS_PREROLL_STORAGE_KEY).then(saved => {
+      if (saved != null) {
+        const n = parseFloat(saved);
+        if (isFinite(n) && n >= TTS_PREROLL_MIN_SEC && n <= TTS_PREROLL_MAX_SEC) {
+          setTtsPrerollSec(n);
+        }
+      }
+    });
+    AsyncStorage.getItem(VAD_SILENCE_STORAGE_KEY).then(saved => {
+      if (saved != null) {
+        const n = parseFloat(saved);
+        if (isFinite(n) && n >= VAD_SILENCE_MIN_SEC && n <= VAD_SILENCE_MAX_SEC) {
+          setVadSilenceSec(n);
+        }
+      }
+    });
+    AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY).then(saved => {
+      if (saved != null) {
+        const n = parseFloat(saved);
+        if (isFinite(n) && n >= CONV_WINDOW_MIN_SEC && n <= CONV_WINDOW_MAX_SEC) {
+          setConvWindowSec(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_KEYWORD_STORAGE).then(saved => {
+      if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
+    });
+    AsyncStorage.getItem('aria_xtts_voice').then(saved => {
+      if (saved) setXttsVoice(saved);
+    });
+    // Voice-Liste vom XTTS-Server holen (via RVS)
+    rvs.send('xtts_list_voices' as any, {});
  }, []);

+  // Speichergroesse berechnen
+  useEffect(() => {
+    const calcSize = async () => {
+      try {
+        const exists = await RNFS.exists(storagePath);
+        if (!exists) { setStorageSize('0 KB'); return; }
+        const items = await RNFS.readDir(storagePath);
+        const totalBytes = items.reduce((sum, f) => sum + (f.size || 0), 0);
+        if (totalBytes > 1024 * 1024) {
+          setStorageSize(`${(totalBytes / 1024 / 1024).toFixed(1)} MB (${items.length} Dateien)`);
+        } else {
+          setStorageSize(`${Math.round(totalBytes / 1024)} KB (${items.length} Dateien)`);
+        }
+      } catch { setStorageSize('nicht verfuegbar'); }
+    };
+    calcSize();
+  }, [storagePath]);
+
+  const saveStoragePath = useCallback(async (newPath: string) => {
+    const clean = newPath.trim();
+    if (!clean) return;
+    await AsyncStorage.setItem(STORAGE_PATH_KEY, clean);
+    setStoragePath(clean);
+    setEditingPath(false);
+    Alert.alert('Gespeichert', `Neuer Speicherort:\n${clean}\n\nWird ab der naechsten Nachricht verwendet.`);
+  }, []);
+
+  const showPathPicker = useCallback(() => {
+    Alert.alert(
+      'Speicherort waehlen',
+      'Wo sollen Anhaenge gespeichert werden?',
+      [
+        {
+          text: 'Ordner auswaehlen...',
+          onPress: async () => {
+            try {
+              const result = await DocumentPicker.pickDirectory();
+              if (result?.uri) {
+                // SAF URI decodieren (content://com.android.externalstorage...)
+                const decoded = decodeURIComponent(result.uri);
+                // Versuche einen lesbaren Pfad zu extrahieren
+                const match = decoded.match(/primary[:%]3A(.+)/);
+                const readablePath = match
+                  ? `/storage/emulated/0/${match[1].replace(/%2F|%3A/g, '/')}`
+                  : decoded;
+                saveStoragePath(readablePath);
+              }
+            } catch (e: any) {
+              if (!DocumentPicker.isCancel(e)) {
+                Alert.alert('Fehler', 'Ordnerauswahl fehlgeschlagen');
+              }
+            }
+          },
+        },
+        {
+          text: 'App-intern (Standard)',
+          onPress: () => saveStoragePath(DEFAULT_STORAGE_PATH),
+        },
+        {
+          text: 'Pfad manuell eingeben',
+          onPress: () => { setTempPath(storagePath); setEditingPath(true); },
+        },
+        { text: 'Abbrechen', style: 'cancel' as const },
+      ],
+    );
+  }, [storagePath]);
+
+  const clearStorageCache = useCallback(async () => {
+    Alert.alert(
+      'Cache loeschen',
+      `Alle lokalen Anhaenge in\n${storagePath}\nloeschen?\n\nDateien koennen ueber RVS erneut heruntergeladen werden.`,
+      [
+        { text: 'Abbrechen', style: 'cancel' },
+        {
+          text: 'Loeschen',
+          style: 'destructive',
+          onPress: async () => {
+            try {
+              const exists = await RNFS.exists(storagePath);
+              if (exists) await RNFS.unlink(storagePath);
+              await RNFS.mkdir(storagePath);
+              setStorageSize('0 KB (0 Dateien)');
+              Alert.alert('Erledigt', 'Cache geleert. Anhaenge werden bei Bedarf neu geladen.');
+            } catch (e: any) {
+              Alert.alert('Fehler', e.message);
+            }
+          },
+        },
+      ],
+    );
+  }, [storagePath]);
+
  // RVS-Nachrichten und Verbindungslog abonnieren
  useEffect(() => {
    const unsubState = rvs.onStateChange(setConnectionState);
@@ -111,6 +300,47 @@ const SettingsScreen: React.FC = () => {
        const mode = message.payload.mode as string;
        if (mode) setCurrentMode(mode);
      }
+
+      // XTTS-Voice-Liste
+      if (message.type === ('xtts_voices_list' as any)) {
+        const voices = ((message.payload as any).voices || []) as Array<{name: string, size: number}>;
+        setAvailableVoices(voices);
+      }
+
+      // Voice wurde gespeichert → Liste neu laden + ggf. auswaehlen
+      if (message.type === ('xtts_voice_saved' as any)) {
+        const name = (message.payload as any).name as string;
+        if (name) {
+          setXttsVoice(name);
+          AsyncStorage.setItem('aria_xtts_voice', name);
+        }
+        rvs.send('xtts_list_voices' as any, {});
+      }
+
+      // Diagnostic-Voice-Wechsel → lokale App-Stimme auf den neuen Default zuruecksetzen.
+      // Zusaetzlich Preload triggern, damit der User weiss wann's geladen ist.
+      if (message.type === ('config' as any)) {
+        const newVoice = ((message.payload as any).xttsVoice as string) ?? '';
+        setXttsVoice(newVoice);
+        AsyncStorage.setItem('aria_xtts_voice', newVoice);
+        if (newVoice) {
+          setLoadingVoice(newVoice);
+        }
+      }
+
+      // XTTS-Bridge meldet: Stimme fertig geladen
+      if (message.type === ('voice_ready' as any)) {
+        const v = ((message.payload as any).voice as string) ?? '';
+        const err = (message.payload as any).error as string | undefined;
+        const ms = (message.payload as any).loadMs as number | undefined;
+        setLoadingVoice(null);
+        if (err) {
+          ToastAndroid.show(`Stimme "${v}" konnte nicht geladen werden: ${err}`, ToastAndroid.LONG);
+        } else {
+          const suffix = ms ? ` (${(ms / 1000).toFixed(1)}s)` : '';
+          ToastAndroid.show(`Stimme "${v || 'Standard'}" bereit${suffix}`, ToastAndroid.SHORT);
+        }
+      }
    });

    return () => {
@@ -174,6 +404,43 @@ const SettingsScreen: React.FC = () => {
    // In Produktion: Wert in AsyncStorage persistieren
  }, []);

+  // --- XTTS Voice ---
+
+  const selectVoice = useCallback((voiceName: string) => {
+    setXttsVoice(voiceName);
+    AsyncStorage.setItem('aria_xtts_voice', voiceName);
+    // Preload nur fuer Custom-Voices — "Standard" braucht keinen Ladevorgang
+    if (voiceName) {
+      setLoadingVoice(voiceName);
+      rvs.send('voice_preload' as any, { voice: voiceName, source: 'app' });
+    } else {
+      setLoadingVoice(null);
+    }
+  }, []);
+
+  const deleteVoice = useCallback((name: string) => {
+    Alert.alert(
+      'Stimme loeschen',
+      `Stimme "${name}" vom Server endgueltig loeschen?\nAlle Apps verlieren sie.`,
+      [
+        { text: 'Abbrechen', style: 'cancel' },
+        {
+          text: 'Loeschen',
+          style: 'destructive',
+          onPress: () => {
+            rvs.send('xtts_delete_voice' as any, { name });
+            if (xttsVoice === name) {
+              setXttsVoice('');
+              AsyncStorage.setItem('aria_xtts_voice', '');
+            }
+            // Liste nach kurzer Wartezeit neu laden (XTTS-Bridge schickt eh neue Liste)
+            setTimeout(() => rvs.send('xtts_list_voices' as any, {}), 500);
+          },
+        },
+      ],
+    );
+  }, [xttsVoice]);
+
  // --- Modus aendern ---

  const handleModeChange = useCallback((modeId: string) => {
@@ -207,6 +474,10 @@ const SettingsScreen: React.FC = () => {
      onScan={handleQRScan}
      onClose={() => setScannerVisible(false)}
    />
+    <VoiceCloneModal
+      visible={voiceCloneVisible}
+      onClose={() => setVoiceCloneVisible(false)}
+    />
    <ScrollView style={styles.container} contentContainerStyle={styles.content}>

      {/* === Verbindung === */}
@@ -332,6 +603,351 @@ const SettingsScreen: React.FC = () => {
        </View>
      </View>

+      {/* === Spracheingabe (geraetelokal) === */}
+      <Text style={styles.sectionTitle}>Spracheingabe</Text>
+      <View style={styles.card}>
+        <Text style={styles.toggleLabel}>Stille-Toleranz</Text>
+        <Text style={styles.toggleHint}>
+          Wie lange du eine Sprechpause machen darfst, bevor die Aufnahme
+          automatisch beendet und gesendet wird. Hoeher = mehr Zeit zum
+          Nachdenken; niedriger = schnelleres Senden.
+          Default: {VAD_SILENCE_DEFAULT_SEC.toFixed(1)}s.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.max(VAD_SILENCE_MIN_SEC, Math.round((vadSilenceSec - 0.5) * 10) / 10);
+              setVadSilenceSec(next);
+              AsyncStorage.setItem(VAD_SILENCE_STORAGE_KEY, String(next));
+            }}
+            disabled={vadSilenceSec <= VAD_SILENCE_MIN_SEC}
+          >
+            <Text style={styles.prerollButtonText}>−0.5</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>{vadSilenceSec.toFixed(1)} s</Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.min(VAD_SILENCE_MAX_SEC, Math.round((vadSilenceSec + 0.5) * 10) / 10);
+              setVadSilenceSec(next);
+              AsyncStorage.setItem(VAD_SILENCE_STORAGE_KEY, String(next));
+            }}
+            disabled={vadSilenceSec >= VAD_SILENCE_MAX_SEC}
+          >
+            <Text style={styles.prerollButtonText}>+0.5</Text>
+          </TouchableOpacity>
+        </View>
+
+        <Text style={[styles.toggleLabel, {marginTop: 24}]}>Konversations-Fenster</Text>
+        <Text style={styles.toggleHint}>
+          Im Gespraechsmodus (Ohr-Button): nach ARIA's Antwort hast du so lange
+          Zeit, weiter zu sprechen, bevor die Konversation automatisch beendet wird.
+          Sprichst du nichts → Mikrofon zu.
+          Default: {CONV_WINDOW_DEFAULT_SEC.toFixed(1)}s.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.max(CONV_WINDOW_MIN_SEC, Math.round((convWindowSec - 1) * 10) / 10);
+              setConvWindowSec(next);
+              AsyncStorage.setItem(CONV_WINDOW_STORAGE_KEY, String(next));
+            }}
+            disabled={convWindowSec <= CONV_WINDOW_MIN_SEC}
+          >
+            <Text style={styles.prerollButtonText}>−1</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>{convWindowSec.toFixed(0)} s</Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.min(CONV_WINDOW_MAX_SEC, Math.round((convWindowSec + 1) * 10) / 10);
+              setConvWindowSec(next);
+              AsyncStorage.setItem(CONV_WINDOW_STORAGE_KEY, String(next));
+            }}
+            disabled={convWindowSec >= CONV_WINDOW_MAX_SEC}
+          >
+            <Text style={styles.prerollButtonText}>+1</Text>
+          </TouchableOpacity>
+        </View>
+      </View>
+
+      {/* === Wake-Word (komplett on-device, openWakeWord) === */}
+      <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.
+        </Text>
+
+        <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.
+        </Text>
+        <View style={{flexDirection: 'row', flexWrap: 'wrap', gap: 6, marginTop: 8}}>
+          {WAKE_KEYWORDS.map(kw => (
+            <TouchableOpacity
+              key={kw}
+              style={[
+                styles.keywordChip,
+                wakeKeyword === kw && styles.keywordChipActive,
+              ]}
+              onPress={() => setWakeKeyword(kw)}
+            >
+              <Text style={[
+                styles.keywordChipText,
+                wakeKeyword === kw && styles.keywordChipTextActive,
+              ]}>
+                {KEYWORD_LABELS[kw]}
+              </Text>
+            </TouchableOpacity>
+          ))}
+        </View>
+
+        <View style={{flexDirection: 'row', gap: 8, marginTop: 16, alignItems: 'center'}}>
+          <TouchableOpacity
+            style={[styles.connectButton, {flex: 1}]}
+            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');
+              } catch (err: any) {
+                setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
+              }
+              setTimeout(() => setWakeStatus(''), 5000);
+            }}
+          >
+            <Text style={styles.connectButtonText}>Speichern + Aktivieren</Text>
+          </TouchableOpacity>
+        </View>
+        {!!wakeStatus && (
+          <Text style={{marginTop: 8, fontSize: 12, color: '#8888AA'}}>{wakeStatus}</Text>
+        )}
+      </View>
+
+      {/* === Sprachausgabe (geraetelokal) === */}
+      <Text style={styles.sectionTitle}>Sprachausgabe</Text>
+      <View style={styles.card}>
+        <View style={styles.toggleRow}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Sprachausgabe auf diesem Geraet</Text>
+            <Text style={styles.toggleHint}>
+              Nur lokal — andere Geraete sind unabhaengig.
+              Wenn aus, erscheint im Chat auch kein Mund-Button.
+            </Text>
+          </View>
+          <Switch
+            value={ttsEnabled}
+            onValueChange={(val) => {
+              setTtsEnabled(val);
+              AsyncStorage.setItem('aria_tts_enabled', String(val));
+            }}
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={ttsEnabled ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+
+        {ttsEnabled && (
+          <View style={{marginTop: 20}}>
+            <Text style={styles.toggleLabel}>Puffer vor Wiedergabestart</Text>
+            <Text style={styles.toggleHint}>
+              Wie viel Audio gesammelt wird bevor die Wiedergabe startet.
+              Hoeher = robuster gegen Render-Pausen, aber mehr Startverzoegerung.
+              Default: {TTS_PREROLL_DEFAULT_SEC.toFixed(1)}s.
+            </Text>
+            <View style={styles.prerollRow}>
+              <TouchableOpacity
+                style={styles.prerollButton}
+                onPress={() => {
+                  const next = Math.max(TTS_PREROLL_MIN_SEC, Math.round((ttsPrerollSec - 0.5) * 10) / 10);
+                  setTtsPrerollSec(next);
+                  AsyncStorage.setItem(TTS_PREROLL_STORAGE_KEY, String(next));
+                }}
+                disabled={ttsPrerollSec <= TTS_PREROLL_MIN_SEC}
+              >
+                <Text style={styles.prerollButtonText}>−0.5</Text>
+              </TouchableOpacity>
+              <Text style={styles.prerollValue}>{ttsPrerollSec.toFixed(1)} s</Text>
+              <TouchableOpacity
+                style={styles.prerollButton}
+                onPress={() => {
+                  const next = Math.min(TTS_PREROLL_MAX_SEC, Math.round((ttsPrerollSec + 0.5) * 10) / 10);
+                  setTtsPrerollSec(next);
+                  AsyncStorage.setItem(TTS_PREROLL_STORAGE_KEY, String(next));
+                }}
+                disabled={ttsPrerollSec >= TTS_PREROLL_MAX_SEC}
+              >
+                <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>
+        )}
+
+        {ttsEnabled && (
+          <View style={{marginTop: 20}}>
+            <Text style={styles.toggleLabel}>Stimme (geraetelokal)</Text>
+            <Text style={styles.toggleHint}>
+              Eine geklonte Stimme auswaehlen. F5-TTS braucht zwingend eine Referenz —
+              ohne Auswahl gilt die in Diagnostic gewaehlte globale Stimme.
+            </Text>
+
+            {availableVoices.length === 0 ? (
+              <Text style={[styles.toggleHint, {marginTop: 8, textAlign: 'center'}]}>
+                Keine geklonten Stimmen vorhanden — unten "Eigene Stimme aufnehmen".
+              </Text>
+            ) : (
+              availableVoices.map(v => (
+                <View key={v.name} style={[styles.voiceRow, xttsVoice === v.name && styles.voiceRowActive]}>
+                  <TouchableOpacity
+                    style={{flex: 1}}
+                    onPress={() => selectVoice(v.name)}
+                  >
+                    <Text style={[styles.voiceRowName, xttsVoice === v.name && styles.voiceRowNameActive]}>
+                      {v.name}
+                    </Text>
+                    <Text style={styles.voiceRowMeta}>{(v.size / 1024).toFixed(0)} KB</Text>
+                  </TouchableOpacity>
+                  {loadingVoice === v.name && (
+                    <ActivityIndicator size="small" color="#0096FF" style={{marginRight: 8}} />
+                  )}
+                  {xttsVoice === v.name && loadingVoice !== v.name && <Text style={styles.voiceRowCheck}>{'\u2713'}</Text>}
+                  <TouchableOpacity onPress={() => deleteVoice(v.name)} style={styles.voiceRowDelete}>
+                    <Text style={styles.voiceRowDeleteIcon}>X</Text>
+                  </TouchableOpacity>
+                </View>
+              ))
+            )}
+
+            <View style={{flexDirection: 'row', gap: 8, marginTop: 12}}>
+              <TouchableOpacity
+                style={[styles.connectButton, {flex: 1}]}
+                onPress={() => setVoiceCloneVisible(true)}
+              >
+                <Text style={styles.connectButtonText}>{'\uD83C\uDFA4'} Eigene Stimme aufnehmen</Text>
+              </TouchableOpacity>
+              <TouchableOpacity
+                style={[styles.clearButton, {flex: 0.4, marginTop: 0}]}
+                onPress={() => rvs.send('xtts_list_voices' as any, {})}
+              >
+                <Text style={styles.clearButtonText}>Aktualisieren</Text>
+              </TouchableOpacity>
+            </View>
+          </View>
+        )}
+      </View>
+
+      {/* === Speicher === */}
+      <Text style={styles.sectionTitle}>Anhang-Speicher</Text>
+      <View style={styles.card}>
+        <View style={styles.toggleRow}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Auto-Download</Text>
+            <Text style={styles.toggleHint}>
+              Fehlende Anhaenge beim App-Start automatisch vom Server laden
+            </Text>
+          </View>
+          <Switch
+            value={autoDownload}
+            onValueChange={(val) => {
+              setAutoDownload(val);
+              AsyncStorage.setItem('aria_auto_download', String(val));
+            }}
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={autoDownload ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+
+        <View style={{height: 16}} />
+        <Text style={styles.toggleLabel}>Lokaler Speicherort</Text>
+        <Text style={styles.toggleHint}>
+          Hier werden Bilder und Dateien aus dem Chat gespeichert.
+          {autoDownload ? ' Fehlende Dateien werden automatisch nachgeladen.' : ' Fehlende Dateien koennen per Tippen geladen werden.'}
+        </Text>
+
+        {editingPath ? (
+          <View style={{marginTop: 10}}>
+            <TextInput
+              style={styles.input}
+              value={tempPath}
+              onChangeText={setTempPath}
+              placeholder="z.B. /storage/emulated/0/ARIA/attachments"
+              placeholderTextColor="#555570"
+              autoCapitalize="none"
+            />
+            <View style={{flexDirection: 'row', gap: 8}}>
+              <TouchableOpacity
+                style={[styles.connectButton, {flex: 1}]}
+                onPress={() => saveStoragePath(tempPath)}
+              >
+                <Text style={styles.connectButtonText}>Speichern</Text>
+              </TouchableOpacity>
+              <TouchableOpacity
+                style={[styles.clearButton, {flex: 1, marginTop: 0}]}
+                onPress={() => setEditingPath(false)}
+              >
+                <Text style={styles.clearButtonText}>Abbrechen</Text>
+              </TouchableOpacity>
+            </View>
+          </View>
+        ) : (
+          <View style={{marginTop: 10}}>
+            <Text style={styles.storagePathText} numberOfLines={2}>{storagePath}</Text>
+            <Text style={styles.storageSizeText}>{storageSize}</Text>
+            <View style={{flexDirection: 'row', gap: 8, marginTop: 8}}>
+              <TouchableOpacity
+                style={[styles.clearButton, {flex: 1, marginTop: 0}]}
+                onPress={showPathPicker}
+              >
+                <Text style={styles.clearButtonText}>Pfad aendern</Text>
+              </TouchableOpacity>
+              <TouchableOpacity
+                style={[styles.clearButton, {flex: 1, marginTop: 0, backgroundColor: 'rgba(255,59,48,0.15)'}]}
+                onPress={clearStorageCache}
+              >
+                <Text style={[styles.clearButtonText, {color: '#FF3B30'}]}>Cache leeren</Text>
+              </TouchableOpacity>
+            </View>
+          </View>
+        )}
+      </View>
+
      {/* === Logs === */}
      <Text style={styles.sectionTitle}>Protokoll</Text>
      <View style={styles.card}>
@@ -416,11 +1032,21 @@ const SettingsScreen: React.FC = () => {
      <Text style={styles.sectionTitle}>{'\u00DC'}ber</Text>
      <View style={styles.card}>
        <Text style={styles.aboutTitle}>ARIA Cockpit</Text>
-        <Text style={styles.aboutVersion}>Version 0.1.0 (Alpha)</Text>
+        <Text style={styles.aboutVersion}>Version {require('../../package.json').version}</Text>
        <Text style={styles.aboutInfo}>
          Stefans Kommandozentrale f{'\u00FC'}r ARIA.{'\n'}
          Gebaut mit React Native + TypeScript.
        </Text>
+        <TouchableOpacity
+          style={[styles.connectButton, {marginTop: 12}]}
+          onPress={() => {
+            const updateService = require('../services/updater').default;
+            updateService.checkForUpdate();
+            Alert.alert('Update-Check', 'Pruefe auf neue Version...');
+          }}
+        >
+          <Text style={styles.connectButtonText}>Auf Updates pr{'\u00FC'}fen</Text>
+        </TouchableOpacity>
      </View>

      {/* Platz am Ende */}
@@ -559,6 +1185,99 @@ const styles = StyleSheet.create({
    marginTop: 2,
  },

+  // XTTS Voice List
+  voiceRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#1E1E2E',
+    borderRadius: 8,
+    padding: 10,
+    marginTop: 6,
+    borderWidth: 1,
+    borderColor: 'transparent',
+  },
+  voiceRowActive: {
+    borderColor: '#0096FF',
+    backgroundColor: '#0D1A2E',
+  },
+  voiceRowName: {
+    color: '#CCCCDD',
+    fontSize: 14,
+    fontWeight: '500',
+  },
+  voiceRowNameActive: {
+    color: '#FFFFFF',
+  },
+  voiceRowMeta: {
+    color: '#666680',
+    fontSize: 11,
+    marginTop: 2,
+  },
+  voiceRowCheck: {
+    color: '#34C759',
+    fontSize: 16,
+    fontWeight: '700',
+    marginHorizontal: 6,
+  },
+  voiceRowDelete: {
+    width: 28,
+    height: 28,
+    borderRadius: 14,
+    backgroundColor: 'rgba(255,59,48,0.2)',
+    alignItems: 'center',
+    justifyContent: 'center',
+    marginLeft: 4,
+  },
+  voiceRowDeleteIcon: {
+    color: '#FF3B30',
+    fontSize: 12,
+    fontWeight: '700',
+  },
+
+  // Stimmen
+  voiceBtn: {
+    flex: 1,
+    padding: 12,
+    borderRadius: 10,
+    backgroundColor: '#1E1E2E',
+    alignItems: 'center',
+    borderWidth: 2,
+    borderColor: 'transparent',
+  },
+  voiceBtnActive: {
+    borderColor: '#0096FF',
+    backgroundColor: '#0D1A2E',
+  },
+  voiceBtnIcon: {
+    fontSize: 28,
+    marginBottom: 4,
+  },
+  voiceBtnText: {
+    color: '#8888AA',
+    fontSize: 14,
+    fontWeight: '600',
+  },
+  voiceBtnTextActive: {
+    color: '#FFFFFF',
+  },
+  voiceBtnHint: {
+    color: '#555570',
+    fontSize: 11,
+    marginTop: 2,
+  },
+
+  // Speicher
+  storagePathText: {
+    color: '#0096FF',
+    fontSize: 12,
+    fontFamily: Platform.OS === 'ios' ? 'Menlo' : 'monospace',
+  },
+  storageSizeText: {
+    color: '#8888AA',
+    fontSize: 12,
+    marginTop: 4,
+  },
+
  // Logs
  tabRow: {
    flexDirection: 'row',
@@ -685,6 +1404,56 @@ const styles = StyleSheet.create({
  bottomSpacer: {
    height: 40,
  },
+
+  prerollRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    marginTop: 12,
+    gap: 16,
+  },
+  prerollButton: {
+    backgroundColor: '#2A2A3E',
+    paddingHorizontal: 18,
+    paddingVertical: 10,
+    borderRadius: 8,
+    minWidth: 72,
+    alignItems: 'center',
+  },
+  prerollButtonText: {
+    color: '#FFFFFF',
+    fontSize: 16,
+    fontWeight: '600',
+  },
+  prerollValue: {
+    color: '#FFFFFF',
+    fontSize: 20,
+    fontWeight: '700',
+    minWidth: 80,
+    textAlign: 'center',
+  },
+
+  keywordChip: {
+    backgroundColor: '#1E1E2E',
+    borderWidth: 1,
+    borderColor: '#2A2A3E',
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderRadius: 14,
+  },
+  keywordChipActive: {
+    backgroundColor: '#0096FF',
+    borderColor: '#0096FF',
+  },
+  keywordChipText: {
+    color: '#8888AA',
+    fontSize: 13,
+    fontWeight: '500',
+  },
+  keywordChipTextActive: {
+    color: '#FFFFFF',
+    fontWeight: '700',
+  },
 });

 export default SettingsScreen;
@@ -6,9 +6,10 @@
 * Nutzt react-native-audio-recorder-player fuer Aufnahme.
 */

-import { Platform, PermissionsAndroid } 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 AudioRecorderPlayer, {
  AudioEncoderAndroidType,
  AudioSourceAndroidType,
@@ -16,6 +17,38 @@ import AudioRecorderPlayer, {
  OutputFormatAndroidType,
 } from 'react-native-audio-recorder-player';

+// Base64-Encoder fuer Binary-Strings (Header-Bytes → Base64)
+const B64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function btoaSafe(bin: string): string {
+  let out = '';
+  const len = bin.length;
+  for (let i = 0; i < len; i += 3) {
+    const b1 = bin.charCodeAt(i) & 0xff;
+    const b2 = i + 1 < len ? bin.charCodeAt(i + 1) & 0xff : 0;
+    const b3 = i + 2 < len ? bin.charCodeAt(i + 2) & 0xff : 0;
+    out += B64_CHARS[b1 >> 2];
+    out += B64_CHARS[((b1 & 0x03) << 4) | (b2 >> 4)];
+    out += i + 1 < len ? B64_CHARS[((b2 & 0x0f) << 2) | (b3 >> 6)] : '=';
+    out += i + 2 < len ? B64_CHARS[b3 & 0x3f] : '=';
+  }
+  return out;
+}
+
+// Native Module fuer Audio-Focus (Ducking/Muten anderer Apps)
+const { AudioFocus, PcmStreamPlayer } = NativeModules as {
+  AudioFocus?: {
+    requestDuck: () => Promise<boolean>;
+    requestExclusive: () => Promise<boolean>;
+    release: () => Promise<boolean>;
+  };
+  PcmStreamPlayer?: {
+    start: (sampleRate: number, channels: number, prerollSeconds: number) => Promise<boolean>;
+    writeChunk: (base64Pcm: string) => Promise<boolean>;
+    end: () => Promise<boolean>;
+    stop: () => Promise<boolean>;
+  };
+};
+
 // --- Typen ---

 export interface RecordingResult {
@@ -41,7 +74,91 @@ const AUDIO_ENCODING = 'audio/wav';

 // VAD (Voice Activity Detection) — Stille-Erkennung
 const VAD_SILENCE_THRESHOLD_DB = -45;  // dB unter dem als "Stille" gilt
-const VAD_SILENCE_DURATION_MS = 1800;  // ms Stille bevor Auto-Stop
+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
+
+// 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;
+export const VAD_SILENCE_MIN_SEC = 1.0;
+export const VAD_SILENCE_MAX_SEC = 8.0;
+export const VAD_SILENCE_STORAGE_KEY = 'aria_vad_silence_sec';
+
+// Konversations-Fenster (in Sekunden) — nach ARIA's Antwort hat der User so
+// lange Zeit, im Gespraechsmodus weiter zu sprechen, ohne dass die Konversation
+// beendet wird. Sprichst du im Fenster nichts → Konversation aus.
+export const CONV_WINDOW_DEFAULT_SEC = 8.0;
+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);
+    if (raw != null) {
+      const n = parseFloat(raw);
+      if (isFinite(n) && n >= CONV_WINDOW_MIN_SEC && n <= CONV_WINDOW_MAX_SEC) {
+        return Math.round(n * 1000);
+      }
+    }
+  } catch {}
+  return Math.round(CONV_WINDOW_DEFAULT_SEC * 1000);
+}
+
+async function loadVadSilenceMs(): Promise<number> {
+  try {
+    const raw = await AsyncStorage.getItem(VAD_SILENCE_STORAGE_KEY);
+    if (raw != null) {
+      const n = parseFloat(raw);
+      if (isFinite(n) && n >= VAD_SILENCE_MIN_SEC && n <= VAD_SILENCE_MAX_SEC) {
+        return Math.round(n * 1000);
+      }
+    }
+  } catch {}
+  return Math.round(VAD_SILENCE_DEFAULT_SEC * 1000);
+}
+
+// Max-Dauer einer Aufnahme (Notbremse gegen Runaway-Loops). Auf 2 Minuten
+// hochgezogen damit auch laengere Erklaerungen durchgehen.
+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_MAX_SEC = 6.0;
+export const TTS_PREROLL_STORAGE_KEY = 'aria_tts_preroll_sec';
+
+async function loadPrerollSec(): Promise<number> {
+  try {
+    const raw = await AsyncStorage.getItem(TTS_PREROLL_STORAGE_KEY);
+    if (raw != null) {
+      const n = parseFloat(raw);
+      if (isFinite(n) && n >= TTS_PREROLL_MIN_SEC && n <= TTS_PREROLL_MAX_SEC) {
+        return n;
+      }
+    }
+  } catch {}
+  return TTS_PREROLL_DEFAULT_SEC;
+}

 // --- Audio-Service ---

@@ -55,16 +172,104 @@ class AudioService {
  private recorder: AudioRecorderPlayer;
  private recordingPath: string = '';

+  // Audio-Queue fuer sequentielle TTS-Wiedergabe
+  private audioQueue: string[] = [];
+  private isPlaying: boolean = false;
+  private preloadedSound: Sound | null = null;
+  private preloadedPath: string = '';
+
+  // Sprach-Gate: Aufnahme erst senden wenn tatsaechlich gesprochen wurde
+  private speechDetected: boolean = false;
+  private speechStartTime: number = 0;
+
+  // PCM-Stream (XTTS): aktive Session + Cache-Puffer pro messageId
+  private pcmStreamActive: boolean = false;
+  private pcmMessageId: string = '';
+  private pcmSampleRate: number = 24000;
+  private pcmChannels: number = 1;
+  private pcmBuffer: string[] = []; // base64-chunks zum spaeteren WAV-Build
+  private pcmBytesCollected: number = 0;
+  private readonly PCM_MAX_CACHE_BYTES = 30 * 1024 * 1024; // 30MB
+
+  // AudioFocus wird verzoegert freigegeben — wenn ARIA eine zweite Antwort
+  // direkt hinterherschickt (oder ein neuer Stream startet), bleibt Spotify
+  // pausiert. Ohne diese Verzoegerung springt Spotify im Mikro-Sekunden-Gap
+  // zwischen zwei Streams kurz wieder an.
+  private focusReleaseTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly FOCUS_RELEASE_DELAY_MS = 800;
+
+  // Conversation-Mode: solange aktiv (Wake-Word Status 'conversing' ODER
+  // wir wissen "ARIA spricht gerade in einem Multi-Turn-Dialog"), halten wir
+  // den AudioFocus DAUERHAFT. Der per-Stream-Release wird unterdrueckt,
+  // damit Spotify nicht in Render-Pausen oder zwischen Antworten zurueckkehrt.
+  private _conversationFocusActive: boolean = false;
+
  // VAD State
  private vadEnabled: boolean = false;
  private lastSpeechTime: number = 0;
  private vadTimer: ReturnType<typeof setInterval> | null = null;
+  private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
+  // Latch damit der Silence-Callback pro Aufnahme genau einmal feuert
+  private silenceFired: boolean = false;
+  private noSpeechTimer: ReturnType<typeof setTimeout> | null = null;

  constructor() {
    this.recorder = new AudioRecorderPlayer();
    this.recorder.setSubscriptionDuration(0.1); // 100ms Metering-Updates
  }

+  /** AudioFocus mit kleiner Verzoegerung freigeben — Spotify/YouTube
+   *  springen sonst im Gap zwischen zwei TTS-Streams (oder wenn ARIA
+   *  eine zweite Antwort direkt hinterherschickt) kurz wieder an.
+   *  Im Conversation-Mode (Wake-Word conversing) wird das Release komplett
+   *  unterdrueckt — der Focus bleibt fuer die ganze Konversation gehalten. */
+  private _releaseFocusDeferred(): void {
+    if (this._conversationFocusActive) {
+      this._cancelDeferredFocusRelease();
+      return;
+    }
+    this._cancelDeferredFocusRelease();
+    this.focusReleaseTimer = setTimeout(() => {
+      this.focusReleaseTimer = null;
+      if (this._conversationFocusActive) return;
+      AudioFocus?.release().catch(() => {});
+    }, this.FOCUS_RELEASE_DELAY_MS);
+  }
+
+  private _cancelDeferredFocusRelease(): void {
+    if (this.focusReleaseTimer) {
+      clearTimeout(this.focusReleaseTimer);
+      this.focusReleaseTimer = null;
+    }
+  }
+
+  /** Conversation-Mode beginnt → AudioFocus dauerhaft halten (Spotify bleibt
+   *  pausiert). Idempotent: mehrfaches Aufrufen ist sicher. */
+  acquireConversationFocus(): void {
+    if (this._conversationFocusActive) return;
+    this._conversationFocusActive = true;
+    this._cancelDeferredFocusRelease();
+    console.log('[Audio] Conversation-Focus aktiv (Spotify bleibt gepaust)');
+    AudioFocus?.requestDuck().catch(() => {});
+  }
+
+  /** Conversation-Mode endet → Focus darf wieder freigegeben werden
+   *  (verzoegert, damit eine direkt folgende Antwort nichts kaputtmacht). */
+  releaseConversationFocus(): void {
+    if (!this._conversationFocusActive) return;
+    this._conversationFocusActive = false;
+    console.log('[Audio] Conversation-Focus inaktiv');
+    this._releaseFocusDeferred();
+  }
+
+  /** TTS-Wiedergabe haart stoppen — z.B. wenn ein Anruf reinkommt.
+   *  Released auch sofort den AudioFocus damit der Anruf-Klingelton hoerbar ist. */
+  haltAllPlayback(reason: string = ''): void {
+    console.log('[Audio] haltAllPlayback: %s', reason || '(no reason)');
+    this._conversationFocusActive = false;
+    this.stopPlayback();
+  }
+
  // --- Berechtigungen ---

  async requestMicrophonePermission(): Promise<boolean> {
@@ -91,8 +296,16 @@ class AudioService {

  // --- Aufnahme ---

-  /** Mikrofon-Aufnahme starten */
-  async startRecording(autoStop: boolean = false): Promise<boolean> {
+  /** Mikrofon-Aufnahme starten.
+   *
+   *  @param autoStop          VAD aktivieren — Auto-Stop bei Stille
+   *  @param noSpeechTimeoutMs Wenn der User innerhalb dieser Zeit nichts sagt,
+   *                           wird Stille gemeldet (Recording wird verworfen).
+   *                           Fuer Conversation-Window: nach ARIA's Antwort
+   *                           hast du nur N Sekunden um anzufangen, sonst
+   *                           Gespraech zu Ende.
+   */
+  async startRecording(autoStop: boolean = false, noSpeechTimeoutMs: number = 0): Promise<boolean> {
    if (this.recordingState !== 'idle') {
      console.warn('[Audio] Aufnahme laeuft bereits');
      return false;
@@ -108,6 +321,10 @@ class AudioService {
      // Laufende Wiedergabe stoppen (damit ARIA sich nicht selbst hoert)
      this.stopPlayback();

+      // Aufraeumen: Alte aria_recording_ und aria_tts_ Files loeschen
+      // (Schutz gegen Cache-Ueberlauf im Gespraechsmodus bei vielen Zyklen)
+      this._cleanupStaleCacheFiles().catch(() => {});
+
      this.recordingPath = `${RNFS.CachesDirectoryPath}/aria_recording_${Date.now()}.mp4`;

      // Aufnahme mit Metering starten
@@ -115,6 +332,8 @@ class AudioService {
        AudioEncoderAndroid: AudioEncoderAndroidType.AAC,
        AudioSourceAndroid: AudioSourceAndroidType.MIC,
        OutputFormatAndroid: OutputFormatAndroidType.MPEG_4,
+        AudioSamplingRateAndroid: 16000,
+        AudioChannelsAndroid: 1,
      }, true); // meteringEnabled = true

      // Metering-Callback
@@ -122,7 +341,21 @@ class AudioService {
        const db = e.currentMetering ?? -160;
        this.meterListeners.forEach(cb => cb(db));

-        // VAD: Stille erkennen
+        // Sprach-Gate: Erkennen ob tatsaechlich gesprochen wird
+        if (db > VAD_SPEECH_THRESHOLD_DB) {
+          if (!this.speechDetected && this.speechStartTime === 0) {
+            this.speechStartTime = Date.now();
+          }
+          if (this.speechStartTime > 0 && Date.now() - this.speechStartTime >= VAD_SPEECH_MIN_MS) {
+            this.speechDetected = true;
+          }
+        } else {
+          if (!this.speechDetected) {
+            this.speechStartTime = 0; // Reset wenn noch nicht als Sprache erkannt
+          }
+        }
+
+        // VAD: Stille erkennen (nur wenn Sprache erkannt wurde)
        if (this.vadEnabled) {
          if (db > VAD_SILENCE_THRESHOLD_DB) {
            this.lastSpeechTime = Date.now();
@@ -132,18 +365,57 @@ class AudioService {

      this.recordingStartTime = Date.now();
      this.lastSpeechTime = Date.now();
+      this.speechDetected = false;
+      this.speechStartTime = 0;
      this.setState('recording');

-      // VAD aktivieren
+      // 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.
      this.vadEnabled = autoStop;
+      this.silenceFired = false;
+      const fireSilenceOnce = (reason: string) => {
+        if (this.silenceFired) return;
+        this.silenceFired = true;
+        this.vadEnabled = false;
+        if (this.vadTimer) { clearInterval(this.vadTimer); this.vadTimer = null; }
+        if (this.maxDurationTimer) { clearTimeout(this.maxDurationTimer); this.maxDurationTimer = null; }
+        if (this.noSpeechTimer) { clearTimeout(this.noSpeechTimer); this.noSpeechTimer = null; }
+        console.log('[Audio] Silence-Fire: %s', reason);
+        this.silenceListeners.forEach(cb => {
+          try { cb(); } catch (e) { console.warn('[Audio] silence listener err:', e); }
+        });
+      };
      if (autoStop) {
+        const vadSilenceMs = await loadVadSilenceMs();
+        console.log('[Audio] startRecording: autoStop=true, VAD-Stille=%dms, MAX=%dms',
+                    vadSilenceMs, MAX_RECORDING_MS);
        this.vadTimer = setInterval(() => {
          const silenceDuration = Date.now() - this.lastSpeechTime;
-          if (silenceDuration >= VAD_SILENCE_DURATION_MS) {
-            console.log(`[Audio] VAD: ${silenceDuration}ms Stille — Auto-Stop`);
-            this.silenceListeners.forEach(cb => cb());
+          if (silenceDuration >= vadSilenceMs) {
+            fireSilenceOnce(`VAD ${silenceDuration}ms Stille (Schwelle=${vadSilenceMs}ms)`);
          }
        }, 200);
+        // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
+        this.maxDurationTimer = setTimeout(() => {
+          fireSilenceOnce(`Max-Dauer ${MAX_RECORDING_MS}ms`);
+        }, MAX_RECORDING_MS);
+      }
+
+      // Conversation-Window: Wenn der User innerhalb noSpeechTimeoutMs nicht
+      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie).
+      if (noSpeechTimeoutMs > 0) {
+        this.noSpeechTimer = setTimeout(() => {
+          if (!this.speechDetected && this.recordingState === 'recording') {
+            fireSilenceOnce(`Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache`);
+          }
+        }, noSpeechTimeoutMs);
      }

      console.log('[Audio] Aufnahme gestartet (autoStop: %s)', autoStop);
@@ -168,12 +440,33 @@ class AudioService {
      clearInterval(this.vadTimer);
      this.vadTimer = null;
    }
+    if (this.maxDurationTimer) {
+      clearTimeout(this.maxDurationTimer);
+      this.maxDurationTimer = null;
+    }
+    if (this.noSpeechTimer) {
+      clearTimeout(this.noSpeechTimer);
+      this.noSpeechTimer = null;
+    }

    try {
      await this.recorder.stopRecorder();
      this.recorder.removeRecordBackListener();

+      // Audio-Focus verzoegert freigeben — gleich kommt die TTS-Antwort,
+      // im Gap soll Spotify nicht hochkommen.
+      this._releaseFocusDeferred();
+
      const durationMs = Date.now() - this.recordingStartTime;
+      const hadSpeech = this.speechDetected;
+
+      // Sprach-Gate: Wenn keine Sprache erkannt → Aufnahme verwerfen
+      if (!hadSpeech) {
+        RNFS.unlink(this.recordingPath).catch(() => {});
+        this.setState('idle');
+        console.log('[Audio] Aufnahme verworfen — keine Sprache erkannt (nur Umgebungsgeraeusche)');
+        return null;
+      }

      // Audio-Datei als Base64 lesen
      const base64Data = await RNFS.readFile(this.recordingPath, 'base64');
@@ -182,7 +475,7 @@ class AudioService {
      RNFS.unlink(this.recordingPath).catch(() => {});

      this.setState('idle');
-      console.log(`[Audio] Aufnahme beendet (${durationMs}ms, ${Math.round(base64Data.length / 1024)}KB)`);
+      console.log(`[Audio] Aufnahme beendet (${durationMs}ms, ${Math.round(base64Data.length / 1024)}KB, Sprache erkannt)`);

      return {
        base64: base64Data,
@@ -198,47 +491,344 @@ class AudioService {

  // --- Wiedergabe ---

-  /** Base64-kodiertes Audio abspielen (z.B. TTS-Antwort von ARIA) */
+  /** Base64-kodiertes Audio in die Queue stellen und abspielen */
  async playAudio(base64Data: string): Promise<void> {
    if (!base64Data) return;

-    // Laufende Wiedergabe stoppen
-    this.stopPlayback();
-
-    try {
-      // Base64 -> temporaere WAV-Datei -> Sound abspielen
-      const tmpPath = `${RNFS.CachesDirectoryPath}/aria_tts_${Date.now()}.wav`;
-      await RNFS.writeFile(tmpPath, base64Data, 'base64');
-
-      this.currentSound = new Sound(tmpPath, '', (error) => {
-        if (error) {
-          console.error('[Audio] Fehler beim Laden:', error);
-          RNFS.unlink(tmpPath).catch(() => {});
-          return;
-        }
-        this.currentSound?.play((success) => {
-          if (success) {
-            console.log('[Audio] Wiedergabe abgeschlossen');
-          } else {
-            console.warn('[Audio] Wiedergabe fehlgeschlagen');
-          }
-          this.currentSound?.release();
-          this.currentSound = null;
-          RNFS.unlink(tmpPath).catch(() => {});
-        });
-      });
-    } catch (err) {
-      console.error('[Audio] Wiedergabefehler:', err);
+    this.audioQueue.push(base64Data);
+    if (!this.isPlaying) {
+      this._playNext();
    }
  }

-  /** Laufende Wiedergabe stoppen */
+  /** Base64-Audio persistent speichern. Gibt file:// Pfad zurueck (oder leer bei Fehler). */
+  async cacheAudio(base64Data: string, messageId: string): Promise<string> {
+    if (!base64Data || !messageId) return '';
+    try {
+      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
+      await RNFS.mkdir(dir).catch(() => {});
+      const path = `${dir}/${messageId}.wav`;
+      // Wenn Datei schon existiert (z.B. XTTS Chunks) → anhaengen statt ueberschreiben
+      const exists = await RNFS.exists(path);
+      if (exists) {
+        // Bestehende + neue Base64 laden, zusammenkleben (fuer jetzt: ueberschreiben)
+        // XTTS sendet mehrere Chunks — bei mehrfacher Ueberschreibung bleibt nur der letzte
+        // Fuer eine echte Konkatenation muesste WAV-Header gemerged werden
+        await RNFS.writeFile(path, base64Data, 'base64');
+      } else {
+        await RNFS.writeFile(path, base64Data, 'base64');
+      }
+      return `file://${path}`;
+    } catch (err) {
+      console.warn('[Audio] cacheAudio fehlgeschlagen:', err);
+      return '';
+    }
+  }
+
+  /** 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();
+  async handlePcmChunk(payload: {
+    base64: string;
+    sampleRate?: number;
+    channels?: number;
+    messageId?: string;
+    chunk?: number;
+    final?: boolean;
+    silent?: boolean;
+  }): Promise<string> {
+    const p = this._pcmChunkQueue.then(() => this._handlePcmChunkImpl(payload)).catch(err => {
+      console.warn('[Audio] handlePcmChunk queued err:', err);
+      return '';
+    });
+    // Chain only on the side effect — callers still get the per-call result
+    this._pcmChunkQueue = p;
+    return p;
+  }
+
+  private async _handlePcmChunkImpl(payload: {
+    base64: string;
+    sampleRate?: number;
+    channels?: number;
+    messageId?: string;
+    chunk?: number;
+    final?: boolean;
+    silent?: boolean;
+  }): Promise<string> {
+    const silent = !!payload.silent;
+    if (!silent && !PcmStreamPlayer) {
+      console.warn('[Audio] PcmStreamPlayer Native Module nicht verfuegbar');
+      return '';
+    }
+    // Debug-Log bei Chunk 0 eines neuen Streams — damit man im adb logcat
+    // sieht warum der Auto-Playback greift oder nicht.
+    if ((payload.chunk ?? 0) === 0 && !this.pcmStreamActive) {
+      console.log('[Audio] PCM-Stream start: silent=%s messageId=%s sr=%s ch=%s',
+                  silent, payload.messageId || '(none)',
+                  payload.sampleRate, payload.channels);
+    }
+
+    const messageId = payload.messageId || '';
+    const sampleRate = payload.sampleRate || 24000;
+    const channels = payload.channels || 1;
+    const base64 = payload.base64 || '';
+    const isFinal = !!payload.final;
+
+    // Neuer Stream? (messageId Wechsel oder nicht aktiv)
+    if (!this.pcmStreamActive || this.pcmMessageId !== messageId) {
+      if (this.pcmStreamActive && !silent) {
+        try { await PcmStreamPlayer!.stop(); } catch {}
+        this.pcmBuffer = [];
+        this.pcmBytesCollected = 0;
+      }
+      this.pcmStreamActive = true;
+      this.pcmMessageId = messageId;
+      this.pcmSampleRate = sampleRate;
+      this.pcmChannels = channels;
+      this.pcmBuffer = [];
+      this.pcmBytesCollected = 0;
+      if (!silent) {
+        const prerollSec = await loadPrerollSec();
+        try {
+          await PcmStreamPlayer!.start(sampleRate, channels, prerollSec);
+        } catch (err) {
+          console.error('[Audio] PcmStreamPlayer.start fehlgeschlagen:', err);
+          this.pcmStreamActive = false;
+          return '';
+        }
+        this._cancelDeferredFocusRelease();
+        AudioFocus?.requestDuck().catch(() => {});
+      }
+    }
+
+    // Chunk — immer cachen, nur bei !silent auch abspielen
+    if (base64) {
+      if (!silent) {
+        try { await PcmStreamPlayer!.writeChunk(base64); } catch (err) { console.warn('[Audio] writeChunk', err); }
+      }
+      if (messageId && this.pcmBytesCollected < this.PCM_MAX_CACHE_BYTES) {
+        this.pcmBuffer.push(base64);
+        this.pcmBytesCollected += Math.floor(base64.length * 0.75);
+      }
+    }
+
+    if (isFinal) {
+      if (!silent) {
+        // end() resolved jetzt erst wenn der native Writer-Thread fertig
+        // ist (alle Samples ausgespielt) — danach AudioFocus verzoegert
+        // freigeben, damit Spotify/YouTube nicht im Mikro-Gap zwischen zwei
+        // ARIA-Antworten wieder hochdrehen. Wenn ein neuer Stream innerhalb
+        // FOCUS_RELEASE_DELAY_MS startet, wird das Release abgebrochen.
+        try { await PcmStreamPlayer!.end(); } catch {}
+        this._releaseFocusDeferred();
+      }
+      this.pcmStreamActive = false;
+
+      if (messageId && this.pcmBuffer.length > 0) {
+        const audioPath = await this._savePcmBufferAsWav(messageId);
+        this.pcmBuffer = [];
+        this.pcmBytesCollected = 0;
+        this.pcmMessageId = '';
+        return audioPath;
+      }
+      this.pcmMessageId = '';
+    }
+    return '';
+  }
+
+  /** Gesammelte PCM-Chunks als WAV speichern. Gibt file:// Pfad zurueck. */
+  private async _savePcmBufferAsWav(messageId: string): Promise<string> {
+    try {
+      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
+      await RNFS.mkdir(dir).catch(() => {});
+      const path = `${dir}/${messageId}.wav`;
+
+      // WAV-Header fuer PCM s16le
+      const sampleRate = this.pcmSampleRate;
+      const channels = this.pcmChannels;
+      const bitsPerSample = 16;
+      const byteRate = sampleRate * channels * bitsPerSample / 8;
+      const blockAlign = channels * bitsPerSample / 8;
+      const dataSize = this.pcmBytesCollected;
+      const fileSize = 36 + dataSize;
+
+      // Header als Base64 (44 bytes)
+      const header = new Uint8Array(44);
+      const dv = new DataView(header.buffer);
+      // "RIFF"
+      header[0] = 0x52; header[1] = 0x49; header[2] = 0x46; header[3] = 0x46;
+      dv.setUint32(4, fileSize, true);
+      // "WAVE"
+      header[8] = 0x57; header[9] = 0x41; header[10] = 0x56; header[11] = 0x45;
+      // "fmt "
+      header[12] = 0x66; header[13] = 0x6d; header[14] = 0x74; header[15] = 0x20;
+      dv.setUint32(16, 16, true);  // fmt chunk size
+      dv.setUint16(20, 1, true);    // PCM format
+      dv.setUint16(22, channels, true);
+      dv.setUint32(24, sampleRate, true);
+      dv.setUint32(28, byteRate, true);
+      dv.setUint16(32, blockAlign, true);
+      dv.setUint16(34, bitsPerSample, true);
+      // "data"
+      header[36] = 0x64; header[37] = 0x61; header[38] = 0x74; header[39] = 0x61;
+      dv.setUint32(40, dataSize, true);
+
+      // Header als base64
+      let headerB64 = '';
+      const chunk = 1024;
+      for (let i = 0; i < header.length; i += chunk) {
+        headerB64 += String.fromCharCode(...Array.from(header.slice(i, i + chunk)));
+      }
+      headerB64 = btoaSafe(headerB64);
+
+      // Datei schreiben: Header + alle PCM-Chunks
+      await RNFS.writeFile(path, headerB64, 'base64');
+      for (const b64 of this.pcmBuffer) {
+        await RNFS.appendFile(path, b64, 'base64');
+      }
+      console.log(`[Audio] PCM-Cache geschrieben: ${path} (${(dataSize / 1024).toFixed(0)}KB, ${this.pcmBuffer.length} chunks)`);
+      return `file://${path}`;
+    } catch (err) {
+      console.warn('[Audio] _savePcmBufferAsWav fehlgeschlagen:', err);
+      return '';
+    }
+  }
+
+  /** Audio aus lokaler Datei (file:// Pfad) in die Queue und abspielen. */
+  async playFromPath(filePath: string): Promise<void> {
+    if (!filePath) return;
+    try {
+      const cleanPath = filePath.replace(/^file:\/\//, '');
+      if (!(await RNFS.exists(cleanPath))) {
+        console.warn('[Audio] Cache-Datei existiert nicht mehr:', cleanPath);
+        return;
+      }
+      const b64 = await RNFS.readFile(cleanPath, 'base64');
+      this.playAudio(b64);
+    } catch (err) {
+      console.warn('[Audio] playFromPath fehlgeschlagen:', err);
+    }
+  }
+
+  // Callback wenn alle Audio-Teile abgespielt sind
+  private playbackFinishedListeners: (() => void)[] = [];
+
+  onPlaybackFinished(callback: () => void): () => void {
+    this.playbackFinishedListeners.push(callback);
+    return () => {
+      this.playbackFinishedListeners = this.playbackFinishedListeners.filter(cb => cb !== callback);
+    };
+  }
+
+  /** 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();
+      // Alle Audio-Teile abgespielt → Listener benachrichtigen
+      this.playbackFinishedListeners.forEach(cb => cb());
+      return;
+    }
+
+    // Beim ersten Playback-Start: andere Apps ducken
+    if (!this.isPlaying) {
+      this._cancelDeferredFocusRelease();
+      AudioFocus?.requestDuck().catch(() => {});
+    }
+    this.isPlaying = true;
+
+    // Preloaded Sound verwenden wenn verfuegbar, sonst neu laden
+    let sound: Sound;
+    let soundPath: string;
+
+    if (this.preloadedSound) {
+      sound = this.preloadedSound;
+      soundPath = this.preloadedPath;
+      this.preloadedSound = null;
+      this.preloadedPath = '';
+      // Daten aus Queue entfernen (wurde schon preloaded)
+      this.audioQueue.shift();
+    } else {
+      const base64Data = this.audioQueue.shift()!;
+      try {
+        soundPath = `${RNFS.CachesDirectoryPath}/aria_tts_${Date.now()}.wav`;
+        await RNFS.writeFile(soundPath, base64Data, 'base64');
+        sound = await new Promise<Sound>((resolve, reject) => {
+          const s = new Sound(soundPath, '', (err) => err ? reject(err) : resolve(s));
+        });
+      } catch (err) {
+        console.error('[Audio] Laden fehlgeschlagen:', err);
+        this._playNext();
+        return;
+      }
+    }
+
+    this.currentSound = sound;
+
+    // Naechstes Audio schon vorbereiten waehrend dieses abspielt
+    this._preloadNext();
+
+    sound.play((success) => {
+      if (!success) console.warn('[Audio] Wiedergabe fehlgeschlagen');
+      sound.release();
+      this.currentSound = null;
+      RNFS.unlink(soundPath).catch(() => {});
+      this._playNext();
+    });
+  }
+
+  /** Naechstes Audio im Hintergrund vorladen (verhindert Stottern) */
+  private async _preloadNext(): Promise<void> {
+    if (this.audioQueue.length === 0 || this.preloadedSound) return;
+
+    const base64Data = this.audioQueue[0]; // Nicht shift — bleibt in Queue
+    try {
+      const tmpPath = `${RNFS.CachesDirectoryPath}/aria_tts_pre_${Date.now()}.wav`;
+      await RNFS.writeFile(tmpPath, base64Data, 'base64');
+      this.preloadedSound = await new Promise<Sound>((resolve, reject) => {
+        const s = new Sound(tmpPath, '', (err) => err ? reject(err) : resolve(s));
+      });
+      this.preloadedPath = tmpPath;
+    } catch {
+      this.preloadedSound = null;
+      this.preloadedPath = '';
+    }
+  }
+
+  /** Laufende Wiedergabe stoppen + Queue leeren */
  stopPlayback(): void {
+    this.audioQueue = [];
+    this.isPlaying = false;
    if (this.currentSound) {
      this.currentSound.stop();
      this.currentSound.release();
      this.currentSound = 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)
+    if (this.pcmStreamActive) {
+      PcmStreamPlayer?.stop().catch(() => {});
+      this.pcmStreamActive = false;
+      this.pcmBuffer = [];
+      this.pcmBytesCollected = 0;
+      this.pcmMessageId = '';
+    }
+    // Audio-Focus sofort freigeben — User hat explizit abgebrochen
+    this._cancelDeferredFocusRelease();
+    AudioFocus?.release().catch(() => {});
  }

  // --- Status & Callbacks ---
@@ -277,6 +867,46 @@ class AudioService {
      this.stateListeners.forEach(cb => cb(state));
    }
  }
+
+  /** 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();
+      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 > 30000) {
+          await RNFS.unlink(f.path).catch(() => {});
+        }
+      }
+    } catch {
+      // silent — cleanup ist best-effort
+    }
+  }
+
+  /** Alte TTS-Cache-Dateien loeschen die nicht mehr referenziert sind (>30 Tage). */
+  async cleanupOldTTSCache(keepMessageIds: Set<string>, maxAgeDays = 30): Promise<void> {
+    try {
+      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
+      if (!(await RNFS.exists(dir))) return;
+      const files = await RNFS.readDir(dir);
+      const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+      const now = Date.now();
+      for (const f of files) {
+        if (!f.isFile() || !f.name.endsWith('.wav')) continue;
+        const messageId = f.name.replace(/\.wav$/, '');
+        const age = now - (f.mtime ? f.mtime.getTime() : 0);
+        // Loeschen wenn: nicht mehr referenziert UND aelter als X Tage
+        if (!keepMessageIds.has(messageId) && age > maxAgeMs) {
+          await RNFS.unlink(f.path).catch(() => {});
+        }
+      }
+    } catch {
+      // silent
+    }
+  }
 }

 // Singleton
@@ -0,0 +1,108 @@
+/**
+ * PhoneCall-Service — pausiert die TTS-Wiedergabe wenn das Telefon klingelt
+ * oder ein Anruf laeuft. Native-Bindung an PhoneCallModule.kt.
+ *
+ * Bei "ringing" oder "offhook" wird audioService.haltAllPlayback() gerufen —
+ * ARIA verstummt sofort. Nach dem Auflegen passiert nichts automatisch
+ * (Audio kommt nicht zurueck), der User muesste die Antwort manuell
+ * nochmal anfordern (Play-Button auf der Nachricht).
+ *
+ * Permission READ_PHONE_STATE muss vom Nutzer einmalig erteilt werden —
+ * wenn nicht, failed start() leise und der Rest funktioniert wie bisher.
+ */
+
+import {
+  NativeEventEmitter,
+  NativeModules,
+  PermissionsAndroid,
+  Platform,
+  ToastAndroid,
+} from 'react-native';
+import audioService from './audio';
+
+interface PhoneCallNative {
+  start(): Promise<boolean>;
+  stop(): Promise<boolean>;
+}
+
+const { PhoneCall } = NativeModules as { PhoneCall?: PhoneCallNative };
+
+type PhoneState = 'idle' | 'ringing' | 'offhook';
+
+class PhoneCallService {
+  private started: boolean = false;
+  private subscription: { remove: () => void } | null = null;
+  private lastState: PhoneState = 'idle';
+
+  async start(): Promise<boolean> {
+    if (this.started || !PhoneCall) return false;
+    if (Platform.OS !== 'android') return false;
+
+    // Runtime-Permission holen (nur einmal noetig)
+    try {
+      const granted = await PermissionsAndroid.request(
+        PermissionsAndroid.PERMISSIONS.READ_PHONE_STATE,
+        {
+          title: 'ARIA Cockpit — Anruf-Erkennung',
+          message: 'Damit ARIA bei einem eingehenden Anruf nicht weiterredet, '
+            + 'darf die App den Anruf-Status sehen (Klingeln/Aktiv/Aufgelegt). '
+            + 'Es werden keine Anrufdaten gelesen oder gespeichert.',
+          buttonPositive: 'Erlauben',
+          buttonNegative: 'Spaeter',
+        },
+      );
+      if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
+        console.warn('[PhoneCall] READ_PHONE_STATE Permission abgelehnt');
+        return false;
+      }
+    } catch (err) {
+      console.warn('[PhoneCall] Permission-Anfrage gescheitert', err);
+    }
+
+    try {
+      const ok = await PhoneCall.start();
+      if (!ok) {
+        console.warn('[PhoneCall] Native start() lieferte false (Permission?)');
+        return false;
+      }
+      const emitter = new NativeEventEmitter(NativeModules.PhoneCall as any);
+      this.subscription = emitter.addListener('PhoneCallStateChanged', (e: { state: PhoneState }) => {
+        this._onStateChanged(e.state);
+      });
+      this.started = true;
+      console.log('[PhoneCall] Listener aktiv');
+      return true;
+    } catch (err: any) {
+      console.warn('[PhoneCall] start gescheitert:', err?.message || err);
+      return false;
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.started || !PhoneCall) return;
+    try {
+      this.subscription?.remove();
+      this.subscription = null;
+      await PhoneCall.stop();
+    } catch {}
+    this.started = false;
+    this.lastState = 'idle';
+  }
+
+  private _onStateChanged(state: PhoneState): void {
+    if (state === this.lastState) return;
+    console.log('[PhoneCall] State: %s → %s', this.lastState, state);
+    this.lastState = state;
+    if (state === 'ringing' || state === 'offhook') {
+      audioService.haltAllPlayback(`Telefon-State: ${state}`);
+      ToastAndroid.show(
+        state === 'ringing' ? 'Anruf — ARIA pausiert' : 'Im Gespraech — ARIA pausiert',
+        ToastAndroid.SHORT,
+      );
+    }
+    // idle: nichts automatisch — User soll nichts unbeabsichtigt re-triggern
+  }
+}
+
+const phoneCallService = new PhoneCallService();
+export default phoneCallService;
@@ -12,7 +12,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';

 export type ConnectionState = 'connecting' | 'connected' | 'disconnected';

-export type MessageType = 'chat' | 'audio' | 'file' | 'location' | 'mode' | 'log' | 'event';
+export type MessageType = 'chat' | 'audio' | 'file' | 'location' | 'mode' | 'log' | 'event' | 'update_available' | string;

 export interface RVSMessage {
  type: MessageType;
@@ -0,0 +1,191 @@
+/**
+ * Auto-Update Service — prueft und installiert App-Updates via RVS
+ *
+ * Flow:
+ * 1. App sendet "update_check" mit aktueller Version an RVS
+ * 2. RVS vergleicht → sendet "update_available" mit Download-URL
+ * 3. App zeigt Benachrichtigung → User bestaetigt → Download + Install
+ */
+
+import { Alert, Linking, Platform, NativeModules } from 'react-native';
+import RNFS from 'react-native-fs';
+import rvs, { RVSMessage } from './rvs';
+
+// Version aus package.json (wird beim Build eingebettet)
+const packageJson = require('../../package.json');
+const APP_VERSION = packageJson.version || '0.0.0.0';
+
+type UpdateCallback = (info: UpdateInfo) => void;
+
+export interface UpdateInfo {
+  version: string;
+  downloadUrl: string;
+  size: number;
+}
+
+class UpdateService {
+  private listeners: UpdateCallback[] = [];
+  private checking = false;
+  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) {
+        const info: UpdateInfo = {
+          version: (msg.payload.version as string) || '',
+          downloadUrl: (msg.payload.downloadUrl as string) || '',
+          size: (msg.payload.size as number) || 0,
+        };
+        if (info.version && this.isNewer(info.version)) {
+          console.log(`[Update] Neue Version verfuegbar: ${info.version} (aktuell: ${APP_VERSION})`);
+          this.listeners.forEach(cb => cb(info));
+        }
+      }
+    });
+  }
+
+  /** Raeumt alte heruntergeladene APK-Dateien aus dem Cache auf. */
+  private async cleanupOldApks(): Promise<void> {
+    try {
+      const files = await RNFS.readDir(RNFS.CachesDirectoryPath);
+      const apks = files.filter(f => /\.apk$/i.test(f.name));
+      let freed = 0;
+      for (const f of apks) {
+        try {
+          const size = parseInt(f.size as any, 10) || 0;
+          await RNFS.unlink(f.path);
+          freed += size;
+          console.log(`[Update] Alte APK geloescht: ${f.name} (${(size / 1024 / 1024).toFixed(1)}MB)`);
+        } catch (err: any) {
+          console.warn(`[Update] APK-Loeschen fehlgeschlagen: ${f.name} (${err?.message || err})`);
+        }
+      }
+      if (apks.length > 0) {
+        console.log(`[Update] Cleanup fertig: ${apks.length} APKs entfernt, ${(freed / 1024 / 1024).toFixed(1)}MB freigegeben`);
+      }
+    } catch (err: any) {
+      console.warn(`[Update] Cleanup-Fehler: ${err?.message || err}`);
+    }
+  }
+
+  /** Bei App-Start Update pruefen */
+  checkForUpdate(): void {
+    if (this.checking) return;
+    this.checking = true;
+
+    console.log(`[Update] Pruefe auf Updates (aktuell: ${APP_VERSION})`);
+    rvs.send('update_check' as any, { version: APP_VERSION });
+
+    setTimeout(() => { this.checking = false; }, 10000);
+  }
+
+  /** Callback registrieren */
+  onUpdateAvailable(callback: UpdateCallback): () => void {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter(cb => cb !== callback);
+    };
+  }
+
+  /** Update-Dialog anzeigen */
+  promptUpdate(info: UpdateInfo): void {
+    const sizeMB = (info.size / 1024 / 1024).toFixed(1);
+    Alert.alert(
+      'ARIA Update verfuegbar',
+      `Version ${info.version} (${sizeMB} MB)\n\nAktuell: ${APP_VERSION}\n\nJetzt herunterladen und installieren?`,
+      [
+        { text: 'Spaeter', style: 'cancel' },
+        {
+          text: 'Installieren',
+          onPress: () => this.downloadAndInstall(info),
+        },
+      ],
+    );
+  }
+
+  /** APK ueber WebSocket herunterladen und installieren */
+  async downloadAndInstall(info: UpdateInfo): Promise<void> {
+    if (this.downloading) return;
+    this.downloading = true;
+
+    try {
+      console.log(`[Update] Fordere APK v${info.version} an...`);
+      Alert.alert('Download gestartet', `Version ${info.version} wird ueber RVS heruntergeladen...`);
+
+      // APK ueber WebSocket anfordern
+      rvs.send('update_download' as any, {});
+
+      // Auf update_data warten (einmalig)
+      const apkData = await new Promise<{base64: string, fileName: string}>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Download-Timeout (60s)')), 60000);
+        const unsub = rvs.onMessage((msg: RVSMessage) => {
+          if ((msg.type as string) === 'update_data') {
+            clearTimeout(timeout);
+            unsub();
+            if (msg.payload.error) {
+              reject(new Error(msg.payload.error as string));
+            } else {
+              resolve({
+                base64: msg.payload.base64 as string,
+                fileName: msg.payload.fileName as string || `ARIA-${info.version}.apk`,
+              });
+            }
+          }
+        });
+      });
+
+      // 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');
+      const fileSize = await RNFS.stat(destPath);
+      console.log(`[Update] APK gespeichert: ${destPath} (${(parseInt(fileSize.size) / 1024 / 1024).toFixed(1)}MB)`);
+
+      // APK installieren via natives ApkInstaller Module (FileProvider + Intent)
+      if (Platform.OS === 'android') {
+        try {
+          const { ApkInstaller } = NativeModules;
+          await ApkInstaller.install(destPath);
+        } catch (installErr: any) {
+          Alert.alert(
+            'APK heruntergeladen',
+            `Version ${info.version} gespeichert.\n\nBitte manuell installieren:\nDateimanager → ${apkData.fileName} antippen.\n\n(${installErr.message})`,
+          );
+        }
+      }
+    } catch (err: any) {
+      console.error(`[Update] Fehler: ${err.message}`);
+      Alert.alert('Update fehlgeschlagen', err.message);
+    } finally {
+      this.downloading = false;
+    }
+  }
+
+  /** Versionsvergleich */
+  private isNewer(remote: string): boolean {
+    const r = remote.split('.').map(Number);
+    const l = APP_VERSION.split('.').map(Number);
+    for (let i = 0; i < Math.max(r.length, l.length); i++) {
+      const diff = (r[i] || 0) - (l[i] || 0);
+      if (diff > 0) return true;
+      if (diff < 0) return false;
+    }
+    return false;
+  }
+
+  getCurrentVersion(): string {
+    return APP_VERSION;
+  }
+}
+
+const updateService = new UpdateService();
+export default updateService;
@@ -1,96 +1,262 @@
 /**
- * Wake Word Service — "ARIA" Erkennung
+ * Gespraechsmodus / Wake Word Service
 *
- * Nutzt react-native-live-audio-stream fuer kontinuierliches Mikrofon-Monitoring.
- * Erkennt Sprache per Energie-Schwellwert und sendet kurze Audio-Clips
- * zur serverseitigen Wake-Word-Pruefung (openwakeword in der Bridge).
+ * 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.
 *
- * Architektur:
- *   App (Mikrofon) → Energie-Erkennung → Audio-Buffer
- *   → RVS "wake_check" → Bridge → openwakeword → Bestaetigung
- *   → App startet Aufnahme
+ * 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),
+ *                AudioRecorder uebernimmt fuer die Aufnahme.
+ *                Nach jeder ARIA-Antwort oeffnet das Mikro fuer X Sekunden
+ *                (Conversation-Window). Stille im Fenster → zurueck zu armed.
 *
- * Aktuell (Phase 1): Einfacher Tap-to-Talk + Auto-Stop.
- * Spaeter (Phase 2): Porcupine on-device "ARIA" Keyword.
+ * Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
+ * 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
 */

-import LiveAudioStream from 'react-native-live-audio-stream';
+import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
+import AsyncStorage from '@react-native-async-storage/async-storage';

 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;

-export type WakeWordState = 'off' | 'listening' | 'detected';
+export type WakeWordState = 'off' | 'armed' | 'conversing';
+
+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',
+  'computer',
+  'alexa',
+  'hey_mycroft',
+  'hey_rhasspy',
+] 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 };

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

-  /** Wake Word Erkennung starten */
-  async start(): Promise<boolean> {
-    if (this.state === 'listening') return true;
+  private keyword: WakeKeyword = DEFAULT_KEYWORD;
+  private nativeReady: boolean = false;
+  private initInProgress: Promise<boolean> | null = null;
+  private eventSub: { remove: () => void } | null = null;

+  /** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
+  async loadFromStorage(): Promise<void> {
    try {
-      if (!this.isInitialized) {
-        LiveAudioStream.init({
-          sampleRate: 16000,
-          channels: 1,
-          bitsPerSample: 16,
-          audioSource: 6, // VOICE_RECOGNITION
-          bufferSize: 4096,
-        });
-        this.isInitialized = true;
-      }
-
-      // Audio-Stream starten und auf Energie pruefen
-      LiveAudioStream.start();
-
-      LiveAudioStream.on('data', (base64Chunk: string) => {
-        if (this.state !== 'listening') return;
-
-        // Base64 → Int16 Array → RMS berechnen
-        const raw = this._base64ToInt16(base64Chunk);
-        const rms = this._calculateRMS(raw);
-
-        // Schwellwert: wenn laut genug → Wake Word erkannt
-        // Phase 1: Einfache Energie-Erkennung (jemand spricht)
-        // Phase 2: Porcupine "ARIA" Keyword
-        if (rms > 2000) {
-          this.setState('detected');
-          this.wakeCallbacks.forEach(cb => cb());
-          // Nach Detection kurz pausieren, Aufnahme uebernimmt das Mikrofon
-          this.stop();
-        }
-      });
-
-      this.setState('listening');
-      console.log('[WakeWord] Listening gestartet');
-      return true;
+      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();
    } catch (err) {
-      console.error('[WakeWord] Start fehlgeschlagen:', err);
-      return false;
+      console.warn('[WakeWord] loadFromStorage', err);
    }
  }

-  /** Wake Word Erkennung stoppen */
-  stop(): void {
-    if (this.state === 'off') return;
-    try {
-      LiveAudioStream.stop();
-    } catch {}
-    this.setState('off');
-    console.log('[WakeWord] Gestoppt');
+  /** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
+  async configure(keyword: string): Promise<boolean> {
+    const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
+      ? (keyword as WakeKeyword)
+      : DEFAULT_KEYWORD;
+    this.keyword = next;
+    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, next);
+
+    // Laufende Instanz stoppen + 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;
  }

-  /** Nach Aufnahme erneut starten */
-  async resume(): Promise<void> {
-    // Kurze Pause damit Aufnahme das Mikrofon freigeben kann
+  private async initNative(): Promise<boolean> {
+    if (!OpenWakeWord) {
+      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
+      this.nativeReady = false;
+      return false;
+    }
+    if (this.initInProgress) return this.initInProgress;
+    this.initInProgress = (async () => {
+      try {
+        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);
+        return true;
+      } catch (err: any) {
+        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
+        this.nativeReady = false;
+        return false;
+      } finally {
+        this.initInProgress = null;
+      }
+    })();
+    return this.initInProgress;
+  }
+
+  private async disposeNative(): Promise<void> {
+    if (!OpenWakeWord) return;
+    try { await OpenWakeWord.dispose(); } catch {}
+    this.nativeReady = false;
+  }
+
+  /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
+  async start(): Promise<boolean> {
+    if (this.state !== 'off') return true;
+    if (this.nativeReady && OpenWakeWord) {
+      try {
+        await OpenWakeWord.start();
+        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
+        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        this.setState('armed');
+        return true;
+      } catch (err: any) {
+        console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
+                     err?.message || err);
+        ToastAndroid.show(
+          `Wake-Word-Start failed: ${err?.message || err}`,
+          ToastAndroid.LONG,
+        );
+      }
+    } else {
+      console.warn('[WakeWord] Native-Modul nicht bereit — Direkt-Aufnahme-Fallback');
+      ToastAndroid.show(
+        'Wake-Word nicht aktiv — direkte Aufnahme startet (Mikro hoert mit)',
+        ToastAndroid.LONG,
+      );
+    }
+    // Fallback: direkt in Konversation
+    console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
+    this.setState('conversing');
    setTimeout(() => {
-      if (this.state === 'off') {
-        this.start();
+      if (this.state === 'conversing') {
+        this.wakeCallbacks.forEach(cb => cb());
      }
    }, 500);
+    return true;
+  }
+
+  /** Komplett ausschalten (Ohr abschalten) */
+  async stop(): Promise<void> {
+    console.log('[WakeWord] Ohr deaktiviert');
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.setState('off');
+  }
+
+  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
+  private async onWakeDetected(): Promise<void> {
+    console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
+    ToastAndroid.show(`Wake-Word "${KEYWORD_LABELS[this.keyword]}" erkannt — sprich jetzt`, ToastAndroid.SHORT);
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.setState('conversing');
+    setTimeout(() => {
+      if (this.state === 'conversing') {
+        this.wakeCallbacks.forEach(cb => cb());
+      }
+    }, 200);
+  }
+
+  /** Konversation beenden — User hat im Window nichts gesagt.
+   *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
+   *  Ohne: zurueck zu 'off'.
+   */
+  async endConversation(): Promise<void> {
+    if (this.state !== 'conversing') return;
+    if (this.nativeReady && OpenWakeWord) {
+      try {
+        await OpenWakeWord.start();
+        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
+        ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        this.setState('armed');
+        return;
+      } catch (err) {
+        console.warn('[WakeWord] re-arm fehlgeschlagen:', err);
+      }
+    }
+    console.log('[WakeWord] Konversation zu Ende — Ohr aus');
+    ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
+    this.setState('off');
+  }
+
+  /** Nach ARIA-Antwort (TTS fertig): naechste Aufnahme im Conversation-Window starten */
+  async resume(): Promise<void> {
+    if (this.state !== 'conversing') return;
+    // Kurze Pause damit TTS-Audio nicht ins Mikrofon geht
+    await new Promise(resolve => setTimeout(resolve, 800));
+    if (this.state === 'conversing') {
+      console.log('[WakeWord] TTS fertig — naechste Aufnahme im Conversation-Window');
+      this.wakeCallbacks.forEach(cb => cb());
+    }
+  }
+
+  /** True solange das Ohr aktiv ist (armed ODER conversing). */
+  isActive(): boolean {
+    return this.state !== 'off';
+  }
+
+  isConversing(): boolean {
+    return this.state === 'conversing';
+  }
+
+  hasWakeWord(): boolean {
+    return this.nativeReady;
+  }
+
+  getKeyword(): WakeKeyword {
+    return this.keyword;
  }

  // --- Callbacks ---
@@ -113,32 +279,12 @@ class WakeWordService {
    return this.state;
  }

-  // --- Hilfsfunktionen ---
-
  private setState(state: WakeWordState): void {
    if (this.state !== state) {
      this.state = state;
      this.stateCallbacks.forEach(cb => cb(state));
    }
  }
-
-  private _base64ToInt16(base64: string): Int16Array {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return new Int16Array(bytes.buffer);
-  }
-
-  private _calculateRMS(samples: Int16Array): number {
-    if (samples.length === 0) return 0;
-    let sum = 0;
-    for (let i = 0; i < samples.length; i++) {
-      sum += samples[i] * samples[i];
-    }
-    return Math.sqrt(sum / samples.length);
-  }
 }

 const wakeWordService = new WakeWordService();
@@ -3,9 +3,12 @@
 # → localhost ist aria-core
 ARIA_CORE_WS=ws://127.0.0.1:18789

-# Piper TTS Stimmen
-PIPER_RAMONA=/voices/de_DE-ramona-low.onnx
-PIPER_THORSTEN=/voices/de_DE-thorsten-high.onnx
-
 # Wake-Word
 WAKE_WORD=aria
+
+# Whisper STT — wird zur Laufzeit in der Diagnostic (Sektion "Whisper") umgeschaltet
+# und in /shared/config/voice_config.json gespeichert. Der Wert hier ist nur der
+# Initial-Default beim ersten Start.
+# Optionen: tiny | base | small | medium | large-v3
+WHISPER_MODEL=medium
+WHISPER_LANGUAGE=de
@@ -1,6 +1,6 @@
 # ════════════════════════════════════════════════
 #  ARIA Voice Bridge — Dockerfile
-#  Whisper STT + Piper TTS + Wake-Word
+#  Whisper STT + Wake-Word (TTS via XTTS v2 remote)
 # ════════════════════════════════════════════════

 FROM python:3.12-slim
@@ -91,6 +91,39 @@ _ACTIVATION_MAP: dict[str, Mode] = {
    mode.config.activation_phrase.lower(): mode for mode in Mode
 }

+# ID-Mapping fuer API-Mode-Wechsel (z.B. App ModeSelector schickt 'normal')
+_ID_MAP: dict[str, Mode] = {
+    "normal": Mode.NORMAL,
+    "nicht_stoeren": Mode.DND,
+    "dnd": Mode.DND,
+    "fluester": Mode.WHISPER,
+    "whisper": Mode.WHISPER,
+    "hangar": Mode.HANGAR,
+    "gaming": Mode.GAMING,
+}
+
+
+def mode_from_id(mode_id: str) -> Optional[Mode]:
+    """ID-basiertes Mapping fuer API-Mode-Wechsel (ohne Aktivierungsphrase)."""
+    if not mode_id:
+        return None
+    return _ID_MAP.get(mode_id.strip().lower())
+
+
+# Kanonische IDs fuer Broadcasts (matchen die App-UI-IDs in ModeSelector)
+_CANONICAL_ID: dict[Mode, str] = {
+    Mode.NORMAL: "normal",
+    Mode.DND: "nicht_stoeren",
+    Mode.WHISPER: "fluester",
+    Mode.HANGAR: "hangar",
+    Mode.GAMING: "gaming",
+}
+
+
+def canonical_id(mode: Mode) -> str:
+    """Kanonische ID die App + Diagnostic + Bridge gleichermassen kennen."""
+    return _CANONICAL_ID.get(mode, mode.name.lower())
+

 def detect_mode_switch(text: str) -> Optional[Mode]:
    """Erkennt ob ein Text eine Modus-Umschaltung enthaelt.
@@ -5,8 +5,7 @@
 # STT — Whisper (lokal, keine API noetig)
 faster-whisper

-# TTS — Piper (offline, deutsche Stimmen)
-piper-tts
+# TTS: laeuft remote ueber XTTS v2 auf dem Gaming-PC (keine lokalen Deps noetig)

 # WebSocket-Verbindung zu aria-core
 websockets
@@ -0,0 +1,16 @@
+@echo off
+REM ================================================================
+REM  ARIA - Cleanup-Wrapper fuer Windows
+REM ================================================================
+REM  Ruft cleanup-windows.ps1 mit ExecutionPolicy Bypass auf.
+REM  Funktioniert auch wenn Windows .ps1 direkt nicht startet.
+REM
+REM  Nutzung:
+REM    cleanup-windows.bat stefan
+REM    cleanup-windows.bat stefan -SkipPrune
+REM
+REM  Doppelklick funktioniert NICHT (braucht Username als Param).
+REM  Per Konsole aufrufen.
+REM ================================================================
+
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0cleanup-windows.ps1" %*
@@ -0,0 +1,184 @@
+# ================================================================
+#  ARIA - Windows / WSL2 / Docker Desktop VHDX Cleanup
+# ================================================================
+#
+#  Findet alle WSL2 + Docker Desktop ext4.vhdx Files unter
+#  C:\Users\<USER>\AppData\Local\... und kompaktiert sie via diskpart.
+#  Damit bekommst du Speicherplatz zurueck den du IN den Distros/
+#  Containern geloescht hast (z.B. nach `docker system prune`),
+#  der aber von der VHDX bisher nicht freigegeben wurde.
+#
+#  Nutzung (PowerShell als ADMIN, oder via cleanup-windows.bat):
+#    .\cleanup-windows.ps1 stefan
+#    .\cleanup-windows.ps1 -User stefan
+#    .\cleanup-windows.ps1 -User stefan -SkipPrune    # nur compacten
+#    .\cleanup-windows.ps1 -User stefan -PruneOnly    # nur prune
+#
+#  Was passiert:
+#    1. Erst (optional): docker system prune + builder prune in WSL2
+#    2. wsl --shutdown
+#    3. Alle gefundenen .vhdx Files mit diskpart compact vdisk shrinken
+#
+#  Hinweis: diskpart braucht KEINE Hyper-V Tools (anders als Optimize-VHD).
+#
+#  ASCII-only damit Windows-PowerShell 5.1 das File ohne BOM korrekt
+#  parsen kann (UTF-8-Sonderzeichen wuerden sonst als Windows-1252
+#  fehlinterpretiert).
+# ================================================================
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory=$true, Position=0,
+               HelpMessage="Dein Windows-Benutzername (z.B. stefan)")]
+    [string]$User,
+
+    [Parameter(HelpMessage="Docker prune ueberspringen - nur compacten")]
+    [switch]$SkipPrune,
+
+    [Parameter(HelpMessage="Docker prune NUR machen, dann beenden")]
+    [switch]$PruneOnly
+)
+
+# Defensive: Process-Scope ExecutionPolicy auf Bypass - verhindert dass
+# Untersaetze (z.B. Module) blockiert werden. Harmless wenn Parent schon
+# Bypass aufgerufen hat.
+try { Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force | Out-Null } catch {}
+
+# Admin-Check + Self-Elevation
+# Wenn nicht als Admin gestartet -> einmal neu starten als Admin, mit
+# ExecutionPolicy Bypass + den Original-Argumenten. User muss nur einmal
+# UAC-Prompt bestaetigen.
+$isAdmin = ([Security.Principal.WindowsPrincipal] `
+    [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(
+    [Security.Principal.WindowsBuiltInRole]::Administrator)
+if (-not $isAdmin) {
+    Write-Host "-> Starte neu als Administrator (mit ExecutionPolicy Bypass)..." -ForegroundColor Yellow
+    $myPath = $MyInvocation.MyCommand.Path
+    $forwardArgs = @("-NoProfile", "-ExecutionPolicy", "Bypass", "-File", "`"$myPath`"")
+    if ($User)      { $forwardArgs += @("-User", $User) }
+    if ($SkipPrune) { $forwardArgs += "-SkipPrune" }
+    if ($PruneOnly) { $forwardArgs += "-PruneOnly" }
+    try {
+        Start-Process powershell.exe -Verb RunAs -ArgumentList $forwardArgs
+    } catch {
+        Write-Host "[FAIL] UAC-Elevation abgebrochen oder fehlgeschlagen." -ForegroundColor Red
+        Write-Host "       Rechtsklick auf PowerShell -> 'Als Administrator ausfuehren'" -ForegroundColor Yellow
+        exit 1
+    }
+    exit 0
+}
+
+$basePath = "C:\Users\$User\AppData\Local"
+if (-not (Test-Path $basePath)) {
+    Write-Host "[FAIL] Pfad existiert nicht: $basePath" -ForegroundColor Red
+    Write-Host "       Pruefe den Benutzernamen." -ForegroundColor Yellow
+    exit 1
+}
+
+Write-Host "================================================================" -ForegroundColor Cyan
+Write-Host "  ARIA Cleanup fuer User: $User" -ForegroundColor Cyan
+Write-Host "================================================================" -ForegroundColor Cyan
+Write-Host ""
+
+# -- 1. Docker prune (in WSL2) -----------------------------------
+if (-not $SkipPrune) {
+    Write-Host "[1/3] Docker Cleanup in WSL2..." -ForegroundColor Yellow
+    Write-Host "      docker system prune -a --volumes -f" -ForegroundColor Gray
+    Write-Host "      docker builder prune -a -f" -ForegroundColor Gray
+    Write-Host ""
+    try {
+        wsl -e bash -c "docker system prune -a --volumes -f && docker builder prune -a -f"
+        Write-Host "      [OK] fertig" -ForegroundColor Green
+    } catch {
+        Write-Host "      [WARN] Docker prune fehlgeschlagen (vielleicht laeuft Docker Desktop nicht?)" -ForegroundColor Yellow
+        Write-Host "             $_" -ForegroundColor Gray
+    }
+    Write-Host ""
+    if ($PruneOnly) {
+        Write-Host "PruneOnly gesetzt - fertig." -ForegroundColor Cyan
+        exit 0
+    }
+}
+
+# -- 2. WSL2 shutdown --------------------------------------------
+Write-Host "[2/3] WSL2 herunterfahren..." -ForegroundColor Yellow
+wsl --shutdown
+Start-Sleep -Seconds 3
+Write-Host "      [OK] fertig" -ForegroundColor Green
+Write-Host ""
+
+# -- 3. VHDX-Files finden + compacten ----------------------------
+Write-Host "[3/3] VHDX-Files suchen + compacten..." -ForegroundColor Yellow
+Write-Host ""
+
+$vhdxFiles = @()
+$vhdxFiles += Get-ChildItem -Path "$basePath\Docker" -Recurse -Filter "*.vhdx" -ErrorAction SilentlyContinue
+$vhdxFiles += Get-ChildItem -Path "$basePath\Packages" -Recurse -Filter "ext4.vhdx" -ErrorAction SilentlyContinue
+$vhdxFiles = $vhdxFiles | Sort-Object FullName -Unique
+
+if ($vhdxFiles.Count -eq 0) {
+    Write-Host "      Keine .vhdx Files gefunden." -ForegroundColor Yellow
+    exit 0
+}
+
+Write-Host "Gefundene Files (vorher):" -ForegroundColor Cyan
+foreach ($f in $vhdxFiles) {
+    $sizeGB = [math]::Round($f.Length / 1GB, 2)
+    Write-Host ("  {0,8} GB  {1}" -f $sizeGB, $f.FullName) -ForegroundColor Gray
+}
+Write-Host ""
+
+$totalBefore = ($vhdxFiles | Measure-Object Length -Sum).Sum
+
+foreach ($f in $vhdxFiles) {
+    Write-Host "-> Compact: $($f.FullName)" -ForegroundColor White
+    $sizeBefore = [math]::Round($f.Length / 1GB, 2)
+
+    # Temporaeres diskpart-Script schreiben
+    $tmp = [System.IO.Path]::GetTempFileName()
+    @"
+select vdisk file="$($f.FullName)"
+attach vdisk readonly
+compact vdisk
+detach vdisk
+exit
+"@ | Out-File -Encoding ASCII -FilePath $tmp
+
+    try {
+        $output = & diskpart /s $tmp 2>&1
+        # Datei neu lesen - Length ist gecacht
+        $newFile = Get-Item $f.FullName
+        $sizeAfter = [math]::Round($newFile.Length / 1GB, 2)
+        $saved = [math]::Round($sizeBefore - $sizeAfter, 2)
+        if ($saved -gt 0) {
+            Write-Host ("  [OK] {0} GB -> {1} GB  (gespart: {2} GB)" -f $sizeBefore, $sizeAfter, $saved) -ForegroundColor Green
+        } else {
+            Write-Host ("  --   {0} GB -> {1} GB  (nichts zu holen - File war schon optimal)" -f $sizeBefore, $sizeAfter) -ForegroundColor DarkGray
+        }
+    } catch {
+        Write-Host "  [FAIL] Fehler: $_" -ForegroundColor Red
+        Write-Host "         diskpart-Output:" -ForegroundColor DarkGray
+        $output | ForEach-Object { Write-Host "         $_" -ForegroundColor DarkGray }
+    } finally {
+        Remove-Item $tmp -ErrorAction SilentlyContinue
+    }
+    Write-Host ""
+}
+
+# -- Zusammenfassung ---------------------------------------------
+$vhdxFilesAfter = @()
+$vhdxFilesAfter += Get-ChildItem -Path "$basePath\Docker" -Recurse -Filter "*.vhdx" -ErrorAction SilentlyContinue
+$vhdxFilesAfter += Get-ChildItem -Path "$basePath\Packages" -Recurse -Filter "ext4.vhdx" -ErrorAction SilentlyContinue
+$vhdxFilesAfter = $vhdxFilesAfter | Sort-Object FullName -Unique
+$totalAfter = ($vhdxFilesAfter | Measure-Object Length -Sum).Sum
+
+$savedTotal = [math]::Round(($totalBefore - $totalAfter) / 1GB, 2)
+
+Write-Host "================================================================" -ForegroundColor Cyan
+Write-Host ("  Gesamt: {0} GB -> {1} GB  (gespart: {2} GB)" -f `
+    [math]::Round($totalBefore / 1GB, 2),
+    [math]::Round($totalAfter / 1GB, 2),
+    $savedTotal) -ForegroundColor Cyan
+Write-Host "================================================================" -ForegroundColor Cyan
+Write-Host ""
+Write-Host "Fertig. Docker Desktop / WSL2 starten ja von alleine wieder beim naechsten Aufruf." -ForegroundColor Green
@@ -0,0 +1,44 @@
+#!/bin/bash
+# ARIA Docker Cleanup
+#
+# Standard:  docker builder prune + image prune (sicher, loescht keine Volumes)
+# --full:    Volle Reinigung inkl. --volumes (Vorsicht bei ungenutzten Volumes!)
+#
+# Usage:
+#   ./cleanup.sh           # sicherer Cleanup
+#   ./cleanup.sh --full    # aggressiver Cleanup (inkl. Volumes)
+
+set -e
+
+FULL=0
+for arg in "$@"; do
+  case "$arg" in
+    --full|-f) FULL=1 ;;
+    -h|--help)
+      grep '^#' "$0" | sed 's/^# \{0,1\}//'
+      exit 0
+      ;;
+  esac
+done
+
+echo "── Docker Speicher VOR Cleanup ───────────────────"
+docker system df
+echo
+
+if [ "$FULL" = "1" ]; then
+  echo ">>> VOLLE Reinigung (inkl. ungenutzter Volumes)"
+  read -p "Wirklich? [y/N] " -n 1 -r REPLY
+  echo
+  [[ ! $REPLY =~ ^[Yy]$ ]] && { echo "Abgebrochen."; exit 0; }
+  docker system prune -a --volumes -f
+else
+  echo ">>> Sicherer Cleanup (Build-Cache + ungenutzte Images)"
+  docker builder prune -a -f
+  docker image prune -a -f
+fi
+
+echo
+echo "── Docker Speicher NACH Cleanup ──────────────────"
+docker system df
+echo
+df -h / | head -2
@@ -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 &&
@@ -18,7 +18,8 @@ services:
      claude-max-api"
    volumes:
      - ~/.claude:/root/.claude                      # Claude CLI Auth (Credentials in /root/.claude/.credentials.json)
-      - ./aria-data/ssh:/root/.ssh:ro               # SSH Keys fuer VM-Zugriff (aria-wohnung)
+      - ./aria-data/ssh:/root/.ssh                    # SSH Keys fuer VM-Zugriff (aria-wohnung, rw fuer ARIA)
+      - aria-shared:/shared                          # Shared Volume fuer Datei-Austausch (Uploads von App)
    environment:
      - HOST=0.0.0.0
      - SHELL=/bin/bash                              # Claude Code Bash-Tool braucht bash (nicht nur sh/ash)
@@ -58,6 +59,7 @@ services:
      - ./aria-data/ssh:/home/node/.ssh                # SSH Keys fuer VM-Zugriff
      - /tmp/.X11-unix:/tmp/.X11-unix
      - /var/run/docker.sock:/var/run/docker.sock  # VM von innen verwalten
+      - aria-shared:/shared                        # Shared Volume fuer Datei-Austausch (Bridge <> Core)
    restart: unless-stopped
    networks:
      - aria-net
@@ -70,8 +72,8 @@ services:
      - aria
    network_mode: "service:aria"                   # Teilt Netzwerk mit aria-core → localhost:18789
    volumes:
-      - ./aria-data/voices:/voices:ro              # TTS Stimmen
      - ./aria-data/config/aria.env:/config/aria.env
+      - aria-shared:/shared                        # Shared Volume fuer Datei-Austausch (Bridge <> Core)
      # Audio-Zugriff
      - /run/user/1000/pulse:/run/user/1000/pulse
      - /dev/snd:/dev/snd
@@ -97,6 +99,7 @@ services:
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./aria-data/config/diag-state:/data           # Persistenter State (aktive Session etc.)
+      - aria-shared:/shared                            # Shared Volume (Uploads + Config)
    environment:
      - ARIA_AUTH_TOKEN=${ARIA_AUTH_TOKEN:-}
      - PROXY_URL=http://proxy:3456
@@ -110,6 +113,7 @@ services:
 volumes:
  openclaw-config:                                 # Persistiert ~/.openclaw (Model, Auth, Sessions)
  claude-config:                                   # Persistiert ~/.claude (Permissions, Settings)
+  aria-shared:                                     # Datei-Austausch zwischen Bridge und Core

 networks:
  aria-net:
@@ -1,32 +0,0 @@
-#!/bin/bash
-# ════════════════════════════════════════════════
-#  ARIA — Piper Stimmen herunterladen
-#  Ramona (Alltag) + Thorsten (epische Momente)
-# ════════════════════════════════════════════════
-
-set -e
-
-VOICES_DIR="aria-data/voices"
-BASE_URL="https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE"
-
-mkdir -p "$VOICES_DIR"
-cd "$VOICES_DIR"
-
-echo "Lade ARIA Stimmen..."
-echo ""
-
-echo "[1/4] Ramona (Modell)..."
-wget -q --show-progress "$BASE_URL/ramona/low/de_DE-ramona-low.onnx"
-
-echo "[2/4] Ramona (Config)..."
-wget -q --show-progress "$BASE_URL/ramona/low/de_DE-ramona-low.onnx.json"
-
-echo "[3/4] Thorsten (Modell)..."
-wget -q --show-progress "$BASE_URL/thorsten/high/de_DE-thorsten-high.onnx"
-
-echo "[4/4] Thorsten (Config)..."
-wget -q --show-progress "$BASE_URL/thorsten/high/de_DE-thorsten-high.onnx.json"
-
-echo ""
-echo "Stimmen geladen!"
-ls -lh *.onnx
@@ -0,0 +1,108 @@
+# ARIA Issues & Features
+
+## Erledigt
+
+- [x] Bildupload funktioniert (Shared Volume /shared/uploads/)
+- [x] Sprachnachrichten werden als Text angezeigt (STT → Chat-Bubble)
+- [x] Cache leeren + Auto-Download von Anhaengen
+- [x] ARIA liest Nachrichten vor (TTS via Piper, später ersetzt)
+- [x] Autoscroll zur letzten Nachricht (inverted FlatList)
+- [x] Bilder im Chat groesser + Vollbild-Vorschau
+- [x] Ohr-Button → Gespraechsmodus (Auto-Aufnahme nach ARIA-Antwort)
+- [x] Play-Button in ARIA-Nachrichten fuer Sprachwiedergabe
+- [x] Chat-Suche in der App (Lupe in Statusleiste)
+- [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
+- [x] Abbrechen-Button im Diagnostic Chat
+- [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
+- [x] Grosse Nachrichten satzweise aufteilen fuer TTS
+- [x] RVS Nachrichten vom Smartphone gehen durch
+- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed pro Stimme — durch XTTS/F5-TTS ersetzt)
+- [x] Highlight-Trigger konfigurierbar in Diagnostic
+- [x] 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
+- [x] Auto-Update System (APK via RVS WebSocket)
+- [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
+- [x] Piper komplett entfernt
+- [x] Gespraechsmodus: Speech-Gate strenger (-28dB / 500ms)
+- [x] Diagnostic: Archivierte Session-Versionen (.reset.*) angezeigt + exportierbar
+- [x] tools/export-jsonl-to-md.js: CLI-Konverter fuer Session-JSONL zu Markdown
+- [x] NO_REPLY-Filter in Bridge + Diagnostic
+- [x] Audio-Ducking + Exklusiv-Focus (Kotlin AudioFocusModule)
+- [x] TTS-Cleanup serverseitig: Code-Bloecke raus, Einheiten ausgeschrieben, Abkuerzungen buchstabiert, URLs zu "ein Link"
+- [x] QR-Code Onboarding: Diagnostic generiert QR, App scannt
+- [x] TTS-Audio-Cache im Filesystem: WAV pro messageId, Play-Button spielt aus Cache
+- [x] Config via Diagnostic: RVS-Credentials + Auth-Token persistiert in /shared/config/runtime.json
+- [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
+- [x] Whisper-Modell hot-swap auf Gamebox via config-Broadcast aus Diagnostic
+- [x] **F5-TTS ersetzt XTTS komplett** — neuer aria-f5tts-bridge Container, Voice Cloning, satzweises Streaming
+- [x] Voice-Upload mit Whisper-Auto-Transkription — User muss keinen Referenz-Text eintippen
+- [x] Audio-Pause statt Ducking: Spotify/YouTube pausieren komplett waehrend TTS (TRANSIENT statt MAY_DUCK)
+- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
+- [x] VAD-Stille einstellbar in App-Settings (1.0-8.0s, Default 2.8s)
+- [x] MAX_RECORDING auf 120s — laengere Erklaerungen moeglich
+- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
+- [x] F5-TTS: Referenz-WAV-Preprocessing — Loudness-Normalisierung -16 LUFS + Silence-Trim + 10s Clip fuer konsistente Cloning-Quali
+- [x] F5-TTS: deutsches Fine-Tune (aihpi/F5-TTS-German, Vocos-Variante) via hf:// Pfad in Diagnostic konfigurierbar
+- [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
+- [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
+- [x] Dynamischer STT-Timeout in aria-bridge: 300s waehrend whisper-bridge 'loading', 45s wenn 'ready'
+- [x] service_status Broadcasts: f5tts/whisper melden Lade-Status, Banner in Diagnostic (unten rechts) + App (oben)
+- [x] config_request Pattern: Bridges fragen beim Connect die aktuelle Voice-Config an, aria-bridge antwortet
+- [x] F5-TTS Tuning via Diagnostic (Modell-ID, Checkpoint, cfg_strength, nfe_step) statt ENV-Vars — Hot-Reload bei Modell-Wechsel
+- [x] Conversation-Window: Gespraechsmodus endet nach X Sekunden Stille (1.0-20.0s, Default 8s, einstellbar in Settings)
+- [x] Porcupine Wake-Word-Integration in der App (Built-In Keywords + Custom spaeter, per Geraet einstellbar)
+- [x] HF-Cache als Bind-Mount statt Docker Volume — kein .vhdx-Bloat auf Docker Desktop / Windows
+- [x] cleanup-windows.ps1 / .bat: VHDX-Cleanup via diskpart (ohne Hyper-V) mit Self-Elevation
+- [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
+- [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
+- [x] App Text-Rendering: Nachrichten selektierbar + Autolink fuer URLs/E-Mails/Telefonnummern (Browser/Mail/Dialer)
+- [x] TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings → 0.5-2.0x in 0.1-Schritten, Default 1.0)
+- [x] Diagnostic: Voice-Preview-Modal (Play-Icon vor Delete-X, Textfeld mit Default, WAV im Browser abspielen)
+
+## Offen
+
+### Bugs
+- [ ] App: Wake-Word "jarvis" triggert nicht zuverlaessig (Porcupine-Debugging via ADB-Logcat ausstehend)
+- [ ] App: Stuerzt beim Lauschen ab, eventuell bei Nebengeraeuschen (Porcupine + Mic-Race, errorCallback haelt's jetzt zurueck — Dauertest ausstehend)
+
+### App Features
+- [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
+- [ ] Background Audio Service (TTS auch bei minimierter App)
+
+### Architektur
+- [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
+- [ ] Auto-Compacting und Memory/Brain Verwaltung (SQLite?)
+- [ ] Diagnostic: System-Info Tab (Container-Status, Disk, RAM, CPU)
+- [ ] RVS Zombie-Connections endgueltig loesen
+- [ ] Alle .env-Variablen ueber Diagnostic konfigurierbar machen (Fallback .env bleibt fuer initialen Bootstrap)
+- [ ] Gamebox: kleine Web-Oberflaeche fuer Credentials/Server-Config oder zentral aus Diagnostic per RVS push
+- [ ] Root-Cause OpenClaw Session-Reset: Herausfinden warum Sessions beim ersten chat.send nach Container-Restart verworfen werden
@@ -51,9 +51,36 @@ fi
 echo -e "  ${GREEN}✓${NC} Login erfolgreich"
 echo ""

+# ── Versionsnummern aktualisieren ─────────────
+echo -e "${GREEN}[1/5] Versionsnummern auf $VERSION setzen...${NC}"
+
+# package.json
+sed -i "s/\"version\": \"[^\"]*\"/\"version\": \"$VERSION\"/" android/package.json
+echo -e "  ${GREEN}✓${NC} package.json → $VERSION"
+
+# build.gradle: versionName + versionCode (aus Version berechnen)
+# Unterstuetzt 3-stellig (1.2.3) und 4-stellig (0.0.1.7)
+IFS='.' read -ra VER_PARTS <<< "$VERSION"
+V1=${VER_PARTS[0]:-0}; V2=${VER_PARTS[1]:-0}; V3=${VER_PARTS[2]:-0}; V4=${VER_PARTS[3]:-0}
+VERSION_CODE=$((V1 * 1000000 + V2 * 10000 + V3 * 100 + V4))
+# Mindestens 1 (Android erfordert versionCode >= 1)
+[ "$VERSION_CODE" -lt 1 ] && VERSION_CODE=1
+sed -i "s/versionName \"[^\"]*\"/versionName \"$VERSION\"/" android/android/app/build.gradle
+sed -i "s/versionCode [0-9]*/versionCode $VERSION_CODE/" android/android/app/build.gradle
+echo -e "  ${GREEN}✓${NC} build.gradle → versionName $VERSION, versionCode $VERSION_CODE"
+
+# SettingsScreen: Anzeige-Version (beliebiges Versionsformat)
+sed -i "s/Version [0-9][0-9.]*[^<]*/Version $VERSION /" android/src/screens/SettingsScreen.tsx
+echo -e "  ${GREEN}✓${NC} SettingsScreen → Version $VERSION"
+
+echo ""
+
 # ── APK bauen ─────────────────────────────────
-echo -e "${GREEN}[1/4] APK bauen...${NC}"
+echo -e "${GREEN}[2/5] APK bauen (Cache leeren + Build)...${NC}"
 cd android
+# Metro + Gradle Cache leeren damit neue Version sauber eingebettet wird
+rm -rf node_modules/.cache 2>/dev/null
+cd android && ./gradlew clean 2>/dev/null; cd ..
 ./build.sh release
 cd ..

@@ -70,7 +97,11 @@ echo -e "  ${GREEN}✓${NC} APK gebaut ($APK_SIZE)"
 echo ""

 # ── Git Tag ───────────────────────────────────
-echo -e "${GREEN}[2/4] Git Tag $TAG...${NC}"
+echo -e "${GREEN}[3/5] Git Tag $TAG...${NC}"
+
+# Versions-Aenderungen committen
+git add android/package.json android/android/app/build.gradle android/src/screens/SettingsScreen.tsx
+git commit -m "release: bump version to $VERSION" 2>/dev/null || echo -e "  ${YELLOW}Keine Aenderungen zum Committen${NC}"

 if git rev-parse "$TAG" &>/dev/null; then
    echo -e "  ${YELLOW}Tag $TAG existiert bereits — überspringe${NC}"
@@ -79,7 +110,7 @@ else
    echo -e "  ${GREEN}✓${NC} Tag $TAG erstellt"
 fi

-git push origin "$TAG"
+git push origin main "$TAG"
 echo -e "  ${GREEN}✓${NC} Tag gepusht"
 echo ""

@@ -102,7 +133,7 @@ fi
 RELEASE_BODY_ESCAPED=$(printf '%s' "$RELEASE_BODY" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '"%s"' "$RELEASE_BODY" | sed 's/"/\\"/g')

 # ── Gitea Release erstellen ───────────────────
-echo -e "${GREEN}[3/4] Gitea Release erstellen...${NC}"
+echo -e "${GREEN}[4/5] Gitea Release erstellen...${NC}"

 RELEASE_RESPONSE=$(curl -s -X POST \
    "$GITEA_URL/api/v1/repos/$GITEA_REPO/releases" \
@@ -127,7 +158,7 @@ echo -e "  ${GREEN}✓${NC} Release #$RELEASE_ID erstellt"
 echo ""

 # ── APK hochladen ─────────────────────────────
-echo -e "${GREEN}[4/4] APK hochladen...${NC}"
+echo -e "${GREEN}[5/5] APK hochladen...${NC}"

 UPLOAD_RESPONSE=$(curl -s -X POST \
    "$GITEA_URL/api/v1/repos/$GITEA_REPO/releases/$RELEASE_ID/assets?name=$APK_NAME" \
@@ -142,6 +173,24 @@ else
    exit 1
 fi

+# ── Auto-Update: APK auf RVS-Server kopieren ─
+RVS_UPDATE_HOST="${RVS_UPDATE_HOST:-}"
+if [ -n "$RVS_UPDATE_HOST" ]; then
+    echo -e "${GREEN}[6/6] APK auf RVS-Server kopieren (Auto-Update)...${NC}"
+    # Alte APKs auf dem RVS loeschen, dann neue hochladen
+    ssh "$RVS_UPDATE_HOST" "rm -f ~/ARIA-AGENT/rvs/updates/ARIA-*.apk" 2>/dev/null
+    scp "$APK_PATH" "${RVS_UPDATE_HOST}:~/ARIA-AGENT/rvs/updates/${APK_NAME}" 2>/dev/null
+    if [ $? -eq 0 ]; then
+        echo -e "  ${GREEN}✓${NC} APK auf RVS-Server kopiert (alte Versionen geloescht)"
+    else
+        echo -e "  ${YELLOW}APK konnte nicht auf RVS kopiert werden (RVS_UPDATE_HOST=$RVS_UPDATE_HOST)${NC}"
+        echo -e "  ${YELLOW}Manuell: scp $APK_PATH $RVS_UPDATE_HOST:~/ARIA-AGENT/rvs/updates/${APK_NAME}${NC}"
+    fi
+else
+    echo -e "${YELLOW}Auto-Update uebersprungen (RVS_UPDATE_HOST nicht gesetzt)${NC}"
+    echo -e "${YELLOW}Setze RVS_UPDATE_HOST in .env fuer automatische Verteilung${NC}"
+fi
+
 # ── Fertig ────────────────────────────────────
 echo ""
 echo -e "${GREEN}╔═══════════════════════════════════════════════════╗${NC}"
@@ -149,4 +198,5 @@ echo -e "${GREEN}║   Release $TAG ist live!$(printf '%*s' $((27 - ${#TAG})) ''
 echo -e "${GREEN}╠═══════════════════════════════════════════════════╣${NC}"
 echo -e "${GREEN}║${NC}   $GITEA_URL/$GITEA_REPO/releases/tag/$TAG"
 echo -e "${GREEN}║${NC}   APK: $APK_NAME ($APK_SIZE)"
+echo -e "${GREEN}║${NC}   Auto-Update: ${RVS_UPDATE_HOST:-nicht konfiguriert}"
 echo -e "${GREEN}╚═══════════════════════════════════════════════════╝${NC}"
@@ -4,5 +4,7 @@ services:
    ports:
      - "${RVS_PORT:-443}:3000"
    restart: always
+    volumes:
+      - ./updates:/updates                # APK-Dateien fuer Auto-Update
    environment:
      - MAX_SESSIONS=10
@@ -1,14 +1,28 @@
 "use strict";

 const { WebSocketServer } = require("ws");
+const fs = require("fs");
+const path = require("path");

 // ── Konfiguration aus Umgebungsvariablen ────────────────────────────
 const PORT = parseInt(process.env.PORT || "3000", 10);
 const MAX_SESSIONS = parseInt(process.env.MAX_SESSIONS || "10", 10);
+const UPDATES_DIR = process.env.UPDATES_DIR || "/updates";
+// Kein Polling — APK wird manuell per git pull bereitgestellt

 // Erlaubte Nachrichtentypen — alles andere wird verworfen
 const ALLOWED_TYPES = new Set([
  "chat", "audio", "file", "location", "mode", "log", "event", "heartbeat",
+  "file_request", "file_response", "file_saved", "stt_result", "config", "tts_request",
+  "xtts_request", "xtts_response", "xtts_list_voices", "xtts_voices_list", "voice_upload", "xtts_voice_saved",
+  "update_check", "update_available", "update_download", "update_data",
+  "agent_activity", "cancel_request",
+  "audio_pcm",
+  "xtts_delete_voice",
+  "voice_preload", "voice_ready",
+  "stt_request", "stt_response",
+  "service_status",
+  "config_request",
 ]);

 // Token-Raum: token -> { clients: Set<ws> }
@@ -41,10 +55,16 @@ function cleanupRooms() {

 // ── WebSocket-Server starten ────────────────────────────────────────

-const wss = new WebSocketServer({ port: PORT });
+// maxPayload 50MB: TTS-Streaming + Voice-Upload (WAV als base64) +
+// audio_pcm Chunks koennen die ws-Library Default 1MB ueberschreiten.
+// Default-Limit war der Killer fuer die voice_upload Pipeline.
+const wss = new WebSocketServer({ port: PORT, maxPayload: 50 * 1024 * 1024 });

 wss.on("listening", () => {
  log(`RVS läuft auf Port ${PORT} | Max Sessions: ${MAX_SESSIONS}`);
+  // Beim Start pruefen ob eine APK da ist
+  const apkInfo = getLatestAPK();
+  if (apkInfo) log(`APK bereit: v${apkInfo.version} (${(fs.statSync(apkInfo.path).size / 1024 / 1024).toFixed(1)}MB)`);
 });

 wss.on("connection", (ws, req) => {
@@ -106,6 +126,52 @@ function registerClient(ws, token) {
      return;
    }

+    // Update-Check: direkt an den anfragenden Client antworten (nicht relay'en)
+    if (msg.type === "update_check") {
+      const clientVersion = msg.payload?.version || "0.0.0.0";
+      const apkInfo = getLatestAPK();
+      if (apkInfo && compareVersions(apkInfo.version, clientVersion) > 0) {
+        ws.send(JSON.stringify({
+          type: "update_available",
+          payload: {
+            version: apkInfo.version,
+            downloadUrl: `/update/latest.apk`,
+            size: fs.statSync(apkInfo.path).size,
+          },
+          timestamp: Date.now(),
+        }));
+      }
+      return;
+    }
+
+    // Update-Download: APK als Base64 ueber WebSocket senden
+    if (msg.type === "update_download") {
+      const apkInfo = getLatestAPK();
+      if (!apkInfo) {
+        ws.send(JSON.stringify({ type: "update_data", payload: { error: "Keine APK verfuegbar" }, timestamp: Date.now() }));
+        return;
+      }
+      try {
+        const data = fs.readFileSync(apkInfo.path);
+        const base64 = data.toString("base64");
+        const sizeMB = (data.length / 1024 / 1024).toFixed(1);
+        log(`APK sende: v${apkInfo.version} (${sizeMB}MB) an Client`);
+        ws.send(JSON.stringify({
+          type: "update_data",
+          payload: {
+            version: apkInfo.version,
+            base64,
+            size: data.length,
+            fileName: `ARIA-v${apkInfo.version}.apk`,
+          },
+          timestamp: Date.now(),
+        }));
+      } catch (err) {
+        ws.send(JSON.stringify({ type: "update_data", payload: { error: err.message }, timestamp: Date.now() }));
+      }
+      return;
+    }
+
    // An alle anderen Clients im Raum weiterleiten
    for (const client of room.clients) {
      if (client !== ws && client.readyState === 1) {
@@ -166,6 +232,63 @@ wss.on("close", () => {
  clearInterval(cleanup);
 });

+// ── Auto-Update: APK-Erkennung + Push ──────────────────────────────
+
+let latestVersion = null;
+
+function getLatestAPK() {
+  try {
+    if (!fs.existsSync(UPDATES_DIR)) return null;
+    const files = fs.readdirSync(UPDATES_DIR)
+      .filter(f => f.endsWith(".apk"))
+      .map(f => {
+        // ARIA-v0.0.2.3.apk oder ARIA-Cockpit-release.apk
+        const match = f.match(/(\d+\.\d+\.\d+[\.\d]*)/);
+        return { file: f, path: path.join(UPDATES_DIR, f), version: match ? match[1] : null };
+      })
+      .filter(f => f.version)
+      .sort((a, b) => compareVersions(b.version, a.version)); // Neueste zuerst
+
+    return files[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+function notifyClientsAboutUpdate(apkInfo) {
+  const msg = JSON.stringify({
+    type: "update_available",
+    payload: {
+      version: apkInfo.version,
+      downloadUrl: `/update/latest.apk`,
+      size: fs.statSync(apkInfo.path).size,
+    },
+    timestamp: Date.now(),
+  });
+
+  // An alle Clients in allen Rooms senden
+  for (const [, room] of rooms) {
+    for (const client of room.clients) {
+      if (client.readyState === 1) {
+        client.send(msg);
+      }
+    }
+  }
+  log(`Update-Benachrichtigung gesendet: v${apkInfo.version} (${rooms.size} Raum/Raeume)`);
+}
+
+// Kein Polling — Update-Check passiert on-demand (update_check Message von App)
+
 // ── Sauberes Herunterfahren ─────────────────────────────────────────

 process.on("SIGTERM", () => {
@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Exportiert ein OpenClaw Session-JSONL (auch .reset.*) als Markdown.
+ *
+ * Nutzung:
+ *   node export-jsonl-to-md.js <input.jsonl> [output.md]
+ *
+ * Oder direkt aus dem aria-core Container:
+ *   docker exec aria-core cat /home/node/.openclaw/agents/main/sessions/<ID>.jsonl.reset.<TS> \
+ *     | node export-jsonl-to-md.js - > output.md
+ */
+
+const fs = require("fs");
+
+const inputArg = process.argv[2];
+const outputArg = process.argv[3];
+
+if (!inputArg) {
+  console.error("Usage: export-jsonl-to-md.js <input.jsonl|-> [output.md]");
+  process.exit(1);
+}
+
+const raw = inputArg === "-" ? fs.readFileSync(0, "utf-8") : fs.readFileSync(inputArg, "utf-8");
+const lines = raw.split("\n").filter(l => l.trim());
+
+const blocks = [];
+for (const line of lines) {
+  let obj;
+  try { obj = JSON.parse(line); } catch { continue; }
+  if (obj.type !== "message" || !obj.message) continue;
+  const role = obj.message.role;
+  if (role !== "user" && role !== "assistant") continue;
+
+  let text = "";
+  const content = obj.message.content;
+  if (typeof content === "string") text = content;
+  else if (Array.isArray(content)) text = content.filter(c => c.type === "text").map(c => c.text || "").join("\n");
+  if (!text) continue;
+
+  if (role === "user") {
+    text = text.replace(/^Sender \(untrusted metadata\):[\s\S]*?```[\s\S]*?```\s*\n*/m, "").trim();
+    text = text.replace(/^\[.*?\]\s*/, "").trim();
+  } else {
+    text = text.replace(/^\[\[reply_to_\w+\]\]\s*/g, "").trim();
+  }
+  if (!text) continue;
+
+  const ts = obj.message.timestamp || obj.timestamp || 0;
+  const when = ts ? new Date(ts).toISOString().replace("T", " ").slice(0, 19) : "";
+  const heading = role === "user" ? "## 🧑 User" : "## 🤖 ARIA";
+  blocks.push(`${heading}${when ? ` — ${when}` : ""}\n\n${text}`);
+}
+
+const exportedAt = new Date().toISOString().replace("T", " ").slice(0, 19);
+const title = inputArg === "-" ? "Session" : inputArg.split("/").pop().replace(/\.jsonl.*/, "");
+const md = [
+  `# Session: ${title}`,
+  ``,
+  `Exportiert: ${exportedAt}  `,
+  `Quelle: ${inputArg === "-" ? "stdin" : inputArg}`,
+  `Nachrichten: ${blocks.length}`,
+  ``,
+  `---`,
+  ``,
+  blocks.join("\n\n---\n\n"),
+  ``,
+].join("\n");
+
+if (outputArg) {
+  fs.writeFileSync(outputArg, md);
+  console.error(`OK: ${blocks.length} Nachrichten → ${outputArg}`);
+} else {
+  process.stdout.write(md);
+}
@@ -0,0 +1,11 @@
+# ════════════════════════════════════════════════
+#  ARIA XTTS v2 — Konfiguration
+#  Kopieren nach .env und anpassen
+# ════════════════════════════════════════════════
+
+# RVS Verbindung (gleiche Daten wie auf der ARIA-VM)
+RVS_HOST=mobil.hacker-net.de
+RVS_PORT=444
+RVS_TLS=true
+RVS_TLS_FALLBACK=true
+RVS_TOKEN=dein_token_hier
@@ -0,0 +1,9 @@
+# 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/
+
+# Docker .env
+.env
@@ -0,0 +1,85 @@
+# ════════════════════════════════════════════════
+#  ARIA Gamebox Stack — GPU F5-TTS + Whisper STT
+#  Laeuft auf dem Gaming-PC (RTX 3060)
+#  Verbindet sich zum RVS fuer TTS/STT-Requests
+# ════════════════════════════════════════════════
+#
+#  Voraussetzungen:
+#    - Docker Desktop mit WSL2
+#    - NVIDIA Container Toolkit
+#    - .env mit RVS-Verbindungsdaten
+#
+#  Start: docker compose up -d
+# ════════════════════════════════════════════════
+
+services:
+
+  # ─── F5-TTS Bridge (GPU) ──────────────────────
+  # Ersetzt den frueheren XTTS-Stack. Empfaengt xtts_request via RVS,
+  # rendert via F5-TTS mit Voice-Cloning, streamt PCM an die App.
+  # Voice-Upload: speichert WAV und laesst whisper-bridge den Referenz-
+  # text transkribieren — der User muss nichts eintippen.
+  f5tts-bridge:
+    build: ./f5tts
+    container_name: aria-f5tts-bridge
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              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.
+    environment:
+      # Bootstrap-only — alle anderen F5-TTS-Settings (Modell, cfg_strength,
+      # nfe_step, Custom-Checkpoint) kommen ueber Diagnostic via RVS-config.
+      - RVS_HOST=${RVS_HOST}
+      - RVS_PORT=${RVS_PORT:-443}
+      - RVS_TLS=${RVS_TLS:-true}
+      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
+      - RVS_TOKEN=${RVS_TOKEN}
+      - F5TTS_DEVICE=${F5TTS_DEVICE:-cuda}
+      - VOICES_DIR=/voices
+    restart: unless-stopped
+
+  # ─── Whisper STT (GPU) ────────────────────────
+  # Faster-Whisper auf der Gamebox statt auf der VM (CPU) —
+  # deutlich schneller. Verbindet sich selbst per WebSocket an
+  # den RVS und nimmt dort stt_request Nachrichten der aria-bridge
+  # entgegen, antwortet mit stt_response. Zusaetzlich nutzt die
+  # f5tts-bridge Whisper intern fuer die Referenz-Transkription bei
+  # Voice-Uploads. Laedt das Modell beim Start vor; auf Config-
+  # Broadcasts (Diagnostic → whisperModel) wird zur Laufzeit hot-
+  # swapped.
+  whisper-bridge:
+    build: ./whisper
+    container_name: aria-whisper-bridge
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    environment:
+      - RVS_HOST=${RVS_HOST}
+      - RVS_PORT=${RVS_PORT:-443}
+      - RVS_TLS=${RVS_TLS:-true}
+      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
+      - RVS_TOKEN=${RVS_TOKEN}
+      - WHISPER_MODEL=${WHISPER_MODEL:-small}
+      - 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.
+    restart: unless-stopped
--- a/Show More
+++ b/Show More