release: bump version to 0.0.4.1

Der QR wurde mit createImgTag() als fester Pixel-IMG gerendert und
ueberlappte den Warnhinweis + Button rechts daneben. Fix:

- createSvgTag mit cellSize=4 + scalable=true
- SVG skaliert auf width:100%/height:100% der 220x220 Box
- Container: flex-shrink:0 (damit Flex ihn nicht weiter schrumpft)
- overflow:hidden als Sicherheit

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

.env.example

@@ -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=

.gitignore

@@ -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/

README.md

@@ -29,11 +29,18 @@ 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
+            ▼                           ▼
+┌───────────────────────────┐
+│  Gaming-PC (optional)      │
+│  RTX 3060, Docker+WSL2    │
+│  XTTS v2 (natuerliche     │
+│  Stimmen, Voice Cloning)   │
+│  xtts/docker-compose.yml  │
+└───────────────────────────┘
 ┌─────────────────────────────────────────────────────────┐
 │     ARIA-VM (Proxmox, Debian 13) — ARIAs Wohnung        │
 │     Basissystem + Docker. Rest richtet ARIA selbst ein.  │
@@ -66,13 +73,14 @@ 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 |
+| XTTS v2 (optional) | Gaming-PC (GPU) | `cd xtts && docker compose up -d` |
+| Android App | Stefans Handy | APK installieren (Auto-Update via RVS) |
 
 ---
 
@@ -95,16 +103,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
@@ -271,15 +294,20 @@ Die Bridge verbindet die Android App mit ARIA und bietet lokale Sprachverarbeitu
 
 **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 → FFmpeg → Whisper STT → chat.send → aria-core
+Datei:  App → RVS → Bridge → /shared/uploads/ → chat.send (mit Pfad) → aria-core
+
+aria-core → Antwort → Gateway → Diagnostic → RVS → App
+                              → Bridge → Piper TTS → RVS → App (Audio)
+                              → Bridge → Lautsprecher (lokal)
 ```
 
 ### Features
 
 - **STT**: faster-whisper (lokal, offline, 16kHz mono)
-- **TTS**: Piper (Ramona + Thorsten, offline)
+- **TTS**: Piper (Ramona + Thorsten, offline) oder XTTS v2 (remote, GPU, Voice Cloning)
+- **Markdown-Bereinigung**: Entfernt **fett**, *kursiv*, `code`, Links, Listen etc. vor TTS (natuerliche Sprache)
 - **Wake-Word**: openwakeword (lokales Mikrofon auf der VM)
 - **App-Audio**: Base64 Audio von App → FFmpeg → Whisper STT → Text an aria-core
 - **Modi**: Normal, Nicht stoeren, Fluestern, Hangar, Gaming
@@ -310,13 +338,19 @@ 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
+- **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-Engine (Piper/XTTS), Stimmen, Speed, Highlight-Trigger, Betriebsmodi, Whisper-Modell (tiny…large-v3, Hot-Reload)
+- **XTTS Voice Cloning**: Audio-Samples hochladen, eigene Stimme erstellen
 - **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,10 +368,19 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 
 - Text-Chat mit ARIA
 - **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
+- **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her, ohne Buttons druecken
 - **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
+- **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt (kein Rauschen an Whisper)
+- **STT (Speech-to-Text)**: Audio wird als 16kHz mono aufgenommen und in der Bridge per Whisper transkribiert, transkribierter Text erscheint im Chat
+- **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
+- **TTS-Wiedergabe**: ARIA antwortet per Lautsprecher (Piper oder XTTS v2), Audio-Queue mit Preloading
+- **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden
+- **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 Engine, Stimmen, Speed pro Stimme, 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
 
@@ -361,15 +404,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, piper-tts) — 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
+Bridge: STT-Ergebnis → RVS → App (Placeholder wird durch transkribierten Text ersetzt)
 aria-core → Antwort → Bridge → Piper TTS (WAV) → Base64 → RVS → App
 App: Base64 → WAV → Lautsprecher
 ```
 
+### 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/
@@ -396,6 +514,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 +534,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 +542,90 @@ 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.
 
 ---
 
+## XTTS v2 — GPU TTS Server (optional)
+
+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
+
+```
+Gaming-PC (Windows, RTX 3060, Docker Desktop + WSL2)
+├── aria-xtts        XTTS v2 GPU Server (Port 8020 intern)
+└── aria-xtts-bridge RVS-Relay (empfaengt Requests, sendet Audio)
+    └── Beide teilen ./voices/ Volume fuer Voice Cloning
+
+         ↕ RVS (Rechenzentrum, WebSocket Relay)
+
+ARIA-VM
+└── aria-bridge: tts_engine="xtts" → xtts_request via RVS → wartet auf xtts_response
+```
+
+### Voraussetzungen
+
+- Docker Desktop mit WSL2 (Windows) oder Docker mit NVIDIA Runtime (Linux)
+- NVIDIA Container Toolkit
+- GPU mit mindestens 4GB VRAM (6GB+ empfohlen)
+- **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 ~2GB Model herunter (danach gecacht)
+```
+
+**Wichtig:** Der XTTS-Server laeuft intern auf Port **8020** (nicht 8000).
+Das Model wird im Volume `xtts-models` gecacht und muss nur einmal geladen werden.
+
+### Features
+
+- **Natuerliche Stimmen**: Deutlich bessere Qualitaet als Piper
+- **Voice Cloning**: Eigene Stimme mit 6-10s Audio-Sample (~2s Latenz auf RTX 3060)
+- **16 Sprachen**: Deutsch, Englisch, Franzoesisch, etc.
+- **Fallback**: Wenn XTTS nicht erreichbar, nutzt die Bridge automatisch Piper
+
+### TTS-Engine umschalten
+
+In der Diagnostic unter Einstellungen → Sprachausgabe:
+- **TTS aktiv**: Global An/Aus
+- **TTS Engine**: Piper (lokal, CPU, schnell) oder XTTS v2 (remote, GPU, natuerlich)
+- **Piper**: Standard-Stimme, Highlight-Stimme, Speed pro Stimme
+- **XTTS**: Stimmen-Auswahl, Voice Cloning
+
+### Stimme klonen
+
+1. TTS Engine auf "XTTS v2" stellen
+2. "Stimme klonen" → Audio-Dateien hochladen (WAV/MP3, 1-10 Dateien, min. 6-10s gesamt)
+3. Name vergeben → "Stimme erstellen"
+4. "Laden" klicken → neue Stimme in der Auswahl
+5. Stimme auswaehlen → Config wird automatisch gespeichert
+
+> **Tipp:** Fuer beste Ergebnisse: saubere Aufnahme, eine Stimme, kein Hintergrund,
+> 10-30 Sekunden Gesamtlaenge. Mehrere kurze Dateien werden zusammengefuegt.
+
+---
+
 ## Docker Volumes
 
 | Volume | Pfad im Container | Zweck |
@@ -433,6 +636,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) |
 
 ---
 
@@ -487,8 +692,15 @@ docker exec aria-core ssh aria-wohnung hostname
   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).
+  In der App gibt es Energy-basierte Erkennung (Phase 1). On-device "ARIA"-Keyword (Porcupine) ist Phase 2.
 - **Audio-Format**: App nimmt AAC/MP4 auf, Bridge konvertiert via FFmpeg zu 16kHz PCM.
+- **RVS Zombie-Connections**: WebSocket-Verbindungen sterben gelegentlich ohne Fehlermeldung.
+  Bridge hat Ping-Check (5s), Diagnostic nutzt frische Verbindungen pro Request.
+- **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 +716,26 @@ 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)
+- [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)
 
 ### Phase 2 — ARIA wird produktiv
 
@@ -513,7 +743,8 @@ 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
 
@@ -521,3 +752,4 @@ docker exec aria-core ssh aria-wohnung hostname
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
 - [ ] Porcupine Wake Word (on-device "ARIA" in der App)
+- [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)

android/android/.gradle/8.3/dependencies-accessors/423f0288fa7dffe069445ffa4b72952b4629a15a/sources/org/gradle/accessors/dm/LibrariesForLibs.java

@@ -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"); }
-
-    }
-
-}

android/android/.gradle/8.3/dependencies-accessors/423f0288fa7dffe069445ffa4b72952b4629a15a/sources/org/gradle/accessors/dm/LibrariesForLibsInPluginsBlock.java

@@ -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"); }
-
-    }
-
-}

android/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +0,0 @@
-#Sun Mar 29 11:32:18 CEST 2026
-gradle.version=8.3

android/android/app/build.gradle

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

android/android/app/build/generated/rncli/src/main/java/com/facebook/react/PackageList.java

@@ -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()
-    ));
-  }
-}

android/android/app/build/generated/source/buildConfig/release/com/ariacockpit/BuildConfig.java

@@ -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;
-}

android/android/app/build/kotlinToolingMetadata/kotlin-tooling-metadata.json

@@ -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"
-        }
-      }
-    }
-  ]
-}

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

@@ -3,6 +3,7 @@
     <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" />
 
     <application
       android:name=".MainApplication"
@@ -24,5 +25,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>

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

@@ -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)
+        }
+    }
+}

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

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

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

@@ -0,0 +1,93 @@
+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 leiser (TTS spricht). */
+    @ReactMethod
+    fun requestDuck(promise: Promise) {
+        requestFocus(
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK,
+            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
+    }
+}

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

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

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

@@ -18,8 +18,8 @@ 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())
             }
 
         override fun getJSMainModuleName(): String = "index"

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

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

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.1.0",
+  "version": "0.0.4.1",
   "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",

android/src/components/FileUpload.tsx

@@ -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,
       };
 

android/src/screens/ChatScreen.tsx

@@ -5,7 +5,7 @@
  * Datei- und Kamera-Upload.
  */
 
-import React, { useState, useEffect, useRef, useCallback } from 'react';
+import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
 import {
   View,
   Text,
@@ -15,12 +15,16 @@ import {
   KeyboardAvoidingView,
   Platform,
   StyleSheet,
+  Image,
+  ScrollView,
   Modal,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import RNFS from 'react-native-fs';
 import rvs, { RVSMessage, ConnectionState } from '../services/rvs';
 import audioService from '../services/audio';
 import wakeWordService from '../services/wakeword';
+import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
 import CameraUpload, { PhotoData } from '../components/CameraUpload';
@@ -33,6 +37,9 @@ interface Attachment {
   type: 'image' | 'file' | 'audio';
   name: string;
   size?: number;
+  uri?: string;         // Lokaler Pfad (file://) fuer Anzeige
+  mimeType?: string;
+  serverPath?: string;  // Pfad auf dem Server (/shared/uploads/...) fuer Re-Download
 }
 
 interface ChatMessage {
@@ -41,12 +48,49 @@ interface ChatMessage {
   text: string;
   timestamp: number;
   attachments?: Attachment[];
+  /** Bridge-Message-ID zur Zuordnung von TTS-Audio */
+  messageId?: string;
+  /** Lokaler Pfad zur gecachten TTS-Audio-Datei (file://...) */
+  audioPath?: string;
 }
 
 // --- Konstanten ---
 
 const CHAT_STORAGE_KEY = 'aria_chat_messages';
 const MAX_STORED_MESSAGES = 500;
+const MAX_MEMORY_MESSAGES = 500;
+
+// Hilfe: Messages-Array auf Max kappen (aelteste raus) — verhindert OOM
+// im Gespraechsmodus bei sehr vielen Nachrichten.
+const capMessages = (msgs: ChatMessage[]): ChatMessage[] =>
+  msgs.length > MAX_MEMORY_MESSAGES ? msgs.slice(-MAX_MEMORY_MESSAGES) : msgs;
+const DEFAULT_ATTACHMENT_DIR = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
+const STORAGE_PATH_KEY = 'aria_attachment_storage_path';
+
+async function getAttachmentDir(): Promise<string> {
+  try {
+    const saved = await AsyncStorage.getItem(STORAGE_PATH_KEY);
+    return saved || DEFAULT_ATTACHMENT_DIR;
+  } catch { return DEFAULT_ATTACHMENT_DIR; }
+}
+
+/** Speichert Base64-Daten als Datei, gibt file:// Pfad zurueck */
+async function persistAttachment(base64Data: string, msgId: string, fileName: string): Promise<string> {
+  const cacheDir = await getAttachmentDir();
+  await RNFS.mkdir(cacheDir);
+  // Dateiendung aus originalem Dateinamen oder Fallback
+  const ext = fileName.includes('.') ? fileName.split('.').pop() : 'bin';
+  const safeName = `${msgId}_${fileName.replace(/[^a-zA-Z0-9._-]/g, '_')}`;
+  const filePath = `${cacheDir}/${safeName}`;
+  await RNFS.writeFile(filePath, base64Data, 'base64');
+  return `file://${filePath}`;
+}
+
+/** Prueft ob eine lokale Datei noch existiert */
+async function checkFileExists(uri: string): Promise<boolean> {
+  if (!uri || !uri.startsWith('file://')) return false;
+  return RNFS.exists(uri.replace('file://', ''));
+}
 
 // --- Komponente ---
 
@@ -58,6 +102,11 @@ const ChatScreen: React.FC = () => {
   const [showCameraUpload, setShowCameraUpload] = useState(false);
   const [gpsEnabled, setGpsEnabled] = useState(false);
   const [wakeWordActive, setWakeWordActive] = useState(false);
+  const [fullscreenImage, setFullscreenImage] = useState<string | null>(null);
+  const [searchQuery, setSearchQuery] = useState('');
+  const [searchVisible, setSearchVisible] = useState(false);
+  const [pendingAttachments, setPendingAttachments] = useState<{file: any, isPhoto: boolean}[]>([]);
+  const [agentActivity, setAgentActivity] = useState<{activity: string, tool: string}>({activity: 'idle', tool: ''});
 
   const flatListRef = useRef<FlatList>(null);
   const messageIdCounter = useRef(0);
@@ -69,34 +118,125 @@ const ChatScreen: React.FC = () => {
   };
 
   // Chat-Verlauf aus AsyncStorage laden
+  const isInitialLoad = useRef(true);
   useEffect(() => {
     const loadMessages = async () => {
       try {
         const stored = await AsyncStorage.getItem(CHAT_STORAGE_KEY);
+        console.log('[Chat] AsyncStorage geladen:', stored ? `${stored.length} Bytes` : 'leer');
         if (stored) {
           const parsed: ChatMessage[] = JSON.parse(stored);
-          setMessages(parsed);
-          // ID-Counter auf hoechsten Wert setzen um Kollisionen zu vermeiden
-          const maxId = parsed.reduce((max, msg) => {
-            const num = parseInt(msg.id.split('_').pop() || '0', 10);
-            return num > max ? num : max;
-          }, 0);
-          messageIdCounter.current = maxId;
+          if (Array.isArray(parsed) && parsed.length > 0) {
+            console.log('[Chat] ${parsed.length} Nachrichten geladen');
+            setMessages(parsed);
+            const maxId = parsed.reduce((max, msg) => {
+              const num = parseInt(msg.id.split('_').pop() || '0', 10);
+              return num > max ? num : max;
+            }, 0);
+            messageIdCounter.current = maxId;
+          }
         }
       } catch (err) {
         console.error('[Chat] Fehler beim Laden des Verlaufs:', err);
+      } finally {
+        isInitialLoad.current = false;
       }
     };
-    loadMessages();
+    loadMessages().then(async () => {
+      // Auto-Re-Download: fehlende Anhänge vom Server nachladen (wenn aktiviert)
+      const autoDownload = await AsyncStorage.getItem('aria_auto_download');
+      if (autoDownload === 'false') return;
+      setTimeout(() => {
+        setMessages(prev => {
+          const missing: {id: string, serverPath: string}[] = [];
+          for (const msg of prev) {
+            for (const att of msg.attachments || []) {
+              if (att.serverPath && !att.uri) {
+                missing.push({ id: msg.id, serverPath: att.serverPath });
+              }
+            }
+          }
+          if (missing.length > 0) {
+            console.log(`[Chat] ${missing.length} fehlende Anhaenge — lade nach...`);
+            for (const m of missing) {
+              rvs.send('file_request' as any, { serverPath: m.serverPath, requestId: m.id });
+            }
+          }
+          return prev;
+        });
+      }, 2000); // Warten bis RVS verbunden ist
+    });
   }, []);
 
   // RVS-Nachrichten abonnieren
   useEffect(() => {
     const unsubMessage = rvs.onMessage((message: RVSMessage) => {
+      // file_saved: Bridge meldet Server-Pfad — in Attachment merken fuer Re-Download
+      if (message.type === 'file_saved') {
+        const serverPath = (message.payload.serverPath as string) || '';
+        const name = (message.payload.name as string) || '';
+        if (serverPath) {
+          setMessages(prev => prev.map(m => ({
+            ...m,
+            attachments: m.attachments?.map(a =>
+              a.name === name && !a.serverPath ? { ...a, serverPath } : a
+            ),
+          })));
+        }
+        return;
+      }
+
+      // file_response: Re-Download von Server — lokal speichern
+      if (message.type === 'file_response') {
+        const reqId = (message.payload.requestId as string) || '';
+        const b64 = (message.payload.base64 as string) || '';
+        const serverPath = (message.payload.serverPath as string) || '';
+        if (b64 && reqId) {
+          const fileName = (message.payload.name as string) || 'download';
+          persistAttachment(b64, reqId, fileName).then(filePath => {
+            setMessages(prev => prev.map(m => ({
+              ...m,
+              attachments: m.attachments?.map(a =>
+                a.serverPath === serverPath ? { ...a, uri: filePath } : a
+              ),
+            })));
+          }).catch(() => {});
+        }
+        return;
+      }
+
       if (message.type === 'chat') {
-        // Nur Nachrichten von ARIA anzeigen — eigene Nachrichten werden lokal hinzugefuegt
         const sender = (message.payload.sender as string) || '';
-        if (sender === 'user' || sender === 'diagnostic') return;
+
+        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben
+        if (sender === 'stt') {
+          const sttText = (message.payload.text as string) || '';
+          if (sttText) {
+            setMessages(prev => prev.map(m =>
+              m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
+                ? { ...m, text: `\uD83C\uDFA4 ${sttText}` }
+                : m
+            ));
+          }
+          return;
+        }
+
+        // Eigene App-Nachrichten ignorieren (werden lokal hinzugefuegt)
+        if (sender === 'user') return;
+
+        // Diagnostic-Nachrichten als User-Nachricht anzeigen
+        if (sender === 'diagnostic') {
+          const diagText = (message.payload.text as string) || '';
+          if (diagText) {
+            setMessages(prev => capMessages([...prev, {
+              id: nextId(),
+              sender: 'user',
+              text: diagText,
+              timestamp: message.timestamp,
+            }]));
+          }
+          return;
+        }
 
         const text = (message.payload.text as string) || '';
         const ts = message.timestamp;
@@ -112,14 +252,33 @@ const ChatScreen: React.FC = () => {
             text,
             timestamp: ts,
             attachments: message.payload.attachments as Attachment[] | undefined,
+            messageId: (message.payload.messageId as string) || undefined,
           };
-          return [...prev, ariaMsg];
+          return capMessages([...prev, ariaMsg]);
         });
       }
 
       // TTS-Audio abspielen wenn vorhanden
       if (message.type === 'audio' && message.payload.base64) {
-        audioService.playAudio(message.payload.base64 as string);
+        const b64 = message.payload.base64 as string;
+        const refId = (message.payload.messageId as string) || '';
+        audioService.playAudio(b64);
+        // Wenn messageId mitgeliefert wurde: Audio in Cache speichern + Pfad in Message eintragen
+        if (refId) {
+          audioService.cacheAudio(b64, refId).then(audioPath => {
+            if (!audioPath) return;
+            setMessages(prev => prev.map(m =>
+              m.messageId === refId ? { ...m, audioPath } : m
+            ));
+          }).catch(() => {});
+        }
+      }
+
+      // Thinking-Indicator Status von der Bridge
+      if (message.type === 'agent_activity') {
+        const activity = (message.payload.activity as string) || 'idle';
+        const tool = (message.payload.tool as string) || '';
+        setAgentActivity({ activity, tool });
       }
     });
 
@@ -136,12 +295,30 @@ const ChatScreen: React.FC = () => {
     };
   }, []);
 
-  // Wake Word: "ARIA" Erkennung → Auto-Aufnahme starten
+  // Auto-Update: Bei App-Start pruefen
+  useEffect(() => {
+    const unsubUpdate = updateService.onUpdateAvailable((info) => {
+      updateService.promptUpdate(info);
+    });
+    // Nach 5s pruefen (RVS muss erst verbunden sein)
+    const timer = setTimeout(() => updateService.checkForUpdate(), 5000);
+    return () => { unsubUpdate(); clearTimeout(timer); };
+  }, []);
+
+  // Gespraechsmodus: Nach TTS-Wiedergabe automatisch Aufnahme starten
+  useEffect(() => {
+    const unsubPlayback = audioService.onPlaybackFinished(() => {
+      if (wakeWordService.isActive()) {
+        wakeWordService.resume();
+      }
+    });
+    return () => unsubPlayback();
+  }, []);
+
+  // Wake Word / Gespraechsmodus: Auto-Aufnahme starten
   useEffect(() => {
     const unsubWake = wakeWordService.onWakeWord(async () => {
-      console.log('[Chat] Wake Word erkannt — starte Auto-Aufnahme');
-      // TTS stoppen damit ARIA sich nicht selbst hoert
-      audioService.stopPlayback();
+      console.log('[Chat] Gespraechsmodus — starte Auto-Aufnahme');
       // Aufnahme mit Auto-Stop (VAD) starten
       const started = await audioService.startRecording(true);
       if (!started) {
@@ -159,11 +336,11 @@ const ChatScreen: React.FC = () => {
         const userMsg: ChatMessage = {
           id: nextId(),
           sender: 'user',
-          text: '[Sprachnachricht]',
+          text: '🎙 Spracheingabe wird verarbeitet...',
           timestamp: Date.now(),
           attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
         };
-        setMessages(prev => [...prev, userMsg]);
+        setMessages(prev => capMessages([...prev, userMsg]));
         rvs.send('audio', {
           base64: result.base64,
           durationMs: result.durationMs,
@@ -192,23 +369,38 @@ const ChatScreen: React.FC = () => {
     }
   }, [wakeWordActive]);
 
-  // Chat-Verlauf in AsyncStorage speichern (letzte N Nachrichten)
+  // Chat-Verlauf in AsyncStorage speichern (debounced, nur nach initialem Laden)
+  const saveTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
   useEffect(() => {
-    if (messages.length === 0) return;
-    const toStore = messages.slice(-MAX_STORED_MESSAGES);
-    AsyncStorage.setItem(CHAT_STORAGE_KEY, JSON.stringify(toStore)).catch(err =>
-      console.error('[Chat] Fehler beim Speichern:', err),
-    );
+    if (messages.length === 0 || isInitialLoad.current) return;
+    // Debounce: 1s warten damit persistAttachment fertig werden kann
+    if (saveTimer.current) clearTimeout(saveTimer.current);
+    saveTimer.current = setTimeout(() => {
+      const toStore = messages.slice(-MAX_STORED_MESSAGES).map(msg => ({
+        ...msg,
+        attachments: msg.attachments?.map(att => ({
+          ...att,
+          // Nur file:// URIs speichern, data: URIs rausfiltern (zu gross fuer AsyncStorage)
+          uri: att.uri?.startsWith('file://') ? att.uri : undefined,
+        })),
+      }));
+      const json = JSON.stringify(toStore);
+      // Sicherheitscheck: nicht speichern wenn >4MB (AsyncStorage Limit)
+      if (json.length > 4 * 1024 * 1024) {
+        console.warn('[Chat] Speicher zu gross, kuerze auf 100 Nachrichten');
+        const shortened = JSON.stringify(toStore.slice(-100));
+        AsyncStorage.setItem(CHAT_STORAGE_KEY, shortened).catch(() => {});
+      } else {
+        AsyncStorage.setItem(CHAT_STORAGE_KEY, json).catch(err =>
+          console.error('[Chat] Speichern fehlgeschlagen:', err),
+        );
+      }
+    }, 1000);
+    return () => { if (saveTimer.current) clearTimeout(saveTimer.current); };
   }, [messages]);
 
-  // Auto-Scroll bei neuen Nachrichten
-  useEffect(() => {
-    if (messages.length > 0) {
-      setTimeout(() => {
-        flatListRef.current?.scrollToEnd({ animated: true });
-      }, 100);
-    }
-  }, [messages]);
+  // Inverted FlatList: neueste Nachrichten unten, kein manuelles Scrollen noetig
+  const invertedMessages = useMemo(() => [...messages].reverse(), [messages]);
 
   // GPS-Position holen (optional)
   const getCurrentLocation = useCallback((): Promise<{ lat: number; lon: number } | null> => {
@@ -234,6 +426,13 @@ const ChatScreen: React.FC = () => {
 
   const sendTextMessage = useCallback(async () => {
     const text = inputText.trim();
+
+    // Wenn pending Anhaenge vorhanden → Anhaenge + Text zusammen senden
+    if (pendingAttachments.length > 0) {
+      sendPendingAttachments(text);
+      return;
+    }
+
     if (!text) return;
 
     setInputText('');
@@ -246,14 +445,20 @@ const ChatScreen: React.FC = () => {
       text,
       timestamp: Date.now(),
     };
-    setMessages(prev => [...prev, userMsg]);
+    setMessages(prev => capMessages([...prev, userMsg]));
 
     // An RVS senden
     rvs.send('chat', {
       text,
       ...(location && { location }),
     });
-  }, [inputText, getCurrentLocation]);
+  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments]);
+
+  // Anfrage abbrechen — sofort lokalen Indicator weg, Bridge triggert doctor --fix
+  const cancelRequest = useCallback(() => {
+    setAgentActivity({ activity: 'idle', tool: '' });
+    rvs.send('cancel_request' as any, {});
+  }, []);
 
   // Sprachaufnahme abgeschlossen
   const handleVoiceRecording = useCallback(async (result: RecordingResult) => {
@@ -262,11 +467,10 @@ const ChatScreen: React.FC = () => {
     const userMsg: ChatMessage = {
       id: nextId(),
       sender: 'user',
-      text: '[Sprachnachricht]',
+      text: '🎙 Spracheingabe wird verarbeitet...',
       timestamp: Date.now(),
-      attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
     };
-    setMessages(prev => [...prev, userMsg]);
+    setMessages(prev => capMessages([...prev, userMsg]));
 
     rvs.send('audio', {
       base64: result.base64,
@@ -276,52 +480,91 @@ const ChatScreen: React.FC = () => {
     });
   }, [getCurrentLocation]);
 
-  // Datei senden
+  // Datei auswaehlen → zur Pending-Liste hinzufuegen
   const handleFileSelected = useCallback(async (file: FileData) => {
     setShowFileUpload(false);
-    const location = await getCurrentLocation();
+    setPendingAttachments(prev => [...prev, { file, isPhoto: false }]);
+  }, []);
 
-    const userMsg: ChatMessage = {
-      id: nextId(),
-      sender: 'user',
-      text: `[Datei: ${file.name}]`,
-      timestamp: Date.now(),
-      attachments: [{ type: 'file', name: file.name, size: file.size }],
-    };
-    setMessages(prev => [...prev, userMsg]);
-
-    rvs.send('file', {
-      name: file.name,
-      type: file.type,
-      size: file.size,
-      base64: file.base64,
-      ...(location && { location }),
-    });
-  }, [getCurrentLocation]);
-
-  // Foto senden
+  // Foto auswaehlen → zur Pending-Liste hinzufuegen
   const handlePhotoSelected = useCallback(async (photo: PhotoData) => {
     setShowCameraUpload(false);
+    setPendingAttachments(prev => [...prev, { file: photo, isPhoto: true }]);
+  }, []);
+
+  // Alle Pending Anhaenge + Text senden
+  const sendPendingAttachments = useCallback(async (messageText: string) => {
+    if (pendingAttachments.length === 0) return;
     const location = await getCurrentLocation();
+    const msgId = nextId();
 
+    // Alle Attachments fuer die Chat-Nachricht sammeln
+    const attachments: Attachment[] = [];
+    for (const { file, isPhoto } of pendingAttachments) {
+      const isImage = isPhoto || (file.type && file.type.startsWith('image/'));
+      const name = isPhoto ? file.fileName : file.name;
+      const base64 = file.base64 || '';
+      const mimeType = file.type || '';
+      const imageUri = isImage && base64 ? `data:${mimeType};base64,${base64}` : file.uri;
+
+      attachments.push({
+        type: isImage ? 'image' : 'file',
+        name,
+        size: file.size,
+        uri: imageUri,
+        mimeType,
+      });
+    }
+
+    // Chat-Nachricht mit allen Anhaengen
     const userMsg: ChatMessage = {
-      id: nextId(),
+      id: msgId,
       sender: 'user',
-      text: `[Foto: ${photo.fileName}]`,
+      text: messageText || `${pendingAttachments.length} Anhang/Anhaenge`,
       timestamp: Date.now(),
-      attachments: [{ type: 'image', name: photo.fileName }],
+      attachments,
     };
-    setMessages(prev => [...prev, userMsg]);
+    setMessages(prev => capMessages([...prev, userMsg]));
 
-    rvs.send('file', {
-      name: photo.fileName,
-      type: photo.type,
-      base64: photo.base64,
-      width: photo.width,
-      height: photo.height,
-      ...(location && { location }),
-    });
-  }, [getCurrentLocation]);
+    // Alle Dateien an RVS senden + auf Disk speichern
+    for (const { file, isPhoto } of pendingAttachments) {
+      const name = isPhoto ? file.fileName : file.name;
+      const base64 = file.base64 || '';
+      const mimeType = file.type || '';
+
+      // Auf Disk speichern
+      if (base64) {
+        persistAttachment(base64, msgId + '_' + name, name).then(filePath => {
+          setMessages(prev => prev.map(m =>
+            m.id === msgId ? { ...m, attachments: m.attachments?.map(a =>
+              a.name === name && !a.uri?.startsWith('file://') ? { ...a, uri: filePath } : a
+            )} : m
+          ));
+        }).catch(() => {});
+      }
+
+      // An RVS senden
+      rvs.send('file', {
+        name,
+        type: mimeType,
+        size: file.size,
+        base64,
+        ...(isPhoto && file.width && { width: file.width, height: file.height }),
+        ...(location && { location }),
+      });
+    }
+
+    // Text als separate Nachricht (damit ARIA weiss was zu tun ist)
+    if (messageText) {
+      rvs.send('chat', {
+        text: messageText,
+        ...(location && { location }),
+      });
+    }
+
+    setPendingAttachments([]);
+    setInputText('');
+  }, [pendingAttachments, getCurrentLocation]);
 
   // --- Rendering ---
 
@@ -334,16 +577,80 @@ const ChatScreen: React.FC = () => {
 
     return (
       <View style={[styles.messageBubble, isUser ? styles.userBubble : styles.ariaBubble]}>
-        <Text style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}>
-          {item.text}
-        </Text>
+        {/* Anhang-Vorschau */}
         {item.attachments?.map((att, idx) => (
-          <View key={idx} style={styles.attachmentBadge}>
-            <Text style={styles.attachmentText}>
-              {att.type === 'image' ? '\uD83D\uDDBC\uFE0F' : att.type === 'audio' ? '\uD83C\uDFA4' : '\uD83D\uDCC4'} {att.name}
-            </Text>
+          <View key={idx}>
+            {att.type === 'image' && att.uri ? (
+              <TouchableOpacity onPress={() => setFullscreenImage(att.uri || null)} activeOpacity={0.8}>
+              <Image
+                source={{ uri: att.uri }}
+                style={styles.attachmentImage}
+                resizeMode="cover"
+                onError={() => {
+                  setMessages(prev => prev.map(m =>
+                    m.id === item.id ? { ...m, attachments: m.attachments?.map((a, i) =>
+                      i === idx ? { ...a, uri: undefined } : a
+                    )} : m
+                  ));
+                }}
+              />
+              </TouchableOpacity>
+            ) : att.type === 'image' && !att.uri ? (
+              <TouchableOpacity
+                style={styles.attachmentFile}
+                onPress={() => {
+                  if (att.serverPath) {
+                    rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: item.id });
+                  }
+                }}
+              >
+                <Text style={styles.attachmentFileIcon}>{'\uD83D\uDDBC\uFE0F'}</Text>
+                <Text style={styles.attachmentFileName} numberOfLines={1}>{att.name}</Text>
+                <Text style={styles.attachmentFileSize}>
+                  {att.serverPath ? '(tippen zum Laden)' : '(nicht verfuegbar)'}
+                </Text>
+              </TouchableOpacity>
+            ) : (
+              <View style={styles.attachmentFile}>
+                <Text style={styles.attachmentFileIcon}>
+                  {att.mimeType?.includes('pdf') ? '\uD83D\uDCC4' :
+                   att.mimeType?.includes('word') || att.mimeType?.includes('document') ? '\uD83D\uDCC3' :
+                   att.mimeType?.includes('sheet') || att.mimeType?.includes('excel') ? '\uD83D\uDCC8' :
+                   '\uD83D\uDCC1'}
+                </Text>
+                <Text style={styles.attachmentFileName} numberOfLines={1}>{att.name}</Text>
+                {att.size ? <Text style={styles.attachmentFileSize}>{Math.round(att.size / 1024)}KB</Text> : null}
+                {!att.uri && att.serverPath && (
+                  <TouchableOpacity onPress={() => rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: item.id })}>
+                    <Text style={[styles.attachmentFileSize, {color: '#0096FF'}]}>(laden)</Text>
+                  </TouchableOpacity>
+                )}
+                {!att.uri && !att.serverPath && <Text style={styles.attachmentFileSize}>(nicht verfuegbar)</Text>}
+              </View>
+            )}
           </View>
         ))}
+        {/* Text (nicht anzeigen wenn nur "Anhang empfangen" und ein Bild da ist) */}
+        {!(item.text === 'Anhang empfangen' && item.attachments?.some(a => a.type === 'image' && a.uri)) && (
+          <Text style={[styles.messageText, isUser ? styles.userText : styles.ariaText]}>
+            {item.text}
+          </Text>
+        )}
+        {/* Play-Button fuer ARIA-Nachrichten — Cache bevorzugt, sonst Regenerierung */}
+        {!isUser && item.text.length > 0 && (
+          <TouchableOpacity
+            style={styles.playButton}
+            onPress={() => {
+              if (item.audioPath) {
+                audioService.playFromPath(item.audioPath);
+              } else {
+                rvs.send('tts_request' as any, { text: item.text, voice: '' });
+              }
+            }}
+          >
+            <Text style={styles.playButtonText}>{item.audioPath ? '\uD83D\uDD0A' : '\uD83D\uDD0A'}</Text>
+          </TouchableOpacity>
+        )}
         <Text style={styles.timestamp}>{time}</Text>
       </View>
     );
@@ -366,12 +673,33 @@ const ChatScreen: React.FC = () => {
           {connectionState === 'connected' ? 'Verbunden' :
            connectionState === 'connecting' ? 'Verbinde...' : 'Getrennt'}
         </Text>
+        <TouchableOpacity onPress={() => setSearchVisible(!searchVisible)} style={{marginLeft: 'auto', paddingHorizontal: 8}}>
+          <Text style={{fontSize: 16}}>{'\uD83D\uDD0D'}</Text>
+        </TouchableOpacity>
       </View>
 
+      {/* Suchleiste */}
+      {searchVisible && (
+        <View style={styles.searchBar}>
+          <TextInput
+            style={styles.searchInput}
+            value={searchQuery}
+            onChangeText={setSearchQuery}
+            placeholder="Chat durchsuchen..."
+            placeholderTextColor="#555570"
+            autoFocus
+          />
+          <TouchableOpacity onPress={() => { setSearchVisible(false); setSearchQuery(''); }}>
+            <Text style={{color: '#FF3B30', fontSize: 14, paddingHorizontal: 8}}>X</Text>
+          </TouchableOpacity>
+        </View>
+      )}
+
       {/* Nachrichtenliste */}
       <FlatList
         ref={flatListRef}
-        data={messages}
+        inverted
+        data={searchQuery ? messages.filter(m => m.text.toLowerCase().includes(searchQuery.toLowerCase())).reverse() : invertedMessages}
         keyExtractor={item => item.id}
         renderItem={renderMessage}
         contentContainerStyle={styles.messageList}
@@ -385,6 +713,56 @@ const ChatScreen: React.FC = () => {
         }
       />
 
+      {/* Thinking-Indicator */}
+      {agentActivity.activity !== 'idle' && (
+        <View style={styles.thinkingBar}>
+          <Text style={styles.thinkingText}>
+            {agentActivity.activity === 'tool' && agentActivity.tool
+              ? `\uD83D\uDD27 ${agentActivity.tool}`
+              : agentActivity.activity === 'assistant'
+              ? '\u270D\uFE0F ARIA schreibt...'
+              : '\uD83D\uDCAD ARIA denkt...'}
+          </Text>
+          <TouchableOpacity style={styles.thinkingCancel} onPress={cancelRequest}>
+            <Text style={styles.thinkingCancelText}>Abbrechen</Text>
+          </TouchableOpacity>
+        </View>
+      )}
+
+      {/* Pending Anhaenge Vorschau */}
+      {pendingAttachments.length > 0 && (
+        <View style={styles.pendingBar}>
+          <ScrollView horizontal showsHorizontalScrollIndicator={false} style={{flex: 1}}>
+            {pendingAttachments.map((att, idx) => (
+              <View key={idx} style={styles.pendingItem}>
+                {att.file.type?.startsWith('image/') || att.isPhoto ? (
+                  <Image
+                    source={{ uri: att.file.base64
+                      ? `data:${att.file.type};base64,${att.file.base64}`
+                      : att.file.uri }}
+                    style={styles.pendingThumb}
+                  />
+                ) : (
+                  <View style={[styles.pendingThumb, {justifyContent: 'center', alignItems: 'center'}]}>
+                    <Text style={{fontSize: 20}}>{'\uD83D\uDCC4'}</Text>
+                  </View>
+                )}
+                <TouchableOpacity
+                  style={styles.pendingRemove}
+                  onPress={() => setPendingAttachments(prev => prev.filter((_, i) => i !== idx))}
+                >
+                  <Text style={{color: '#fff', fontSize: 10, fontWeight: 'bold'}}>X</Text>
+                </TouchableOpacity>
+              </View>
+            ))}
+          </ScrollView>
+          <Text style={{color: '#8888AA', fontSize: 11, marginLeft: 8}}>{pendingAttachments.length}</Text>
+          <TouchableOpacity onPress={() => setPendingAttachments([])}>
+            <Text style={{color: '#FF3B30', fontSize: 14, paddingHorizontal: 8}}>Alle X</Text>
+          </TouchableOpacity>
+        </View>
+      )}
+
       {/* Eingabebereich */}
       <View style={styles.inputContainer}>
         {/* Datei-Buttons */}
@@ -407,7 +785,7 @@ const ChatScreen: React.FC = () => {
           style={styles.textInput}
           value={inputText}
           onChangeText={setInputText}
-          placeholder="Nachricht an ARIA..."
+          placeholder={pendingAttachments.length > 0 ? "Text zu den Anhaengen (optional)..." : "Nachricht an ARIA..."}
           placeholderTextColor="#555570"
           multiline
           maxLength={4000}
@@ -416,25 +794,44 @@ const ChatScreen: React.FC = () => {
         />
 
         {/* Senden oder Sprache */}
-        {inputText.trim() ? (
+        {inputText.trim() || pendingAttachments.length > 0 ? (
           <TouchableOpacity style={styles.sendButton} onPress={sendTextMessage}>
             <Text style={styles.sendIcon}>{'\u2B06\uFE0F'}</Text>
           </TouchableOpacity>
         ) : (
-          <VoiceButton
-            onRecordingComplete={handleVoiceRecording}
-            disabled={connectionState !== 'connected'}
-            wakeWordActive={wakeWordActive}
-          />
-          <TouchableOpacity
-            style={[styles.wakeWordBtn, wakeWordActive && styles.wakeWordBtnActive]}
-            onPress={toggleWakeWord}
-          >
-            <Text style={styles.wakeWordIcon}>{wakeWordActive ? '👂' : '🔇'}</Text>
-          </TouchableOpacity>
+          <>
+            <VoiceButton
+              onRecordingComplete={handleVoiceRecording}
+              disabled={connectionState !== 'connected'}
+              wakeWordActive={wakeWordActive}
+            />
+            <TouchableOpacity
+              style={[styles.wakeWordBtn, wakeWordActive && styles.wakeWordBtnActive]}
+              onPress={toggleWakeWord}
+            >
+              <Text style={styles.wakeWordIcon}>{wakeWordActive ? '👂' : '🔇'}</Text>
+            </TouchableOpacity>
+          </>
         )}
       </View>
 
+      {/* Bild-Vollbild Modal */}
+      <Modal visible={!!fullscreenImage} transparent animationType="fade" onRequestClose={() => setFullscreenImage(null)}>
+        <TouchableOpacity
+          style={styles.fullscreenOverlay}
+          activeOpacity={1}
+          onPress={() => setFullscreenImage(null)}
+        >
+          {fullscreenImage && (
+            <Image
+              source={{ uri: fullscreenImage }}
+              style={styles.fullscreenImage}
+              resizeMode="contain"
+            />
+          )}
+        </TouchableOpacity>
+      </Modal>
+
       {/* Datei-Upload Modal */}
       <Modal visible={showFileUpload} transparent animationType="slide">
         <View style={styles.modalOverlay}>
@@ -515,17 +912,35 @@ const styles = StyleSheet.create({
   ariaText: {
     color: '#E0E0F0',
   },
-  attachmentBadge: {
-    backgroundColor: 'rgba(255,255,255,0.1)',
-    borderRadius: 6,
-    paddingHorizontal: 8,
-    paddingVertical: 4,
-    marginTop: 6,
-    alignSelf: 'flex-start',
+  attachmentImage: {
+    width: '100%',
+    minHeight: 200,
+    maxHeight: 400,
+    borderRadius: 8,
+    marginBottom: 6,
+    backgroundColor: '#0D0D1A',
   },
-  attachmentText: {
-    color: '#CCCCDD',
-    fontSize: 12,
+  attachmentFile: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: 'rgba(255,255,255,0.1)',
+    borderRadius: 8,
+    padding: 10,
+    marginBottom: 6,
+  },
+  attachmentFileIcon: {
+    fontSize: 24,
+    marginRight: 8,
+  },
+  attachmentFileName: {
+    flex: 1,
+    color: '#E0E0F0',
+    fontSize: 13,
+  },
+  attachmentFileSize: {
+    color: '#8888AA',
+    fontSize: 11,
+    marginLeft: 8,
   },
   timestamp: {
     color: 'rgba(255,255,255,0.4)',
@@ -610,6 +1025,97 @@ const styles = StyleSheet.create({
   wakeWordIcon: {
     fontSize: 16,
   },
+  thinkingBar: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    backgroundColor: '#1E1E2E',
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderTopWidth: 1,
+    borderTopColor: '#2A2A3E',
+  },
+  thinkingText: {
+    color: '#FFD60A',
+    fontSize: 12,
+    flex: 1,
+  },
+  thinkingCancel: {
+    paddingHorizontal: 10,
+    paddingVertical: 4,
+    borderWidth: 1,
+    borderColor: '#FF3B30',
+    borderRadius: 4,
+  },
+  thinkingCancelText: {
+    color: '#FF3B30',
+    fontSize: 11,
+    fontWeight: 'bold',
+  },
+  pendingBar: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#1E1E2E',
+    paddingHorizontal: 12,
+    paddingVertical: 8,
+    borderTopWidth: 1,
+    borderTopColor: '#2A2A3E',
+  },
+  pendingItem: {
+    position: 'relative',
+    marginRight: 8,
+  },
+  pendingThumb: {
+    width: 50,
+    height: 50,
+    borderRadius: 6,
+    backgroundColor: '#0D0D1A',
+  },
+  pendingRemove: {
+    position: 'absolute',
+    top: -4,
+    right: -4,
+    width: 18,
+    height: 18,
+    borderRadius: 9,
+    backgroundColor: '#FF3B30',
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  searchBar: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#12122A',
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderBottomWidth: 1,
+    borderBottomColor: '#1E1E2E',
+  },
+  searchInput: {
+    flex: 1,
+    color: '#FFFFFF',
+    fontSize: 14,
+    paddingVertical: 4,
+  },
+  playButton: {
+    alignSelf: 'flex-end',
+    paddingHorizontal: 8,
+    paddingVertical: 2,
+    marginTop: 4,
+  },
+  playButtonText: {
+    fontSize: 16,
+  },
+  fullscreenOverlay: {
+    flex: 1,
+    backgroundColor: 'rgba(0,0,0,0.95)',
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  fullscreenImage: {
+    width: '100%',
+    height: '100%',
+  },
   modalOverlay: {
     flex: 1,
     backgroundColor: 'rgba(0,0,0,0.6)',

android/src/screens/SettingsScreen.tsx

@@ -16,10 +16,16 @@ import {
   Alert,
   Platform,
 } 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 ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
 
+const STORAGE_PATH_KEY = 'aria_attachment_storage_path';
+const DEFAULT_STORAGE_PATH = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
+
 // --- Typen ---
 
 interface LogEntry {
@@ -62,6 +68,16 @@ 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 [defaultVoice, setDefaultVoice] = useState('ramona');
+  const [highlightVoice, setHighlightVoice] = useState('thorsten');
+  const [speedRamona, setSpeedRamona] = useState(1.0);
+  const [speedThorsten, setSpeedThorsten] = useState(1.0);
+  const [editingPath, setEditingPath] = useState(false);
+  const [tempPath, setTempPath] = useState('');
 
   let logIdCounter = 0;
 
@@ -73,8 +89,122 @@ 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('aria_default_voice').then(saved => {
+      if (saved) setDefaultVoice(saved);
+    });
+    AsyncStorage.getItem('aria_highlight_voice').then(saved => {
+      if (saved) setHighlightVoice(saved);
+    });
+    AsyncStorage.getItem('aria_speed_ramona').then(saved => {
+      if (saved) setSpeedRamona(parseFloat(saved));
+    });
+    AsyncStorage.getItem('aria_speed_thorsten').then(saved => {
+      if (saved) setSpeedThorsten(parseFloat(saved));
+    });
   }, []);
 
+  // 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);
@@ -332,6 +462,208 @@ const SettingsScreen: React.FC = () => {
         </View>
       </View>
 
+      {/* === Sprachausgabe === */}
+      <Text style={styles.sectionTitle}>Sprachausgabe</Text>
+      <View style={styles.card}>
+        {/* TTS An/Aus */}
+        <View style={styles.toggleRow}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Sprachausgabe</Text>
+            <Text style={styles.toggleHint}>ARIA antwortet per Sprache (TTS)</Text>
+          </View>
+          <Switch
+            value={ttsEnabled}
+            onValueChange={(val) => {
+              setTtsEnabled(val);
+              AsyncStorage.setItem('aria_tts_enabled', String(val));
+              rvs.send('config' as any, { ttsEnabled: val });
+            }}
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={ttsEnabled ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+
+        {/* Standard-Stimme */}
+        <View style={{marginTop: 16}}>
+          <Text style={styles.toggleLabel}>Standard-Stimme</Text>
+          <Text style={styles.toggleHint}>Fuer normale Antworten und Gespraeche</Text>
+          <View style={{flexDirection: 'row', gap: 8, marginTop: 8}}>
+            <TouchableOpacity
+              style={[styles.voiceBtn, defaultVoice === 'ramona' && styles.voiceBtnActive]}
+              onPress={() => { setDefaultVoice('ramona'); AsyncStorage.setItem('aria_default_voice', 'ramona'); rvs.send('config' as any, { defaultVoice: 'ramona' }); }}
+            >
+              <Text style={styles.voiceBtnIcon}>{'\uD83D\uDE4E\u200D\u2640\uFE0F'}</Text>
+              <Text style={[styles.voiceBtnText, defaultVoice === 'ramona' && styles.voiceBtnTextActive]}>Ramona</Text>
+              <Text style={styles.voiceBtnHint}>Weiblich, warm</Text>
+            </TouchableOpacity>
+            <TouchableOpacity
+              style={[styles.voiceBtn, defaultVoice === 'thorsten' && styles.voiceBtnActive]}
+              onPress={() => { setDefaultVoice('thorsten'); AsyncStorage.setItem('aria_default_voice', 'thorsten'); rvs.send('config' as any, { defaultVoice: 'thorsten' }); }}
+            >
+              <Text style={styles.voiceBtnIcon}>{'\uD83E\uDDD4'}</Text>
+              <Text style={[styles.voiceBtnText, defaultVoice === 'thorsten' && styles.voiceBtnTextActive]}>Thorsten</Text>
+              <Text style={styles.voiceBtnHint}>Maennlich, tief</Text>
+            </TouchableOpacity>
+          </View>
+        </View>
+
+        {/* Highlight-Stimme */}
+        <View style={{marginTop: 16}}>
+          <Text style={styles.toggleLabel}>Highlight-Stimme</Text>
+          <Text style={styles.toggleHint}>Fuer besondere Ereignisse (Deploy, Alarm, Erfolg)</Text>
+          <View style={{flexDirection: 'row', gap: 8, marginTop: 8}}>
+            <TouchableOpacity
+              style={[styles.voiceBtn, highlightVoice === 'thorsten' && styles.voiceBtnActive]}
+              onPress={() => { setHighlightVoice('thorsten'); AsyncStorage.setItem('aria_highlight_voice', 'thorsten'); rvs.send('config' as any, { highlightVoice: 'thorsten' }); }}
+            >
+              <Text style={styles.voiceBtnIcon}>{'\uD83E\uDDD4'}</Text>
+              <Text style={[styles.voiceBtnText, highlightVoice === 'thorsten' && styles.voiceBtnTextActive]}>Thorsten</Text>
+            </TouchableOpacity>
+            <TouchableOpacity
+              style={[styles.voiceBtn, highlightVoice === 'ramona' && styles.voiceBtnActive]}
+              onPress={() => { setHighlightVoice('ramona'); AsyncStorage.setItem('aria_highlight_voice', 'ramona'); rvs.send('config' as any, { highlightVoice: 'ramona' }); }}
+            >
+              <Text style={styles.voiceBtnIcon}>{'\uD83D\uDE4E\u200D\u2640\uFE0F'}</Text>
+              <Text style={[styles.voiceBtnText, highlightVoice === 'ramona' && styles.voiceBtnTextActive]}>Ramona</Text>
+            </TouchableOpacity>
+          </View>
+        </View>
+
+        {/* Sprechgeschwindigkeit Ramona */}
+        <View style={{marginTop: 16}}>
+          <Text style={styles.toggleLabel}>Ramona Speed: {speedRamona.toFixed(1)}x</Text>
+          <View style={{flexDirection: 'row', justifyContent: 'space-around', marginTop: 8}}>
+            {[0.5, 0.75, 1.0, 1.25, 1.5, 2.0].map(speed => (
+              <TouchableOpacity
+                key={speed}
+                onPress={() => {
+                  setSpeedRamona(speed);
+                  AsyncStorage.setItem('aria_speed_ramona', String(speed));
+                  rvs.send('config' as any, { speedRamona: speed });
+                }}
+                style={{
+                  paddingHorizontal: 10, paddingVertical: 6, borderRadius: 6,
+                  backgroundColor: speedRamona === speed ? '#0096FF' : '#1E1E2E',
+                }}
+              >
+                <Text style={{color: speedRamona === speed ? '#fff' : '#8888AA', fontSize: 12, fontWeight: '600'}}>
+                  {speed}x
+                </Text>
+              </TouchableOpacity>
+            ))}
+          </View>
+        </View>
+
+        {/* Sprechgeschwindigkeit Thorsten */}
+        <View style={{marginTop: 16}}>
+          <Text style={styles.toggleLabel}>Thorsten Speed: {speedThorsten.toFixed(1)}x</Text>
+          <View style={{flexDirection: 'row', justifyContent: 'space-around', marginTop: 8}}>
+            {[0.5, 0.75, 1.0, 1.25, 1.5, 2.0].map(speed => (
+              <TouchableOpacity
+                key={speed}
+                onPress={() => {
+                  setSpeedThorsten(speed);
+                  AsyncStorage.setItem('aria_speed_thorsten', String(speed));
+                  rvs.send('config' as any, { speedThorsten: speed });
+                }}
+                style={{
+                  paddingHorizontal: 10, paddingVertical: 6, borderRadius: 6,
+                  backgroundColor: speedThorsten === speed ? '#0096FF' : '#1E1E2E',
+                }}
+              >
+                <Text style={{color: speedThorsten === speed ? '#fff' : '#8888AA', fontSize: 12, fontWeight: '600'}}>
+                  {speed}x
+                </Text>
+              </TouchableOpacity>
+            ))}
+          </View>
+        </View>
+
+        {/* Highlight-Trigger Info */}
+        <View style={{marginTop: 16, padding: 10, backgroundColor: '#1E1E2E', borderRadius: 8}}>
+          <Text style={styles.toggleLabel}>{'\u26A1'} Highlight-Trigger</Text>
+          <Text style={[styles.toggleHint, {marginTop: 4}]}>
+            Die Highlight-Stimme wird automatisch bei diesen Woertern verwendet:{'\n'}
+            deploy, erfolgreich, alarm, so soll es sein, kritisch, server down, sicherheitswarnung, ticket geloest, aufgabe abgeschlossen
+          </Text>
+        </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 +748,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 +901,50 @@ const styles = StyleSheet.create({
     marginTop: 2,
   },
 
+  // 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',

android/src/services/audio.ts

@@ -6,7 +6,7 @@
  * 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 AudioRecorderPlayer, {
@@ -16,6 +16,15 @@ import AudioRecorderPlayer, {
   OutputFormatAndroidType,
 } from 'react-native-audio-recorder-player';
 
+// Native Module fuer Audio-Focus (Ducking/Muten anderer Apps)
+const { AudioFocus } = NativeModules as {
+  AudioFocus?: {
+    requestDuck: () => Promise<boolean>;
+    requestExclusive: () => Promise<boolean>;
+    release: () => Promise<boolean>;
+  };
+};
+
 // --- Typen ---
 
 export interface RecordingResult {
@@ -42,6 +51,11 @@ 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
+
+// Max-Dauer einer Aufnahme in Gespraechsmodus (Notbremse gegen Runaway-Loops)
+const MAX_RECORDING_MS = 30000;
 
 // --- Audio-Service ---
 
@@ -55,10 +69,21 @@ 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;
+
   // VAD State
   private vadEnabled: boolean = false;
   private lastSpeechTime: number = 0;
   private vadTimer: ReturnType<typeof setInterval> | null = null;
+  private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor() {
     this.recorder = new AudioRecorderPlayer();
@@ -108,6 +133,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 +144,8 @@ class AudioService {
         AudioEncoderAndroid: AudioEncoderAndroidType.AAC,
         AudioSourceAndroid: AudioSourceAndroidType.MIC,
         OutputFormatAndroid: OutputFormatAndroidType.MPEG_4,
+        AudioSamplingRateAndroid: 16000,
+        AudioChannelsAndroid: 1,
       }, true); // meteringEnabled = true
 
       // Metering-Callback
@@ -122,7 +153,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,8 +177,13 @@ class AudioService {
 
       this.recordingStartTime = Date.now();
       this.lastSpeechTime = Date.now();
+      this.speechDetected = false;
+      this.speechStartTime = 0;
       this.setState('recording');
 
+      // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
+      AudioFocus?.requestExclusive().catch(() => {});
+
       // VAD aktivieren
       this.vadEnabled = autoStop;
       if (autoStop) {
@@ -144,6 +194,11 @@ class AudioService {
             this.silenceListeners.forEach(cb => cb());
           }
         }, 200);
+        // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
+        this.maxDurationTimer = setTimeout(() => {
+          console.warn(`[Audio] Max-Dauer ${MAX_RECORDING_MS}ms erreicht — Zwangs-Stop`);
+          this.silenceListeners.forEach(cb => cb());
+        }, MAX_RECORDING_MS);
       }
 
       console.log('[Audio] Aufnahme gestartet (autoStop: %s)', autoStop);
@@ -168,12 +223,28 @@ class AudioService {
       clearInterval(this.vadTimer);
       this.vadTimer = null;
     }
+    if (this.maxDurationTimer) {
+      clearTimeout(this.maxDurationTimer);
+      this.maxDurationTimer = null;
+    }
 
     try {
       await this.recorder.stopRecorder();
       this.recorder.removeRecordBackListener();
 
+      // Audio-Focus freigeben — andere Apps duerfen wieder
+      AudioFocus?.release().catch(() => {});
+
       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 +253,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 +269,158 @@ 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 '';
+    }
+  }
+
+  /** 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 abgeben → andere Apps volle Lautstaerke
+      AudioFocus?.release().catch(() => {});
+      // Alle Audio-Teile abgespielt → Listener benachrichtigen
+      this.playbackFinishedListeners.forEach(cb => cb());
+      return;
+    }
+
+    // Beim ersten Playback-Start: andere Apps ducken
+    if (!this.isPlaying) {
+      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 = '';
+    }
+    // Audio-Focus freigeben
+    AudioFocus?.release().catch(() => {});
   }
 
   // --- Status & Callbacks ---
@@ -277,6 +459,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

android/src/services/rvs.ts

@@ -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;

android/src/services/updater.ts

@@ -0,0 +1,158 @@
+/**
+ * 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() {
+    // 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));
+        }
+      }
+    });
+  }
+
+  /** 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`,
+              });
+            }
+          }
+        });
+      });
+
+      // 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;

android/src/services/wakeword.ts

@@ -1,21 +1,13 @@
 /**
- * Wake Word Service — "ARIA" Erkennung
+ * Gespraechsmodus — "Ohr-Button"
  *
- * 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).
+ * Wenn aktiv: Nach jeder ARIA-Antwort (TTS fertig) startet automatisch die Aufnahme.
+ * Wie ein Walkie-Talkie / natuerliches Gespraech:
+ *   ARIA spricht → Aufnahme startet → User spricht → VAD stoppt → ARIA antwortet → ...
  *
- * Architektur:
- *   App (Mikrofon) → Energie-Erkennung → Audio-Buffer
- *   → RVS "wake_check" → Bridge → openwakeword → Bestaetigung
- *   → App startet Aufnahme
- *
- * Aktuell (Phase 1): Einfacher Tap-to-Talk + Auto-Stop.
- * Spaeter (Phase 2): Porcupine on-device "ARIA" Keyword.
+ * Phase 2 (geplant): Porcupine "ARIA" Wake Word fuer passives Lauschen.
  */
 
-import LiveAudioStream from 'react-native-live-audio-stream';
-
 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;
 
@@ -25,72 +17,40 @@ class WakeWordService {
   private state: WakeWordState = 'off';
   private wakeCallbacks: WakeWordCallback[] = [];
   private stateCallbacks: StateCallback[] = [];
-  private isInitialized = false;
 
-  /** Wake Word Erkennung starten */
+  /** Gespraechsmodus starten */
   async start(): Promise<boolean> {
     if (this.state === 'listening') return true;
-
-    try {
-      if (!this.isInitialized) {
-        LiveAudioStream.init({
-          sampleRate: 16000,
-          channels: 1,
-          bitsPerSample: 16,
-          audioSource: 6, // VOICE_RECOGNITION
-          bufferSize: 4096,
-        });
-        this.isInitialized = true;
+    console.log('[WakeWord] Gespraechsmodus aktiviert — starte sofort Aufnahme');
+    this.setState('listening');
+    // Sofort erste Aufnahme starten
+    setTimeout(() => {
+      if (this.state === 'listening') {
+        this.wakeCallbacks.forEach(cb => cb());
       }
+    }, 500);
+    return true;
+  }
 
-      // Audio-Stream starten und auf Energie pruefen
-      LiveAudioStream.start();
+  /** Gespraechsmodus stoppen */
+  stop(): void {
+    console.log('[WakeWord] Gespraechsmodus deaktiviert');
+    this.setState('off');
+  }
 
-      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;
-    } catch (err) {
-      console.error('[WakeWord] Start fehlgeschlagen:', err);
-      return false;
+  /** Nach ARIA-Antwort (TTS fertig): Aufnahme automatisch starten */
+  async resume(): Promise<void> {
+    if (this.state !== 'listening') return;
+    // Kurze Pause damit TTS-Audio nicht ins Mikrofon geht
+    await new Promise(resolve => setTimeout(resolve, 800));
+    if (this.state === 'listening') {
+      console.log('[WakeWord] TTS fertig — starte automatisch Aufnahme');
+      this.wakeCallbacks.forEach(cb => cb());
     }
   }
 
-  /** Wake Word Erkennung stoppen */
-  stop(): void {
-    if (this.state === 'off') return;
-    try {
-      LiveAudioStream.stop();
-    } catch {}
-    this.setState('off');
-    console.log('[WakeWord] Gestoppt');
-  }
-
-  /** Nach Aufnahme erneut starten */
-  async resume(): Promise<void> {
-    // Kurze Pause damit Aufnahme das Mikrofon freigeben kann
-    setTimeout(() => {
-      if (this.state === 'off') {
-        this.start();
-      }
-    }, 500);
+  isActive(): boolean {
+    return this.state === 'listening';
   }
 
   // --- Callbacks ---
@@ -113,32 +73,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();

aria-data/config/aria.env.example

@@ -9,3 +9,10 @@ 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

bridge/aria_bridge.py

@@ -38,6 +38,7 @@ import websockets
 from faster_whisper import WhisperModel
 from openwakeword.model import Model as WakeWordModel
 from piper import PiperVoice
+from piper.config import SynthesisConfig
 
 from modes import Mode, detect_mode_switch, should_speak
 
@@ -62,7 +63,7 @@ RVS_TLS = os.getenv("RVS_TLS", "true")       # true = wss://, false = ws://
 RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true")  # Bei TLS-Fehler ws:// versuchen
 RVS_TOKEN = os.getenv("RVS_TOKEN", "")       # Pairing-Token (gleich wie in der App)
 DIAGNOSTIC_URL = os.getenv("DIAGNOSTIC_URL", "http://127.0.0.1:3001")  # Diagnostic API
-WHISPER_MODEL = os.getenv("WHISPER_MODEL", "small")
+WHISPER_MODEL = os.getenv("WHISPER_MODEL", "medium")
 WHISPER_LANGUAGE = os.getenv("WHISPER_LANGUAGE", "de")
 
 # Audio-Parameter
@@ -72,7 +73,7 @@ BLOCK_SIZE = 1280  # 80ms bei 16kHz — gut fuer Wake-Word-Erkennung
 RECORD_SECONDS = 8  # Max. Aufnahmedauer nach Wake-Word
 
 # Epische Trigger — bei diesen Woertern spricht Thorsten
-EPIC_TRIGGERS = [
+EPIC_TRIGGERS_DEFAULT = [
     "deploy",
     "erfolgreich",
     "alarm",
@@ -84,9 +85,34 @@ EPIC_TRIGGERS = [
     "aufgabe abgeschlossen",
 ]
 
+# Trigger aus Shared-Config laden (von Diagnostic gespeichert)
+TRIGGERS_FILE = "/shared/config/highlight_triggers.json"
+
+def load_epic_triggers():
+    """Laedt Highlight-Trigger aus Shared-Config oder nutzt Defaults."""
+    try:
+        if os.path.exists(TRIGGERS_FILE):
+            with open(TRIGGERS_FILE) as f:
+                triggers = json.load(f)
+            if isinstance(triggers, list) and len(triggers) > 0:
+                logger.info("Highlight-Trigger geladen: %d aus %s", len(triggers), TRIGGERS_FILE)
+                return triggers
+    except Exception as e:
+        logger.warning("Highlight-Trigger laden fehlgeschlagen: %s — nutze Defaults", e)
+    return EPIC_TRIGGERS_DEFAULT
+
+EPIC_TRIGGERS = load_epic_triggers()
+
 
 def load_config() -> dict[str, str]:
-    """Laedt Konfiguration aus /config/aria.env."""
+    """Laedt Konfiguration.
+
+    Reihenfolge (hoechste Prioritaet zuletzt):
+    1. /config/aria.env (bind-mount)
+    2. /shared/config/runtime.json (zentral gepflegt ueber Diagnostic UI)
+
+    Werte aus runtime.json ueberschreiben die env-Datei.
+    """
     config: dict[str, str] = {}
     if CONFIG_PATH.exists():
         for line in CONFIG_PATH.read_text().splitlines():
@@ -99,18 +125,124 @@ def load_config() -> dict[str, str]:
         logger.info("Konfiguration geladen aus %s", CONFIG_PATH)
     else:
         logger.warning("Keine Konfiguration gefunden: %s", CONFIG_PATH)
+
+    # Runtime-Overrides aus zentralem Shared-Volume (Diagnostic UI)
+    runtime_path = Path("/shared/config/runtime.json")
+    if runtime_path.exists():
+        try:
+            runtime = json.loads(runtime_path.read_text())
+            overrides = {k: str(v) for k, v in runtime.items() if v not in (None, "")}
+            if overrides:
+                config.update(overrides)
+                logger.info("Runtime-Overrides geladen: %s", sorted(overrides.keys()))
+        except Exception as e:
+            logger.warning("runtime.json konnte nicht gelesen werden: %s", e)
     return config
 
 
 # ── Voice Engine ─────────────────────────────────────────────
 
 
+import re as _re_tts
+
+_UNIT_WORDS = [
+    (r'\bTB\b', 'Terabyte'),
+    (r'\bGB\b', 'Gigabyte'),
+    (r'\bMB\b', 'Megabyte'),
+    (r'\bKB\b', 'Kilobyte'),
+    (r'\bkB\b', 'Kilobyte'),
+    (r'\bms\b', 'Millisekunden'),
+    (r'\bkm/h\b', 'Kilometer pro Stunde'),
+    (r'\bkm\b', 'Kilometer'),
+    (r'\bm/s\b', 'Meter pro Sekunde'),
+    (r'\bkg\b', 'Kilogramm'),
+    (r'\b°C\b', 'Grad Celsius'),
+    (r'°C', ' Grad Celsius'),
+    (r'\bMbps\b', 'Megabit pro Sekunde'),
+    (r'\bGbps\b', 'Gigabit pro Sekunde'),
+    (r'\bMhz\b|\bMHz\b', 'Megahertz'),
+    (r'\bGhz\b|\bGHz\b', 'Gigahertz'),
+    (r'%', ' Prozent'),
+    (r'\bCPU\b', 'C P U'),
+    (r'\bGPU\b', 'G P U'),
+    (r'\bRAM\b', 'R A M'),
+    (r'\bSSD\b', 'S S D'),
+    (r'\bHDD\b', 'H D D'),
+    (r'\bURL\b', 'U R L'),
+    (r'\bAPI\b', 'A P I'),
+    (r'\bRVS\b', 'R V S'),
+    (r'\bSSH\b', 'S S H'),
+    (r'\bVM\b', 'V M'),
+    (r'\bUI\b', 'U I'),
+    (r'\bTTS\b', 'T T S'),
+    (r'\bSTT\b', 'S T T'),
+    (r'\bTLS\b', 'T L S'),
+]
+
+
+def clean_text_for_tts(text: str) -> str:
+    """Bereitet Chat-Text fuer Sprachausgabe auf.
+
+    - `<voice>...</voice>` Tag: wenn vorhanden, NUR dieser Inhalt wird gelesen
+    - Code-Bloecke (```...``` und `...`) werden komplett entfernt
+    - Markdown (Fett, Kursiv, Links, Headings, Listen, Zitate) wird abgeraeumt
+    - Einheiten und gaengige Abkuerzungen werden ausgeschrieben (22GB → 22 Gigabyte)
+    - URLs werden durch "ein Link" ersetzt
+    - Mehrfach-Leerzeichen/Umbrueche normalisiert
+    """
+    if not text:
+        return ""
+
+    # <voice>...</voice> wenn vorhanden → nur das nehmen
+    voice_match = _re_tts.search(r'<voice>([\s\S]*?)</voice>', text, _re_tts.IGNORECASE)
+    if voice_match:
+        text = voice_match.group(1)
+
+    t = text
+
+    # Code-Bloecke komplett raus (Zeilenumbruch statt Platzhalter — sonst bricht Satzlogik)
+    t = _re_tts.sub(r'```[\s\S]*?```', '. ', t)
+    t = _re_tts.sub(r'`[^`]+`', '', t)
+
+    # Markdown
+    t = _re_tts.sub(r'\*\*([^*]+)\*\*', r'\1', t)
+    t = _re_tts.sub(r'\*([^*]+)\*', r'\1', t)
+    t = _re_tts.sub(r'__([^_]+)__', r'\1', t)
+    t = _re_tts.sub(r'\[([^\]]+)\]\((https?://[^)]+)\)', r'\1, ein Link', t)
+    t = _re_tts.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', t)
+    t = _re_tts.sub(r'https?://\S+', 'ein Link', t)
+    t = _re_tts.sub(r'^#{1,6}\s*', '', t, flags=_re_tts.MULTILINE)
+    t = _re_tts.sub(r'^>\s*', '', t, flags=_re_tts.MULTILINE)
+    t = _re_tts.sub(r'^[\-\*]\s+', '', t, flags=_re_tts.MULTILINE)
+
+    # Zahlen + Einheit: "22GB" → "22 Gigabyte" (Leerzeichen einfuegen)
+    t = _re_tts.sub(r'(\d+)([A-Za-z]{1,4})\b', r'\1 \2', t)
+
+    # Einheiten/Abkuerzungen ausschreiben
+    for pat, repl in _UNIT_WORDS:
+        t = _re_tts.sub(pat, repl, t)
+
+    # Anfuehrungszeichen
+    t = _re_tts.sub(r'["""„`]', '', t)
+
+    # Absaetze/Zeilenumbrueche normalisieren
+    t = _re_tts.sub(r'\n{2,}', '. ', t)
+    t = _re_tts.sub(r'\n', ', ', t)
+    t = _re_tts.sub(r'\s{2,}', ' ', t)
+    t = _re_tts.sub(r'\s*\.\s*\.\s*', '. ', t)
+
+    return t.strip()
+
+
 class VoiceEngine:
     """Verwaltet Piper TTS mit zwei Stimmen: Ramona und Thorsten."""
 
     def __init__(self, voices_dir: Path) -> None:
         self.voices_dir = voices_dir
         self.voices: dict[str, PiperVoice] = {}
+        self.default_voice = "ramona"
+        self.highlight_voice = "thorsten"
+        self.speech_speed = {"ramona": 1.0, "thorsten": 1.0}
 
     def initialize(self) -> None:
         """Laedt die Piper-Stimmen aus dem Voices-Verzeichnis."""
@@ -154,14 +286,14 @@ class VoiceEngine:
         if requested_voice and requested_voice in self.voices:
             return requested_voice
 
-        # Epische Trigger pruefen
+        # Highlight-Trigger pruefen
         text_lower = text.lower()
         for trigger in EPIC_TRIGGERS:
             if trigger in text_lower:
-                logger.info("Epischer Trigger erkannt: '%s' — Thorsten spricht", trigger)
-                return "thorsten"
+                logger.info("Highlight-Trigger erkannt: '%s' — %s spricht", trigger, self.highlight_voice)
+                return self.highlight_voice
 
-        return "ramona"
+        return self.default_voice
 
     def synthesize(self, text: str, voice_name: str = "ramona") -> Optional[bytes]:
         """Erzeugt Audio-Daten aus Text mit der gewaehlten Stimme.
@@ -179,20 +311,50 @@ class VoiceEngine:
             return None
 
         try:
-            # Piper gibt PCM-Samples zurueck, wir schreiben sie als WAV
+            # Zentraler TTS-Cleanup (Markdown, Code, Einheiten, URLs)
+            import re
+            clean = clean_text_for_tts(text)
+            sentences = re.split(r'(?<=[.!?])\s+', clean)
+            sentences = [s.strip() for s in sentences if s.strip()]
+
+            if not sentences:
+                return None
+
+            # Jeden Satz einzeln synthetisieren und WAVs zusammenfuegen
+            all_audio = b""
+            sample_rate = None
+            for sentence in sentences:
+                if not sentence:
+                    continue
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+                    tmp_path = tmp.name
+                speed = self.speech_speed.get(voice_name, 1.0)
+                syn_config = SynthesisConfig(length_scale=1.0 / max(0.3, speed))
+                with wave.open(tmp_path, "wb") as wav_file:
+                    voice.synthesize_wav(sentence, wav_file, syn_config=syn_config)
+                with wave.open(tmp_path, "rb") as wav_file:
+                    if sample_rate is None:
+                        sample_rate = wav_file.getframerate()
+                    all_audio += wav_file.readframes(wav_file.getnframes())
+                Path(tmp_path).unlink(missing_ok=True)
+
+            # Zusammengefuegtes WAV erstellen
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
-                tmp_path = tmp.name
+                final_path = tmp.name
+            with wave.open(final_path, "wb") as wav_file:
+                wav_file.setnchannels(1)
+                wav_file.setsampwidth(2)
+                wav_file.setframerate(sample_rate or 22050)
+                wav_file.writeframes(all_audio)
 
-            with wave.open(tmp_path, "wb") as wav_file:
-                voice.synthesize(text, wav_file)
-
-            audio_data = Path(tmp_path).read_bytes()
-            Path(tmp_path).unlink(missing_ok=True)
+            audio_data = Path(final_path).read_bytes()
+            Path(final_path).unlink(missing_ok=True)
 
             logger.info(
-                "TTS: %d bytes erzeugt mit %s — '%s'",
+                "TTS: %d bytes erzeugt mit %s (%d Saetze) — '%s'",
                 len(audio_data),
                 voice_name,
+                len(sentences),
                 text[:60],
             )
             return audio_data
@@ -266,6 +428,25 @@ class STTEngine:
         self.model = WhisperModel(self.model_size, device="cpu", compute_type="int8")
         logger.info("Whisper-Modell geladen")
 
+    def reload(self, model_size: str) -> bool:
+        """Laedt ein anderes Whisper-Modell (bei Config-Aenderung)."""
+        if model_size == self.model_size and self.model is not None:
+            return False
+        allowed = {"tiny", "base", "small", "medium", "large-v3"}
+        if model_size not in allowed:
+            logger.warning("Ungueltiges Whisper-Modell: %s (erlaubt: %s)", model_size, allowed)
+            return False
+        logger.info("Lade Whisper-Modell neu: %s -> %s", self.model_size, model_size)
+        self.model_size = model_size
+        self.model = None
+        try:
+            self.model = WhisperModel(model_size, device="cpu", compute_type="int8")
+            logger.info("Whisper-Modell '%s' geladen", model_size)
+            return True
+        except Exception:
+            logger.exception("Whisper-Modell '%s' konnte nicht geladen werden", model_size)
+            return False
+
     def transcribe(self, audio_data: np.ndarray) -> str:
         """Transkribiert Audio-Daten zu Text.
 
@@ -437,8 +618,30 @@ class ARIABridge:
 
         # Komponenten
         self.voice_engine = VoiceEngine(VOICES_DIR)
+        self.tts_enabled = True
+        vc: dict = {}
+        # Gespeicherte Voice-Config laden
+        try:
+            vc_path = "/shared/config/voice_config.json"
+            if os.path.exists(vc_path):
+                with open(vc_path) as f:
+                    vc = json.load(f)
+                self.voice_engine.default_voice = vc.get("defaultVoice", "ramona")
+                self.voice_engine.highlight_voice = vc.get("highlightVoice", "thorsten")
+                self.voice_engine.speech_speed = {
+                    "ramona": vc.get("speedRamona", 1.0),
+                    "thorsten": vc.get("speedThorsten", 1.0),
+                }
+                self.tts_enabled = vc.get("ttsEnabled", True)
+                self.tts_engine_type = vc.get("ttsEngine", "piper")
+                self.xtts_voice = vc.get("xttsVoice", "")
+                logger.info("Voice-Config geladen: %s", vc)
+        except Exception as e:
+            logger.warning("Voice-Config laden fehlgeschlagen: %s", e)
+        # Whisper-Modell: Config hat Vorrang, dann env/Default (medium)
+        whisper_model = vc.get("whisperModel") or self.config.get("WHISPER_MODEL", WHISPER_MODEL)
         self.stt_engine = STTEngine(
-            model_size=self.config.get("WHISPER_MODEL", WHISPER_MODEL),
+            model_size=whisper_model,
             language=self.config.get("WHISPER_LANGUAGE", WHISPER_LANGUAGE),
         )
         self.wake_word = WakeWordDetector()
@@ -447,6 +650,12 @@ class ARIABridge:
         self.ws_core: Optional[websockets.WebSocketClientProtocol] = None
         self.ws_rvs: Optional[websockets.WebSocketClientProtocol] = None
 
+        # Letzter gesendeter agent_activity-State (zum Entduplizieren)
+        self._last_activity_state: Optional[tuple] = None
+        # Zeitstempel des letzten chat:final — waehrend 3s danach werden
+        # trailing Agent-Events unterdrueckt (Core raeumt manchmal nach).
+        self._last_chat_final_at: float = 0.0
+
     def initialize(self) -> None:
         """Initialisiert alle Komponenten.
 
@@ -461,17 +670,20 @@ class ARIABridge:
         # Voice-Engine IMMER laden — rendert Audio fuer die App (auch ohne Soundkarte)
         self.voice_engine.initialize()
 
+        # STT IMMER laden — verarbeitet Audio von der App (braucht kein Sounddevice)
+        self.stt_engine.initialize()
+
         # Audio-Hardware pruefen (fuer lokales Mikro/Lautsprecher)
         self.audio_available = False
         try:
-            sd.query_devices()
+            devices = sd.query_devices()
+            sd.query_devices(kind='output')
             self.audio_available = True
             logger.info("Audio-Geraet gefunden — Wake-Word und lokale TTS aktiv")
-            self.stt_engine.initialize()
             self.wake_word.initialize()
         except (sd.PortAudioError, Exception):
-            logger.warning("Kein Audio-Geraet — Wake-Word und lokale TTS deaktiviert")
-            logger.info("Piper TTS rendert Audio fuer die App (via RVS)")
+            logger.warning("Kein Audio-Geraet — Wake-Word und lokale Wiedergabe deaktiviert")
+            logger.info("TTS rendert fuer App (via RVS), STT verarbeitet App-Audio")
 
         logger.info("Alle Komponenten initialisiert")
         logger.info("aria-core:  %s", self.ws_url)
@@ -648,8 +860,18 @@ class ARIABridge:
         if event_name == "agent":
             data = payload.get("data", {})
             delta = data.get("delta", "")
-            if delta and payload.get("stream") == "assistant":
+            stream = payload.get("stream", "")
+            if delta and stream == "assistant":
                 logger.debug("[core] Delta: '%s'", delta[:40])
+            # Activity-Signal zur App (entdupliziert)
+            tool_name = data.get("name") or data.get("tool") or payload.get("tool") or ""
+            if stream == "tool_use" or data.get("type") == "tool_use":
+                activity = "tool"
+            elif stream == "assistant":
+                activity = "assistant"
+            else:
+                activity = "thinking"
+            await self._emit_activity(activity, tool_name)
             return
 
         # ── chat Events: Snapshots mit state=delta|final|error ──
@@ -658,6 +880,8 @@ class ARIABridge:
 
             if state == "final":
                 text = self._extract_chat_text(payload)
+                self._last_chat_final_at = asyncio.get_event_loop().time()
+                await self._emit_activity("idle", "")
                 if not text:
                     logger.warning("[core] chat final ohne Text: %s", json.dumps(payload)[:200])
                     return
@@ -668,6 +892,8 @@ class ARIABridge:
             if state == "error":
                 error = payload.get("error", "Unbekannt")
                 logger.error("[core] Chat-Fehler: %s", error)
+                self._last_chat_final_at = asyncio.get_event_loop().time()
+                await self._emit_activity("idle", "")
                 await self._send_to_rvs({
                     "type": "chat",
                     "payload": {
@@ -739,6 +965,14 @@ class ARIABridge:
         - Leitet Antwort an die App weiter (via RVS)
         - Sprachausgabe ueber TTS (wenn Modus erlaubt)
         """
+        # NO_REPLY Token: ARIA signalisiert explizit "nicht antworten"
+        # → komplett verwerfen (keine Chat-Nachricht, kein TTS)
+        # Toleranz fuer Variationen: "NO_REPLY", "no_reply", mit Punkt/Anfuehrungszeichen
+        stripped = text.strip().strip('."\'`*').upper()
+        if stripped == "NO_REPLY" or stripped.startswith("NO_REPLY"):
+            logger.info("[core] NO_REPLY empfangen — Antwort still verworfen")
+            return
+
         metadata = payload.get("metadata", {})
         is_critical = metadata.get("critical", False)
         requested_voice = metadata.get("voice")
@@ -761,6 +995,9 @@ class ARIABridge:
         # Stimme auswaehlen
         voice_name = requested_voice or self.voice_engine.select_voice(text)
 
+        # Eindeutige Message-ID fuer Audio-Cache-Zuordnung
+        message_id = str(uuid.uuid4())
+
         # Antwort an die App weiterleiten (als Chat-Nachricht)
         await self._send_to_rvs({
             "type": "chat",
@@ -768,23 +1005,59 @@ class ARIABridge:
                 "text": text,
                 "sender": "aria",
                 "voice": voice_name,
+                "messageId": message_id,
             },
             "timestamp": int(asyncio.get_event_loop().time() * 1000),
         })
 
         # TTS-Audio rendern und an die App senden (wenn Modus es erlaubt)
-        if should_speak(self.current_mode, is_critical):
-            audio_data = self.voice_engine.synthesize(text, voice_name)
-            if audio_data:
-                audio_b64 = base64.b64encode(audio_data).decode("ascii")
-                await self._send_to_rvs({
-                    "type": "audio",
-                    "payload": {
-                        "base64": audio_b64,
-                        "mimeType": "audio/wav",
-                        "voice": voice_name,
-                    },
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
+        if getattr(self, 'tts_enabled', True) and should_speak(self.current_mode, is_critical):
+            tts_engine = getattr(self, 'tts_engine_type', 'piper')
+
+            if tts_engine == "xtts":
+                # XTTS: aufbereiteter Text (Code-Bloecke raus, Einheiten ausgeschrieben)
+                xtts_voice = getattr(self, 'xtts_voice', '')
+                tts_text = clean_text_for_tts(text)
+                if not tts_text:
+                    logger.info("[core] TTS-Text leer nach Cleanup — XTTS uebersprungen")
+                    return
+                try:
+                    await self._send_to_rvs({
+                        "type": "xtts_request",
+                        "payload": {
+                            "text": tts_text,
+                            "voice": xtts_voice,
+                            "language": "de",
+                            "requestId": str(uuid.uuid4()),
+                        },
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                    logger.info("[core] XTTS-Request gesendet (%s): '%s'", xtts_voice or "default", tts_text[:60])
+                except Exception as e:
+                    logger.warning("[core] XTTS-Request fehlgeschlagen: %s — Fallback auf Piper", e)
+                    # Fallback auf Piper
+                    audio_data = self.voice_engine.synthesize(text, voice_name)
+                    if audio_data:
+                        audio_b64 = base64.b64encode(audio_data).decode("ascii")
+                        await self._send_to_rvs({
+                            "type": "audio",
+                            "payload": {"base64": audio_b64, "mimeType": "audio/wav", "voice": voice_name, "messageId": message_id},
+                            "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                        })
+            else:
+                # Piper: Lokal rendern
+                audio_data = self.voice_engine.synthesize(text, voice_name)
+                if audio_data:
+                    audio_b64 = base64.b64encode(audio_data).decode("ascii")
+                    await self._send_to_rvs({
+                        "type": "audio",
+                        "payload": {
+                            "base64": audio_b64,
+                            "mimeType": "audio/wav",
+                            "voice": voice_name,
+                            "messageId": message_id,
+                        },
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
                 })
                 logger.info("[core] TTS-Audio gesendet: %d bytes (%s)", len(audio_data), voice_name)
 
@@ -893,10 +1166,22 @@ class ARIABridge:
                 retry_delay = min(retry_delay * 2, 30)
 
     async def _rvs_heartbeat(self) -> None:
-        """Sendet Heartbeats an den RVS damit die Verbindung offen bleibt."""
+        """Sendet Heartbeats + WebSocket Pings an den RVS damit die Verbindung offen bleibt."""
         while True:
-            await asyncio.sleep(25)
-            if self.ws_rvs and self.ws_rvs.open:
+            await asyncio.sleep(15)
+            if self.ws_rvs:
+                try:
+                    # WebSocket Protocol-Level Ping (haelt TCP-Verbindung am Leben)
+                    pong = await self.ws_rvs.ping()
+                    await asyncio.wait_for(pong, timeout=10)
+                except Exception:
+                    logger.warning("[rvs] Ping fehlgeschlagen — Verbindung tot, erzwinge Reconnect")
+                    try:
+                        await self.ws_rvs.close()
+                    except Exception:
+                        pass
+                    self.ws_rvs = None
+                    break
                 try:
                     await self.ws_rvs.send(json.dumps({
                         "type": "heartbeat",
@@ -925,7 +1210,130 @@ class ARIABridge:
         payload = message.get("payload", {})
 
         if msg_type == "chat":
-            # Text von der App → an aria-core
+            # Nur User-Nachrichten weiterleiten — ARIA/Diagnostic-Antworten ignorieren (sonst Loop!)
+            sender = payload.get("sender", "")
+            if sender in ("aria", "stt"):
+                return
+            text = payload.get("text", "")
+            if text:
+                logger.info("[rvs] App-Chat: '%s'", text[:80])
+                await self.send_to_core(text, source="app")
+            return
+
+        if msg_type == "cancel_request":
+            logger.info("[rvs] Cancel-Request von App — rufe Diagnostic /api/cancel auf")
+            await self._cancel_via_diagnostic()
+            await self._emit_activity("idle", "")
+            return
+
+        elif msg_type == "xtts_response":
+            # XTTS-Audio vom Gaming-PC empfangen → an App weiterleiten
+            audio_b64 = payload.get("base64", "")
+            error = payload.get("error", "")
+            if error:
+                logger.warning("[rvs] XTTS Fehler: %s", error)
+                return
+            if audio_b64:
+                logger.info("[rvs] XTTS-Audio empfangen: %dKB", len(audio_b64) // 1365)
+                await self._send_to_rvs({
+                    "type": "audio",
+                    "payload": {
+                        "base64": audio_b64,
+                        "mimeType": payload.get("mimeType", "audio/wav"),
+                        "voice": payload.get("voice", "xtts"),
+                    },
+                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                })
+            return
+
+        elif msg_type == "tts_request":
+            # App fordert TTS-Audio fuer einen Text an (Play-Button)
+            text = payload.get("text", "")
+            requested_voice = payload.get("voice", "")
+            if text:
+                voice_name = requested_voice or self.voice_engine.select_voice(text)
+                audio_data = self.voice_engine.synthesize(text, voice_name)
+                if audio_data:
+                    audio_b64 = base64.b64encode(audio_data).decode("ascii")
+                    try:
+                        await self._send_to_rvs({
+                            "type": "audio",
+                            "payload": {
+                                "base64": audio_b64,
+                                "mimeType": "audio/wav",
+                                "voice": voice_name,
+                            },
+                            "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                        })
+                        logger.info("[rvs] TTS on-demand: %d bytes (%s)", len(audio_data), voice_name)
+                    except Exception as e:
+                        logger.warning("[rvs] TTS on-demand senden fehlgeschlagen: %s", e)
+            return
+
+        elif msg_type == "config":
+            # Konfiguration von App/Diagnostic empfangen + persistent speichern
+            changed = False
+            if "defaultVoice" in payload:
+                new_voice = payload["defaultVoice"]
+                if new_voice in self.voice_engine.voices:
+                    self.voice_engine.default_voice = new_voice
+                    logger.info("[rvs] Standard-Stimme gewechselt: %s", new_voice)
+                    changed = True
+            if "highlightVoice" in payload:
+                new_voice = payload["highlightVoice"]
+                if new_voice in self.voice_engine.voices:
+                    self.voice_engine.highlight_voice = new_voice
+                    logger.info("[rvs] Highlight-Stimme gewechselt: %s", new_voice)
+                    changed = True
+            if "ttsEnabled" in payload:
+                self.tts_enabled = bool(payload["ttsEnabled"])
+                logger.info("[rvs] TTS %s", "aktiviert" if self.tts_enabled else "deaktiviert")
+                changed = True
+            if "ttsEngine" in payload:
+                self.tts_engine_type = payload["ttsEngine"]
+                logger.info("[rvs] TTS-Engine: %s", self.tts_engine_type)
+                changed = True
+            if "xttsVoice" in payload:
+                self.xtts_voice = payload["xttsVoice"]
+                logger.info("[rvs] XTTS-Stimme: %s", self.xtts_voice)
+                changed = True
+            if "speedRamona" in payload:
+                self.voice_engine.speech_speed["ramona"] = max(0.3, min(2.0, float(payload["speedRamona"])))
+                logger.info("[rvs] Speed Ramona: %.1f", self.voice_engine.speech_speed["ramona"])
+                changed = True
+            if "speedThorsten" in payload:
+                self.voice_engine.speech_speed["thorsten"] = max(0.3, min(2.0, float(payload["speedThorsten"])))
+                logger.info("[rvs] Speed Thorsten: %.1f", self.voice_engine.speech_speed["thorsten"])
+                changed = True
+            whisper_reloaded = False
+            if "whisperModel" in payload:
+                new_model = payload["whisperModel"]
+                if new_model and new_model != self.stt_engine.model_size:
+                    logger.info("[rvs] Whisper-Modell Wechsel: %s -> %s (laedt...)", self.stt_engine.model_size, new_model)
+                    loop = asyncio.get_event_loop()
+                    whisper_reloaded = await loop.run_in_executor(None, self.stt_engine.reload, new_model)
+                    if whisper_reloaded:
+                        changed = True
+            # Persistent speichern in Shared Volume
+            if changed:
+                try:
+                    os.makedirs("/shared/config", exist_ok=True)
+                    config_data = {
+                        "defaultVoice": self.voice_engine.default_voice,
+                        "highlightVoice": self.voice_engine.highlight_voice,
+                        "ttsEnabled": getattr(self, "tts_enabled", True),
+                        "ttsEngine": getattr(self, "tts_engine_type", "piper"),
+                        "xttsVoice": getattr(self, "xtts_voice", ""),
+                        "speedRamona": self.voice_engine.speech_speed.get("ramona", 1.0),
+                        "speedThorsten": self.voice_engine.speech_speed.get("thorsten", 1.0),
+                        "whisperModel": self.stt_engine.model_size,
+                    }
+                    with open("/shared/config/voice_config.json", "w") as f:
+                        json.dump(config_data, f, indent=2)
+                    logger.info("[rvs] Voice-Config gespeichert: %s", config_data)
+                except Exception as e:
+                    logger.warning("[rvs] Config speichern fehlgeschlagen: %s", e)
+            return
             text = payload.get("text", "")
             if text:
                 logger.info("[rvs] App-Chat: '%s'", text[:80])
@@ -954,10 +1362,99 @@ class ARIABridge:
                 await self.ws_core.send(raw_message)
 
         elif msg_type == "file":
-            # Datei von der App → an aria-core
-            logger.info("[rvs] Datei empfangen: %s", payload.get("name", "?"))
-            if self.ws_core:
-                await self.ws_core.send(raw_message)
+            # Datei von der App → als Text-Nachricht an aria-core
+            file_name = payload.get("name", "unbekannt")
+            file_type = payload.get("type", "")
+            file_b64 = payload.get("base64", "")
+            file_size = payload.get("size", 0)
+            width = payload.get("width", 0)
+            height = payload.get("height", 0)
+            logger.info("[rvs] Datei empfangen: %s (%s, %dKB)",
+                        file_name, file_type, len(file_b64) // 1365 if file_b64 else 0)
+
+            # Shared Volume: /shared/ ist in Bridge UND aria-core gemountet
+            SHARED_DIR = "/shared/uploads"
+            os.makedirs(SHARED_DIR, exist_ok=True)
+
+            if file_b64 and file_type.startswith("image/"):
+                # Bild in Shared Volume speichern
+                ext = ".jpg" if "jpeg" in file_type or "jpg" in file_type else ".png"
+                safe_name = f"img_{int(asyncio.get_event_loop().time())}_{file_name.replace('/', '_')}"
+                file_path = os.path.join(SHARED_DIR, safe_name if safe_name.endswith(ext) else safe_name + ext)
+                with open(file_path, "wb") as f:
+                    f.write(base64.b64decode(file_b64))
+                size_kb = len(file_b64) // 1365
+                logger.info("[rvs] Bild gespeichert: %s (%dKB)", file_path, size_kb)
+                # ERST an aria-core senden (wichtigster Schritt)
+                text = (f"Stefan hat dir ein Bild geschickt: {file_name}"
+                        f"{f' ({width}x{height}px)' if width else ''}"
+                        f", {size_kb}KB."
+                        f" Das Bild liegt unter: {file_path}"
+                        f" Warte auf Stefans Anweisung was du damit tun sollst.")
+                await self.send_to_core(text, source="app-file")
+                # Dann App informieren (optional, darf nicht crashen)
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
+            elif file_b64:
+                # Andere Datei in Shared Volume speichern
+                safe_name = f"file_{int(asyncio.get_event_loop().time())}_{file_name.replace('/', '_')}"
+                file_path = os.path.join(SHARED_DIR, safe_name)
+                with open(file_path, "wb") as f:
+                    f.write(base64.b64decode(file_b64))
+                size_kb = len(file_b64) // 1365
+                logger.info("[rvs] Datei gespeichert: %s (%dKB)", file_path, size_kb)
+                # ERST an aria-core senden
+                text = (f"Stefan hat dir eine Datei geschickt: {file_name}"
+                        f" ({file_type}, {size_kb}KB)."
+                        f" Die Datei liegt unter: {file_path}"
+                        f" Warte auf Stefans Anweisung was du damit tun sollst.")
+                await self.send_to_core(text, source="app-file")
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
+            else:
+                text = f"Stefan hat eine Datei gesendet ({file_name}, {file_type}) aber die Daten sind leer angekommen."
+                await self.send_to_core(text, source="app-file")
+
+        elif msg_type == "file_request":
+            # App fordert eine Datei an (Re-Download nach Cache-Leerung)
+            server_path = payload.get("serverPath", "")
+            req_id = payload.get("requestId", "")
+            if not server_path or not server_path.startswith("/shared/"):
+                logger.warning("[rvs] Ungueltiger file_request: %s", server_path)
+                return
+            if not os.path.isfile(server_path):
+                logger.warning("[rvs] Datei nicht gefunden: %s", server_path)
+                await self._send_to_rvs({
+                    "type": "file_response",
+                    "payload": {"requestId": req_id, "error": "Datei nicht gefunden"},
+                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                })
+                return
+            with open(server_path, "rb") as f:
+                file_b64 = base64.b64encode(f.read()).decode("ascii")
+            logger.info("[rvs] Re-Download: %s (%dKB)", server_path, len(file_b64) // 1365)
+            await self._send_to_rvs({
+                "type": "file_response",
+                "payload": {
+                    "requestId": req_id,
+                    "serverPath": server_path,
+                    "base64": file_b64,
+                    "name": os.path.basename(server_path),
+                },
+                "timestamp": int(asyncio.get_event_loop().time() * 1000),
+            })
 
         elif msg_type == "audio":
             # Audio von der App → decodieren → STT → an aria-core
@@ -1017,7 +1514,21 @@ class ARIABridge:
 
             if text.strip():
                 logger.info("[rvs] STT Ergebnis: '%s'", text[:80])
+                # ERST an aria-core senden (wichtigster Schritt)
                 await self.send_to_core(text, source="app-voice")
+                # STT-Text an RVS senden (fuer Anzeige in App + Diagnostic)
+                # sender="stt" damit Bridge es ignoriert (kein Loop)
+                try:
+                    await self._send_to_rvs({
+                        "type": "chat",
+                        "payload": {
+                            "text": text,
+                            "sender": "stt",
+                        },
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] STT-Text konnte nicht an RVS gesendet werden: %s", e)
             else:
                 logger.info("[rvs] Keine Sprache erkannt — ignoriert")
 
@@ -1033,17 +1544,68 @@ class ARIABridge:
                         pass
 
     async def _send_to_rvs(self, message: dict) -> None:
-        """Sendet eine Nachricht an die App (via RVS)."""
-        if self.ws_rvs is None or not self.ws_rvs.open:
+        """Sendet eine Nachricht an die App (via RVS) mit Verbindungs-Check."""
+        if self.ws_rvs is None:
+            return
+
+        # Ping-Check: Verbindung wirklich aktiv?
+        try:
+            pong = await self.ws_rvs.ping()
+            await asyncio.wait_for(pong, timeout=5)
+        except Exception:
+            logger.warning("[rvs] Ping fehlgeschlagen — Verbindung tot, erzwinge Reconnect")
+            try:
+                await self.ws_rvs.close()
+            except Exception:
+                pass
+            self.ws_rvs = None
+            # Reconnect wird vom connect_to_rvs Loop uebernommen
             return
 
         try:
             await self.ws_rvs.send(json.dumps(message))
         except Exception:
-            logger.exception("[rvs] Sendefehler")
+            logger.warning("[rvs] Sendefehler — RVS nicht erreichbar")
 
     # ── Log-Streaming an die App ─────────────────────────────
 
+    async def _cancel_via_diagnostic(self) -> None:
+        """Ruft das Diagnostic /api/cancel an — dort laeuft die volle Abbruch-Logik
+        (openclaw doctor --fix mit Docker-Socket)."""
+        def _do_request():
+            try:
+                req = urllib.request.Request(
+                    f"{self._diagnostic_url}/api/cancel",
+                    method="POST",
+                    data=b"",
+                )
+                with urllib.request.urlopen(req, timeout=5) as resp:
+                    return resp.status
+            except Exception as e:
+                return f"error: {e}"
+
+        status = await asyncio.get_event_loop().run_in_executor(None, _do_request)
+        logger.info("[cancel] Diagnostic /api/cancel: %s", status)
+
+    async def _emit_activity(self, activity: str, tool: str = "") -> None:
+        """Sendet agent_activity an die App — nur wenn sich der State geaendert hat.
+
+        Trailing Agent-Events nach chat:final werden 3s lang unterdrueckt
+        (nur 'idle' kommt immer durch)."""
+        if activity != "idle" and self._last_chat_final_at > 0:
+            since_final = asyncio.get_event_loop().time() - self._last_chat_final_at
+            if since_final < 3.0:
+                return
+        state = (activity, tool)
+        if state == self._last_activity_state:
+            return
+        self._last_activity_state = state
+        await self._send_to_rvs({
+            "type": "agent_activity",
+            "payload": {"activity": activity, "tool": tool},
+            "timestamp": int(asyncio.get_event_loop().time() * 1000),
+        })
+
     async def send_log_to_app(self, source: str, message: str, level: str = "info") -> None:
         """Sendet einen Log-Eintrag an die App (erscheint im Log-Viewer)."""
         await self._send_to_rvs({
@@ -1112,8 +1674,10 @@ class ARIABridge:
                         logger.info("Keine Sprache erkannt — ignoriert")
 
             except sd.PortAudioError:
-                logger.error("Audio-Geraet nicht verfuegbar — warte 5 Sekunden")
-                await asyncio.sleep(5)
+                if not hasattr(self, '_audio_warned'):
+                    logger.warning("Audio-Geraet nicht verfuegbar — lokales Mikrofon deaktiviert (kein Spam mehr)")
+                    self._audio_warned = True
+                await asyncio.sleep(60)  # 60s statt 5s — spart Log-Spam
             except Exception:
                 logger.exception("Fehler in der Audio-Schleife")
                 await asyncio.sleep(1)

cleanup.sh

@@ -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

diagnostic/server.js

@@ -37,15 +37,76 @@ const state = {
 };
 const SESSION_KEY_FILE = "/data/active-session";
 // /data Verzeichnis sicherstellen (Volume Mount)
-try { fs.mkdirSync("/data", { recursive: true }); } catch {}
+try { fs.mkdirSync("/data", { recursive: true }); } catch (e) {
+  console.error(`[startup] /data mkdir fehlgeschlagen: ${e.message}`);
+}
+// sessionFromFile zeigt an, ob der aktive Key aus der Datei kam.
+// Wenn true, darf resolveActiveSession NICHT mehr auto-picken (Wahl respektieren).
+let sessionFromFile = false;
 let activeSessionKey = (() => {
   try {
     const saved = fs.readFileSync(SESSION_KEY_FILE, "utf-8").trim();
-    if (saved) { console.log(`[startup] Gespeicherte Session geladen: '${saved}'`); return saved; }
-  } catch {}
+    if (saved) {
+      console.log(`[startup] Gespeicherte Session geladen: '${saved}'`);
+      sessionFromFile = true;
+      return saved;
+    }
+  } catch (e) {
+    console.error(`[startup] SESSION_KEY_FILE read: ${e.code || e.message}`);
+  }
   console.log("[startup] Keine gespeicherte Session — Fallback 'main'");
   return "main";
 })();
+
+// ── Runtime-Config: /shared/config/runtime.json ─────────────
+// ENV-Werte sind Defaults; Werte aus runtime.json haben Vorrang.
+// Bridge und ggf. andere Komponenten lesen dieselbe Datei.
+const RUNTIME_CONFIG_FILE = "/shared/config/runtime.json";
+const RUNTIME_CONFIG_FIELDS = [
+  "RVS_HOST", "RVS_PORT", "RVS_TLS", "RVS_TOKEN",
+  "ARIA_AUTH_TOKEN", "WHISPER_MODEL", "WHISPER_LANGUAGE",
+];
+function readRuntimeConfig() {
+  const envDefaults = {
+    RVS_HOST, RVS_PORT, RVS_TLS, RVS_TOKEN,
+    ARIA_AUTH_TOKEN: process.env.ARIA_AUTH_TOKEN || "",
+    WHISPER_MODEL: process.env.WHISPER_MODEL || "medium",
+    WHISPER_LANGUAGE: process.env.WHISPER_LANGUAGE || "de",
+  };
+  try {
+    const raw = fs.readFileSync(RUNTIME_CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...envDefaults, ...parsed };
+  } catch {
+    return envDefaults;
+  }
+}
+function writeRuntimeConfig(patch) {
+  let current = {};
+  try { current = JSON.parse(fs.readFileSync(RUNTIME_CONFIG_FILE, "utf-8")); } catch {}
+  for (const key of Object.keys(patch)) {
+    if (RUNTIME_CONFIG_FIELDS.includes(key)) current[key] = patch[key];
+  }
+  fs.mkdirSync("/shared/config", { recursive: true });
+  const tmp = RUNTIME_CONFIG_FILE + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(current, null, 2));
+  fs.renameSync(tmp, RUNTIME_CONFIG_FILE);
+}
+
+// Atomic write: temp-file + rename, laute Logs bei Fehler.
+function persistActiveSession(key) {
+  try {
+    const tmp = SESSION_KEY_FILE + ".tmp";
+    fs.writeFileSync(tmp, key);
+    fs.renameSync(tmp, SESSION_KEY_FILE);
+    sessionFromFile = true;
+    console.log(`[session] Aktive Session persistiert: '${key}'`);
+    return true;
+  } catch (e) {
+    console.error(`[session] FEHLER beim Persistieren von '${key}': ${e.message}`);
+    return false;
+  }
+}
 const logs = [];
 let gatewayWs = null;
 let rvsWs = null;
@@ -56,6 +117,12 @@ const browserClients = new Set();
 let pipelineActive = false;
 let pipelineStartTime = 0;
 
+// Nach chat:final kommen oft noch Trailing Agent-Events. Waehrend dieses
+// Fensters unterdruecken wir agent_activity-Broadcasts, damit der
+// Thinking-Indicator nicht wieder anspringt.
+let lastChatFinalAt = 0;
+const SETTLED_WINDOW_MS = 3000;
+
 function plog(message, level) {
   const elapsed = pipelineActive ? `+${Date.now() - pipelineStartTime}ms` : "";
   const entry = { ts: new Date().toISOString(), level: level || "info", source: "pipeline", message: `${elapsed ? `[${elapsed}] ` : ""}${message}` };
@@ -74,8 +141,8 @@ function pipelineStart(method, text) {
   pipelineStartTime = Date.now();
   if (pipelineTimeout) clearTimeout(pipelineTimeout);
   pipelineTimeout = setTimeout(() => {
-    if (pipelineActive) pipelineEnd(false, "Timeout — keine Antwort nach 60s");
-  }, 60000);
+    if (pipelineActive) pipelineEnd(false, "Timeout — keine Antwort nach 10min");
+  }, 600000);
   plog(`━━━ Pipeline Start: ${method} ━━━`);
   plog(`Nachricht: "${text}"`);
 }
@@ -91,6 +158,9 @@ function pipelineEnd(ok, detail) {
   }
   plog(`━━━ Pipeline Ende ━━━`);
   pipelineActive = false;
+  // Thinking-Indikator IMMER zuruecksetzen — auch bei Timeout/Fehler/Abbruch
+  broadcast({ type: "agent_activity", activity: "idle" });
+  pendingMessageTime = 0;
 }
 
 // ── Auto-Restart bei Netzwerk-Namespace-Verlust ──────
@@ -257,8 +327,10 @@ async function connectGateway() {
       state.gateway.handshakeOk = false;
       gatewayWs = null;
       broadcastState();
+      // Stuck "ARIA denkt..." vermeiden, falls Gateway waehrend Pipeline abkackt
+      if (pipelineActive) pipelineEnd(false, `Gateway-Verbindung verloren (${code})`);
+      else broadcast({ type: "agent_activity", activity: "idle" });
       checkGatewayHealth();
-      // Auto-Reconnect nach 5s
       setTimeout(connectGateway, 5000);
     });
 
@@ -319,10 +391,29 @@ function handleGatewayMessage(msg) {
     if (event === "agent") {
       const data = payload.data || {};
       const delta = data.delta || "";
-      if (delta && payload.stream === "assistant") {
+      const stream = payload.stream || "";
+
+      if (delta && stream === "assistant") {
         broadcast({ type: "chat_delta", delta, payload });
       }
-      // agent Events nicht einzeln loggen (zu viele)
+
+      // Nach chat:final trickeln noch Aufraeum-Events rein — unterdruecken,
+      // damit der Thinking-Indicator nicht wieder anspringt.
+      const settled = lastChatFinalAt && (Date.now() - lastChatFinalAt) < SETTLED_WINDOW_MS;
+
+      // Tool-Nutzung erkennen und broadcasten
+      if (stream === "tool_use" || data.type === "tool_use") {
+        const toolName = data.name || data.tool || payload.tool || "";
+        if (toolName && !settled) {
+          broadcast({ type: "agent_activity", activity: "tool", tool: toolName, data });
+          log("info", "gateway", `Tool: ${toolName}`);
+        }
+      }
+
+      if (!settled) {
+        broadcast({ type: "agent_activity", activity: stream || "thinking" });
+      }
+      updateAgentActivity();
       return;
     }
 
@@ -335,9 +426,31 @@ function handleGatewayMessage(msg) {
         const runId = payload.runId || "";
         if (runId && seenFinalRuns.has(runId)) return; // Duplikat
         if (runId) { seenFinalRuns.add(runId); setTimeout(() => seenFinalRuns.delete(runId), 60000); }
+
+        // NO_REPLY → ARIA signalisiert "nicht antworten", Pipeline beenden aber nichts zeigen
+        const trimmed = (text || "").trim().replace(/^["'`*.\s]+|["'`*.\s]+$/g, "").toUpperCase();
+        if (trimmed === "NO_REPLY" || trimmed.startsWith("NO_REPLY")) {
+          log("info", "gateway", "NO_REPLY empfangen — still verworfen");
+          lastChatFinalAt = Date.now();
+          if (pipelineActive) pipelineEnd(true, "NO_REPLY (stumm)");
+          broadcast({ type: "agent_activity", activity: "idle" });
+          pendingMessageTime = 0;
+          updateAgentActivity();
+          return;
+        }
+
         log("info", "gateway", `ANTWORT: "${text.slice(0, 200)}"`);
+        lastChatFinalAt = Date.now();
         if (pipelineActive) pipelineEnd(true, `"${text.slice(0, 120)}"`);
         broadcast({ type: "chat_final", text, payload });
+        broadcast({ type: "agent_activity", activity: "idle" });
+        pendingMessageTime = 0; // Watchdog: Antwort erhalten
+        updateAgentActivity();
+        // Antwort in Backup-Log schreiben
+        try {
+          const entry = JSON.stringify({ ts: Date.now(), role: "assistant", text: text.slice(0, 2000), session: activeSessionKey }) + "\n";
+          fs.appendFileSync("/shared/config/chat_backup.jsonl", entry);
+        } catch {}
         return;
       }
 
@@ -350,6 +463,7 @@ function handleGatewayMessage(msg) {
         const error = payload.error || text || "Unbekannt";
         log("error", "gateway", `Chat-Fehler: ${error}`);
         if (pipelineActive) pipelineEnd(false, error);
+        else broadcast({ type: "agent_activity", activity: "idle" });
         broadcast({ type: "chat_error", error, payload });
         return;
       }
@@ -370,7 +484,9 @@ function handleGatewayMessage(msg) {
       if (runId) { seenFinalRuns.add(runId); setTimeout(() => seenFinalRuns.delete(runId), 60000); }
       const text = extractChatText(payload) || payload.text || "";
       log("info", "gateway", `ANTWORT: "${text.slice(0, 200)}"`);
+      lastChatFinalAt = Date.now();
       if (pipelineActive) pipelineEnd(true, `"${text.slice(0, 120)}"`);
+      else broadcast({ type: "agent_activity", activity: "idle" });
       broadcast({ type: "chat_final", text, payload });
       return;
     }
@@ -378,6 +494,7 @@ function handleGatewayMessage(msg) {
       const error = payload.error || payload.message || "Unbekannt";
       log("error", "gateway", `Chat-Fehler: ${error}`);
       if (pipelineActive) pipelineEnd(false, error);
+      else broadcast({ type: "agent_activity", activity: "idle" });
       broadcast({ type: "chat_error", error, payload });
       return;
     }
@@ -410,8 +527,17 @@ function sendToGateway(text, isPipeline) {
   const payload = JSON.stringify(msg);
   log("debug", "gateway", `RAW >>> ${payload}`);
   gatewayWs.send(payload);
+  pendingMessageTime = Date.now(); // Watchdog: Nachricht gesendet
+  // Nachricht sofort in Backup-Log schreiben (OpenClaw speichert erst nach Run-Ende)
+  try {
+    fs.mkdirSync("/shared/config", { recursive: true });
+    const entry = JSON.stringify({ ts: Date.now(), role: "user", text, session: activeSessionKey }) + "\n";
+    fs.appendFileSync("/shared/config/chat_backup.jsonl", entry);
+  } catch {}
   log("info", "gateway", `chat.send [${reqId}]: "${text}"`);
   if (isPipeline) plog(`chat.send [${reqId}] an Gateway gesendet — warte auf ACK...`);
+
+  // Gateway-Nachrichten NICHT an RVS senden (sonst doppelter ARIA-Request via Bridge)
   return true;
 }
 
@@ -425,7 +551,13 @@ function connectRVS(forcePlain) {
     return;
   }
 
-  // TLS-Logik: wss zuerst, bei Fehler Fallback auf ws (wenn erlaubt)
+  // Alte Verbindung sauber schliessen
+  if (rvsWs) {
+    try { rvsWs.removeAllListeners(); rvsWs.close(); } catch (_) {}
+    rvsWs = null;
+  }
+
+  // TLS-Logik: wss zuerst, bei Fehler Fallback auf ws
   const useTls = RVS_TLS === "true" && !forcePlain;
   const proto = useTls ? "wss" : "ws";
   const url = `${proto}://${RVS_HOST}:${RVS_PORT}?token=${RVS_TOKEN}`;
@@ -434,7 +566,18 @@ function connectRVS(forcePlain) {
   broadcastState();
   log("info", "rvs", `Verbinde: ${proto}://${RVS_HOST}:${RVS_PORT}`);
 
-  const ws = new WebSocket(url);
+  let ws;
+  try {
+    ws = new WebSocket(url);
+  } catch (err) {
+    log("error", "rvs", `WebSocket erstellen fehlgeschlagen: ${err.message}`);
+    if (useTls && RVS_TLS_FALLBACK === "true") {
+      connectRVS(true);
+    }
+    return;
+  }
+
+  let fallbackTriggered = false;
 
   ws.on("open", () => {
     log("info", "rvs", `Verbunden (${proto})`);
@@ -442,6 +585,16 @@ function connectRVS(forcePlain) {
     state.rvs.lastError = null;
     rvsWs = ws;
     broadcastState();
+
+    // Keepalive: alle 25s ein Ping senden damit die Verbindung nicht stirbt
+    const keepalive = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        try { ws.ping(); } catch (_) {}
+      } else {
+        clearInterval(keepalive);
+      }
+    }, 25000);
+    ws._keepalive = keepalive;
   });
 
   ws.on("message", (raw) => {
@@ -449,11 +602,24 @@ function connectRVS(forcePlain) {
       const msg = JSON.parse(raw.toString());
       if (msg.type === "chat" && msg.payload) {
         const sender = msg.payload.sender || "?";
+        // Eigene Nachrichten ignorieren (Echo)
+        if (sender === "diagnostic") return;
         log("info", "rvs", `Chat von ${sender}: "${(msg.payload.text || "").slice(0, 100)}"`);
-        if (pipelineActive && sender !== "diagnostic") {
+        if (pipelineActive) {
           pipelineEnd(true, `Antwort via RVS von ${sender}: "${(msg.payload.text || "").slice(0, 120)}"`);
         }
         broadcast({ type: "rvs_chat", msg });
+      } else if (msg.type === "file_saved" && msg.payload) {
+        // Bild/Datei-Upload von der App — im Chat anzeigen
+        const name = msg.payload.name || "?";
+        const serverPath = msg.payload.serverPath || "";
+        const mimeType = msg.payload.mimeType || "";
+        log("info", "rvs", `Datei empfangen: ${name} (${serverPath})`);
+        // Als User-Nachricht mit Pfad broadcasten (Diagnostic zeigt Bilder inline)
+        broadcast({ type: "rvs_chat", msg: {
+          type: "chat",
+          payload: { text: `Anhang: ${name}\n${serverPath}`, sender: "user" }
+        }});
       } else if (msg.type === "heartbeat") {
         // ignorieren
       } else {
@@ -464,10 +630,13 @@ function connectRVS(forcePlain) {
 
   ws.on("close", () => {
     log("warn", "rvs", "Verbindung geschlossen");
+    if (ws._keepalive) clearInterval(ws._keepalive);
     state.rvs.status = "disconnected";
-    rvsWs = null;
+    if (rvsWs === ws) rvsWs = null;
     broadcastState();
-    setTimeout(() => connectRVS(), 5000);
+    if (!fallbackTriggered) {
+      setTimeout(() => connectRVS(), 5000);
+    }
   });
 
   ws.on("error", (err) => {
@@ -475,31 +644,71 @@ function connectRVS(forcePlain) {
     state.rvs.lastError = err.message;
     broadcastState();
 
-    // TLS Fallback: wenn wss fehlschlaegt und Fallback erlaubt → ws versuchen
-    if (useTls && RVS_TLS_FALLBACK === "true") {
+    // TLS Fallback
+    if (useTls && RVS_TLS_FALLBACK === "true" && !fallbackTriggered) {
+      fallbackTriggered = true;
       log("warn", "rvs", "TLS fehlgeschlagen — Fallback auf ws://");
-      ws.removeAllListeners();
-      try { ws.close(); } catch (_) {}
+      try { ws.removeAllListeners(); ws.close(); } catch (_) {}
+      if (rvsWs === ws) rvsWs = null;
       connectRVS(true);
     }
   });
 }
 
-function sendToRVS(text, isPipeline) {
-  if (!rvsWs || rvsWs.readyState !== WebSocket.OPEN) {
-    log("error", "rvs", "Nicht verbunden");
-    if (isPipeline) pipelineEnd(false, "RVS nicht verbunden");
-    return false;
-  }
+function sendToRVS_withResponse(sendType, sendPayload, expectType, clientWs) {
+  if (!RVS_HOST || !RVS_TOKEN) return;
+  const proto = RVS_TLS === "true" ? "wss" : "ws";
+  const url = `${proto}://${RVS_HOST}:${RVS_PORT}?token=${RVS_TOKEN}`;
+  const freshWs = new WebSocket(url);
+  const timeout = setTimeout(() => {
+    try { freshWs.close(); } catch (_) {}
+    clientWs.send(JSON.stringify({ type: expectType, payload: { voices: [], error: "Timeout" }, timestamp: Date.now() }));
+  }, 15000);
+  freshWs.on("open", () => {
+    freshWs.send(JSON.stringify({ type: sendType, payload: sendPayload, timestamp: Date.now() }));
+  });
+  freshWs.on("message", (raw) => {
+    try {
+      const resp = JSON.parse(raw.toString());
+      if (resp.type === expectType) {
+        clearTimeout(timeout);
+        clientWs.send(JSON.stringify(resp));
+        setTimeout(() => { try { freshWs.close(); } catch (_) {} }, 1000);
+      }
+    } catch {}
+  });
+  freshWs.on("error", () => {});
+}
 
-  rvsWs.send(JSON.stringify({
+function sendToRVS_raw(msgObj) {
+  if (!RVS_HOST || !RVS_TOKEN) return;
+  const proto = RVS_TLS === "true" ? "wss" : "ws";
+  const url = `${proto}://${RVS_HOST}:${RVS_PORT}?token=${RVS_TOKEN}`;
+  const freshWs = new WebSocket(url);
+  freshWs.on("open", () => {
+    freshWs.send(JSON.stringify(msgObj));
+    setTimeout(() => { try { freshWs.close(); } catch (_) {} }, 5000);
+  });
+  freshWs.on("error", () => {});
+}
+
+function sendToRVS(text, isPipeline) {
+  // Ueber Gateway senden (zuverlaessig) UND an RVS fuer App-Sichtbarkeit
+  // Die Bridge empfaengt RVS-Nachrichten von der App zuverlaessig,
+  // aber die Diagnostic→RVS→Bridge Route hat Zombie-Probleme.
+  // Deshalb: Gateway fuer ARIA, RVS nur fuer App-Anzeige.
+
+  // 1. An Gateway senden (damit ARIA antwortet)
+  const gatewayOk = sendToGateway(text, isPipeline);
+
+  // 2. An RVS senden (damit die App die Nachricht sieht)
+  sendToRVS_raw({
     type: "chat",
     payload: { text, sender: "diagnostic" },
     timestamp: Date.now(),
-  }));
-  log("info", "rvs", `Gesendet via RVS: "${text}"`);
-  if (isPipeline) plog(`Nachricht an RVS gesendet — warte auf Antwort via RVS...`);
-  return true;
+  });
+
+  return gatewayOk;
 }
 
 // ── Claude Proxy Test ────────────────────────────────────
@@ -517,7 +726,7 @@ async function testProxy(prompt) {
 
     const modelsRes = await fetch(healthUrl, {
       headers: { "Authorization": "Bearer not-needed" },
-      signal: AbortSignal.timeout(10000),
+      signal: AbortSignal.timeout(30000),
     });
 
     if (!modelsRes.ok) {
@@ -544,7 +753,7 @@ async function testProxy(prompt) {
     }
 
     // Schritt 2: Chat Completion testen (kurzer Prompt)
-    const testPrompt = prompt || "Antworte mit genau einem Wort: Ping";
+    const testPrompt = prompt || "Antworte in einem Satz: Wer bist du und funktionierst du?";
     log("info", "proxy", `Sende Test-Prompt: "${testPrompt}"`);
 
     const chatRes = await fetch(`${PROXY_URL}/v1/chat/completions`, {
@@ -558,7 +767,7 @@ async function testProxy(prompt) {
         messages: [{ role: "user", content: testPrompt }],
         max_tokens: 200,
       }),
-      signal: AbortSignal.timeout(30000),
+      signal: AbortSignal.timeout(120000), // 2min — Cold Start braucht Zeit
     });
 
     if (!chatRes.ok) {
@@ -923,6 +1132,64 @@ function waitForMessage(ws, timeoutMs) {
   });
 }
 
+// ── Watchdog: Stuck Run Erkennung ────────────────────────
+
+let lastAgentActivity = Date.now();
+let watchdogWarned = false;
+let watchdogFixAttempted = false;
+let pendingMessageTime = 0; // Wann wurde die letzte Nachricht gesendet
+
+function updateAgentActivity() {
+  lastAgentActivity = Date.now();
+  watchdogWarned = false;
+}
+
+// Watchdog prüft alle 30s ob ARIA nach einer gesendeten Nachricht reagiert
+setInterval(async () => {
+  if (pendingMessageTime === 0) return; // Keine Nachricht gesendet
+  const waitingMs = Date.now() - pendingMessageTime;
+
+  // Nach 2min ohne Agent-Activity: Warnung
+  if (waitingMs > 120000 && !watchdogWarned) {
+    watchdogWarned = true;
+    log("warn", "server", `Watchdog: Keine ARIA-Aktivitaet seit ${Math.round(waitingMs / 1000)}s — moeglicherweise stuck`);
+    broadcast({ type: "watchdog", status: "warning", waitingMs, message: "ARIA reagiert nicht — moeglicherweise stuck Run" });
+  }
+
+  // Nach 5min: doctor --fix
+  if (waitingMs > 300000 && watchdogWarned && !watchdogFixAttempted) {
+    watchdogFixAttempted = true;
+    log("error", "server", "Watchdog: 5min ohne Antwort — fuehre openclaw doctor --fix aus");
+    broadcast({ type: "watchdog", status: "fixing", message: "Auto-Fix: openclaw doctor --fix" });
+    try {
+      await dockerExec("aria-core", "openclaw doctor --fix 2>/dev/null || true");
+      log("info", "server", "Watchdog: doctor --fix ausgefuehrt");
+      broadcast({ type: "watchdog", status: "fixed", message: "doctor --fix ausgefuehrt — warte auf Antwort..." });
+    } catch (err) {
+      log("error", "server", `Watchdog: doctor --fix fehlgeschlagen: ${err.message}`);
+    }
+  }
+
+  // Nach 8min: Container neustarten
+  if (waitingMs > 480000 && watchdogFixAttempted) {
+    log("error", "server", "Watchdog: 8min ohne Antwort — starte aria-core + aria-proxy neu");
+    broadcast({ type: "watchdog", status: "restarting", message: "Container-Restart: aria-core + aria-proxy" });
+    try {
+      const { execSync } = require("child_process");
+      execSync("docker restart aria-core aria-proxy", { timeout: 60000 });
+      log("info", "server", "Watchdog: Container neugestartet");
+      broadcast({ type: "watchdog", status: "restarted", message: "Container neugestartet — warte auf Gateway-Reconnect..." });
+      // Gateway wird sich automatisch neu verbinden
+    } catch (err) {
+      log("error", "server", `Watchdog: Container-Restart fehlgeschlagen: ${err.message}`);
+      broadcast({ type: "watchdog", status: "error", message: `Restart fehlgeschlagen: ${err.message}` });
+    }
+    pendingMessageTime = 0;
+    watchdogWarned = false;
+    watchdogFixAttempted = false;
+  }
+}, 30000);
+
 // ── HTTP Server + WebSocket fuer Browser ────────────────
 
 const htmlPath = path.join(__dirname, "index.html");
@@ -937,6 +1204,67 @@ const server = http.createServer((req, res) => {
   } else if (req.url === "/api/session") {
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ sessionKey: activeSessionKey }));
+  } else if (req.url === "/api/runtime-config" && req.method === "GET") {
+    // Zentrale Runtime-Config (ENV + Override aus /shared/config/runtime.json)
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(readRuntimeConfig()));
+  } else if (req.url === "/api/runtime-config" && req.method === "POST") {
+    let body = "";
+    req.on("data", chunk => { body += chunk; if (body.length > 32768) req.destroy(); });
+    req.on("end", () => {
+      try {
+        const patch = JSON.parse(body);
+        writeRuntimeConfig(patch);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, config: readRuntimeConfig() }));
+        log("info", "server", `Runtime-Config aktualisiert: ${Object.keys(patch).join(", ")}`);
+      } catch (err) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: err.message }));
+      }
+    });
+    return;
+  } else if (req.url === "/api/onboarding") {
+    // RVS-Credentials fuer QR-Code App-Onboarding
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      rvsHost: RVS_HOST,
+      rvsPort: RVS_PORT,
+      rvsTLS: RVS_TLS === "true" || RVS_TLS === true,
+      rvsToken: RVS_TOKEN,
+    }));
+  } else if (req.url === "/api/cancel" && req.method === "POST") {
+    log("warn", "server", "HTTP /api/cancel — Cancel-Request (von Bridge)");
+    pendingMessageTime = 0;
+    watchdogWarned = false;
+    watchdogFixAttempted = false;
+    if (pipelineActive) pipelineEnd(false, "Vom Benutzer abgebrochen (App)");
+    else broadcast({ type: "agent_activity", activity: "idle" });
+    dockerExec("aria-core", "openclaw doctor --fix 2>/dev/null || true").catch(() => {});
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true }));
+  } else if (req.url.startsWith("/shared/")) {
+    // Dateien aus Shared Volume ausliefern (Bilder, Uploads)
+    const filePath = decodeURIComponent(req.url);
+    const safePath = path.resolve(filePath);
+    if (!safePath.startsWith("/shared/")) {
+      res.writeHead(403);
+      res.end("Forbidden");
+      return;
+    }
+    try {
+      if (!fs.existsSync(safePath)) { res.writeHead(404); res.end("Not Found"); return; }
+      const ext = path.extname(safePath).toLowerCase();
+      const mimeTypes = { ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".gif": "image/gif",
+                          ".pdf": "application/pdf", ".txt": "text/plain", ".json": "application/json" };
+      const contentType = mimeTypes[ext] || "application/octet-stream";
+      const data = fs.readFileSync(safePath);
+      res.writeHead(200, { "Content-Type": contentType, "Content-Length": data.length });
+      res.end(data);
+    } catch (err) {
+      res.writeHead(500);
+      res.end("Error");
+    }
   } else {
     res.writeHead(404);
     res.end("Not Found");
@@ -987,6 +1315,62 @@ wss.on("connection", (ws) => {
         if (ws._sshSock) ws._sshSock.write(msg.data);
       } else if (msg.action === "live_ssh_close") {
         if (ws._sshSock) { ws._sshSock.end(); ws._sshSock = null; }
+      } else if (msg.action === "send_file") {
+        // Datei von Diagnostic an Bridge via RVS senden
+        sendToRVS_raw({
+          type: "file",
+          payload: { name: msg.name, type: msg.type, size: msg.size, base64: msg.base64 },
+          timestamp: Date.now(),
+        });
+        log("info", "server", `Datei gesendet: ${msg.name} (${msg.type})`);
+      } else if (msg.action === "cancel_request") {
+        // Laufende Anfrage abbrechen — doctor --fix beendet stuck runs
+        log("warn", "server", "Anfrage abgebrochen — fuehre doctor --fix aus");
+        pendingMessageTime = 0;
+        watchdogWarned = false;
+        watchdogFixAttempted = false;
+        if (pipelineActive) pipelineEnd(false, "Vom Benutzer abgebrochen");
+        broadcast({ type: "agent_activity", activity: "idle" });
+        dockerExec("aria-core", "openclaw doctor --fix 2>/dev/null || true").catch(() => {});
+      } else if (msg.action === "voice_upload") {
+        // Voice-Samples an XTTS-Bridge via RVS weiterleiten, auf Bestätigung warten
+        log("info", "server", `Voice-Upload '${msg.name}' (${(msg.samples || []).length} Samples) sende an RVS...`);
+        sendToRVS_withResponse("voice_upload", { name: msg.name, samples: msg.samples }, "xtts_voice_saved", ws);
+      } else if (msg.action === "xtts_list_voices") {
+        // Frische Verbindung die auf Antwort wartet
+        sendToRVS_withResponse("xtts_list_voices", {}, "xtts_voices_list", ws);
+      } else if (msg.action === "get_voice_config") {
+        handleGetVoiceConfig(ws);
+      } else if (msg.action === "send_voice_config") {
+        // Stimmen-Config persistent speichern + an Bridge via RVS senden
+        // Bestehende Config lesen um Felder zu mergen die dieser Call nicht setzt
+        let existing = {};
+        try { existing = JSON.parse(fs.readFileSync("/shared/config/voice_config.json", "utf-8")); } catch {}
+        const voiceConfig = {
+          ...existing,
+          defaultVoice: msg.defaultVoice || "ramona",
+          highlightVoice: msg.highlightVoice || "thorsten",
+          ttsEnabled: msg.ttsEnabled !== false,
+          ttsEngine: msg.ttsEngine || "piper",
+          xttsVoice: msg.xttsVoice || "",
+          speedRamona: msg.speedRamona || 1.0,
+          speedThorsten: msg.speedThorsten || 1.0,
+        };
+        if (msg.whisperModel !== undefined) voiceConfig.whisperModel = msg.whisperModel;
+        try {
+          fs.mkdirSync("/shared/config", { recursive: true });
+          fs.writeFileSync("/shared/config/voice_config.json", JSON.stringify(voiceConfig, null, 2));
+        } catch {}
+        sendToRVS_raw({ type: "config", payload: voiceConfig, timestamp: Date.now() });
+        log("info", "server", `Voice-Config gespeichert+gesendet: default=${voiceConfig.defaultVoice}, whisper=${voiceConfig.whisperModel || "-"}`);
+      } else if (msg.action === "get_triggers") {
+        handleGetTriggers(ws);
+      } else if (msg.action === "save_triggers") {
+        handleSaveTriggers(ws, msg.triggers || []);
+      } else if (msg.action === "test_tts") {
+        handleTestTTS(ws, msg.voice || "ramona", msg.text || "Test");
+      } else if (msg.action === "check_tts") {
+        handleCheckTTS(ws);
       } else if (msg.action === "check_desktop") {
         checkDesktopAvailable(ws);
       } else if (msg.action === "load_chat_history") {
@@ -995,6 +1379,8 @@ wss.on("connection", (ws) => {
         handleListSessions(ws);
       } else if (msg.action === "read_session") {
         handleReadSession(ws, msg.sessionPath);
+      } else if (msg.action === "export_session") {
+        handleExportSession(ws, msg.sessionPath, msg.sessionKey);
       } else if (msg.action === "delete_session") {
         handleDeleteSession(ws, msg.sessionPath);
       } else if (msg.action === "set_active_session") {
@@ -1113,6 +1499,123 @@ function startLiveSSH(clientWs) {
   createReq.end(createBody);
 }
 
+// ── Voice-Config laden ────────────────────────────────
+
+function handleGetVoiceConfig(clientWs) {
+  try {
+    const configPath = "/shared/config/voice_config.json";
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      clientWs.send(JSON.stringify({ type: "voice_config", ...config }));
+    } else {
+      clientWs.send(JSON.stringify({ type: "voice_config", defaultVoice: "ramona", highlightVoice: "thorsten", ttsEnabled: true }));
+    }
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "voice_config", defaultVoice: "ramona", highlightVoice: "thorsten", ttsEnabled: true }));
+  }
+}
+
+// ── Highlight-Trigger ─────────────────────────────────
+
+const TRIGGERS_FILE = "/shared/config/highlight_triggers.json";
+
+async function handleGetTriggers(clientWs) {
+  try {
+    // Zuerst aus Shared Volume lesen, dann Fallback auf Bridge-Defaults
+    let triggers;
+    if (fs.existsSync(TRIGGERS_FILE)) {
+      triggers = JSON.parse(fs.readFileSync(TRIGGERS_FILE, "utf-8"));
+    } else {
+      // Defaults aus der Bridge lesen
+      const result = await dockerExec("aria-bridge", `python3 -c "
+import sys; sys.path.insert(0,'/app')
+from aria_bridge import EPIC_TRIGGERS
+print('\\n'.join(EPIC_TRIGGERS))
+"`);
+      triggers = result.trim().split("\n").filter(t => t);
+    }
+    clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "trigger_list", triggers: [], error: err.message }));
+  }
+}
+
+async function handleSaveTriggers(clientWs, triggers) {
+  try {
+    // In Shared Volume speichern (fuer Bridge lesbar)
+    fs.mkdirSync("/shared/config", { recursive: true });
+    fs.writeFileSync(TRIGGERS_FILE, JSON.stringify(triggers, null, 2));
+    log("info", "server", `${triggers.length} Highlight-Trigger gespeichert`);
+    // Bridge informieren (wird beim naechsten Start geladen)
+    clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
+  } catch (err) {
+    log("error", "server", `Trigger speichern fehlgeschlagen: ${err.message}`);
+  }
+}
+
+// ── TTS Diagnose ──────────────────────────────────────
+async function handleTestTTS(clientWs, voice, text) {
+  try {
+    log("info", "server", `TTS-Test: ${voice} — "${text}"`);
+    const result = await dockerExec("aria-bridge", `python3 -c "
+import time, sys
+sys.path.insert(0, '/app')
+from piper import PiperVoice
+import wave, tempfile, os
+voices = {'ramona': '/voices/de_DE-ramona-low.onnx', 'thorsten': '/voices/de_DE-thorsten-high.onnx'}
+path = voices.get('${voice}')
+if not path or not os.path.exists(path):
+    print('FEHLER: Stimme nicht gefunden')
+    sys.exit(1)
+v = PiperVoice.load(path)
+start = time.time()
+tmp = tempfile.NamedTemporaryFile(suffix='.wav', delete=False)
+with wave.open(tmp.name, 'wb') as wf:
+    wf.setnchannels(1)
+    wf.setsampwidth(2)
+    wf.setframerate(v.config.sample_rate)
+    v.synthesize('${text.replace(/'/g, "\\'")}', wf)
+size = os.path.getsize(tmp.name)
+dur = int((time.time() - start) * 1000)
+os.unlink(tmp.name)
+print(f'OK:{dur}:{size}')
+"`);
+    const parts = result.trim().split(":");
+    if (parts[0] === "OK") {
+      clientWs.send(JSON.stringify({ type: "tts_result", ok: true, voice, duration: parts[1], size: parts[2] }));
+    } else {
+      clientWs.send(JSON.stringify({ type: "tts_result", ok: false, voice, error: result.trim() }));
+    }
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "tts_result", ok: false, voice, error: err.message }));
+  }
+}
+
+async function handleCheckTTS(clientWs) {
+  try {
+    const result = await dockerExec("aria-bridge", `python3 -c "
+import os, json
+voices = {}
+for name, path in [('ramona', '/voices/de_DE-ramona-low.onnx'), ('thorsten', '/voices/de_DE-thorsten-high.onnx')]:
+    voices[name] = os.path.exists(path)
+print(json.dumps(voices))
+"`);
+    const voices = JSON.parse(result.trim());
+    const available = Object.entries(voices).filter(([,v]) => v).map(([k]) => k);
+    const missing = Object.entries(voices).filter(([,v]) => !v).map(([k]) => k);
+    clientWs.send(JSON.stringify({
+      type: "tts_status",
+      ok: missing.length === 0,
+      voices: available,
+      defaultVoice: "ramona",
+      highlightVoice: "thorsten",
+      error: missing.length > 0 ? `Fehlend: ${missing.join(", ")}` : null,
+    }));
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "tts_status", ok: false, error: err.message }));
+  }
+}
+
 function checkDesktopAvailable(clientWs) {
   // Pruefen ob VNC auf der VM laeuft (Port 5900/5901)
   const checkSock = net.connect({ host: "host.docker.internal", port: 5901 }, () => {
@@ -1149,17 +1652,17 @@ async function handleListSessions(clientWs) {
   try {
     log("info", "server", "Lade Sessions aus aria-core...");
 
-    // sessions.json als Index lesen + Datei-Details holen
+    // sessions.json als Index lesen + Datei-Details holen (inkl. .reset.* Archive)
     const raw = await dockerExec("aria-core", `
       cat ${SESSIONS_DIR}/sessions.json 2>/dev/null || echo '{}' &&
       echo '===FILE_DETAILS===' &&
-      for f in ${SESSIONS_DIR}/*.jsonl; do
+      for f in ${SESSIONS_DIR}/*.jsonl ${SESSIONS_DIR}/*.jsonl.reset.*; do
         [ -f "$f" ] || continue
         name=$(basename "$f")
-        lines=$(wc -l < "$f" 2>/dev/null || echo 0)
+        msgs=$(grep -cE '"role":"(user|assistant)"' "$f" 2>/dev/null || echo 0)
         size=$(du -h "$f" 2>/dev/null | cut -f1)
         modified=$(stat -c '%Y' "$f" 2>/dev/null || echo 0)
-        echo "FILE:$name|LINES:$lines|SIZE:$size|MODIFIED:$modified"
+        echo "FILE:$name|LINES:$msgs|SIZE:$size|MODIFIED:$modified"
       done
     `.trim());
 
@@ -1214,8 +1717,29 @@ async function handleListSessions(clientWs) {
       delete fileDetails[filename];
     }
 
-    // Dateien die nicht im Index stehen (Waisen / Reset-Files)
+    // Dateien die nicht im Index stehen (Waisen ODER Reset-Archive)
     for (const [filename, details] of Object.entries(fileDetails)) {
+      // .jsonl.reset.<ISO-Timestamp>Z → archivierte Session (OpenClaw-Reset)
+      // Format: 528f4d70-...jsonl.reset.2026-04-18T09-49-44.814Z
+      const resetMatch = filename.match(/^([a-f0-9-]+)\.jsonl\.reset\.(.+Z)$/);
+      if (resetMatch) {
+        const id = resetMatch[1];
+        // Timestamp ISO-8601 parsen: 2026-04-18T09-49-44.814Z → 2026-04-18T09:49:44.814Z
+        const tsStr = resetMatch[2].replace(/T(\d{2})-(\d{2})-(\d{2})/, "T$1:$2:$3");
+        const resetAt = Math.floor(new Date(tsStr).getTime() / 1000) || parseInt(details.MODIFIED) || 0;
+        sessions.push({
+          path: `${SESSIONS_DIR}/${filename}`,
+          sessionKey: id.slice(0, 8) + "… (archiv)",
+          sessionId: id,
+          lines: parseInt(details.LINES) || 0,
+          size: details.SIZE || "?",
+          modified: resetAt,
+          archived: true,
+          resetAt,
+        });
+        continue;
+      }
+      // Echte Waisen (UUID.jsonl ohne Eintrag in sessions.json)
       const id = filename.replace(".jsonl", "");
       sessions.push({
         path: `${SESSIONS_DIR}/${filename}`,
@@ -1260,6 +1784,68 @@ async function handleReadSession(clientWs, sessionPath) {
   }
 }
 
+async function handleExportSession(clientWs, sessionPath, sessionKey) {
+  if (!sessionPath || sessionPath.includes("..") || !sessionPath.startsWith(SESSIONS_DIR)) {
+    clientWs.send(JSON.stringify({ type: "session_export", ok: false, error: "Ungueltiger Pfad" }));
+    return;
+  }
+  try {
+    const safePath = sessionPath.replace(/'/g, "");
+    const raw = await dockerExec("aria-core", `cat '${safePath}'`);
+    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 = sessionKey || sessionPath.split("/").pop().replace(".jsonl", "");
+    const markdown = [
+      `# Session: ${title}`,
+      ``,
+      `Exportiert: ${exportedAt}  `,
+      `Quelle: ${sessionPath}`,
+      ``,
+      `---`,
+      ``,
+      blocks.join("\n\n---\n\n"),
+      ``,
+    ].join("\n");
+
+    const safeKey = (sessionKey || "session").replace(/[^a-zA-Z0-9_-]/g, "_");
+    const filename = `${exportedAt.slice(0, 10)}_${safeKey}.md`;
+    clientWs.send(JSON.stringify({ type: "session_export", ok: true, filename, markdown }));
+    log("info", "server", `Session exportiert: ${filename} (${blocks.length} Nachrichten)`);
+  } catch (err) {
+    log("error", "server", `Session-Export fehlgeschlagen: ${err.message}`);
+    clientWs.send(JSON.stringify({ type: "session_export", ok: false, error: err.message }));
+  }
+}
+
 async function handleDeleteSession(clientWs, sessionPath) {
   if (!sessionPath || sessionPath.includes("..") || !sessionPath.startsWith(SESSIONS_DIR)) {
     clientWs.send(JSON.stringify({ type: "session_deleted", ok: false, error: "Ungueltiger Pfad" }));
@@ -1300,13 +1886,11 @@ async function handleDeleteSession(clientWs, sessionPath) {
 }
 
 // ── Session-Aufloesung: letzte aktive Session finden ────
+// Wird nach Gateway-(Re-)Connect aufgerufen. Darf die explizit gewaehlte
+// Session NIE ueberschreiben — nur beim absoluten Erststart auto-picken.
 async function resolveActiveSession() {
-  // Nur bei Fallback-Key "main" automatisch aufloesen — gespeicherte Wahl respektieren
-  const hasSavedSession = (() => {
-    try { return !!fs.readFileSync(SESSION_KEY_FILE, "utf-8").trim(); } catch { return false; }
-  })();
-  if (hasSavedSession && activeSessionKey !== "main") {
-    log("info", "server", `Gespeicherte Session '${activeSessionKey}' wird beibehalten`);
+  if (sessionFromFile) {
+    log("info", "server", `Session '${activeSessionKey}' aus /data — keine Auto-Wahl`);
     return;
   }
 
@@ -1325,10 +1909,19 @@ async function resolveActiveSession() {
   const keys = entries.map(e => (e.key || e.sessionKey || e.name || "?").replace(/^agent:main:/, ""));
   log("info", "server", `Verfuegbare Sessions: [${keys.join(", ")}]`);
 
-  // Neueste Session nehmen
+  // Neueste Session nehmen — aber user-definierte bevorzugen.
+  // aria-bridge / aria-diagnostic werden von den Services auto-erstellt;
+  // bei erstem Start soll lieber eine "echte" Session gewaehlt werden,
+  // falls vorhanden.
+  const AUTO_KEYS = new Set(["aria-bridge", "aria-diagnostic"]);
+  const normalise = (e) => (e.key || e.sessionKey || e.name || "").replace(/^agent:main:/, "");
+
+  const userEntries = entries.filter(e => !AUTO_KEYS.has(normalise(e)));
+  const pool = userEntries.length > 0 ? userEntries : entries;
+
   let newest = null;
   let newestTime = 0;
-  for (const entry of entries) {
+  for (const entry of pool) {
     const t = entry.updatedAt || entry.createdAt || 0;
     if (t >= newestTime) {
       newestTime = t;
@@ -1337,12 +1930,11 @@ async function resolveActiveSession() {
   }
 
   if (newest) {
-    const rawKey = newest.key || newest.sessionKey || newest.name || "";
-    const key = rawKey.replace(/^agent:main:/, "");
+    const key = normalise(newest);
     if (key) {
       activeSessionKey = key;
-      try { fs.writeFileSync(SESSION_KEY_FILE, activeSessionKey); } catch {}
-      log("info", "server", `Aktive Session auf neueste gewechselt: '${activeSessionKey}'`);
+      persistActiveSession(activeSessionKey);
+      log("info", "server", `Auto-Wahl Erststart: '${activeSessionKey}'`);
       for (const c of browserClients) {
         c.send(JSON.stringify({ type: "active_session", sessionKey: activeSessionKey }));
       }
@@ -1431,8 +2023,11 @@ function handleSetActiveSession(clientWs, sessionKey) {
     return;
   }
   activeSessionKey = sessionKey;
-  try { fs.writeFileSync(SESSION_KEY_FILE, activeSessionKey); } catch {}
-  log("info", "server", `Aktive Session: ${activeSessionKey}`);
+  const ok = persistActiveSession(activeSessionKey);
+  log("info", "server", `Aktive Session: ${activeSessionKey}${ok ? "" : " (WARN: nicht persistiert!)"}`);
+  if (!ok) {
+    clientWs.send(JSON.stringify({ type: "active_session", ok: false, sessionKey: activeSessionKey, error: "Persistierung fehlgeschlagen — /data Volume pruefen" }));
+  }
   // Allen Clients mitteilen
   for (const c of browserClients) {
     c.send(JSON.stringify({ type: "active_session", sessionKey: activeSessionKey }));
@@ -1448,7 +2043,7 @@ async function handleCreateSession(clientWs, sessionName) {
   try {
     // Session wird automatisch erstellt wenn man die erste Nachricht sendet
     activeSessionKey = sessionName;
-    try { fs.writeFileSync(SESSION_KEY_FILE, activeSessionKey); } catch {}
+    persistActiveSession(activeSessionKey);
     log("info", "server", `Neue Session erstellt und aktiviert: ${sessionName}`);
     // Allen Clients mitteilen
     for (const c of browserClients) {

docker-compose.yml

@@ -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
@@ -72,6 +74,7 @@ services:
     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 +100,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 +114,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:

issue.md

@@ -0,0 +1,81 @@
+# 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)
+- [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)
+- [x] Highlight-Trigger konfigurierbar in Diagnostic
+- [x] XTTS v2 Integration (Gaming-PC, GPU, Voice Cloning)
+- [x] XTTS Voice Cloning (Audio-Samples hochladen, eigene Stimme)
+- [x] TTS Engine waehlbar (Piper/XTTS) in Diagnostic + App
+- [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 (verhindert dass Umgebungsgeraeusche an Whisper gehen)
+- [x] Session-Persistenz: Gewaehlte Session bleibt ueber Container-Restarts erhalten (sessionFromFile-Flag, atomic write)
+- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen (pipelineEnd broadcastet immer idle, auch bei Timeout/Fehler/Disconnect)
+- [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 in Bridge, Default auf medium
+- [x] App: Audio-Aufnahme explizit 16kHz mono (spart Resample, optimal fuer Whisper)
+- [x] Gespraechsmodus: Speech-Gate strenger (-28dB / 500ms) — keine Umgebungsgeraeusche mehr
+- [x] Gespraechsmodus: Max-Dauer 30s pro Aufnahme, Cache-Cleanup alter Files, Messages-Array gekappt (500)
+- [x] Diagnostic: Archivierte Session-Versionen (.reset.*) werden angezeigt + exportierbar — OpenClaw resettet Sessions bei erster Nutzung nach Container-Restart, Inhalt ist aber in .reset.<timestamp> Dateien gesichert
+- [x] tools/export-jsonl-to-md.js: CLI-Konverter fuer beliebige Session-JSONL zu Markdown
+- [x] NO_REPLY-Filter in Bridge + Diagnostic — still verworfen (kein Chat, kein TTS)
+- [x] Audio-Ducking + Exklusiv-Focus (Kotlin AudioFocusModule): andere Apps leiser bei TTS, pausiert bei Aufnahme
+- [x] TTS-Cleanup serverseitig: Code-Bloecke raus, Einheiten ausgeschrieben (22GB → Gigabyte), Abkuerzungen buchstabiert (CPU), URLs zu "ein Link". `<voice></voice>` Tag wird bevorzugt wenn ARIA ihn liefert.
+- [x] QR-Code Onboarding: Diagnostic generiert QR, App scannt (bestehender QRScanner funktioniert out of the box)
+- [x] TTS-Audio-Cache im Filesystem: Piper-Audio wird mit messageId verknuepft, als WAV in DocumentDirectory/tts_cache gespeichert, Play-Button spielt aus Cache statt regenerieren
+- [x] Config via Diagnostic: RVS-Credentials + Aria-Auth-Token via /api/runtime-config, persistiert in /shared/config/runtime.json, Bridge liest beim Start (Overrides der ENV)
+
+## Offen
+
+### Bugs (Prioritaet)
+- [ ] App: Audioausgabe hoert ab und zu einfach auf (mitten im Satz oder zwischen Chunks)
+- [ ] NO_REPLY wird als "NO" im Chat angezeigt — sollte still verworfen werden (Token nicht gesaeubert)
+
+### App Features
+- [ ] Wake Word on-device (Porcupine "ARIA" Keyword, Phase 2 — passives Lauschen)
+- [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
+- [ ] Background Audio Service (TTS auch bei minimierter App)
+- [ ] Audio-Ducking: andere App-Audio-Ausgaben leiser stellen waehrend ARIA spricht (AudioFocus API)
+- [ ] Audio-Muten waehrend Aufnahme/Ohr-Modus: andere Audio stumm (wie WhatsApp-Sprachaufnahme)
+- [ ] Spracheingabe-Timeout erhoehen fuer laengere Texte
+- [ ] Generierte TTS-Audiodaten in der Chat-Nachricht einbetten (oder lokal cachen), Play-Button spielt aus Cache statt Regenerierung via XTTS. Base64 im Tag <soundfile></soundfile> (invisible) oder lokaler Datei-Cache mit Referenz in der Message.
+- [ ] QR-Code Onboarding: Diagnostic generiert QR mit RVS-Credentials, App scannt — keine manuelle Eingabe mehr
+
+### TTS / Audio
+- [ ] XTTS Audio-Streaming (PCM-Stream statt WAV-Dateien, eliminiert Stottern komplett)
+- [ ] Audio-Normalisierung (Lautstaerke zwischen Chunks angleichen)
+- [ ] Piper Voices Download ueber Diagnostic (neue Sprachen/Stimmen)
+- [ ] TTS-Text-Aufbereitung: Code-Bloecke rausfiltern, Einheiten ausschreiben ("22GB" → "zweiundzwanzig Gigabyte"). Zwei Varianten denkbar: (a) server-side Cleanup in Bridge, (b) ARIA schreibt `<voice></voice>` Block der in UI hidden bleibt aber fuer TTS genutzt wird.
+- [ ] Piper evtl. komplett entfernen (klingt schlecht vs. XTTS) — oder nur als Fallback wenn XTTS offline ist
+
+### 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 (kein File-Sync mehr noetig, da alle ARIA-Container auf der gleichen VM laufen). Fallback .env bleibt fuer initialen Bootstrap.
+- [ ] XTTS-Container: 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 (abortedLastRun / systemSent Theorie pruefen, ggf. Flag preemptiv patchen)

release.sh

@@ -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}"

rvs/docker-compose.yml

@@ -4,5 +4,7 @@ services:
     ports:
       - "${RVS_PORT:-443}:3000"
     restart: always
+    volumes:
+      - ./updates:/updates                # APK-Dateien fuer Auto-Update
     environment:
       - MAX_SESSIONS=10

rvs/server.js

@@ -1,14 +1,22 @@
 "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",
 ]);
 
 // Token-Raum: token -> { clients: Set<ws> }
@@ -45,6 +53,9 @@ const wss = new WebSocketServer({ port: PORT });
 
 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 +117,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 +223,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", () => {

tools/export-jsonl-to-md.js

@@ -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);
+}

xtts/.env.example

@@ -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

xtts/Dockerfile

@@ -0,0 +1,5 @@
+FROM node:22-alpine
+WORKDIR /app
+COPY bridge.js package.json ./
+RUN npm install --production
+CMD ["node", "bridge.js"]

xtts/bridge.js

@@ -0,0 +1,312 @@
+/**
+ * ARIA XTTS Bridge — Verbindet XTTS v2 Server mit dem RVS
+ *
+ * Empfaengt tts_request ueber RVS → rendert Audio via XTTS API → sendet zurueck
+ * Empfaengt voice_upload → speichert Voice-Sample fuer Cloning
+ * Empfaengt xtts_list_voices → listet verfuegbare Stimmen
+ */
+
+const WebSocket = require("ws");
+const http = require("http");
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+
+const XTTS_API_URL = process.env.XTTS_API_URL || "http://xtts:8000";
+const RVS_HOST = process.env.RVS_HOST || "";
+const RVS_PORT = process.env.RVS_PORT || "443";
+const RVS_TLS = process.env.RVS_TLS || "true";
+const RVS_TLS_FALLBACK = process.env.RVS_TLS_FALLBACK || "true";
+const RVS_TOKEN = process.env.RVS_TOKEN || "";
+const VOICES_DIR = "/voices";
+
+function log(msg) {
+  console.log(`[${new Date().toISOString()}] ${msg}`);
+}
+
+// ── RVS Verbindung ──────────────────────────────────
+
+let rvsWs = null;
+let retryDelay = 2;
+
+function connectRVS(forcePlain) {
+  if (!RVS_HOST || !RVS_TOKEN) {
+    log("RVS nicht konfiguriert — beende");
+    process.exit(1);
+  }
+
+  const useTls = RVS_TLS === "true" && !forcePlain;
+  const proto = useTls ? "wss" : "ws";
+  const url = `${proto}://${RVS_HOST}:${RVS_PORT}?token=${RVS_TOKEN}`;
+
+  log(`Verbinde zu RVS: ${proto}://${RVS_HOST}:${RVS_PORT}`);
+
+  const ws = new WebSocket(url);
+
+  ws.on("open", () => {
+    log("RVS verbunden — warte auf TTS-Requests");
+    rvsWs = ws;
+    retryDelay = 2;
+
+    // Keepalive
+    setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.ping();
+        ws.send(JSON.stringify({ type: "heartbeat", timestamp: Date.now() }));
+      }
+    }, 25000);
+  });
+
+  ws.on("message", async (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+
+      if (msg.type === "xtts_request") {
+        await handleTTSRequest(msg.payload);
+      } else if (msg.type === "voice_upload") {
+        await handleVoiceUpload(msg.payload);
+      } else if (msg.type === "xtts_list_voices") {
+        await handleListVoices();
+      }
+    } catch (err) {
+      log(`Fehler: ${err.message}`);
+    }
+  });
+
+  ws.on("close", () => {
+    log("RVS Verbindung geschlossen");
+    rvsWs = null;
+    setTimeout(() => connectRVS(), Math.min(retryDelay * 1000, 30000));
+    retryDelay = Math.min(retryDelay * 2, 30);
+  });
+
+  ws.on("error", (err) => {
+    log(`RVS Fehler: ${err.message}`);
+    if (useTls && RVS_TLS_FALLBACK === "true") {
+      log("TLS fehlgeschlagen — Fallback auf ws://");
+      ws.removeAllListeners();
+      try { ws.close(); } catch (_) {}
+      connectRVS(true);
+    }
+  });
+}
+
+// ── TTS Request Handler ─────────────────────────────
+
+async function handleTTSRequest(payload) {
+  const { text, voice, requestId, language } = payload;
+  if (!text) return;
+
+  // Markdown + Sonderzeichen entfernen fuer natuerliche Sprache
+  let cleanText = text
+    .replace(/\*\*([^*]+)\*\*/g, "$1")     // **fett** → fett
+    .replace(/\*([^*]+)\*/g, "$1")          // *kursiv* → kursiv
+    .replace(/`([^`]+)`/g, "$1")            // `code` → code
+    .replace(/```[\s\S]*?```/g, "")         // Code-Bloecke entfernen
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1") // [text](url) → text
+    .replace(/#{1,6}\s*/g, "")              // ### Ueberschriften → entfernen
+    .replace(/>\s*/g, "")                   // > Zitate → entfernen
+    .replace(/[-*]\s+/g, "")               // - Listen → entfernen
+    .replace(/\n{2,}/g, ". ")               // Mehrere Newlines → Punkt
+    .replace(/\n/g, ", ")                   // Einzelne Newlines → Komma
+    .replace(/\s{2,}/g, " ")               // Mehrfach-Leerzeichen
+    .replace(/["""„]/g, "")                 // Anfuehrungszeichen entfernen
+    .replace(/\(\)/g, "")                   // Leere Klammern
+    .trim();
+
+  // Text in Saetze aufteilen, dann zu Chunks von 2-3 Saetzen zusammenfassen
+  // (mehr Kontext = konsistentere Stimme/Lautstaerke, aber nicht zu lang fuer WebSocket)
+  const sentences = cleanText.split(/(?<=[.!?])\s+/)
+    .map(s => s.trim())
+    .filter(s => s.length > 0)
+    .map(s => s.replace(/[.]+$/, '')); // Punkt am Ende entfernen
+
+  const MAX_CHUNK_CHARS = 150; // Max ~150 Zeichen pro Chunk (schnelles Rendering, Preloading reicht)
+  const chunks = [];
+  let currentChunk = '';
+  for (const sentence of sentences) {
+    if (currentChunk && (currentChunk.length + sentence.length + 2) > MAX_CHUNK_CHARS) {
+      chunks.push(currentChunk);
+      currentChunk = sentence;
+    } else {
+      currentChunk = currentChunk ? currentChunk + ', ' + sentence : sentence;
+    }
+  }
+  if (currentChunk) chunks.push(currentChunk);
+  if (chunks.length === 0) return;
+
+  log(`TTS-Request: "${cleanText.slice(0, 60)}..." (${sentences.length} Saetze → ${chunks.length} Chunks, voice: ${voice || "default"}, lang: ${language || "de"})`);
+
+  try {
+    const voiceSample = voice ? path.join(VOICES_DIR, `${voice}.wav`) : null;
+    const hasCustomVoice = voiceSample && fs.existsSync(voiceSample);
+
+    // Streaming: Chunk rendern → sofort senden → naechster Chunk
+    // App spielt mit Preloading-Queue nahtlos ab
+    let sentCount = 0;
+
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      try {
+        const audioBuffer = await callXTTSAPI(chunk, language || "de", hasCustomVoice ? voiceSample : null);
+
+        if (audioBuffer && audioBuffer.length > 100) {
+          log(`TTS [${i + 1}/${chunks.length}]: ${(audioBuffer.length / 1024).toFixed(0)}KB — "${chunk.slice(0, 50)}"`);
+
+          sendToRVS({
+            type: "xtts_response",
+            payload: {
+              requestId: `${requestId || ""}_${i}`,
+              base64: audioBuffer.toString("base64"),
+              mimeType: "audio/wav",
+              voice: voice || "default",
+              engine: "xtts",
+              part: i + 1,
+              totalParts: chunks.length,
+            },
+            timestamp: Date.now(),
+          });
+          sentCount++;
+        }
+      } catch (chunkErr) {
+        log(`TTS [${i + 1}/${chunks.length}] Fehler: ${chunkErr.message} — ueberspringe`);
+      }
+    }
+
+    log(`TTS komplett: ${sentCount}/${chunks.length} Chunks gestreamt`);
+  } catch (err) {
+    log(`TTS Fehler: ${err.message}`);
+    sendToRVS({
+      type: "xtts_response",
+      payload: { requestId, error: err.message },
+      timestamp: Date.now(),
+    });
+  }
+}
+
+function callXTTSAPI(text, language, speakerWav) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      text,
+      language,
+      speaker_wav: speakerWav || "",
+    });
+
+    const url = new URL(`${XTTS_API_URL}/tts_to_audio/`);
+    const options = {
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body),
+      },
+      timeout: 60000,
+    };
+
+    const req = http.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        if (res.statusCode === 200) {
+          resolve(Buffer.concat(chunks));
+        } else {
+          reject(new Error(`XTTS API HTTP ${res.statusCode}: ${Buffer.concat(chunks).toString().slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("XTTS API Timeout (60s)")); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// ── Voice Upload Handler ────────────────────────────
+
+async function handleVoiceUpload(payload) {
+  const { name, samples } = payload;
+  if (!name || !samples || !Array.isArray(samples) || samples.length === 0) {
+    log("Voice Upload: Ungueltige Daten");
+    return;
+  }
+
+  log(`Voice Upload: "${name}" (${samples.length} Samples)`);
+
+  try {
+    // Alle Samples zusammenfuegen
+    const buffers = samples.map(s => Buffer.from(s.base64, "base64"));
+    const combined = Buffer.concat(buffers);
+
+    // Als WAV speichern
+    fs.mkdirSync(VOICES_DIR, { recursive: true });
+    const filePath = path.join(VOICES_DIR, `${name.replace(/[^a-zA-Z0-9_-]/g, "_")}.wav`);
+    fs.writeFileSync(filePath, combined);
+
+    log(`Voice gespeichert: ${filePath} (${(combined.length / 1024).toFixed(0)}KB)`);
+
+    sendToRVS({
+      type: "xtts_voice_saved",
+      payload: { name, size: combined.length, path: filePath },
+      timestamp: Date.now(),
+    });
+  } catch (err) {
+    log(`Voice Upload Fehler: ${err.message}`);
+  }
+}
+
+// ── Voice List Handler ──────────────────────────────
+
+async function handleListVoices() {
+  try {
+    const files = fs.existsSync(VOICES_DIR)
+      ? fs.readdirSync(VOICES_DIR).filter(f => f.endsWith(".wav"))
+      : [];
+
+    const voices = files.map(f => ({
+      name: path.basename(f, ".wav"),
+      file: f,
+      size: fs.statSync(path.join(VOICES_DIR, f)).size,
+    }));
+
+    log(`Stimmen: ${voices.length} verfuegbar`);
+
+    sendToRVS({
+      type: "xtts_voices_list",
+      payload: { voices },
+      timestamp: Date.now(),
+    });
+  } catch (err) {
+    log(`Stimmen-Liste Fehler: ${err.message}`);
+  }
+}
+
+// ── RVS senden ──────────────────────────────────────
+
+function sendToRVS(msg) {
+  if (rvsWs && rvsWs.readyState === WebSocket.OPEN) {
+    rvsWs.send(JSON.stringify(msg));
+  }
+}
+
+// ── Start ───────────────────────────────────────────
+
+log("ARIA XTTS Bridge startet...");
+log(`XTTS API: ${XTTS_API_URL}`);
+log(`RVS: ${RVS_HOST}:${RVS_PORT}`);
+
+// Warten bis XTTS API erreichbar ist
+function waitForXTTS(callback, attempts) {
+  if (attempts <= 0) { log("XTTS API nicht erreichbar — starte trotzdem"); callback(); return; }
+  http.get(`${XTTS_API_URL}/docs`, (res) => {
+    log(`XTTS API erreichbar (HTTP ${res.statusCode})`);
+    callback();
+  }).on("error", () => {
+    log(`XTTS API noch nicht bereit — warte (${attempts} Versuche uebrig)...`);
+    setTimeout(() => waitForXTTS(callback, attempts - 1), 10000); // 10s statt 5s (Model laden dauert)
+  });
+}
+
+waitForXTTS(() => connectRVS(), 30); // Max 5min warten

xtts/docker-compose.yml

@@ -0,0 +1,56 @@
+# ════════════════════════════════════════════════
+#  ARIA XTTS v2 — GPU TTS Server
+#  Laeuft auf dem Gaming-PC (RTX 3060)
+#  Verbindet sich zum RVS fuer TTS-Requests
+# ════════════════════════════════════════════════
+#
+#  Voraussetzungen:
+#    - Docker Desktop mit WSL2
+#    - NVIDIA Container Toolkit
+#    - .env mit RVS-Verbindungsdaten
+#
+#  Start: docker compose up -d
+#  Test:  curl http://localhost:8000/docs
+# ════════════════════════════════════════════════
+
+services:
+
+  # ─── XTTS v2 API Server (GPU) ─────────────────
+  xtts:
+    image: daswer123/xtts-api-server:latest
+    container_name: aria-xtts
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    ports:
+      - "8000:8020"
+    volumes:
+      - xtts-models:/app/xtts_models             # Model-Cache (~2GB)
+      - ./voices:/voices                        # Custom Voice Samples
+    environment:
+      - COQUI_TOS_AGREED=1
+    restart: unless-stopped
+
+  # ─── XTTS Bridge (verbindet zu RVS) ───────────
+  xtts-bridge:
+    build: .
+    container_name: aria-xtts-bridge
+    depends_on:
+      - xtts
+    volumes:
+      - ./voices:/voices                        # Shared mit XTTS-Server
+    environment:
+      - XTTS_API_URL=http://xtts:8020
+      - 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}
+    restart: unless-stopped
+
+volumes:
+  xtts-models:

xtts/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "aria-xtts-bridge",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "ws": "^8.16.0"
+  }
+}