fix: WebSocket max_size hochgedreht — voice_upload sprengte Default 1MB

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

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

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

.env.example

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

.gitignore

@@ -9,19 +9,15 @@
 .env.*
 !.env.example
 !.env.*.example
+aria-data/config/*.env
+!aria-data/config/*.env.example
+!aria-data/config/openclaw.env
 
-# Privater User-Profile-Snippet (Tool-Stack, interne URLs) —
-# liegt jetzt in brain-import/ (frueher aria-data/config/USER.md).
-# USER.md.example ist Repo-Inhalt, USER.md lokal selbst anlegen.
-aria-data/brain-import/USER.md
+# ── ARIAs Gedächtnis (nur per tar gesichert) ────
+aria-data/brain/
 
-# ── ARIAs Gedächtnis (Vector-DB, Skills, Models) ──
-# Backup via Diagnostic → Gehirn-Export (tar.gz), nicht via Git.
-aria-data/brain/data/
-aria-data/brain/qdrant/
-
-# Diagnostic-State (aktive Session etc.)
-aria-data/config/diag-state/
+# ── Stimmen (große Binärdateien) ─────────────────
+aria-data/voices/
 
 # ── Node / npm ──────────────────────────────────
 node_modules/
@@ -50,6 +46,7 @@ desktop/dist/
 __pycache__/
 *.pyc
 *.pyo
+bridge/__pycache__/
 
 # ── macOS ────────────────────────────────────────
 .DS_Store

README.md

@@ -57,44 +57,38 @@ ARIA hat zwei Rollen:
 │  ┌─────────────────────────────────────────────────┐    │
 │  │  [proxy]    claude-max-api-proxy Container        │    │
 │  │             Claude Max Sub → lokale API           │    │
+│  │             Port 3456, mit sed-Patches fuer       │    │
+│  │             Tool-Permissions + Host-Binding       │    │
 │  │                                                   │    │
-│  │  [qdrant]   Vector-DB fuer ARIAs Gedaechtnis     │    │
-│  │             Bind-Mount: aria-data/brain/qdrant/  │    │
-│  │                                                   │    │
-│  │  [brain]    ARIA Agent + Memory Container         │    │
-│  │             FastAPI auf Port 8080                 │    │
-│  │             Eigener Agent-Loop, Skills,           │    │
-│  │             Vector-Memory, SSH-Zugriff zur VM     │    │
-│  │             Bind-Mount: aria-data/brain/data/    │    │
+│  │  [aria]     OpenClaw Container (aria-core)        │    │
+│  │             Gateway, Sessions, Memory, Skills     │    │
+│  │             Liest BOOTSTRAP.md + AGENT.md         │    │
 │  │                                                   │    │
 │  │  [bridge]   ARIA Voice Bridge Container           │    │
-│  │             Wake-Word, STT, TTS-Forwarding        │    │
-│  │             Spricht mit Brain via HTTP/8080       │    │
+│  │             Wake-Word (lokales Mikro auf VM)       │    │
+│  │             STT primaer remote (Gamebox-Whisper)   │    │
+│  │             Fallback: lokales faster-whisper (CPU) │    │
+│  │             TTS via F5-TTS auf Gamebox             │    │
+│  │             Bruecke: App <> RVS <> Bridge <> ARIA │    │
 │  │                                                   │    │
 │  │  [diagnostic] Selbstcheck-UI + Einstellungen      │    │
-│  │               Port 3001 (im Netzwerk der Bridge)  │    │
-│  │               Chat, Gehirn, Dateien, Logs         │    │
+│  │               Gateway + RVS + Proxy Status        │    │
+│  │               Chat, Sessions, Login, Logs         │    │
 │  └──────────────────┬──────────────────────────────┘    │
 │                     │ Volume Mount                       │
 │                     ▼                                    │
 │  ┌─────────────────────────────────────────────────┐    │
-│  │  ./aria-data/  — Konfiguration + SSH-Keys         │    │
-│  │  ./aria-data/brain/ — Vector-DB + Skills (gitignored)│
-│  │  Backup via Diagnostic → "Gehirn-Export" (tar.gz) │    │
+│  │  ./aria-data/  — Ein tar = vollstaendiges Backup  │    │
 │  └─────────────────────────────────────────────────┘    │
 └─────────────────────────────────────────────────────────┘
 ```
 
-> OpenClaw (frueher `aria-core`) ist abgerissen — ARIA laeuft jetzt mit eigenem Agent-Framework im
-> `aria-brain` Container. Eigene Tools, Skills, Vector-Memory statt Sessions. Letzter OpenClaw-Stand
-> ist als Git-Tag `v0.1.2.0` archiviert.
-
 **Vier separate Deployments:**
 
 | Was | Wo | Wie |
 |-----|----|-----|
 | RVS | Rechenzentrum | `cd rvs && docker compose up -d` |
-| ARIA Brain/Bridge/Diagnostic | Debian 13 VM | `./init.sh && ./aria-setup.sh && docker compose up -d` |
+| ARIA Core | Debian 13 VM | `docker compose up -d && ./aria-setup.sh` |
 | Gamebox-Stack (F5-TTS + Whisper) | Gamebox (GPU) | `cd xtts && docker compose up -d` |
 | Android App | Stefans Handy | APK installieren (Auto-Update via RVS) |
 
@@ -120,12 +114,12 @@ apt install -y docker.io docker-compose-plugin git curl jq
 git clone git@gitea.hackersoft.de:aria/aria.git ~/ARIA-AGENT
 cd ~/ARIA-AGENT
 cp .env.example .env
-bash init.sh    # legt USER.md aus Vorlage an (idempotent, schadet nicht)
 ```
 
 `.env` Datei editieren (Details siehe `.env.example`):
 ```bash
-# Auth-Token: Alle ARIA-Services nutzen ihn fuer interne Auth
+# 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
@@ -134,18 +128,17 @@ RVS_PORT=443
 RVS_TLS=true
 RVS_TLS_FALLBACK=true
 
-# Pairing-Token: Verbindet App, Bridge, Diagnostic und Gamebox im gleichen RVS-Room
+# 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=
 ```
 
-Alle anderen Einstellungen (Stimmen, Modi, Wake-Word, F5-TTS-Tuning) leben in
-`/shared/config/runtime.json` und werden ueber die Diagnostic-UI gepflegt — nicht
-in der `.env`. Komplett-Reset jederzeit moeglich via "🗑 ALLES löschen" im
-Diagnostic-Einstellungen-Tab.
-
 **Zwei Tokens, zwei Zwecke:**
-- **ARIA_AUTH_TOKEN**: Interner Auth-Token zwischen ARIAs Containern.
+- **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)
@@ -163,24 +156,48 @@ claude login
 **Wichtig:** Der Ordner `~/.claude/` (nicht `~/.config/claude/`!) wird als Volume
 in den Proxy gemountet. Die Credentials ueberleben Container-Restarts.
 
-### 3. SSH-Key fuer aria-wohnung generieren + RVS-Token + Container
+### 3. Voice Bridge konfigurieren
 
 ```bash
-# SSH-Key fuer den Zugriff von ARIA auf die VM (aria-wohnung)
-./aria-setup.sh
+cp aria-data/config/aria.env.example aria-data/config/aria.env
+# Bei Bedarf anpassen (Whisper-Modell als Fallback, Sprache, Wake-Word)
+```
 
-# RVS-Token generieren — schreibt RVS_TOKEN in .env, zeigt QR-Code
+STT laeuft primaer auf der Gamebox (faster-whisper auf GPU), TTS ausschliesslich
+ueber F5-TTS auf der Gamebox — siehe Abschnitt "Gamebox-Stack — F5-TTS + Whisper"
+weiter unten.
+
+### 5. RVS-Token generieren & Container starten
+
+```bash
+# Token generieren — schreibt RVS_TOKEN in .env, zeigt QR-Code
 ./generate-token.sh
 
 # Alle Container starten
 docker compose up -d
 ```
 
-`aria-setup.sh` generiert den ed25519-Key in `aria-data/ssh/` und traegt den
-Public-Key in `/root/.ssh/authorized_keys` ein (Script laeuft als root auf der VM
-aria-wohnung). Brain + Proxy nutzen den gleichen Key.
+### 6. ARIA Setup ausfuehren (einmalig!)
 
-### 4. App verbinden
+```bash
+./aria-setup.sh
+```
+
+Dieses Script ist **essentiell** — es macht:
+1. Wartet bis aria-core laeuft
+2. Fixt Volume-Permissions (Docker → node User)
+3. Schreibt `openclaw.json` (Proxy-Provider, Model-Config, Timeout 900s)
+4. Setzt exec-approvals Wildcard (Tool-Ausfuehrung im headless-Modus)
+5. Generiert SSH-Key fuer VM-Zugriff (`aria-data/ssh/`)
+6. Fixt SSH-Permissions im Container
+7. Startet aria-core neu
+
+**SSH-Key auf der VM eintragen** (wird vom Script angezeigt):
+```bash
+cat ~/ARIA-AGENT/aria-data/ssh/id_ed25519.pub >> /root/.ssh/authorized_keys
+```
+
+### 7. App verbinden
 
 App oeffnen → QR-Code scannen → "ARIA, hoerst du mich?"
 
@@ -188,20 +205,20 @@ Der QR-Code enthaelt: Host, Port, Token, TLS-Flag — einmal scannen, nie wieder
 
 Bestehendes Token nochmal als QR anzeigen: `./generate-token.sh show`
 
-### 5. Diagnostic pruefen
+### 8. Diagnostic pruefen
 
 ```bash
 # Im Browser:
 http://<VM-IP>:3001
 ```
 
-Die Diagnostic-UI hat fünf Top-Tabs:
-
-- **Main** — Live-Chat-Test, Status (Brain / RVS / Proxy), End-to-End-Trace
-- **Gehirn** — Memory-Verwaltung (Vector-DB), Token/Call-Metrics (Subscription-Quota), Bootstrap & Migration, Komplett-Gehirn Export/Import
-- **Skills** — Liste mit Logs, Run, Activate/Deactivate, Export/Import als tar.gz
-- **Dateien** — alle Dateien aus `/shared/uploads/` mit Multi-Select, Bulk-Download (ZIP) + Bulk-Delete
-- **Einstellungen** — Reparatur (Container-Restart), Wipe, Sprachausgabe, Whisper, Sprachmodell, Runtime-Config, App-Onboarding (QR), Komplett-Reset
+Die Diagnostic-UI zeigt:
+- Gateway-Verbindung (gruener Punkt = OK)
+- RVS-Verbindung
+- Proxy-Status + Claude Login
+- Chat-Test (direkt an ARIA schreiben)
+- Session-Verwaltung
+- Container-Logs
 
 ---
 
@@ -209,7 +226,7 @@ Die Diagnostic-UI hat fünf Top-Tabs:
 
 Der Proxy ist das Herzsttueck: Er macht aus der Claude Max Subscription eine lokale API.
 
-**Ablauf:** `aria-brain → HTTP → claude-max-api-proxy → Claude Code CLI (--print) → Anthropic API`
+**Ablauf:** `OpenClaw (aria-core) → HTTP → claude-max-api-proxy → Claude Code CLI (--print) → Anthropic API`
 
 Der Proxy-Container (`node:22-alpine`) installiert bei jedem Start:
 - `@anthropic-ai/claude-code` — Claude Code CLI
@@ -230,34 +247,52 @@ Danach werden per `sed` vier Patches angewendet:
 
 ## Konfigurationsdateien
 
-### aria-data/
+### aria-data/config/
 
-| Pfad | Zweck |
-|------|-------|
-| `.env` | Tokens (ARIA_AUTH_TOKEN, RVS_TOKEN, RVS_HOST) — minimal, alles andere lebt in der DB |
-| `aria-data/ssh/` | SSH-Key fuer den Zugriff auf aria-wohnung (Brain + Proxy teilen den Key) |
-| `aria-data/brain/qdrant/` | Vector-DB-Storage (Bind-Mount, gitignored) |
-| `aria-data/brain/data/` | Skills, Embedding-Modell-Cache (Bind-Mount, gitignored) |
-| `aria-data/brain-import/` | `AGENT.md`, `USER.md.example`, `TOOLING.md.example` — Quelle fuer den initialen Memory-Import in die Vector-DB |
-| `aria-data/config/diag-state/` | Diagnostic State (z.B. zuletzt aktive Session) |
+| Datei | Zweck | Gemountet als |
+|-------|-------|---------------|
+| `BOOTSTRAP.md` | ARIAs System-Prompt: Identitaet, Sicherheitsregeln, Tool-Freigaben, Infrastruktur | `BOOTSTRAP.md` + `CLAUDE.md` im Workspace |
+| `AGENT.md` | ARIAs Persoenlichkeit, Tool-Freigaben, Arbeitsprinzipien | `AGENT.md` im Workspace |
+| `USER.md` | Stefans Praeferenzen, Kommunikationsstil | `USER.md` im Workspace |
+| `openclaw.env` | OpenClaw Container-Environment | `.env` im Workspace |
+| `aria.env` | Voice Bridge Konfiguration (Whisper, Stimmen) | `/config/aria.env` in Bridge |
 
-### /shared/config/ (im aria-shared Volume)
+**BOOTSTRAP.md** ist die wichtigste Datei — sie definiert:
+- Wer ARIA ist (Name, Rolle, Persoenlichkeit)
+- Sicherheitsregeln (kein ClawHub, Prompt Injection abwehren)
+- Tool-Freigaben (alle Claude Code Tools: WebFetch, Bash, etc.)
+- SSH-Zugriff auf aria-wohnung (VM)
+- Gedaechtnis-System
 
-| Datei | Zweck |
-|-------|-------|
-| `voice_config.json` | TTS-Engine, geclonte Stimme, Whisper-Modell, F5-TTS-Tuning |
-| `runtime.json` | Token + RVS-Override + Whisper-Sprache (durch Diagnostic gepflegt) |
-| `highlight_triggers.json` | Highlight-Trigger-Woerter |
-| `chat_backup.jsonl` | Append-only Chat-Log (Quelle fuer die Chat-History in Diagnostic) |
+### openclaw.json (via aria-setup.sh)
 
-`voice_config.json` + `highlight_triggers.json` lassen sich via Diagnostic →
-"Sprachausgabe" als Bundle exportieren/importieren.
+Wird von `aria-setup.sh` in den Container geschrieben:
+```json
+{
+  "agents": {
+    "defaults": {
+      "model": { "primary": "proxy/claude-sonnet-4" },
+      "timeoutSeconds": 900,
+      "maxConcurrent": 4
+    }
+  },
+  "models": {
+    "providers": {
+      "proxy": {
+        "api": "openai-completions",
+        "baseUrl": "http://proxy:3456/v1",
+        "apiKey": "not-needed"
+      }
+    }
+  },
+  "tools": { "profile": "full" },
+  "messages": { "ackReactionScope": "all" }
+}
+```
 
-### Backup / Reset
-
-- **Gehirn-Backup**: Diagnostic → Gehirn → "⬇ Export herunterladen" — komplettes Brain (Memories + Skills + Qdrant-DB) als `.tar.gz`
-- **Stimmen-Backup**: pro Stimme ein `.tar.gz` (Diagnostic → Sprachausgabe → ⬇ pro Stimme); Import via Upload-Button
-- **Komplett-Reset**: Diagnostic → Einstellungen → "🗑 ALLES löschen" — Memory + Stimmen + Settings weg; `.env` + SSH-Keys bleiben
+**timeoutSeconds: 900** (15 Min) — notwendig weil jede Anfrage einen neuen
+`claude --print` Prozess spawnt (Cold Start). Bei Tool-Nutzung (WebFetch, Bash)
+braucht ARIA mehrere API-Roundtrips.
 
 ---
 
@@ -268,14 +303,14 @@ auf der Gamebox.
 
 **Nachrichtenfluss:**
 ```
-Text:   App → RVS → Bridge → aria-brain (HTTP)
+Text:   App → RVS → Bridge → chat.send → aria-core
 Audio:  App → RVS → Bridge → stt_request (RVS) → whisper-bridge (Gamebox)
-                          → stt_response → Bridge → aria-brain
+                          → stt_response → Bridge → chat.send → aria-core
         Fallback bei Timeout: lokales faster-whisper (CPU)
-Datei:  App → RVS → Bridge → /shared/uploads/ → aria-brain (mit Pfad)
+Datei:  App → RVS → Bridge → /shared/uploads/ → chat.send (mit Pfad) → aria-core
 
-aria-brain → Antwort → Bridge → RVS → App
-                              → xtts_request (RVS) → f5tts-bridge
+aria-core → Antwort → Gateway → Diagnostic → RVS → App
+                              → Bridge → xtts_request (RVS) → f5tts-bridge
                               → audio_pcm Stream → RVS → App AudioTrack
 ```
 
@@ -307,25 +342,34 @@ aria-brain → Antwort → Bridge → RVS → App
 
 ## Diagnostic — Selbstcheck-UI und Einstellungen
 
-Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
+Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit aria-core.
 
-### Tabs
+### Features
 
-- **Main**: Brain/RVS/Proxy-Status, Chat-Test, "ARIA denkt..."-Indikator, End-to-End-Trace, Container-Logs
-- **Gehirn**: Memory-Browser (Vector-DB), Suche + Filter, Edit/Add/Delete, Konversation-Status mit Destillat-Trigger, **Token/Call-Metrics mit Subscription-Quota-Tracking**, Bootstrap & Migration (3 Wiederherstellungs-Wege), Gehirn-Export/Import (tar.gz). Info-Buttons (ℹ) ueberall mit Modal-Erklaerung.
-- **Skills**: Liste aller Skills mit Logs pro Run, Activate/Deactivate, Export/Import als tar.gz, "von ARIA"-Badge fuer selbst gebaute
-- **Dateien**: Browser fuer `/shared/uploads/` mit Multi-Select + "Alle markieren" + Bulk-Download (ZIP bei 2+) + Bulk-Delete. Live-Update der Chat-Bubbles beim Delete.
-- **Einstellungen**: Reparatur (Container-Restart fuer Brain/Bridge/Qdrant), Komplett-Reset, Betriebsmodi, Sprachausgabe + Voice-Cloning + F5-TTS-Tuning + Voice Export/Import, Whisper, Sprachmodell (brainModel), Onboarding-QR, App-Cleanup
-
-### Was zusaetzlich noch drin steckt
-
-- **Disk-Voll Banner** mit copy-baren Cleanup-Befehlen (safe + aggressiv)
-- **Token/Call-Metrics**: pro Claude-Call ein Eintrag in `/data/metrics.jsonl` mit ts + Token-Schaetzung. Gehirn-Tab zeigt 1h/5h/24h/30d-Aggregat plus Progress-Bar gegen Plan-Limit (Pro / Max 5x / Max 20x / Custom). Warn-Schwelle 80%, kritisch 90%.
-- **Voice Cloning**: Audio-Samples hochladen, Whisper transkribiert den Ref-Text automatisch
-- **Voice Export/Import**: einzelne Stimmen als `.tar.gz` zwischen Gameboxen mitnehmen
-- **Settings Export/Import**: `voice_config.json` + `highlight_triggers.json` als JSON-Bundle
+- **Status-Karten**: Gateway (Handshake), RVS (TLS-Fallback), Proxy (Auth)
+- **Disk-Voll Banner**: Rotes Overlay wenn die VM-Disk knapp wird, mit copy-baren Cleanup-Befehlen (safe + aggressiv)
+- **Chat-Test**: Nachrichten direkt an ARIA senden (Gateway oder via RVS), Vollbild-Modus
+- **"ARIA denkt..." Indikator**: Zeigt live was ARIA gerade tut (Denken, Tool, Schreiben)
+- **Abbrechen-Button**: Stoppt laufende Anfragen + doctor --fix
+- **Session-Verwaltung**: Sessions auflisten, wechseln, erstellen, loeschen, als Markdown exportieren (⬇ Button)
+- **Chat-History**: Wird beim Laden und Session-Wechsel angezeigt (read-only aus JSONL)
+- **TTS-Diagnose Tab**: Stimmen testen, Status pruefen, Fehler anzeigen
+- **Einstellungen**: TTS aktiv-Toggle, F5-TTS-Voice (gecloned), Betriebsmodi, Whisper-Modell (tiny…large-v3, Hot-Reload auf der Gamebox)
+- **Voice-Status**: Beim Wechsel der globalen Stimme zeigt ein Status-Text "Lade…" → "bereit (X.Ys)" — getriggert ueber `voice_preload`/`voice_ready`
+- **Voice Cloning**: Audio-Samples hochladen, Referenz-Text wird automatisch via Whisper transkribiert
 - **Claude Login**: Browser-Terminal zum Einloggen in den Proxy
-- **SSH Terminal**: direkter SSH-Zugang zu aria-wohnung
+- **Core Terminal**: Shell in aria-core (openclaw CLI)
+- **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
+
+Die in der Diagnostic gewaehlte Session gilt **global** — Bridge und App nutzen
+dieselbe Session. Die aktive Session wird unter `/data/active-session` persistiert
+und ueberlebt Container-Restarts.
+
+API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 
 ---
 
@@ -334,13 +378,9 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 ### Features
 
 - Text-Chat mit ARIA
-- **Sprachaufnahme**: Tap-to-Talk (tippen startet, tippen stoppt, Auto-Stop bei Stille via VAD)
+- **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
 - **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
-- **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
-- **VAD (Voice Activity Detection)**: Adaptive Schwelle (Baseline aus ersten 500ms Mic-Pegel + 6dB Offset). Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme einstellbar (1–30 min, Default 5 min)
-- **Barge-In**: Wenn du waehrend ARIAs Antwort eine neue Sprach-/Text-Nachricht reinschickst, wird sie unterbrochen + bekommt den Hint "das ist eine Korrektur"
-- **Wake-Word waehrend TTS**: Du kannst "Computer" sagen waehrend ARIA noch redet — AcousticEchoCanceler verhindert dass ARIAs eigene Stimme das Wake-Word triggert
-- **Anruf-Pause + Auto-Resume**: TTS verstummt bei klassischem Anruf oder VoIP-Call (WhatsApp/Signal/Discord). Nach dem Auflegen geht ARIA von der **genauen Stelle** weiter wo sie unterbrochen wurde — die App misst die Position vom Wiedergabe-Anfang und nutzt den WAV-Cache der Antwort
+- **VAD (Voice Activity Detection)**: Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme 120s.
 - **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
 - **STT (Speech-to-Text)**: 16kHz mono → Bridge → Gamebox-Whisper (CUDA) → Text im Chat. Fast in Echtzeit.
 - **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
@@ -353,53 +393,10 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 - **Mehrere Anhaenge**: Bilder + Dateien sammeln, Text hinzufuegen, dann zusammen senden
 - **Paste-Support**: Bilder aus Zwischenablage einfuegen (Diagnostic)
 - **Anhaenge**: Bridge speichert in Shared Volume, ARIA kann darauf zugreifen, Re-Download ueber RVS
-- **Einstellungen**: TTS-aktiv, F5-TTS-Voice, Pre-Roll-Buffer, Stille-Toleranz, Speicherort, Auto-Download, GPS, Verbose-Logging
+- **Einstellungen**: TTS-aktiv, F5-TTS-Voice, Pre-Roll-Buffer, Stille-Toleranz, Speicherort, Auto-Download, GPS
 - **Auto-Update**: Prueft beim Start + per Button auf neue Version, Download + Installation ueber RVS (FileProvider)
-- GPS-Position (optional, mit Runtime-Permission-Request) — wird in jeden Chat/Audio-Payload mitgegeben und ist in Diagnostic als Debug-Block einblendbar
+- GPS-Position (optional)
 - QR-Code Scanner fuer Token-Pairing
-- **ARIA-Dateien empfangen**: Wenn ARIA eine PDF/Bild/Markdown/ZIP fuer dich erstellt (Marker `[FILE: /shared/uploads/aria_*]` in der Antwort), erscheint sie als eigene Anhang-Bubble. Tippen → wird via RVS geladen + mit Android-Intent-Picker geoeffnet (PDF-Viewer, Bildbetrachter, Standard-App). Inline-Bilder aus Markdown-`![alt](url)`-Syntax werden direkt unter dem Text gerendert (PNG/JPG via Image, SVG via react-native-svg)
-- **Vollbild mit Pinch-Zoom**: Bilder im Vollbild-Modal sind pinch-zoombar (1x..5x), 1-Finger-Pan wenn gezoomt, Doppel-Tap toggelt 1x↔2.5x — alles ohne externe Lib
-- **Container-Restart-Buttons** (Settings → Reparatur): aria-bridge / aria-brain / aria-qdrant gezielt neu starten (jeweils ~5s Downtime). Geht ueber RVS → Bridge → Diagnostic → Docker-Socket-API.
-- **Cache-Cleanup**: Beim App-Start werden orphane TTS-WAVs aus dem Cache geraeumt. Plus Settings-Buttons "TTS-Cache leeren", "Update-Cache leeren", "Anhang-Cache leeren"
-
-### Wake-Word (openWakeWord, on-device)
-
-Wake-Word-Erkennung laeuft komplett **on-device** ueber [openWakeWord](https://github.com/dscripka/openWakeWord)
-mit ONNX Runtime — kein API-Key, kein Cloud-Roundtrip, kein Cent Lizenzgebuehren,
-und das Audio verlaesst das Geraet nie.
-
-**Mitgelieferte Wake-Words** (ONNX-Dateien in `android/android/app/src/main/assets/openwakeword/`):
-- `Hey Jarvis` (Default, openWakeWord-Original)
-- `Computer` (Star-Trek-Style, Community-Modell)
-- `Alexa`, `Hey Mycroft`, `Hey Rhasspy` (openWakeWord-Originale)
-
-Community-Modelle stammen aus [fwartner/home-assistant-wakewords-collection](https://github.com/fwartner/home-assistant-wakewords-collection).
-
-**Bedienung:**
-- App → **Einstellungen** → **Wake-Word** → gewuenschtes Keyword waehlen → **Speichern + Aktivieren**
-- **Ohr-Button (👂)** in der Statusleiste tippen → Wake-Word ist scharf, App hoert passiv mit
-- Wake-Word sagen → Symbol wechselt auf 🎙️, **Bereit-Sound** (Ding-Dong, optional in Settings) + Toast "🎤 sprich jetzt" sobald das Mikro wirklich offen ist
-- Nach jeder ARIA-Antwort oeffnet sich das Mikro nochmal — Stille → zurueck zu 👂
-- Erneut tippen → Ohr aus (🔇)
-
-**Eigene Wake-Words trainieren** (gratis, ~30 Min):
-
-1. openWakeWord Trainings-Notebook auf Colab oeffnen (Link im
-   [openWakeWord Repo](https://github.com/dscripka/openWakeWord) unter "Training Custom Models")
-2. Wake-Word-Phrase eingeben (z.B. "ARIA", "Hey Stefan"), Notebook ausfuehren —
-   das Notebook generiert synthetische Trainings-Beispiele und trainiert das Modell.
-3. Resultierende `.onnx`-Datei runterladen
-4. Datei in `android/android/app/src/main/assets/openwakeword/` ablegen
-5. In `android/src/services/wakeword.ts` den Dateinamen (ohne `.onnx`) zur
-   `WAKE_KEYWORDS`-Liste hinzufuegen
-6. APK neu bauen
-
-*(Diagnostic-Upload fuer Custom-`.onnx` ohne Rebuild kommt spaeter.)*
-
-**Tuning** (in [wakeword.ts](android/src/services/wakeword.ts)):
-- `DEFAULT_THRESHOLD = 0.5` — Score-Schwelle (raise auf 0.6–0.7 bei False-Positives)
-- `DEFAULT_PATIENCE = 2` — wie viele Frames ueber Threshold noetig
-- `DEFAULT_DEBOUNCE_MS = 1500` — Mindestabstand zwischen zwei Triggern
 
 ### Ersteinrichtung (Dev-Maschine, einmalig)
 
@@ -468,44 +465,18 @@ Der Update-Flow:
 
 ```
 App (Mikrofon) → AAC/MP4 Aufnahme → Base64 → RVS → Bridge
-Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-brain
+Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-core
 Bridge: STT-Ergebnis → RVS → App (Placeholder wird durch transkribierten Text ersetzt)
-aria-brain → Antwort → Bridge → F5-TTS (Gaming-PC) → PCM-Stream → RVS → App
+aria-core → Antwort → Bridge → XTTS (Gaming-PC) → PCM-Stream → RVS → App
 App: AudioTrack MODE_STREAM (nahtlos), Cache als WAV pro Message
 ```
 
-### Audio-Verhalten in der App
-
-| Phase                        | Andere App (Spotify) | ARIA-Mikro              |
-|------------------------------|----------------------|-------------------------|
-| Idle / Ohr aus               | spielt frei          | aus                     |
-| Wake-Word lauscht (armed)    | spielt frei          | passiv (openWakeWord)   |
-| User-Aufnahme laeuft         | pausiert (EXCLUSIVE) | Recording               |
-| Aufnahme zu Ende             | resumed              | aus                     |
-| ARIA denkt/schreibt (~20s)   | spielt frei          | aus                     |
-| TTS startet                  | pausiert (DUCK)      | aus (oder barge)        |
-| TTS spielt (auch GPU-Pausen) | bleibt pausiert      | barge wenn Wake-Word    |
-| TTS zu Ende                  | nach 800ms resumed   | (Conversation-Window)   |
-| Eingehender Anruf (auch VoIP)| —                    | Mikro pausiert          |
-| Anruf vorbei (Auto-Resume)   | pausiert wieder       | aus                     |
-| Neue Frage waehrend Anruf    | —                    | (Resume verworfen)      |
-
-Mechanismen: Underrun-Schutz im PcmStreamPlayer (Stille-Fill in Render-
-Pausen), Conversation-Focus bei Wake-Word, Foreground-Service mit
-mediaPlayback|microphone, Anruf-Erkennung ueber TelephonyManager +
-AudioFocus-Loss-Listener mit Polling-Fallback (VoIP). Bei Anruf wird
-die Wiedergabe-Position gemerkt — nach dem Auflegen spielt ARIA ab
-der genauen Stelle weiter (oder verwirft das wenn der User waehrend
-des Telefonats per Text eine neue Frage gestellt hat). PcmPlayback-
-Finished-Event vom Native sorgt dafuer dass Spotify erst pausiert
-bleibt bis ARIA wirklich verstummt ist.
-
 ### Datei-Pipeline (Bilder & Anhaenge)
 
 ```
 App (Kamera/Dateimanager) → Base64 → RVS → Bridge
-Bridge: Speichert in /shared/uploads/ (Shared Volume, fuer aria-brain sichtbar)
-Bridge: aria-brain → "Stefan hat ein Bild geschickt: foto.jpg — liegt unter /shared/uploads/..."
+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
 ```
 
@@ -535,34 +506,35 @@ ist in den App-Einstellungen konfigurierbar.
 
 ## Datenverzeichnis — aria-data/
 
+Alles was ARIA weiss, kann und ist — liegt hier. Ein `tar` = vollstaendiges Backup.
+
 ```
 aria-data/
-├── brain/                          ← ARIAs Gehirn — Bind-Mount, GITIGNORED
-│   ├── qdrant/                     ← Vector-DB Storage (Memories, Skills-Embeddings)
-│   └── data/                       ← Skills, Embedding-Modell-Cache
-│       └── skills/<name>/          ← Pro Skill ein Ordner mit Manifest, Code, venv
+├── brain/                          ← ARIAs Gedaechtnis (OpenClaw Memory)
+│   ├── MEMORY.md                   ← Langzeitgedaechtnis
+│   └── memory/                     ← Tageslogbuecher
 │
-├── brain-import/                   ← Quell-Dateien fuer den initialen Import in die DB
-│   ├── AGENT.md                    ← Persoenlichkeit (wird Memory-Punkte vom Typ identity/rule)
-│   ├── BOOTSTRAP.md
-│   ├── TOOLING.md.example
-│   └── USER.md.example
+├── skills/                         ← ARIAs Faehigkeiten (selbst geschrieben!)
 │
 ├── config/
+│   ├── BOOTSTRAP.md                ← System-Prompt (Identitaet, Regeln, Tools)
+│   ├── AGENT.md                    ← Persoenlichkeit & Arbeitsprinzipien
+│   ├── USER.md                     ← Stefans Praeferenzen
+│   ├── openclaw.env                ← OpenClaw Environment
+│   ├── aria.env                    ← Voice Bridge Config
 │   └── diag-state/                 ← Diagnostic persistenter State
 │
-└── ssh/                            ← SSH Keys (Brain + Proxy teilen sich)
-    ├── id_ed25519
-    ├── id_ed25519.pub
-    └── config                      ← Host aria-wohnung
+│   (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!)
+    └── config                      ← SSH Config (Host aria-wohnung)
 ```
 
-`aria-data/brain/` (Vector-DB + Skills) ist gitignored — Backup laeuft ueber
-den Gehirn-Export-Button in der Diagnostic, nicht ueber Git.
-
-Settings im Shared Volume (`/shared/config/`): `voice_config.json`,
-`highlight_triggers.json`, `runtime.json`, `chat_backup.jsonl`.
-
 **Backup:**
 ```bash
 tar -czf aria-backup-$(date +%Y%m%d).tar.gz aria-data/
@@ -678,46 +650,20 @@ In der Diagnostic unter Einstellungen → Sprachausgabe:
 > **Tipp:** Fuer beste Ergebnisse: saubere Aufnahme, eine Stimme, kein Hintergrund,
 > 10-30 Sekunden Gesamtlaenge. Mehrere kurze Dateien werden zusammengefuegt.
 
-### Deutsches Fine-Tune (bessere Qualitaet auf Deutsch)
-
-Das Default-Modell `F5TTS_v1_Base` ist primaer auf Englisch + Chinesisch trainiert
-und liefert auf Deutsch merklich schwaechere Voice-Cloning-Qualitaet als XTTS es
-tat. Community-Fine-Tune von [aihpi](https://huggingface.co/aihpi/F5-TTS-German)
-auf dem Emilia-Dataset + Common Voice 19.0 funktioniert deutlich besser.
-
-**Konfiguration ueber Diagnostic → "F5-TTS Modell-Tuning (advanced)":**
-
-| Feld | Wert |
-|------|------|
-| Modell-Architektur | `F5TTS_Base` *(nicht v1_Base! Fine-Tune basiert auf der alten Architektur)* |
-| Custom Checkpoint | `hf://aihpi/F5-TTS-German/F5TTS_Base/model_365000.safetensors` |
-| Custom Vocab | `hf://aihpi/F5-TTS-German/vocab.txt` |
-| cfg_strength | `2.0` |
-| nfe_step | `32` |
-
-→ "Anwenden" klicken. Die `hf://`-Pfade werden einmalig automatisch runter-
-geladen (~3-5GB, landet im `xtts/hf-cache/`) und bei Container-Restart aus
-dem Cache wiederverwendet.
-
-> **Warnung zur BigVGAN-Variante** (`F5TTS_Base_bigvgan/model_295000.safetensors`):
-> funktioniert AKTUELL NICHT mit dieser Bridge. Die f5-tts Library laedt
-> per Default den Vocos-Vocoder, die BigVGAN-Weights sind damit inkompatibel
-> → Modell produziert NaN, App bleibt stumm. Nur die **Vocos-Variante
-> (F5TTS_Base/model_365000.safetensors)** nutzen.
-
 ---
 
 ## Docker Volumes
 
-| Volume / Bind | Pfad im Container | Zweck |
-|---------------|-------------------|-------|
-| `~/.claude` (bind) | `/root/.claude` (proxy) | Claude CLI Credentials |
-| `./aria-data/ssh` (bind) | `/root/.ssh` (proxy, brain) | SSH-Keys fuer aria-wohnung |
-| `./aria-data/brain/qdrant` (bind) | `/qdrant/storage` (qdrant) | Vector-DB Storage |
-| `./aria-data/brain/data` (bind) | `/data` (brain) | Skills + Embedding-Modell-Cache |
-| `./aria-data/brain` (bind) | `/brain` (diagnostic) | Brain-Export/Import-Endpoints |
-| `aria-shared` | `/shared` (brain, bridge, proxy, diagnostic) | Datei-Austausch, Config, Uploads |
-| `./aria-data/config/diag-state` (bind) | `/data` (diagnostic) | Diagnostic persistenter State |
+| Volume | Pfad im Container | Zweck |
+|--------|-------------------|-------|
+| `openclaw-config` | `/home/node/.openclaw` | OpenClaw Config, Sessions, Auth |
+| `claude-config` | `/home/node/.claude` | Claude Code Settings, Permissions |
+| `~/.claude` (bind) | `/root/.claude` (Proxy) | Claude CLI Credentials |
+| `./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) |
 
 ---
 
@@ -746,21 +692,22 @@ docker compose down
 
 # Einzelnen Container neu bauen
 docker compose up -d --build diagnostic
-docker compose up -d --build bridge brain
+docker compose up -d --build bridge
 
 # Logs
-docker compose logs -f               # alle
-docker compose logs -f brain         # nur Agent + Memory
-docker compose logs -f qdrant        # nur Vector-DB
-docker compose logs -f bridge        # nur Voice-Bridge
-docker compose logs -f proxy         # nur Claude-Proxy
+docker compose logs -f              # alle
+docker compose logs -f aria          # nur aria-core
+docker compose logs -f proxy         # nur proxy
 
-# SSH-Test (Brain zu aria-wohnung)
-docker exec aria-brain ssh aria-wohnung hostname
+# Setup wiederholen (nach Config-Aenderungen)
+./aria-setup.sh
 
-# Brain-API direkt testen
-docker exec aria-brain curl localhost:8080/health
-docker exec aria-brain curl localhost:8080/memory/stats
+# SSH-Test
+docker exec aria-core ssh aria-wohnung hostname
+
+# Tool-Test
+# Neue Session in Diagnostic anlegen, dann:
+# "Wie wird das Wetter in Bremen?"
 ```
 
 ---
@@ -770,10 +717,8 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - **Proxy Cold Start**: Jede Nachricht spawnt einen neuen `claude --print` Prozess.
   Dadurch ist ARIA langsamer als die direkte Claude CLI. Timeout ist auf 900s (15 Min).
 - **Kein Streaming zur App**: Die App zeigt erst die fertige Antwort, keine Streaming-Tokens.
-- **Wake-Word in der App nur eingebaute Keywords**: `Hey Jarvis`, `Alexa`, `Hey Mycroft`,
-  `Hey Rhasspy` funktionieren sofort, eigene Wake-Words muessen aktuell noch als
-  `.onnx`-Datei ins App-Bundle gelegt + zur Liste in `wakeword.ts` hinzugefuegt werden.
-  Die Diagnostic-Upload-UI ist Phase 2.
+- **Wake Word nur auf VM**: Die Bridge hoert auf "ARIA" ueber das lokale Mikrofon der VM.
+  In der App gibt es Energy-basierte Erkennung (Phase 1). On-device "ARIA"-Keyword (Porcupine) ist Phase 2.
 - **Audio-Format**: App nimmt AAC/MP4 auf, Bridge konvertiert via FFmpeg zu 16kHz PCM.
 - **RVS Zombie-Connections**: WebSocket-Verbindungen sterben gelegentlich ohne Fehlermeldung.
   Bridge hat Ping-Check (5s), Diagnostic nutzt frische Verbindungen pro Request.
@@ -799,7 +744,7 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] SSH-Zugriff auf VM (aria-wohnung)
 - [x] Diagnostic Web-UI + Einstellungen
 - [x] Session-Verwaltung + Chat-History
-- [x] Stimmen-Einstellungen (frueher Piper Ramona/Thorsten, Highlight-Trigger) — durch XTTS, dann F5-TTS Voice Cloning ersetzt
+- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed, Highlight-Trigger) — durch XTTS v2 Voice Cloning ersetzt
 - [x] Piper komplett entfernt — nur noch XTTS v2 als TTS (Gaming-PC)
 - [x] Streaming TTS: PCM-Chunks direkt in AudioTrack, nahtlose Wiedergabe
 - [x] TTS satzweise fuer lange Texte
@@ -826,57 +771,22 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] Whisper STT auf die Gamebox ausgelagert (CUDA float16, fast Echtzeit)
 - [x] **F5-TTS ersetzt XTTS** — bessere Voice-Cloning-Qualitaet, Whisper-auto-transkribierter Referenz-Text
 - [x] Audio-Pause statt Ducking (TRANSIENT statt MAY_DUCK) + release-Timing fix
-- [x] VAD-Stille-Toleranz einstellbar (1-8s) + adaptive Mikro-Baseline + Max-Aufnahme einstellbar (1-30 min)
-- [x] Barge-In: User kann ARIA waehrend Antwort unterbrechen, aria-core bekommt Kontext-Hint
-- [x] Anruf-Pause + Auto-Resume: TTS verstummt bei Anruf, faehrt nach Auflegen ab der gemerkten Position fort (Date.now()-Tracking + WAV-Cache der Antwort)
-- [x] PcmPlaybackFinished-Event: AudioFocus wird erst released wenn AudioTrack wirklich durch ist — kein Spotify-mid-TTS mehr
-- [x] Edge-Case: neue Frage waehrend Telefonat verwirft pending Auto-Resume, neueste Antwort gewinnt
-- [x] Settings-Sub-Screens: 8 Kategorien statt langer Liste
-- [x] APK ABI-Split arm64-v8a: 35 MB statt 136 MB
-- [x] Sprachnachrichten-Bubble: audioRequestId statt Substring-Match — keine vertauschten Bubbles mehr bei parallelen Aufnahmen
-- [x] Bereit-Sound (Airplane Ding-Dong) wenn Mikro nach Wake-Word offen ist — akustische Bestaetigung, in Settings abschaltbar
-- [x] Wake-Word parallel zu TTS mit AcousticEchoCanceler — "Computer" sagen waehrend ARIA spricht stoppt sie und oeffnet Mikro
-- [x] GPS-Position mit Nachrichten mitsenden (Toggle in Settings) — ARIA nutzt sie nur bei standortbezogenen Fragen, im Chat sichtbar nur in ihrer Antwort
-- [x] Sprachnachrichten ohne STT-Result werden nach Timeout automatisch entfernt (skaliert mit Aufnahmedauer)
-- [x] Background Audio Service: TTS, Wake-Word-Lauschen + Aufnahme laufen auch bei minimierter App weiter (Foreground-Service mit mediaPlayback|microphone, dynamische Notification)
+- [x] VAD-Stille-Toleranz und Max-Aufnahme einstellbar (1-8s, 120s)
 - [x] Disk-Voll Banner in Diagnostic mit copy-baren Cleanup-Befehlen
-- [x] Wake-Word on-device via openWakeWord (ONNX Runtime, kein API-Key) + State-Icon
-
-### Phase A — Refactor: OpenClaw raus, eigenes Brain rein
-
-- [x] aria-brain Container-Skeleton (FastAPI, Qdrant, sentence-transformers)
-- [x] aria-core (OpenClaw) komplett abgerissen — Tag `v0.1.2.0` als Archiv
-- [x] Diagnostic: Gehirn-Tab (Memory Search/Filter, Add/Edit/Delete)
-- [x] Diagnostic: Gehirn-Export/Import als tar.gz
-- [x] Diagnostic: Datei-Manager (Liste, Suche, Download, Delete, Multi-Select + ZIP + Bulk-Delete)
-- [x] Diagnostic: Komplett-Reset (Wipe All)
-- [x] Diagnostic: Info-Buttons mit Modal-Erklaerungen (Status, Konversation, Memories, Bootstrap)
-- [x] App: Datei-Manager als Modal in den Einstellungen (mit Multi-Select + ZIP-Download)
-- [x] Voice Export/Import (einzelne Stimmen + F5/Whisper-Settings als Bundle)
-
-### Phase B — Brain mit Memory + Loop + Skills
-
-- [x] **Phase B Punkt 2:** Migration aus `aria-data/brain-import/` → atomare Memory-Punkte (Identity / Rule / Preference / Tool / Skill, idempotent ueber migration_key) + Bootstrap-Snapshot Export/Import (nur pinned)
-- [x] **Phase B Punkt 3:** Brain Conversation-Loop (Single-Chat UI, Rolling Window 50 Turns, Schwelle 60 → automatisches Destillat, manueller Trigger)
-- [x] **Phase B Punkt 4:** Skills-System (Python-only via local-venv, skill_create als Tool, dynamische run_<skill> Tools, Diagnostic Skills-Tab mit Logs/Toggle/Export/Import, skill_created Live-Notification in App+Diagnostic, harte Schwelle "pip → Skill")
-- [x] Sprachmodell-Setting wieder funktional (brainModel in runtime.json statt aria-core)
-- [x] App-Chat-Sync: kompletter Server-Sync bei Reconnect (Server = Source of Truth) + chat_cleared Live-Update. Lokal-only Bubbles (Skill-Notifications, laufende Voice ohne STT) bleiben erhalten.
-- [x] App: Chat-Suche mit Next/Prev Navigation statt Filter
-- [x] Token/Call-Metrics + Subscription-Quota-Tracking (Pro / Max 5x / Max 20x / Custom)
-- [x] Datei-Manager Multi-Select: Bulk-Download als ZIP + Bulk-Delete (Diagnostic + App)
 
 ### Phase 2 — ARIA wird produktiv
 
-- [ ] Erste Skills bauen lassen (yt-dlp, pdf-extract, etc. — durch normale Anfragen)
+- [ ] Skills bauen (Bildgenerierung, etc.)
 - [ ] Gitea-Integration
 - [ ] VM einrichten (Desktop, Browser, Tools)
 - [ ] Heartbeat (periodische Selbst-Checks)
 - [ ] Lokales LLM als Waechter (Triage vor Claude-Call)
+- [ ] Auto-Compacting / Memory-Verwaltung
 
 ### Phase 3 — Erweiterungen
 
 - [ ] STARFACE Telefonie-Skill
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
-- [ ] Custom-`.onnx`-Upload fuer Wake-Word ueber Diagnostic (ohne App-Rebuild)
+- [ ] Porcupine Wake Word (on-device "ARIA" in der App)
 - [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)

android/App.tsx

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

android/android/app/build.gradle

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

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

@@ -4,19 +4,6 @@
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
-    <!-- Anruf-State lesen damit TTS bei klingelndem Telefon pausiert -->
-    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
-    <!-- Optional: GPS-Position der Frage anhaengen (nur wenn User in Settings aktiviert) -->
-    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
-    <!-- Foreground-Service damit TTS auch bei minimierter App weiterlaeuft.
-         FOREGROUND_SERVICE_MICROPHONE ist Pflicht ab Android 14 wenn der
-         Service waehrend des Backgrounds aufs Mikro zugreift (Wake-Word,
-         Aufnahme im Gespraechsmodus). -->
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
       android:name=".MainApplication"
@@ -48,10 +35,5 @@
           android:name="android.support.FILE_PROVIDER_PATHS"
           android:resource="@xml/file_paths" />
       </provider>
-
-      <service
-        android:name=".AriaPlaybackService"
-        android:exported="false"
-        android:foregroundServiceType="mediaPlayback|microphone" />
     </application>
 </manifest>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

android/build.sh

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

android/package.json

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

android/src/components/MessageText.tsx

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

android/src/components/VoiceButton.tsx

@@ -44,6 +44,7 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
   const [meterDb, setMeterDb] = useState(-160);
   const pulseAnim = useRef(new Animated.Value(1)).current;
   const durationTimer = useRef<ReturnType<typeof setInterval> | null>(null);
+  const isLongPress = useRef(false);
 
   // Puls-Animation starten/stoppen
   useEffect(() => {
@@ -92,62 +93,66 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     }
   }, [isRecording]);
 
-  // VAD Silence Callback — Auto-Stop.
-  // WICHTIG: NICHT auf isRecording prüfen (Closure ist stale) — stattdessen
-  // audioService selber fragen. Empty deps → Listener wird EINMAL registriert.
-  // audioService garantiert jetzt dass der Callback pro Aufnahme nur einmal
-  // feuert (silenceFired-Latch).
-  const onCompleteRef = useRef(onRecordingComplete);
-  useEffect(() => { onCompleteRef.current = onRecordingComplete; }, [onRecordingComplete]);
+  // VAD Silence Callback — Auto-Stop
   useEffect(() => {
     const unsubSilence = audioService.onSilenceDetected(async () => {
-      if (audioService.getRecordingState() !== 'recording') return;
-      const result = await audioService.stopRecording();
+      if (!isRecording) return;
       setIsRecording(false);
+      const result = await audioService.stopRecording();
       if (result && result.durationMs > 500) {
-        onCompleteRef.current(result);
+        onRecordingComplete(result);
       }
     });
     return unsubSilence;
-  }, []);
+  }, [isRecording, onRecordingComplete]);
 
   // Auto-Start fuer Wake Word (extern getriggert)
   const startAutoRecording = useCallback(async () => {
     if (disabled || isRecording) return;
     const started = await audioService.startRecording(true); // autoStop = true
     if (started) {
+      isLongPress.current = false;
       setIsRecording(true);
     }
   }, [disabled, isRecording]);
 
-  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop.
-  // Guard gegen Doppel-Tap während asyncer Start/Stop.
-  const tapBusy = useRef(false);
+  // Push-to-Talk: Lang druecken
+  const handlePressIn = async () => {
+    if (disabled || isRecording) return;
+    isLongPress.current = true;
+    const started = await audioService.startRecording(false); // kein autoStop
+    if (started) {
+      setIsRecording(true);
+    }
+  };
+
+  const handlePressOut = async () => {
+    if (!isRecording || !isLongPress.current) return;
+    isLongPress.current = false;
+    setIsRecording(false);
+    const result = await audioService.stopRecording();
+    if (result && result.durationMs > 300) {
+      onRecordingComplete(result);
+    }
+  };
+
+  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop
   const handleTap = async () => {
-    if (disabled || tapBusy.current) return;
-    tapBusy.current = true;
-    try {
-      // Fragen WIR den Service, nicht den React-State (Closure kann stale sein)
-      const svcState = audioService.getRecordingState();
-      if (svcState === 'recording') {
-        // Aufnahme manuell stoppen
-        const result = await audioService.stopRecording();
-        setIsRecording(false);
-        if (result && result.durationMs > 300) {
-          onRecordingComplete(result);
-        }
-      } else if (svcState === 'idle') {
-        // Aufnahme mit Auto-Stop starten
-        const started = await audioService.startRecording(true);
-        if (started) {
-          setIsRecording(true);
-        }
+    if (disabled) return;
+    if (isRecording) {
+      // Aufnahme manuell stoppen
+      setIsRecording(false);
+      const result = await audioService.stopRecording();
+      if (result && result.durationMs > 300) {
+        onRecordingComplete(result);
+      }
+    } else {
+      // Aufnahme mit Auto-Stop starten
+      const started = await audioService.startRecording(true);
+      if (started) {
+        isLongPress.current = false;
+        setIsRecording(true);
       }
-      // svcState === 'processing': Stopp in progress — nichts tun, User
-      // muss nochmal tippen wenn fertig. Aber wir blockieren mit tapBusy
-      // kurz damit der User's UI-Feedback synchron bleibt.
-    } finally {
-      tapBusy.current = false;
     }
   };
 
@@ -178,6 +183,10 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
           isRecording && styles.buttonOuterRecording,
           { transform: [{ scale: pulseAnim }] },
         ]}
+        onStartShouldSetResponder={() => true}
+        onResponderGrant={handlePressIn}
+        onResponderRelease={handlePressOut}
+        onResponderTerminate={handlePressOut}
       >
         <TouchableOpacity
           activeOpacity={0.8}

android/src/components/ZoomableImage.tsx

@@ -1,224 +0,0 @@
-/**
- * ZoomableImage — Pinch-to-Zoom + Pan fuers Vollbild-Modal.
- *
- * Reine RN-Implementation, ohne react-native-gesture-handler.
- *
- *  - 2 Finger: Pinch (Zoom 1x..5x) + simultaner Pan via Focal-Punkt
- *  - 1 Finger: Pan wenn schon gezoomt (>1.02x)
- *  - Doppel-Tap (<300ms zw. zwei Single-Taps): Toggle 1x ↔ 2.5x
- *
- * Implementierungs-Hinweise zur alten Version (warum's nicht ging):
- *  - `gestureState.numberActiveTouches` ist nicht zuverlaessig direkt
- *    nach onPanResponderGrant. Wir lesen Finger-Anzahl jetzt
- *    ausschliesslich aus `e.nativeEvent.touches.length`.
- *  - Beim Wechsel von 2 → 1 Fingern bleib die Pinch-Referenz haengen.
- *    Jetzt: bei jedem Finger-Wechsel re-snapshotten wir die Geste.
- *  - Animated.Image bekommt jetzt pointerEvents="none" damit der View
- *    GARANTIERT die Touches abbekommt.
- *  - useNativeDriver ist bewusst AUS — sonst koennen wir setValue()
- *    nicht synchron mit dem Pan-Responder zusammen nutzen.
- */
-
-import React, { useMemo, useRef } from 'react';
-import {
-  Animated,
-  PanResponder,
-  GestureResponderEvent,
-  ImageStyle,
-  StyleProp,
-  StyleSheet,
-  View,
-} from 'react-native';
-
-interface Props {
-  uri: string;
-  containerWidth: number;
-  containerHeight: number;
-  style?: StyleProp<ImageStyle>;
-}
-
-const MIN_SCALE = 1;
-const MAX_SCALE = 5;
-const DOUBLE_TAP_MS = 300;
-const DOUBLE_TAP_DIST = 30;     // Bewegung max. damit ein Tap als Tap gilt
-const PAN_SLOP_AT_SCALE_1 = 4;  // Mikro-Movement nicht als Pan werten
-
-const ZoomableImage: React.FC<Props> = ({ uri, containerWidth, containerHeight, style }) => {
-  // Animated-Werte fuer die Render-Transformation
-  const scale = useRef(new Animated.Value(1)).current;
-  const tx = useRef(new Animated.Value(0)).current;
-  const ty = useRef(new Animated.Value(0)).current;
-
-  // Logische Zustaende — wir lesen Animated.Value nicht zurueck (waere async)
-  const view = useRef({ scale: 1, x: 0, y: 0 }).current;
-
-  // Geste-Snapshot: was war zu Beginn dieser Geste-Phase
-  const gesture = useRef({
-    fingers: 0,                // aktuelle Finger-Anzahl
-    startScale: 1,
-    startX: 0,
-    startY: 0,
-    startDist: 0,              // Pinch-Referenz-Distanz
-    startFocalX: 0,
-    startFocalY: 0,
-    movedSinceTouch: 0,        // fuer Tap-Erkennung
-    touchStartedAt: 0,
-    touchStartX: 0,
-    touchStartY: 0,
-  }).current;
-
-  // Doppel-Tap
-  const lastTap = useRef({ at: 0, x: 0, y: 0 });
-
-  const clamp = (v: number, lo: number, hi: number) => Math.max(lo, Math.min(hi, v));
-
-  const applyClamped = (s: number, x: number, y: number) => {
-    const ns = clamp(s, MIN_SCALE, MAX_SCALE);
-    // Translation auf das verfuegbare Volumen begrenzen
-    const maxX = Math.max(0, (containerWidth * ns - containerWidth) / 2);
-    const maxY = Math.max(0, (containerHeight * ns - containerHeight) / 2);
-    const nx = clamp(x, -maxX, maxX);
-    const ny = clamp(y, -maxY, maxY);
-    view.scale = ns;
-    view.x = nx;
-    view.y = ny;
-    scale.setValue(ns);
-    tx.setValue(nx);
-    ty.setValue(ny);
-  };
-
-  const distance = (touches: any[]) =>
-    Math.hypot(touches[0].pageX - touches[1].pageX, touches[0].pageY - touches[1].pageY);
-
-  const focal = (touches: any[]) => ({
-    x: (touches[0].pageX + touches[1].pageX) / 2,
-    y: (touches[0].pageY + touches[1].pageY) / 2,
-  });
-
-  // Snapshot vor jedem Phasenwechsel (1↔2 Finger) — verhindert Spruenge
-  const snapshot = (touches: any[]) => {
-    gesture.startScale = view.scale;
-    gesture.startX = view.x;
-    gesture.startY = view.y;
-    if (touches.length >= 2) {
-      gesture.startDist = distance(touches);
-      const f = focal(touches);
-      gesture.startFocalX = f.x;
-      gesture.startFocalY = f.y;
-    } else if (touches.length === 1) {
-      gesture.startDist = 0;
-      gesture.startFocalX = touches[0].pageX;
-      gesture.startFocalY = touches[0].pageY;
-    }
-  };
-
-  const responder = useMemo(
-    () =>
-      PanResponder.create({
-        onStartShouldSetPanResponder: () => true,
-        onStartShouldSetPanResponderCapture: () => true,
-        onMoveShouldSetPanResponder: () => true,
-        onMoveShouldSetPanResponderCapture: () => true,
-
-        onPanResponderGrant: (e: GestureResponderEvent) => {
-          const touches = e.nativeEvent.touches as any[];
-          gesture.fingers = touches.length;
-          gesture.movedSinceTouch = 0;
-          gesture.touchStartedAt = Date.now();
-          gesture.touchStartX = touches[0]?.pageX ?? 0;
-          gesture.touchStartY = touches[0]?.pageY ?? 0;
-          snapshot(touches);
-        },
-
-        onPanResponderMove: (e: GestureResponderEvent, _gs) => {
-          const touches = e.nativeEvent.touches as any[];
-
-          // Phasenwechsel? → Re-Snapshot, damit nicht gesprungen wird
-          if (touches.length !== gesture.fingers) {
-            gesture.fingers = touches.length;
-            snapshot(touches);
-            return;
-          }
-
-          gesture.movedSinceTouch += 1;
-
-          if (touches.length >= 2) {
-            // Pinch + Pan via Focal
-            const d = distance(touches);
-            if (gesture.startDist === 0) {
-              // Sicherheitsnetz falls Snapshot gemissed wurde
-              snapshot(touches);
-              return;
-            }
-            const factor = d / gesture.startDist;
-            const f = focal(touches);
-            const newScale = clamp(gesture.startScale * factor, MIN_SCALE, MAX_SCALE);
-            // Focal-basierter Pan: zoomt um den Mittelpunkt der zwei Finger
-            const newX = gesture.startX + (f.x - gesture.startFocalX);
-            const newY = gesture.startY + (f.y - gesture.startFocalY);
-            applyClamped(newScale, newX, newY);
-          } else if (touches.length === 1 && view.scale > 1.02) {
-            const dx = touches[0].pageX - gesture.startFocalX;
-            const dy = touches[0].pageY - gesture.startFocalY;
-            if (Math.abs(dx) < PAN_SLOP_AT_SCALE_1 && Math.abs(dy) < PAN_SLOP_AT_SCALE_1) return;
-            applyClamped(view.scale, gesture.startX + dx, gesture.startY + dy);
-          }
-        },
-
-        onPanResponderRelease: (e: GestureResponderEvent) => {
-          const elapsed = Date.now() - gesture.touchStartedAt;
-          const dx = (e.nativeEvent.changedTouches?.[0]?.pageX ?? gesture.touchStartX) - gesture.touchStartX;
-          const dy = (e.nativeEvent.changedTouches?.[0]?.pageY ?? gesture.touchStartY) - gesture.touchStartY;
-          const wasTap =
-            elapsed < 280 &&
-            Math.abs(dx) < DOUBLE_TAP_DIST &&
-            Math.abs(dy) < DOUBLE_TAP_DIST;
-          if (wasTap) {
-            const now = Date.now();
-            if (now - lastTap.current.at < DOUBLE_TAP_MS) {
-              // Doppel-Tap → Zoom-Toggle
-              if (view.scale > 1.1) {
-                applyClamped(1, 0, 0);
-              } else {
-                applyClamped(2.5, 0, 0);
-              }
-              lastTap.current = { at: 0, x: 0, y: 0 };
-            } else {
-              lastTap.current = { at: now, x: gesture.touchStartX, y: gesture.touchStartY };
-            }
-          }
-          gesture.fingers = 0;
-          gesture.startDist = 0;
-        },
-
-        onPanResponderTerminate: () => {
-          gesture.fingers = 0;
-          gesture.startDist = 0;
-        },
-      }),
-    [],
-  );
-
-  return (
-    <View
-      style={StyleSheet.absoluteFill}
-      collapsable={false}
-      {...responder.panHandlers}
-    >
-      <Animated.View pointerEvents="none" style={StyleSheet.absoluteFill}>
-        <Animated.Image
-          source={{ uri }}
-          style={[
-            style,
-            {
-              transform: [{ translateX: tx }, { translateY: ty }, { scale }],
-            },
-          ]}
-          resizeMode="contain"
-        />
-      </Animated.View>
-    </View>
-  );
-};
-
-export default ZoomableImage;

android/src/services/audio.ts

@@ -6,11 +6,10 @@
  * Nutzt react-native-audio-recorder-player fuer Aufnahme.
  */
 
-import { Platform, PermissionsAndroid, NativeModules, ToastAndroid, NativeEventEmitter } from 'react-native';
+import { Platform, PermissionsAndroid, NativeModules } from 'react-native';
 import Sound from 'react-native-sound';
 import RNFS from 'react-native-fs';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { acquireBackgroundAudio, releaseBackgroundAudio, stopBackgroundAudio } from './backgroundAudio';
 import AudioRecorderPlayer, {
   AudioEncoderAndroidType,
   AudioSourceAndroidType,
@@ -41,8 +40,6 @@ const { AudioFocus, PcmStreamPlayer } = NativeModules as {
     requestDuck: () => Promise<boolean>;
     requestExclusive: () => Promise<boolean>;
     release: () => Promise<boolean>;
-    kickReleaseMedia: () => Promise<boolean>;
-    getMode?: () => Promise<number>;
   };
   PcmStreamPlayer?: {
     start: (sampleRate: number, channels: number, prerollSeconds: number) => Promise<boolean>;
@@ -75,41 +72,11 @@ const AUDIO_SAMPLE_RATE = 16000;
 const AUDIO_CHANNELS = 1;
 const AUDIO_ENCODING = 'audio/wav';
 
-// VAD (Voice Activity Detection) — Stille-Erkennung.
-// Fallback-Werte falls die adaptive Baseline-Messung fehlschlaegt (z.B. weil
-// das Mikro keine metering-Updates liefert). Adaptive Werte werden zur
-// Laufzeit aus den ersten BASELINE_SAMPLES gemessen und auf baseline+offset
-// gesetzt — funktioniert in lauten wie leisen Umgebungen.
-const VAD_SILENCE_FALLBACK_DB = -38;   // Fallback Stille-Schwelle
-const VAD_SPEECH_FALLBACK_DB = -22;    // Fallback Sprach-Schwelle
-const VAD_SILENCE_OFFSET_DB = 6;       // Sprache = Baseline + 6dB
-const VAD_SPEECH_OFFSET_DB = 12;       // sicheres Speech = Baseline + 12dB
-const VAD_BASELINE_SAMPLES = 5;        // 5 × 100ms = 500ms Baseline
+// VAD (Voice Activity Detection) — Stille-Erkennung
+const VAD_SILENCE_THRESHOLD_DB = -45;  // dB unter dem als "Stille" gilt
+const VAD_SPEECH_THRESHOLD_DB = -28;   // dB ueber dem als "Sprache" gilt (Sprach-Gate) — hoeher = weniger Umgebungsgeraeusche
 const VAD_SPEECH_MIN_MS = 500;         // ms Sprache bevor Aufnahme zaehlt — laenger = keine Huestler/Klopfer mehr
 
-// Override fuer die Stille-Schwelle — wenn gesetzt, wird die adaptive Baseline
-// ignoriert. Nuetzlich wenn die adaptive Logik in spezifischen Umgebungen
-// nicht zuverlaessig greift. Range -55..-15 dB. Speech-Schwelle wird auf
-// override+10 dB gesetzt (Speech muss klar lauter als Stille sein).
-export const VAD_SILENCE_DB_DEFAULT = -38;  // wenn User Manuell-Modus waehlt
-export const VAD_SILENCE_DB_MIN = -85;      // extrem empfindlich, praktisch alles gilt als Sprache
-export const VAD_SILENCE_DB_MAX = -15;      // sehr unempfindlich, nur lautes Reden gilt
-export const VAD_SILENCE_DB_OVERRIDE_KEY = 'aria_vad_silence_db_override';
-
-/** Liefert den manuellen Override-Wert oder null wenn "automatisch". */
-export async function loadVadSilenceDbOverride(): Promise<number | null> {
-  try {
-    const raw = await AsyncStorage.getItem(VAD_SILENCE_DB_OVERRIDE_KEY);
-    if (raw == null || raw === '') return null;
-    const n = parseFloat(raw);
-    if (!isFinite(n)) return null;
-    if (n < VAD_SILENCE_DB_MIN || n > VAD_SILENCE_DB_MAX) return null;
-    return n;
-  } catch {
-    return null;
-  }
-}
-
 // VAD-Stille (in Sekunden) — wie lange Sprechpause toleriert wird, bevor
 // die Aufnahme automatisch beendet wird. Einstellbar in den App-Settings.
 export const VAD_SILENCE_DEFAULT_SEC = 2.8;
@@ -125,24 +92,6 @@ export const CONV_WINDOW_MIN_SEC = 3.0;
 export const CONV_WINDOW_MAX_SEC = 20.0;
 export const CONV_WINDOW_STORAGE_KEY = 'aria_conv_window_sec';
 
-// TTS-Wiedergabegeschwindigkeit — wird pro Geraet gespeichert und an die
-// Bridge mitgegeben (speed-Param im F5-TTS infer()). 1.0 = normal.
-export const TTS_SPEED_DEFAULT = 1.0;
-export const TTS_SPEED_MIN = 0.1;
-export const TTS_SPEED_MAX = 5.0;
-export const TTS_SPEED_STORAGE_KEY = 'aria_tts_speed';
-
-export async function loadTtsSpeed(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY);
-    if (raw != null) {
-      const n = parseFloat(raw);
-      if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) return n;
-    }
-  } catch {}
-  return TTS_SPEED_DEFAULT;
-}
-
 export async function loadConvWindowMs(): Promise<number> {
   try {
     const raw = await AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY);
@@ -171,29 +120,12 @@ async function loadVadSilenceMs(): Promise<number> {
 
 // Max-Dauer einer Aufnahme (Notbremse gegen Runaway-Loops). Auf 2 Minuten
 // hochgezogen damit auch laengere Erklaerungen durchgehen.
-// Default 5 Minuten — konfigurierbar in den App-Settings (1-30 Minuten).
-export const MAX_RECORDING_DEFAULT_SEC = 300;
-export const MAX_RECORDING_MIN_SEC = 60;
-export const MAX_RECORDING_MAX_SEC = 1800;
-export const MAX_RECORDING_STORAGE_KEY = 'aria_max_recording_sec';
-
-export async function loadMaxRecordingMs(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(MAX_RECORDING_STORAGE_KEY);
-    if (raw != null) {
-      const n = parseFloat(raw);
-      if (isFinite(n) && n >= MAX_RECORDING_MIN_SEC && n <= MAX_RECORDING_MAX_SEC) {
-        return Math.round(n * 1000);
-      }
-    }
-  } catch {}
-  return MAX_RECORDING_DEFAULT_SEC * 1000;
-}
+const MAX_RECORDING_MS = 120000;
 
 // Pre-Roll: Wie lange Audio im AudioTrack-Buffer liegt bevor play() startet.
 // Einstellbar via Diagnostic/Settings (Key: aria_tts_preroll_sec).
 export const TTS_PREROLL_DEFAULT_SEC = 3.5;
-export const TTS_PREROLL_MIN_SEC = 0;     // 0 = sofort abspielen (F5-TTS ist schnell genug)
+export const TTS_PREROLL_MIN_SEC = 1.0;
 export const TTS_PREROLL_MAX_SEC = 6.0;
 export const TTS_PREROLL_STORAGE_KEY = 'aria_tts_preroll_sec';
 
@@ -241,281 +173,16 @@ class AudioService {
   private pcmBytesCollected: number = 0;
   private readonly PCM_MAX_CACHE_BYTES = 30 * 1024 * 1024; // 30MB
 
-  // AudioFocus wird verzoegert freigegeben — wenn ARIA eine zweite Antwort
-  // direkt hinterherschickt (oder ein neuer Stream startet), bleibt Spotify
-  // pausiert. Ohne diese Verzoegerung springt Spotify im Mikro-Sekunden-Gap
-  // zwischen zwei Streams kurz wieder an.
-  private focusReleaseTimer: ReturnType<typeof setTimeout> | null = null;
-  private readonly FOCUS_RELEASE_DELAY_MS = 800;
-
-  // Conversation-Mode: solange aktiv (Wake-Word Status 'conversing' ODER
-  // wir wissen "ARIA spricht gerade in einem Multi-Turn-Dialog"), halten wir
-  // den AudioFocus DAUERHAFT. Der per-Stream-Release wird unterdrueckt,
-  // damit Spotify nicht in Render-Pausen oder zwischen Antworten zurueckkehrt.
-  private _conversationFocusActive: boolean = false;
-
   // VAD State
   private vadEnabled: boolean = false;
   private lastSpeechTime: number = 0;
   private vadTimer: ReturnType<typeof setInterval> | null = null;
   private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
-  // Latch damit der Silence-Callback pro Aufnahme genau einmal feuert
-  private silenceFired: boolean = false;
   private noSpeechTimer: ReturnType<typeof setTimeout> | null = null;
-  // Adaptive Schwellen — werden in den ersten 500ms aus dem Mikro-Pegel
-  // gemessen. baseline = avg dB der ersten 5 Samples, dann:
-  //   silence  = baseline + VAD_SILENCE_OFFSET_DB  (6dB ueber ambient)
-  //   speech   = baseline + VAD_SPEECH_OFFSET_DB   (12dB ueber ambient = klares Reden)
-  // Funktioniert sowohl im stillen Buero als auch im lauten Cafe.
-  private vadBaselineSamples: number[] = [];
-  private vadAdaptiveSilenceDb: number = VAD_SILENCE_FALLBACK_DB;
-  private vadAdaptiveSpeechDb: number = VAD_SPEECH_FALLBACK_DB;
-
-  // Interruption-Tracking fuer Auto-Resume nach Anruf:
-  // - playbackStartTime: ms-Timestamp wenn AudioTrack tatsaechlich anfing
-  //   abzuspielen (= _firePlaybackStarted)
-  // - currentPlaybackMsgId: welche Antwort lief gerade
-  // - pausedPosition / pausedMessageId: bei captureInterruption gemerkt
-  private playbackStartTime: number = 0;
-  private currentPlaybackMsgId: string = '';
-  private pausedPosition: number = 0;       // Sekunden in der Audio-Datei
-  private pausedMessageId: string = '';
-  private resumeSound: Sound | null = null;  // halten damit GC nicht zuschlaegt
-  // Leading-Silence wird im Native vor den Chunks geschrieben — beim
-  // Position-Berechnen vom playbackStarted abziehen
-  private readonly LEADING_SILENCE_SEC = 0.3;
 
   constructor() {
     this.recorder = new AudioRecorderPlayer();
     this.recorder.setSubscriptionDuration(0.1); // 100ms Metering-Updates
-    // Native Event: AudioTrack hat alle Samples wirklich durchgespielt (nach
-    // dem finally{}-Block im Writer-Thread). ERST jetzt darf AudioFocus
-    // freigegeben werden — sonst spielt Spotify schon waehrend ARIA noch
-    // redet (PcmStreamPlayer.end() returnt mit 15s-Cap viel zu frueh).
-    if (PcmStreamPlayer) {
-      try {
-        const emitter = new NativeEventEmitter(NativeModules.PcmStreamPlayer as any);
-        emitter.addListener('PcmPlaybackFinished', () => {
-          console.log('[Audio] PcmPlaybackFinished — Focus jetzt freigeben');
-          this._releaseFocusDeferred();
-        });
-      } catch (err) {
-        console.warn('[Audio] PcmPlaybackFinished-Subscription fehlgeschlagen:', err);
-      }
-    }
-    // App-Start: orphaned aria_tts_*.wav / aria_recording_*.mp4 aus dem Cache
-    // wegraeumen. Sammeln sich an wenn Sound mid-playback gestoppt wird (Anruf,
-    // Mute, Barge-In) — der completion-callback feuert dann nicht und die Datei
-    // bleibt liegen. 5min-Threshold damit gerade aktiv geschriebene Files sicher
-    // sind. cleanupOnStartup ist async, blockt den Constructor nicht.
-    this._cleanupStaleCacheFiles(5 * 60 * 1000).catch(() => {});
-  }
-
-  /** AudioFocus mit kleiner Verzoegerung freigeben — Spotify/YouTube
-   *  springen sonst im Gap zwischen zwei TTS-Streams (oder wenn ARIA
-   *  eine zweite Antwort direkt hinterherschickt) kurz wieder an.
-   *  Im Conversation-Mode (Wake-Word conversing) wird das Release komplett
-   *  unterdrueckt — der Focus bleibt fuer die ganze Konversation gehalten. */
-  private _releaseFocusDeferred(): void {
-    if (this._conversationFocusActive) {
-      console.log('[Audio] _releaseFocusDeferred: Conversation aktiv → kein Release');
-      this._cancelDeferredFocusRelease();
-      return;
-    }
-    this._cancelDeferredFocusRelease();
-    console.log('[Audio] _releaseFocusDeferred: in %dms', this.FOCUS_RELEASE_DELAY_MS);
-    this.focusReleaseTimer = setTimeout(() => {
-      this.focusReleaseTimer = null;
-      if (this._conversationFocusActive) {
-        console.log('[Audio] Focus-Release abgebrochen (Conversation jetzt aktiv)');
-        return;
-      }
-      console.log('[Audio] AudioFocus jetzt released');
-      AudioFocus?.release().catch(() => {});
-    }, this.FOCUS_RELEASE_DELAY_MS);
-  }
-
-  private _cancelDeferredFocusRelease(): void {
-    if (this.focusReleaseTimer) {
-      clearTimeout(this.focusReleaseTimer);
-      this.focusReleaseTimer = null;
-    }
-  }
-
-  /** Conversation-Mode beginnt → AudioFocus dauerhaft halten (Spotify bleibt
-   *  pausiert). Idempotent: mehrfaches Aufrufen ist sicher. */
-  acquireConversationFocus(): void {
-    if (this._conversationFocusActive) return;
-    this._conversationFocusActive = true;
-    this._cancelDeferredFocusRelease();
-    console.log('[Audio] Conversation-Focus aktiv (Spotify bleibt gepaust)');
-    AudioFocus?.requestDuck().catch(() => {});
-  }
-
-  /** Conversation-Mode endet → Focus darf wieder freigegeben werden
-   *  (verzoegert, damit eine direkt folgende Antwort nichts kaputtmacht). */
-  releaseConversationFocus(): void {
-    if (!this._conversationFocusActive) return;
-    this._conversationFocusActive = false;
-    console.log('[Audio] Conversation-Focus inaktiv');
-    this._releaseFocusDeferred();
-  }
-
-  /** TTS-Wiedergabe haart stoppen — z.B. fuer Barge-In. Buffer wird geleert,
-   *  kein Auto-Resume. Released auch sofort den AudioFocus. */
-  haltAllPlayback(reason: string = ''): void {
-    console.log('[Audio] haltAllPlayback: %s', reason || '(no reason)');
-    this._conversationFocusActive = false;
-    this.stopPlayback();
-  }
-
-  /** Speziell fuer Anrufe: AudioTrack stoppen + Focus releasen, ABER pcm-
-   *  Buffer + messageId behalten damit weitere Chunks der unterbrochenen
-   *  Antwort weiter gesammelt werden. isFinal schreibt dann die WAV trotz
-   *  Anruf — und resumeFromInterruption findet sie. */
-  pauseForCall(reason: string = ''): void {
-    console.log('[Audio] pauseForCall: %s', reason || '(no reason)');
-    this._conversationFocusActive = false;
-    this._pausedForCall = true;
-    // Queue + isPlaying ruecksetzen — sonst klemmt der naechste Play-Button
-    // (playAudio sieht isPlaying=true und ruft _playNext nicht mehr auf).
-    this.audioQueue = [];
-    this.isPlaying = false;
-    // Foreground-Service stoppen — Notification waere sonst irrefuehrend
-    stopBackgroundAudio().catch(() => {});
-    // SoundPool/RNSound (Resume-Sound, Play-Button) stoppen — nicht relevant fuer Auto-Resume
-    if (this.currentSound) {
-      try { this.currentSound.stop(); this.currentSound.release(); } catch {}
-      this.currentSound = null;
-    }
-    if (this.resumeSound) {
-      try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
-      this.resumeSound = null;
-    }
-    // AudioTrack hart stoppen damit nichts mehr aus dem Lautsprecher kommt.
-    // pcmStreamActive bleibt true, pcmBuffer/pcmMessageId BLEIBEN — damit
-    // weitere Chunks gesammelt werden und isFinal die WAV schreiben kann.
-    PcmStreamPlayer?.stop().catch(() => {});
-    this._cancelDeferredFocusRelease();
-    AudioFocus?.release().catch(() => {});
-  }
-
-  /** Anruf vorbei → weitere Chunks duerfen wieder abgespielt werden.
-   *  resumeFromInterruption uebernimmt die Wiedergabe ab gemerkter Position. */
-  endCallPause(): void {
-    if (!this._pausedForCall) return;
-    this._pausedForCall = false;
-    console.log('[Audio] endCallPause');
-  }
-
-  /** Bei Anruf: aktuelle Wiedergabe-Position merken damit wir nach dem
-   *  Auflegen von dort weitermachen koennen. Returnt Position in Sekunden
-   *  oder 0 wenn nichts spielte.
-   *
-   *  Idempotent: bei mehrfachem Aufruf (ringing → offhook) wird die Position
-   *  vom ersten Mal NICHT ueberschrieben. playbackStartTime laeuft stumpf
-   *  weiter obwohl das Audio gestoppt ist — der erste Halt ist der echte. */
-  captureInterruption(): number {
-    if (this.pausedMessageId) {
-      console.log('[Audio] captureInterruption: bereits erfasst (msgId=%s pos=%ss) — skip',
-                  this.pausedMessageId, this.pausedPosition.toFixed(2));
-      return this.pausedPosition;
-    }
-    if (!this.playbackStartTime || !this.currentPlaybackMsgId) {
-      console.log('[Audio] captureInterruption: nichts spielte (startTime=%s, msgId=%s)',
-                  this.playbackStartTime, this.currentPlaybackMsgId || '(leer)');
-      this.pausedPosition = 0;
-      this.pausedMessageId = '';
-      return 0;
-    }
-    const elapsedMs = Date.now() - this.playbackStartTime;
-    const positionSec = Math.max(0, elapsedMs / 1000 - this.LEADING_SILENCE_SEC);
-    this.pausedPosition = positionSec;
-    this.pausedMessageId = this.currentPlaybackMsgId;
-    console.log('[Audio] captureInterruption: msgId=%s pos=%ss',
-                this.pausedMessageId, positionSec.toFixed(2));
-    return positionSec;
-  }
-
-  /** Nach Anruf-Ende: ab gemerkter Position weiterspielen. Wenn Cache noch
-   *  nicht geschrieben (final kam waehrend Anruf vielleicht doch nicht),
-   *  warten bis maxWaitMs und dann probieren. Returnt true wenn gestartet. */
-  async resumeFromInterruption(maxWaitMs: number = 30000): Promise<boolean> {
-    const msgId = this.pausedMessageId;
-    const position = this.pausedPosition;
-    if (!msgId) {
-      console.log('[Audio] resumeFromInterruption: kein gemerkter Stand — skip');
-      return false;
-    }
-    console.log('[Audio] resumeFromInterruption: starte fuer msgId=%s pos=%ss',
-                msgId, position.toFixed(2));
-    this.pausedMessageId = '';  // konsumieren
-    const cachePath = `${RNFS.DocumentDirectoryPath}/tts_cache/${msgId}.wav`;
-    const startTime = Date.now();
-    while (Date.now() - startTime < maxWaitMs) {
-      try {
-        if (await RNFS.exists(cachePath)) {
-          return await this._playFromPathAtPosition(cachePath, position);
-        }
-      } catch {}
-      await new Promise(r => setTimeout(r, 500));
-    }
-    console.warn('[Audio] resumeFromInterruption: WAV %s nicht binnen %dms verfuegbar',
-                  msgId, maxWaitMs);
-    return false;
-  }
-
-  private async _playFromPathAtPosition(path: string, positionSec: number): Promise<boolean> {
-    try {
-      // Bestehende laufende Wiedergabe abbrechen damit wir sauber starten
-      if (this.resumeSound) {
-        try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
-        this.resumeSound = null;
-      }
-      const sound = await new Promise<Sound>((resolve, reject) => {
-        const s = new Sound(path.replace(/^file:\/\//, ''), '', (err) =>
-          err ? reject(err) : resolve(s));
-      });
-      // Audio-Focus anfordern damit Spotify pausiert
-      this._cancelDeferredFocusRelease();
-      AudioFocus?.requestDuck().catch(() => {});
-      this._firePlaybackStarted();
-      this.isPlaying = true;
-      this.resumeSound = sound;
-      // Tracking auch fuer den Resume-Sound aktualisieren — sonst kann
-      // captureInterruption bei einem zweiten Anruf die Position nicht
-      // mehr ermitteln (playbackStartTime waere von der ersten Wiedergabe).
-      const msgIdMatch = path.match(/([^/\\]+)\.wav$/i);
-      if (msgIdMatch) this.currentPlaybackMsgId = msgIdMatch[1];
-      // Virtuelle Start-Zeit so setzen, dass captureInterruption (das den
-      // Leading-Silence-Offset wieder abzieht) die korrekte Position liefert.
-      this.playbackStartTime = Date.now() - (positionSec + this.LEADING_SILENCE_SEC) * 1000;
-      console.log('[Audio] Resume von Position %ss aus %s',
-                  positionSec.toFixed(2), path);
-      sound.setCurrentTime(Math.max(0, positionSec));
-      sound.play((success) => {
-        if (!success) console.warn('[Audio] Resume-Wiedergabe fehlgeschlagen');
-        try { sound.release(); } catch {}
-        if (this.resumeSound === sound) this.resumeSound = null;
-        this.isPlaying = false;
-        this.playbackFinishedListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] cb err:', e); }
-        });
-        this._releaseFocusDeferred();
-      });
-      return true;
-    } catch (err: any) {
-      console.warn('[Audio] _playFromPathAtPosition fehlgeschlagen:', err?.message || err);
-      return false;
-    }
-  }
-
-  /** True wenn ARIA gerade was abspielt — egal ob WAV-Queue oder PCM-Stream.
-   *  Nuetzlich fuer "Barge-In": wenn der User spricht waehrend ARIA spricht,
-   *  soll die ARIA-Wiedergabe abgebrochen + die neue User-Message verarbeitet
-   *  werden ("ach vergiss es, mach lieber X"). */
-  isPlayingAudio(): boolean {
-    return this.isPlaying || this.pcmStreamActive;
   }
 
   // --- Berechtigungen ---
@@ -575,12 +242,6 @@ class AudioService {
 
       this.recordingPath = `${RNFS.CachesDirectoryPath}/aria_recording_${Date.now()}.mp4`;
 
-      // Foreground-Service VOR dem AudioRecord starten — sonst blockt Android
-      // den Background-Mic-Zugriff (foregroundServiceType=microphone muss zum
-      // Zeitpunkt des startRecorder() schon aktiv sein, sonst greifen die
-      // Background-Mic-Restrictions ab Android 11+).
-      await acquireBackgroundAudio('rec');
-
       // Aufnahme mit Metering starten
       await this.recorder.startRecorder(this.recordingPath, {
         AudioEncoderAndroid: AudioEncoderAndroidType.AAC,
@@ -595,36 +256,8 @@ class AudioService {
         const db = e.currentMetering ?? -160;
         this.meterListeners.forEach(cb => cb(db));
 
-        // Adaptive Baseline: erste 5 Samples (~500ms) sammeln, dann Schwellen
-        // anpassen. -160 (kein Metering) ignorieren — sonst wird die Baseline
-        // sinnlos niedrig.
-        if (this.vadBaselineSamples.length < VAD_BASELINE_SAMPLES) {
-          if (db > -100) {
-            this.vadBaselineSamples.push(db);
-            if (this.vadBaselineSamples.length === VAD_BASELINE_SAMPLES) {
-              // Minimum statt Mittelwert: robust gegen Spike-Samples (z.B. wenn
-              // der User direkt nach Wake-Word sofort spricht oder das Wake-Word-
-              // Echo noch im Mikro ist). Min ist der ruhigste Moment.
-              const lowest = Math.min(...this.vadBaselineSamples);
-              const rawSilence = lowest + VAD_SILENCE_OFFSET_DB;
-              const rawSpeech = lowest + VAD_SPEECH_OFFSET_DB;
-              // Cap auf einen vernuenftigen Bereich:
-              // - Silence-Schwelle nicht ueber -28dB (sonst zaehlt Hintergrund-
-              //   geraeusch dauerhaft als "Sprache" → VAD feuert nie)
-              // - Silence-Schwelle nicht unter -50dB (sonst zu strikt)
-              this.vadAdaptiveSilenceDb = Math.max(-50, Math.min(rawSilence, -28));
-              this.vadAdaptiveSpeechDb = Math.max(-40, Math.min(rawSpeech, -18));
-              const msg = `VAD: ambient=${lowest.toFixed(0)}dB stille>${this.vadAdaptiveSilenceDb.toFixed(0)}dB`;
-              console.log('[Audio] %s speech>%s (raw silence=%s speech=%s)',
-                          msg, this.vadAdaptiveSpeechDb.toFixed(1),
-                          rawSilence.toFixed(1), rawSpeech.toFixed(1));
-              try { ToastAndroid.show(msg, ToastAndroid.SHORT); } catch {}
-            }
-          }
-        }
-
         // Sprach-Gate: Erkennen ob tatsaechlich gesprochen wird
-        if (db > this.vadAdaptiveSpeechDb) {
+        if (db > VAD_SPEECH_THRESHOLD_DB) {
           if (!this.speechDetected && this.speechStartTime === 0) {
             this.speechStartTime = Date.now();
           }
@@ -639,7 +272,7 @@ class AudioService {
 
         // VAD: Stille erkennen (nur wenn Sprache erkannt wurde)
         if (this.vadEnabled) {
-          if (db > this.vadAdaptiveSilenceDb) {
+          if (db > VAD_SILENCE_THRESHOLD_DB) {
             this.lastSpeechTime = Date.now();
           }
         }
@@ -649,71 +282,38 @@ class AudioService {
       this.lastSpeechTime = Date.now();
       this.speechDetected = false;
       this.speechStartTime = 0;
-      // VAD-Adaptive zurueckgesetzt: Baseline wird in den ersten 500ms neu
-      // gemessen. Bis dahin gelten die Fallback-Schwellen.
-      this.vadBaselineSamples = [];
-      this.vadAdaptiveSilenceDb = VAD_SILENCE_FALLBACK_DB;
-      this.vadAdaptiveSpeechDb = VAD_SPEECH_FALLBACK_DB;
-
-      // Manueller Override aus Settings — wenn gesetzt, wird die adaptive
-      // Baseline-Messung uebersteuert. User-Wahl gewinnt vor Auto-Magic.
-      const dbOverride = await loadVadSilenceDbOverride();
-      if (dbOverride != null) {
-        this.vadAdaptiveSilenceDb = dbOverride;
-        this.vadAdaptiveSpeechDb = dbOverride + 10;  // Speech klar ueber Stille
-        this.vadBaselineSamples = new Array(VAD_BASELINE_SAMPLES).fill(0);  // Baseline-Sammeln deaktivieren
-        const msg = `VAD: manuell stille>${dbOverride}dB`;
-        console.log('[Audio] %s', msg);
-        try { ToastAndroid.show(msg, ToastAndroid.SHORT); } catch {}
-      }
       this.setState('recording');
 
       // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
-      this._cancelDeferredFocusRelease();
       AudioFocus?.requestExclusive().catch(() => {});
 
-      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar).
-      // WICHTIG: jeder Trigger (VAD-Stille / Max-Dauer / No-Speech-Window)
-      // disable SOFORT den VAD-Flag und clear den Timer, BEVOR die Listener
-      // gefeuert werden. Sonst feuert das setInterval weiter alle 200ms und
-      // ruft stopRecording parallel auf → audio-recorder-player crasht.
+      // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar)
       this.vadEnabled = autoStop;
-      this.silenceFired = false;
-      const fireSilenceOnce = (reason: string) => {
-        if (this.silenceFired) return;
-        this.silenceFired = true;
-        this.vadEnabled = false;
-        if (this.vadTimer) { clearInterval(this.vadTimer); this.vadTimer = null; }
-        if (this.maxDurationTimer) { clearTimeout(this.maxDurationTimer); this.maxDurationTimer = null; }
-        if (this.noSpeechTimer) { clearTimeout(this.noSpeechTimer); this.noSpeechTimer = null; }
-        console.log('[Audio] Silence-Fire: %s', reason);
-        this.silenceListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] silence listener err:', e); }
-        });
-      };
       if (autoStop) {
         const vadSilenceMs = await loadVadSilenceMs();
-        const maxRecordingMs = await loadMaxRecordingMs();
-        console.log('[Audio] startRecording: autoStop=true, VAD-Stille=%dms, MAX=%dms',
-                    vadSilenceMs, maxRecordingMs);
+        console.log('[Audio] VAD-Stille:', vadSilenceMs, 'ms');
         this.vadTimer = setInterval(() => {
           const silenceDuration = Date.now() - this.lastSpeechTime;
           if (silenceDuration >= vadSilenceMs) {
-            fireSilenceOnce(`VAD ${silenceDuration}ms Stille (Schwelle=${vadSilenceMs}ms)`);
+            console.log(`[Audio] VAD: ${silenceDuration}ms Stille — Auto-Stop`);
+            this.silenceListeners.forEach(cb => cb());
           }
         }, 200);
-        // Notbremse: Nach maxRecordingMs zwangsweise stoppen
+        // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
         this.maxDurationTimer = setTimeout(() => {
-          fireSilenceOnce(`Max-Dauer ${maxRecordingMs}ms`);
-        }, maxRecordingMs);
+          console.warn(`[Audio] Max-Dauer ${MAX_RECORDING_MS}ms erreicht — Zwangs-Stop`);
+          this.silenceListeners.forEach(cb => cb());
+        }, MAX_RECORDING_MS);
       }
 
       // Conversation-Window: Wenn der User innerhalb noSpeechTimeoutMs nicht
-      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie).
+      // anfaengt zu sprechen → Aufnahme abbrechen (Speech-Gate verwirft sie),
+      // ChatScreen erkennt das und beendet die Konversation.
       if (noSpeechTimeoutMs > 0) {
         this.noSpeechTimer = setTimeout(() => {
           if (!this.speechDetected && this.recordingState === 'recording') {
-            fireSilenceOnce(`Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache`);
+            console.log(`[Audio] Conversation-Window ${noSpeechTimeoutMs}ms ohne Sprache — Stop`);
+            this.silenceListeners.forEach(cb => cb());
           }
         }, noSpeechTimeoutMs);
       }
@@ -753,9 +353,8 @@ class AudioService {
       await this.recorder.stopRecorder();
       this.recorder.removeRecordBackListener();
 
-      // Audio-Focus verzoegert freigeben — gleich kommt die TTS-Antwort,
-      // im Gap soll Spotify nicht hochkommen.
-      this._releaseFocusDeferred();
+      // Audio-Focus freigeben — andere Apps duerfen wieder
+      AudioFocus?.release().catch(() => {});
 
       const durationMs = Date.now() - this.recordingStartTime;
       const hadSpeech = this.speechDetected;
@@ -794,15 +393,8 @@ class AudioService {
   /** Base64-kodiertes Audio in die Queue stellen und abspielen */
   async playAudio(base64Data: string): Promise<void> {
     if (!base64Data) return;
-    // Mute-Flag respektieren — robust gegen Race-Conditions zwischen User-
-    // Klick auf Mute und einem TTS-Chunk der im selben Tick eintrifft.
-    if (this._muted) {
-      console.log('[Audio] playAudio: muted=true → skip');
-      return;
-    }
+
     this.audioQueue.push(base64Data);
-    console.log('[Audio] playAudio: queued (queue=%d isPlaying=%s pausedForCall=%s)',
-                this.audioQueue.length, this.isPlaying, this._pausedForCall);
     if (!this.isPlaying) {
       this._playNext();
     }
@@ -834,13 +426,7 @@ class AudioService {
 
   /** Einen PCM-Chunk aus einer audio_pcm Nachricht empfangen.
    *  silent=true → nur cachen, nicht abspielen (z.B. wenn TTS geraetelokal gemutet).
-   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached.
-   *
-   *  Wrapper serialisiert aufeinanderfolgende Chunk-Calls via Promise-Queue —
-   *  sonst gabs bei kurzen Streams einen Race: final-Chunk konnte `end()` rufen
-   *  BEVOR der vorherige `start()` im Native-Modul fertig war. Der Writer-
-   *  Thread sah dann endRequested=true ohne jemals Chunks zu verarbeiten. */
-  private _pcmChunkQueue: Promise<any> = Promise.resolve();
+   *  Gibt bei final=true den Cache-Pfad zurueck (file://) oder '' wenn nicht gecached. */
   async handlePcmChunk(payload: {
     base64: string;
     sampleRate?: number;
@@ -850,45 +436,11 @@ class AudioService {
     final?: boolean;
     silent?: boolean;
   }): Promise<string> {
-    const p = this._pcmChunkQueue.then(() => this._handlePcmChunkImpl(payload)).catch(err => {
-      console.warn('[Audio] handlePcmChunk queued err:', err);
-      return '';
-    });
-    // Chain only on the side effect — callers still get the per-call result
-    this._pcmChunkQueue = p;
-    return p;
-  }
-
-  private async _handlePcmChunkImpl(payload: {
-    base64: string;
-    sampleRate?: number;
-    channels?: number;
-    messageId?: string;
-    chunk?: number;
-    final?: boolean;
-    silent?: boolean;
-  }): Promise<string> {
-    // _stoppedMessageId: User hat diese Antwort mid-Wiedergabe gestoppt
-    // (Mute geklickt). Auch wenn Mute jetzt wieder aus ist, soll diese
-    // Antwort nicht weiterspielen. Erst eine neue messageId resetted das.
-    const incomingMsgId = payload.messageId || '';
-    const stoppedByUser = !!this._stoppedMessageId && incomingMsgId === this._stoppedMessageId;
-    // Globaler Mute-Flag uebersteuert das per-Call silent — verhindert
-    // Race-Conditions wenn der User zwischen Chunks den Mute-Knopf drueckt.
-    // _pausedForCall: AudioTrack ist gestoppt waehrend Anruf — Chunks weiter
-    // sammeln (fuer WAV-Cache), aber NICHT in den Player schicken.
-    const silent = !!payload.silent || this._muted || this._pausedForCall || stoppedByUser;
+    const silent = !!payload.silent;
     if (!silent && !PcmStreamPlayer) {
       console.warn('[Audio] PcmStreamPlayer Native Module nicht verfuegbar');
       return '';
     }
-    // Debug-Log bei Chunk 0 eines neuen Streams — damit man im adb logcat
-    // sieht warum der Auto-Playback greift oder nicht.
-    if ((payload.chunk ?? 0) === 0 && !this.pcmStreamActive) {
-      console.log('[Audio] PCM-Stream start: silent=%s messageId=%s sr=%s ch=%s',
-                  silent, payload.messageId || '(none)',
-                  payload.sampleRate, payload.channels);
-    }
 
     const messageId = payload.messageId || '';
     const sampleRate = payload.sampleRate || 24000;
@@ -903,28 +455,6 @@ class AudioService {
         this.pcmBuffer = [];
         this.pcmBytesCollected = 0;
       }
-      // Resume-Sound stoppen falls noch aktiv (User hat nach Anruf eine
-      // neue Frage gestellt — die alte interruptierte Antwort ist obsolet).
-      if (this.resumeSound) {
-        try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
-        this.resumeSound = null;
-      }
-      // Pending Auto-Resume verwerfen wenn die neue Antwort eine andere
-      // messageId hat. Sonst spielt nach 30s-Wartezeit der Resume die
-      // ueberholte Antwort ab.
-      if (this.pausedMessageId && this.pausedMessageId !== messageId) {
-        console.log('[Audio] Neue TTS-Antwort (msgId=%s) — Auto-Resume fuer %s verworfen',
-                    messageId, this.pausedMessageId);
-        this.pausedMessageId = '';
-        this.pausedPosition = 0;
-      }
-      // Stop-Marker zuruecksetzen wenn neue messageId — neue Antwort darf
-      // wieder normal abspielen, egal ob Mute zwischendurch aktiv war.
-      if (this._stoppedMessageId && this._stoppedMessageId !== messageId) {
-        console.log('[Audio] Neue Antwort (msgId=%s) — Stop-Marker fuer %s zurueckgesetzt',
-                    messageId, this._stoppedMessageId);
-        this._stoppedMessageId = '';
-      }
       this.pcmStreamActive = true;
       this.pcmMessageId = messageId;
       this.pcmSampleRate = sampleRate;
@@ -940,9 +470,7 @@ class AudioService {
           this.pcmStreamActive = false;
           return '';
         }
-        this._cancelDeferredFocusRelease();
         AudioFocus?.requestDuck().catch(() => {});
-        this._firePlaybackStarted();
       }
     }
 
@@ -959,16 +487,12 @@ class AudioService {
 
     if (isFinal) {
       if (!silent) {
-        // end() signalisiert dem Writer "keine weiteren Chunks". Aber WIR
-        // releasen den AudioFocus NICHT hier — der writer braucht u.U. noch
-        // 30+ Sekunden bis der Buffer wirklich abgespielt ist. Den release
-        // triggert das native Event "PcmPlaybackFinished" wenn AudioTrack
-        // wirklich am Ende ist (siehe ensurePlaybackFinishedListener).
+        // end() resolved jetzt erst wenn der native Writer-Thread fertig
+        // ist (alle Samples ausgespielt) — danach erst AudioFocus freigeben,
+        // damit Spotify/YouTube nicht waehrend des Pre-Roll-Ausklangs
+        // wieder aufdrehen.
         try { await PcmStreamPlayer!.end(); } catch {}
-        // playbackFinished-Listener informieren (UI-Logik)
-        this.playbackFinishedListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] playbackFinished cb err:', e); }
-        });
+        AudioFocus?.release().catch(() => {});
       }
       this.pcmStreamActive = false;
 
@@ -1042,10 +566,7 @@ class AudioService {
     }
   }
 
-  /** Audio aus lokaler Datei (file:// Pfad) in die Queue und abspielen.
-   *  Setzt zusaetzlich playbackStartTime + currentPlaybackMsgId damit ein
-   *  Anruf waehrend dieses Playbacks korrekt erfasst wird (ohne dieses
-   *  Tracking liefert captureInterruption nichts → kein Auto-Resume). */
+  /** Audio aus lokaler Datei (file:// Pfad) in die Queue und abspielen. */
   async playFromPath(filePath: string): Promise<void> {
     if (!filePath) return;
     try {
@@ -1054,14 +575,6 @@ class AudioService {
         console.warn('[Audio] Cache-Datei existiert nicht mehr:', cleanPath);
         return;
       }
-      // Dateiname ohne .wav als messageId nehmen (egal ob UUID oder andere ID)
-      const fileMatch = cleanPath.match(/([^/\\]+)\.wav$/i);
-      const msgId = fileMatch ? fileMatch[1] : '';
-      console.log('[Audio] playFromPath: cleanPath=%s → msgId=%s', cleanPath, msgId || '(leer)');
-      if (msgId) {
-        this.currentPlaybackMsgId = msgId;
-        this.playbackStartTime = Date.now() - this.LEADING_SILENCE_SEC * 1000;
-      }
       const b64 = await RNFS.readFile(cleanPath, 'base64');
       this.playAudio(b64);
     } catch (err) {
@@ -1071,7 +584,6 @@ class AudioService {
 
   // Callback wenn alle Audio-Teile abgespielt sind
   private playbackFinishedListeners: (() => void)[] = [];
-  private playbackStartedListeners: (() => void)[] = [];
 
   onPlaybackFinished(callback: () => void): () => void {
     this.playbackFinishedListeners.push(callback);
@@ -1080,47 +592,20 @@ class AudioService {
     };
   }
 
-  /** Callback wenn ARIAs TTS-Wiedergabe startet — fuer Wake-Word-parallel-
-   *  Listening waehrend ARIA spricht (Barge-In via "Computer" sagen). */
-  onPlaybackStarted(callback: () => void): () => void {
-    this.playbackStartedListeners.push(callback);
-    return () => {
-      this.playbackStartedListeners = this.playbackStartedListeners.filter(cb => cb !== callback);
-    };
-  }
-
-  private _firePlaybackStarted(): void {
-    // Tracking fuer Auto-Resume nach Anruf-Pause: NUR setzen wenn ein
-    // PCM-Stream laeuft (Live-TTS). Bei Play-Button / Resume-Sound hat der
-    // Caller (playFromPath / _playFromPathAtPosition) das Tracking schon
-    // korrekt mit der msgId aus dem Pfad gesetzt — sonst wuerden wir hier
-    // mit leerem pcmMessageId ueberschreiben.
-    if (this.pcmMessageId) {
-      this.playbackStartTime = Date.now();
-      this.currentPlaybackMsgId = this.pcmMessageId;
-    }
-    this.playbackStartedListeners.forEach(cb => {
-      try { cb(); } catch (e) { console.warn('[Audio] playbackStarted listener err:', e); }
-    });
-  }
-
   /** Naechstes Audio aus der Queue abspielen */
   private async _playNext(): Promise<void> {
     if (this.audioQueue.length === 0) {
       this.isPlaying = false;
-      // Audio-Focus verzoegert abgeben → wenn gleich noch eine Antwort kommt,
-      // bleibt Spotify pausiert.
-      this._releaseFocusDeferred();
+      // Audio-Focus abgeben → andere Apps volle Lautstaerke
+      AudioFocus?.release().catch(() => {});
       // Alle Audio-Teile abgespielt → Listener benachrichtigen
       this.playbackFinishedListeners.forEach(cb => cb());
       return;
     }
 
-    // Beim ersten Playback-Start: andere Apps ducken + Listener informieren
+    // Beim ersten Playback-Start: andere Apps ducken
     if (!this.isPlaying) {
-      this._cancelDeferredFocusRelease();
       AudioFocus?.requestDuck().catch(() => {});
-      this._firePlaybackStarted();
     }
     this.isPlaying = true;
 
@@ -1151,13 +636,11 @@ class AudioService {
     }
 
     this.currentSound = sound;
-    console.log('[Audio] Sound.play startet (path=%s)', soundPath);
 
     // Naechstes Audio schon vorbereiten waehrend dieses abspielt
     this._preloadNext();
 
     sound.play((success) => {
-      console.log('[Audio] Sound.play callback: success=%s queue=%d', success, this.audioQueue.length);
       if (!success) console.warn('[Audio] Wiedergabe fehlgeschlagen');
       sound.release();
       this.currentSound = null;
@@ -1184,51 +667,8 @@ class AudioService {
     }
   }
 
-  /** Mute: alle eingehenden TTS-Chunks/WAVs werden ignoriert bis wieder
-   *  unmuted. Robuster als ein React-Ref weil hier kein Re-Render-Race ist
-   *  — die Bridge kann einen Chunk im selben JS-Tick liefern in dem der
-   *  User Mute geklickt hat. */
-  private _muted: boolean = false;
-  /** Anruf laeuft → Chunks werden nur in den Cache-Buffer gepusht, nicht
-   *  abgespielt. Wird in pauseForCall gesetzt, in endCallPause/resumeFrom-
-   *  Interruption zurueckgenommen. */
-  private _pausedForCall: boolean = false;
-  /** Wenn der User mid-Wiedergabe Mute drueckt: messageId der ABGEBROCHENEN
-   *  Antwort merken. Folge-Chunks dieser msgId werden silent ignoriert, auch
-   *  wenn der User Mute wieder ausschaltet — kein "Resume mid-Antwort". Eine
-   *  NEUE messageId resetted das, dann spielt's wieder normal. */
-  private _stoppedMessageId: string = '';
-  setMuted(muted: boolean): void {
-    console.log('[Audio] setMuted: %s (currentSound=%s pcmStreamActive=%s)',
-                muted, this.currentSound ? 'aktiv' : 'null', this.pcmStreamActive);
-    this._muted = muted;
-    if (muted) {
-      // Aktuell laufende Antwort als "verworfen" markieren — nachfolgende
-      // chunks dieser msgId werden silent gehalten auch wenn der User Mute
-      // gleich wieder ausschaltet. Erst eine NEUE Antwort darf wieder reden.
-      const activeMsgId = this.pcmMessageId || this.currentPlaybackMsgId;
-      if (activeMsgId) {
-        this._stoppedMessageId = activeMsgId;
-        console.log('[Audio] Antwort %s als gestoppt markiert', activeMsgId);
-      }
-      this.stopPlayback();
-    }
-  }
-  isMuted(): boolean { return this._muted; }
-
   /** Laufende Wiedergabe stoppen + Queue leeren */
   stopPlayback(): void {
-    // Idempotent: wenn nichts mehr aktiv ist, NICHT noch einen Focus-Release/
-    // Kick-Cycle anstossen — Re-Renders triggern setMuted oft mehrfach hinter-
-    // einander, und jeder weitere Kick lässt Spotify nochmal kurz pausieren.
-    const hasAnything = !!(this.currentSound || this.resumeSound || this.preloadedSound
-                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying);
-    if (!hasAnything) return;
-    console.log('[Audio] stopPlayback: currentSound=%s queue=%d pcm=%s',
-                this.currentSound ? 'aktiv' : 'null', this.audioQueue.length, this.pcmStreamActive);
-    // Foreground-Service auch stoppen — sonst bleibt die Notification haengen
-    // wenn Wiedergabe abgebrochen wird (Anruf, Cancel, Barge-In).
-    stopBackgroundAudio().catch(() => {});
     this.audioQueue = [];
     this.isPlaying = false;
     if (this.currentSound) {
@@ -1236,32 +676,21 @@ class AudioService {
       this.currentSound.release();
       this.currentSound = null;
     }
-    if (this.resumeSound) {
-      this.resumeSound.stop();
-      this.resumeSound.release();
-      this.resumeSound = null;
-    }
     if (this.preloadedSound) {
       this.preloadedSound.release();
       this.preloadedSound = null;
       if (this.preloadedPath) RNFS.unlink(this.preloadedPath).catch(() => {});
       this.preloadedPath = '';
     }
-    // PCM-Stream ebenfalls hart stoppen (Cancel/Abbruch).
-    // pcmStreamActive wird beim isFinal-Chunk schon false gesetzt — der
-    // AudioTrack spielt aber noch sekundenlang aus seinem Buffer ab. Daher
-    // IMMER stop() aufrufen, ohne den Flag zu pruefen (ist idempotent).
-    PcmStreamPlayer?.stop().catch(() => {});
-    this.pcmStreamActive = false;
-    this.pcmBuffer = [];
-    this.pcmBytesCollected = 0;
-    this.pcmMessageId = '';
-    // Audio-Focus sofort freigeben — User hat explizit abgebrochen.
-    // Unser Focus war TRANSIENT, Spotify resumed darum automatisch beim
-    // Abandon. Den frueheren kickReleaseMedia haben wir entfernt: er
-    // requestete USAGE_MEDIA mit GAIN (permanent), was Spotify als
-    // "user-action stopp" interpretierte und Auto-Resume verhinderte.
-    this._cancelDeferredFocusRelease();
+    // PCM-Stream ebenfalls hart stoppen (Cancel/Abbruch)
+    if (this.pcmStreamActive) {
+      PcmStreamPlayer?.stop().catch(() => {});
+      this.pcmStreamActive = false;
+      this.pcmBuffer = [];
+      this.pcmBytesCollected = 0;
+      this.pcmMessageId = '';
+    }
+    // Audio-Focus freigeben
     AudioFocus?.release().catch(() => {});
   }
 
@@ -1302,29 +731,19 @@ class AudioService {
     }
   }
 
-  /** Alte Aufnahme- und TTS-Files aus dem Cache loeschen.
-   *  Default 30s — verwendet beim Mikro-Start (kurze Lebensdauer reicht).
-   *  App-Start nutzt 5min damit gerade aktive Files nicht erwischt werden. */
-  private async _cleanupStaleCacheFiles(maxAgeMs: number = 30000): Promise<void> {
+  /** Alte Aufnahme- und TTS-Files aus dem Cache loeschen (>30s alt). */
+  private async _cleanupStaleCacheFiles(): Promise<void> {
     try {
       const files = await RNFS.readDir(RNFS.CachesDirectoryPath);
       const now = Date.now();
-      let removed = 0;
-      let freedBytes = 0;
       for (const f of files) {
         if (!f.isFile()) continue;
         if (!f.name.startsWith('aria_recording_') && !f.name.startsWith('aria_tts_')) continue;
         const age = now - (f.mtime ? f.mtime.getTime() : 0);
-        if (age > maxAgeMs) {
-          freedBytes += parseInt(f.size as any, 10) || 0;
+        if (age > 30000) {
           await RNFS.unlink(f.path).catch(() => {});
-          removed += 1;
         }
       }
-      if (removed > 0) {
-        console.log('[Audio] Cache-Cleanup: %d Files entfernt, %.1fMB freigegeben',
-                    removed, freedBytes / 1024 / 1024);
-      }
     } catch {
       // silent — cleanup ist best-effort
     }
@@ -1351,43 +770,6 @@ class AudioService {
       // silent
     }
   }
-
-  /** Aktuelle Groesse des TTS-Caches. */
-  async getTtsCacheSize(): Promise<{ count: number; totalMB: number }> {
-    let count = 0;
-    let total = 0;
-    try {
-      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
-      if (await RNFS.exists(dir)) {
-        const files = await RNFS.readDir(dir);
-        for (const f of files) {
-          if (!f.isFile() || !f.name.endsWith('.wav')) continue;
-          count += 1;
-          total += parseInt(f.size as any, 10) || 0;
-        }
-      }
-    } catch {}
-    return { count, totalMB: total / 1024 / 1024 };
-  }
-
-  /** TTS-Cache komplett leeren (Settings-Button). */
-  async clearTtsCache(): Promise<{ removed: number; freedMB: number }> {
-    let removed = 0;
-    let freed = 0;
-    try {
-      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
-      if (!(await RNFS.exists(dir))) return { removed: 0, freedMB: 0 };
-      const files = await RNFS.readDir(dir);
-      for (const f of files) {
-        if (!f.isFile() || !f.name.endsWith('.wav')) continue;
-        const size = parseInt(f.size as any, 10) || 0;
-        await RNFS.unlink(f.path).catch(() => {});
-        removed += 1;
-        freed += size;
-      }
-    } catch {}
-    return { removed, freedMB: freed / 1024 / 1024 };
-  }
 }
 
 // Singleton

android/src/services/backgroundAudio.ts

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

android/src/services/logger.ts

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

android/src/services/phoneCall.ts

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

android/src/services/updater.ts

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

android/src/services/wakeReadySound.ts

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

android/src/services/wakeword.ts

@@ -1,154 +1,107 @@
 /**
  * Gespraechsmodus / Wake Word Service
  *
- * Wake-Word-Engine: openWakeWord (https://github.com/dscripka/openWakeWord),
- * komplett on-device via ONNX Runtime in Native-Kotlin (siehe
- * OpenWakeWordModule.kt + assets/openwakeword/). Kein API-Key, kein Cloud-
- * Roundtrip, kein Cent Lizenzgebuehren.
- *
  * Drei Zustaende:
  *   off        — Ohr aus, nichts laeuft
- *   armed      — Ohr aktiv, openWakeWord hoert passiv auf das Wake-Word.
- *                Das Mikro ist von OpenWakeWord belegt; AudioRecorder ist aus.
- *   conversing — Wake-Word getriggert (oder Ohr-Tap manuell):
- *                aktive Konversation. OpenWakeWord pausiert (gibt Mikro frei),
+ *   armed      — Ohr aktiv, Porcupine hoert passiv auf das Wake-Word.
+ *                Das Mikro ist von Porcupine belegt; AudioRecorder ist aus.
+ *   conversing — Wake-Word getriggert (oder Ohr-Tap ohne Wake-Word):
+ *                aktive Konversation. Porcupine pausiert (gibt Mikro frei),
  *                AudioRecorder uebernimmt fuer die Aufnahme.
  *                Nach jeder ARIA-Antwort oeffnet das Mikro fuer X Sekunden
  *                (Conversation-Window). Stille im Fenster → zurueck zu armed.
  *
- * Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
- * 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
+ * Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
+ * direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
+ * geht dann nach 'off' statt 'armed'.
  */
 
-import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { acquireBackgroundAudio } from './backgroundAudio';
 
 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;
 
 export type WakeWordState = 'off' | 'armed' | 'conversing';
 
+export const WAKE_ACCESS_KEY_STORAGE = 'aria_wake_access_key';
 export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';
 
-/** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
- *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
- *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
- *  werden — Diagnostic-Upload ist Phase 2. */
-export const WAKE_KEYWORDS = [
-  'hey_jarvis',
+/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
+ *  Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
+ *  Console — wird spaeter ueber Diagnostic uploadbar. */
+export const BUILTIN_KEYWORDS = [
+  'jarvis',
   'computer',
+  'picovoice',
+  'porcupine',
+  'bumblebee',
+  'terminator',
   'alexa',
-  'hey_mycroft',
-  'hey_rhasspy',
+  'hey google',
+  'ok google',
+  'hey siri',
 ] as const;
-export type WakeKeyword = typeof WAKE_KEYWORDS[number];
-export const DEFAULT_KEYWORD: WakeKeyword = 'hey_jarvis';
-
-/** Hilfs-Mapping fuer die Anzeige im UI. */
-export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
-  hey_jarvis: 'Hey Jarvis',
-  computer: 'Computer',
-  alexa: 'Alexa',
-  hey_mycroft: 'Hey Mycroft',
-  hey_rhasspy: 'Hey Rhasspy',
-};
-
-// Detection-Tuning — kann in Settings spaeter konfigurierbar werden.
-const DEFAULT_THRESHOLD = 0.5;
-const DEFAULT_PATIENCE = 2;
-const DEFAULT_DEBOUNCE_MS = 1500;
-
-interface OpenWakeWordModule {
-  init(modelName: string, threshold: number, patience: number, debounceMs: number): Promise<boolean>;
-  start(): Promise<boolean>;
-  stop(): Promise<boolean>;
-  dispose(): Promise<boolean>;
-  isAvailable(): Promise<boolean>;
-}
-
-const { OpenWakeWord } = NativeModules as { OpenWakeWord?: OpenWakeWordModule };
+export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
+export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
 
 class WakeWordService {
   private state: WakeWordState = 'off';
   private wakeCallbacks: WakeWordCallback[] = [];
   private stateCallbacks: StateCallback[] = [];
-  /** Barge-In-Callbacks: feuern wenn Wake-Word WAEHREND ARIA spricht erkannt
-   *  wird. ChatScreen reagiert mit TTS-stop + neuer Aufnahme. */
-  private bargeCallbacks: WakeWordCallback[] = [];
-  /** True solange Wake-Word parallel zu TTS aktiv ist. */
-  private bargeListening: boolean = false;
-  /** Anruf-Pause: state wird gemerkt damit nach Auflegen wiederhergestellt wird. */
-  private callPaused: boolean = false;
-  private preCallState: WakeWordState = 'off';
-  /** Cooldown nach App-Resume: kurze Phase in der Wake-Word-Detections
-   *  ignoriert werden. Beim Wechsel von Background nach Vordergrund gibt's
-   *  oft einen Audio-Pegel-Spike (AudioFocus-Switch, AudioTrack re-route),
-   *  der openWakeWord faelschlich triggern kann. */
-  private cooldownUntilMs: number = 0;
 
-  private keyword: WakeKeyword = DEFAULT_KEYWORD;
-  private nativeReady: boolean = false;
+  // Picovoice Manager (lazy, da Native Module nicht in jedem Build verfuegbar ist)
+  private porcupine: any = null;
+  private accessKey: string = '';
+  private keyword: string = DEFAULT_KEYWORD;
   private initInProgress: Promise<boolean> | null = null;
-  private eventSub: { remove: () => void } | null = null;
 
-  /** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
+  /** Beim App-Start aufrufen — laedt Settings, baut Porcupine wenn Key da ist. */
   async loadFromStorage(): Promise<void> {
     try {
+      const k = await AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE);
       const w = await AsyncStorage.getItem(WAKE_KEYWORD_STORAGE);
-      const wt = (w || DEFAULT_KEYWORD).trim() as WakeKeyword;
-      this.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
-      await this.initNative();
+      this.accessKey = (k || '').trim();
+      this.keyword = (w || DEFAULT_KEYWORD).trim();
+      if (this.accessKey) {
+        // Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
+        await this.initPorcupine();
+      }
     } catch (err) {
       console.warn('[WakeWord] loadFromStorage', err);
     }
   }
 
-  /** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
-  async configure(keyword: string): Promise<boolean> {
-    const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
-      ? (keyword as WakeKeyword)
-      : DEFAULT_KEYWORD;
-    this.keyword = next;
-    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, next);
+  /** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
+  async configure(accessKey: string, keyword: string): Promise<boolean> {
+    this.accessKey = (accessKey || '').trim();
+    this.keyword = (keyword || DEFAULT_KEYWORD).trim();
+    await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
+    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);
 
-    // Laufende Instanz stoppen + neu initialisieren
-    await this.disposeNative();
-    const ok = await this.initNative();
-    if (!ok) {
-      ToastAndroid.show(
-        `Wake-Word "${KEYWORD_LABELS[next]}" konnte nicht initialisiert werden — Logs pruefen`,
-        ToastAndroid.LONG,
-      );
-    }
-    return ok;
+    // Laufende Instanz stoppen
+    await this.disposePorcupine();
+    if (!this.accessKey) return false;
+
+    // Neu initialisieren
+    return this.initPorcupine();
   }
 
-  private async initNative(): Promise<boolean> {
-    if (!OpenWakeWord) {
-      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
-      this.nativeReady = false;
-      return false;
-    }
+  private async initPorcupine(): Promise<boolean> {
     if (this.initInProgress) return this.initInProgress;
     this.initInProgress = (async () => {
       try {
-        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
-        // Subscribe nur einmal
-        if (!this.eventSub) {
-          const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
-          this.eventSub = emitter.addListener('WakeWordDetected', () => {
-            console.log('[WakeWord] Native Detection-Event empfangen');
-            this.onWakeDetected().catch(err =>
-              console.warn('[WakeWord] onWakeDetected crashed:', err));
-          });
-        }
-        this.nativeReady = true;
-        console.log('[WakeWord] Init OK (model=%s)', this.keyword);
+        const { PorcupineManager } = require('@picovoice/porcupine-react-native');
+        // Built-In Keyword-Identifier sind lower-case strings im SDK
+        this.porcupine = await PorcupineManager.fromBuiltInKeywords(
+          this.accessKey,
+          [this.keyword],
+          (_keywordIndex: number) => this.onWakeDetected(),
+        );
+        console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
         return true;
-      } catch (err: any) {
-        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
-        this.nativeReady = false;
+      } catch (err) {
+        console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err);
+        this.porcupine = null;
         return false;
       } finally {
         this.initInProgress = null;
@@ -157,43 +110,30 @@ class WakeWordService {
     return this.initInProgress;
   }
 
-  private async disposeNative(): Promise<void> {
-    if (!OpenWakeWord) return;
-    try { await OpenWakeWord.dispose(); } catch {}
-    this.nativeReady = false;
+  private async disposePorcupine() {
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
+      try { await this.porcupine.delete(); } catch {}
+      this.porcupine = null;
+    }
   }
 
   /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
   async start(): Promise<boolean> {
     if (this.state !== 'off') return true;
-    // Foreground-Service VOR dem Mic-Zugriff hochziehen damit Background-
-    // Lauschen funktioniert (Android braucht foregroundServiceType=microphone
-    // aktiv zum Zeitpunkt des AudioRecord.startRecording).
-    await acquireBackgroundAudio('wake');
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine) {
+      // Passives Lauschen via Porcupine
       try {
-        await OpenWakeWord.start();
-        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
-        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        await this.porcupine.start();
+        console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
         this.setState('armed');
         return true;
-      } catch (err: any) {
-        console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
-                     err?.message || err);
-        ToastAndroid.show(
-          `Wake-Word-Start failed: ${err?.message || err}`,
-          ToastAndroid.LONG,
-        );
+      } catch (err) {
+        console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:', err);
       }
-    } else {
-      console.warn('[WakeWord] Native-Modul nicht bereit — Direkt-Aufnahme-Fallback');
-      ToastAndroid.show(
-        'Wake-Word nicht aktiv — direkte Aufnahme startet (Mikro hoert mit)',
-        ToastAndroid.LONG,
-      );
     }
-    // Fallback: direkt in Konversation
-    console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
+    // Fallback: direkt in die Konversation
+    console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
     this.setState('conversing');
     setTimeout(() => {
       if (this.state === 'conversing') {
@@ -206,46 +146,20 @@ class WakeWordService {
   /** Komplett ausschalten (Ohr abschalten) */
   async stop(): Promise<void> {
     console.log('[WakeWord] Ohr deaktiviert');
-    if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
     }
-    this.bargeListening = false;
     this.setState('off');
   }
 
-  /** Cooldown setzen — alle Wake-Word-Detections in den naechsten ms ignorieren.
-   *  Wird beim App-Resume gerufen weil AppState-Wechsel Audio-Spikes erzeugen
-   *  die openWakeWord faelschlich als Trigger interpretiert. */
-  setResumeCooldown(ms: number = 1500): void {
-    this.cooldownUntilMs = Date.now() + ms;
-    console.log('[WakeWord] Cooldown aktiv fuer %dms', ms);
-  }
-
-  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
+  /** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
   private async onWakeDetected(): Promise<void> {
-    const now = Date.now();
-    if (now < this.cooldownUntilMs) {
-      const left = this.cooldownUntilMs - now;
-      console.log('[WakeWord] Trigger ignoriert (Cooldown noch %dms aktiv — wahrscheinlich App-Resume-Spike)', left);
-      return;
-    }
-    console.log('[WakeWord] Wake-Word "%s" erkannt! (state=%s, barge=%s)',
-                this.keyword, this.state, this.bargeListening);
-    if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
-    }
-    this.bargeListening = false;
-    // Wenn wir bereits in 'conversing' sind und der Trigger waehrend ARIAs TTS
-    // kam (Barge-In via Wake-Word), feuern wir einen separaten Callback damit
-    // ChatScreen das TTS abbrechen + neue Aufnahme starten kann. Sonst normal.
-    if (this.state === 'conversing') {
-      this.bargeCallbacks.forEach(cb => {
-        try { cb(); } catch (e) { console.warn('[WakeWord] barge cb err:', e); }
-      });
-      // Kein erneutes setState — wir bleiben in 'conversing'.
-      return;
+    console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
+    if (this.porcupine) {
+      try { await this.porcupine.stop(); } catch {}
     }
     this.setState('conversing');
+    // kurz warten damit Mikrofon frei ist
     setTimeout(() => {
       if (this.state === 'conversing') {
         this.wakeCallbacks.forEach(cb => cb());
@@ -253,83 +167,16 @@ class WakeWordService {
     }, 200);
   }
 
-  /** Wake-Word PARALLEL zur TTS-Wiedergabe lauschen lassen — User kann
-   *  "Computer" sagen waehrend ARIA noch redet, AcousticEchoCanceler im
-   *  Native-Modul verhindert dass ARIAs eigene Stimme triggert.
-   *  Voraussetzung: AudioRecorder muss frei sein (Recording aus). Wenn der
-   *  AudioRecorder gerade laeuft, hat der Vorrang — Wake-Word geht nicht. */
-  async startBargeListening(): Promise<void> {
-    if (!this.nativeReady || !OpenWakeWord) return;
-    if (this.state !== 'conversing') return;
-    if (this.bargeListening) return;
-    try {
-      await OpenWakeWord.start();
-      this.bargeListening = true;
-      console.log('[WakeWord] Barge-Listening aktiv (parallel zu TTS)');
-    } catch (err) {
-      console.warn('[WakeWord] Barge-Listening start fehlgeschlagen:', err);
-    }
-  }
-
-  /** Barge-Listening wieder aus — z.B. wenn der AudioRecorder fuer die
-   *  naechste Aufnahme das Mikro braucht. */
-  async stopBargeListening(): Promise<void> {
-    if (!this.bargeListening) return;
-    if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
-    }
-    this.bargeListening = false;
-    console.log('[WakeWord] Barge-Listening aus');
-  }
-
-  /** Bei eingehendem Anruf: Wake-Word + Aufnahme stoppen, Pre-Call-State
-   *  merken. Telefonie-App belegt das Mikro waehrend des Anrufs, plus ARIA
-   *  soll nicht in laufende Telefonate reinhoeren. */
-  async pauseForCall(): Promise<void> {
-    if (this.callPaused) return;
-    this.preCallState = this.state;
-    if (this.state === 'off') {
-      this.callPaused = true;  // merken dass wir pausiert wurden
-      return;
-    }
-    this.callPaused = true;
-    if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
-    }
-    this.bargeListening = false;
-    console.log('[WakeWord] Anruf — Wake-Word pausiert (war: %s)', this.preCallState);
-  }
-
-  /** Nach Auflegen: Pre-Call-State wiederherstellen. Aktive Konversation
-   *  geht zu armed zurueck (User soll nicht in einen halben Dialog springen). */
-  async resumeFromCall(): Promise<void> {
-    if (!this.callPaused) return;
-    const restoreTo = this.preCallState;
-    this.callPaused = false;
-    this.preCallState = 'off';
-    console.log('[WakeWord] Anruf zu Ende — restore state=%s', restoreTo);
-    if (restoreTo === 'off') return;
-    // Aktive Konversation war wahrscheinlich durch haltAllPlayback eh abgebrochen,
-    // sicher zu armed degraden.
-    if (restoreTo === 'conversing') this.setState('armed');
-    if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.start(); } catch (err) {
-        console.warn('[WakeWord] Restore-Start fehlgeschlagen:', err);
-      }
-    }
-  }
-
   /** Konversation beenden — User hat im Window nichts gesagt.
-   *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
+   *  Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
    *  Ohne: zurueck zu 'off'.
    */
   async endConversation(): Promise<void> {
     if (this.state !== 'conversing') return;
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine && this.accessKey) {
       try {
-        await OpenWakeWord.start();
+        await this.porcupine.start();
         console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
-        ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return;
       } catch (err) {
@@ -337,7 +184,6 @@ class WakeWordService {
       }
     }
     console.log('[WakeWord] Konversation zu Ende — Ohr aus');
-    ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
     this.setState('off');
   }
 
@@ -362,10 +208,10 @@ class WakeWordService {
   }
 
   hasWakeWord(): boolean {
-    return this.nativeReady;
+    return !!this.porcupine;
   }
 
-  getKeyword(): WakeKeyword {
+  getKeyword(): string {
     return this.keyword;
   }
 
@@ -378,19 +224,6 @@ class WakeWordService {
     };
   }
 
-  /** Subscribe auf Barge-In-Events: Wake-Word erkannt waehrend ARIA noch
-   *  spricht. ChatScreen sollte dann TTS abbrechen + neue Aufnahme starten. */
-  onBargeIn(callback: WakeWordCallback): () => void {
-    this.bargeCallbacks.push(callback);
-    return () => {
-      this.bargeCallbacks = this.bargeCallbacks.filter(cb => cb !== callback);
-    };
-  }
-
-  isBargeListening(): boolean {
-    return this.bargeListening;
-  }
-
   onStateChange(callback: StateCallback): () => void {
     this.stateCallbacks.push(callback);
     return () => {

aria-brain/Dockerfile

@@ -1,35 +0,0 @@
-# ════════════════════════════════════════════════════════════
-#  ARIA Brain — Agent + Memory Container
-#
-#  FastAPI-Server mit Vector-DB-Memory (Qdrant).
-#  Spricht via HTTP/WebSocket mit Bridge und Diagnostic.
-#  LLM-Calls gehen ueber den Proxy (claude-max-api-proxy).
-# ════════════════════════════════════════════════════════════
-
-FROM python:3.12-slim
-
-# System-Tools die Skills brauchen koennten (curl, jq, git, ssh-client,
-# Build-Basics fuer venv-Compiles). Bewusst sparsam — alles weitere
-# bringt der Skill selbst mit (siehe execution=local-bin).
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl \
-    jq \
-    git \
-    openssh-client \
-    ca-certificates \
- && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-# Embedding-Model-Cache und Skills landen unter /data (Volume)
-ENV SENTENCE_TRANSFORMERS_HOME=/data/_models
-ENV ARIA_DATA_DIR=/data
-
-EXPOSE 8080
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

aria-brain/agent.py

@@ -1,525 +0,0 @@
-"""
-Conversation-Loop. Eine Anfrage von Stefan, eine Antwort von ARIA.
-
-Pro Turn:
-  1. user-Turn an die laufende Conversation appenden
-  2. Hot Memory holen (alle pinned Punkte)
-  3. Cold Memory holen (Top-K semantisch zur user-Nachricht)
-  4. System-Prompt aus Hot+Cold bauen
-  5. Messages = [system, *window, user]
-  6. Claude via Proxy aufrufen
-  7. Assistant-Reply in Conversation appenden + zurueckgeben
-
-Memory-Destillat laeuft asynchron NACH dem Reply, gesteuert vom
-/chat-Endpoint ueber BackgroundTasks.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Optional
-
-from conversation import Conversation, Turn
-from memory import Embedder, VectorStore, MemoryPoint
-from prompts import build_system_prompt
-from proxy_client import ProxyClient, Message as ProxyMessage
-import skills as skills_mod
-import triggers as triggers_mod
-import watcher as watcher_mod
-
-logger = logging.getLogger(__name__)
-
-
-# Meta-Tool: ARIA kann selbst neue Skills bauen
-META_TOOLS = [
-    {
-        "type": "function",
-        "function": {
-            "name": "skill_create",
-            "description": (
-                "Erstelle einen neuen Skill (wiederverwendbare Faehigkeit). "
-                "Skills sind IMMER Python — jeder Skill bekommt seine eigene venv "
-                "mit den pip_packages die er braucht.\n\n"
-                "HARTE REGEL — IMMER Skill anlegen wenn: die Loesung erfordert eine "
-                "pip-Library. Sonst muesste der Install bei jedem Container-Restart "
-                "neu laufen (Brain hat keinen persistenten State ausser /data/skills/).\n\n"
-                "Sonst NUR wenn ALLE Kriterien erfuellt sind:\n"
-                "  1) wiederkehrend (Aufgabe kommt realistisch nochmal),\n"
-                "  2) nicht-trivial (mehrere Schritte),\n"
-                "  3) parametrisierbar (nimmt Eingaben, gibt Ergebnis),\n"
-                "  4) wiederverwendbar als ganzes Paket.\n"
-                "NICHT fuer einzelne Shell-Befehle (date, hostname, ls etc.) und "
-                "nicht fuer Einmal-Faelle. Stefan kann Skill-Erstellung explizit "
-                "triggern (\"bau daraus einen Skill\").\n\n"
-                "Wenn etwas nur via apt-Paket geht — Stefan fragen ob es ins "
-                "Brain-Dockerfile soll, NICHT als Skill bauen."
-            ),
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "name": {"type": "string", "description": "kurz, kebab-case, a-z 0-9 - _"},
-                    "description": {"type": "string", "description": "Was kann der Skill? 1 Satz."},
-                    "entry_code": {
-                        "type": "string",
-                        "description": (
-                            "Python-Code. Args lesen via os.environ['ARG_NAME']. "
-                            "Resultat per print() (stdout) zurueck. Bei Fehler: "
-                            "non-zero exit (sys.exit(1) o.ae.)."
-                        ),
-                    },
-                    "readme": {"type": "string", "description": "Markdown — was macht der Skill, Beispiel-Aufrufe"},
-                    "pip_packages": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "description": "pip-Pakete die in der venv installiert werden (z.B. requests, yt-dlp, pypdf)",
-                    },
-                    "args": {
-                        "type": "array",
-                        "items": {"type": "object"},
-                        "description": "Argumente-Schema [{name, type, required, description}]",
-                    },
-                },
-                "required": ["name", "description", "entry_code"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "skill_list",
-            "description": "Zeigt alle Skills (inkl. deaktivierte). Sollte selten noetig sein — die Liste steht eh im System-Prompt.",
-            "parameters": {"type": "object", "properties": {}},
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "trigger_timer",
-            "description": (
-                "Lege einen Timer-Trigger an — feuert EINMALIG zum angegebenen Zeitpunkt "
-                "und ruft dich selbst auf (Push-Nachricht an Stefan). "
-                "Use-Case: 'erinnere mich in 10min', 'sag mir um 14:30 Bescheid'."
-            ),
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "name": {"type": "string", "description": "kurzer kebab-case-Name, a-z 0-9 - _"},
-                    "fires_at": {
-                        "type": "string",
-                        "description": (
-                            "Absoluter ISO-Timestamp UTC, z.B. '2026-05-12T14:30:00Z'. "
-                            "Berechne aus relativer Angabe ('in 10min') selbst — die "
-                            "aktuelle Zeit findest du im System-Prompt nicht, also nutze "
-                            "Bash: `date -u -d '+10 minutes' --iso-8601=seconds`."
-                        ),
-                    },
-                    "message": {"type": "string", "description": "Was soll bei der Erinnerung gesagt werden"},
-                },
-                "required": ["name", "fires_at", "message"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "trigger_watcher",
-            "description": (
-                "Lege einen Watcher-Trigger an — pollt alle paar Minuten eine Condition, "
-                "feuert wenn sie wahr wird (mit Throttle damit's nicht spammt). "
-                "Use-Case: 'sag bescheid wenn Disk unter 5GB', 'pingt mich wenn um 8 Uhr'. "
-                "Welche Variablen verfuegbar sind und ihre Bedeutung steht im System-Prompt."
-            ),
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "name": {"type": "string", "description": "kurzer Name"},
-                    "condition": {
-                        "type": "string",
-                        "description": (
-                            "Boolescher Ausdruck mit den erlaubten Variablen, z.B. "
-                            "'disk_free_gb < 5', 'hour_of_day == 8 and day_of_week == \"mon\"'. "
-                            "Operatoren: < > <= >= == != and or not"
-                        ),
-                    },
-                    "message": {"type": "string", "description": "Was soll bei Erfuellung gesagt werden"},
-                    "check_interval_sec": {
-                        "type": "integer",
-                        "description": "Wie oft Condition pruefen (Default 300 = alle 5min, min 30)",
-                    },
-                    "throttle_sec": {
-                        "type": "integer",
-                        "description": "Mindestabstand zwischen 2 Feuerungen (Default 3600 = max 1x/h)",
-                    },
-                },
-                "required": ["name", "condition", "message"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "trigger_cancel",
-            "description": "Loescht einen Trigger (Timer abbrechen oder Watcher entfernen).",
-            "parameters": {
-                "type": "object",
-                "properties": {"name": {"type": "string"}},
-                "required": ["name"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "trigger_list",
-            "description": "Zeigt alle Trigger (active + inaktiv). Selten noetig — Stefan sieht sie im Diagnostic.",
-            "parameters": {"type": "object", "properties": {}},
-        },
-    },
-]
-
-
-def _skill_to_tool(s: dict) -> dict:
-    """Mappt einen Skill auf ein OpenAI-Function-Tool."""
-    args = s.get("args") or []
-    props = {}
-    required = []
-    for a in args:
-        if not isinstance(a, dict):
-            continue
-        name = a.get("name") or ""
-        if not name:
-            continue
-        props[name] = {
-            "type": a.get("type", "string"),
-            "description": a.get("description", ""),
-        }
-        if a.get("required"):
-            required.append(name)
-    return {
-        "type": "function",
-        "function": {
-            "name": f"run_{s['name']}",
-            "description": s.get("description", "(ohne Beschreibung)"),
-            "parameters": {
-                "type": "object",
-                "properties": props,
-                "required": required,
-            },
-        },
-    }
-
-
-class Agent:
-    def __init__(self, store: VectorStore, embedder: Embedder,
-                 conversation: Conversation, proxy: ProxyClient,
-                 cold_k: int = 5):
-        self.store = store
-        self.embedder = embedder
-        self.conversation = conversation
-        self.proxy = proxy
-        self.cold_k = cold_k
-        # Side-Channel-Events die im Turn entstehen (z.B. skill_create).
-        # Werden vom /chat-Endpoint in der Response mitgeschickt, damit
-        # Stefan in der App und Diagnostic eine sichtbare Bubble bekommt.
-        self._pending_events: list[dict] = []
-
-    def pop_events(self) -> list[dict]:
-        """Holt die Events des letzten chat()-Calls und leert die Liste."""
-        events = self._pending_events
-        self._pending_events = []
-        return events
-
-    # ── Hauptpfad: ein User-Turn → Tool-Loop → finaler Reply ──
-
-    MAX_TOOL_ITERATIONS = 8  # Schutz vor Endlos-Loops
-
-    def chat(self, user_message: str, source: str = "") -> str:
-        user_message = (user_message or "").strip()
-        if not user_message:
-            raise ValueError("Leere Nachricht")
-
-        # Events vom letzten Turn weglassen
-        self._pending_events = []
-
-        # 1. User-Turn an die Konversation
-        self.conversation.add("user", user_message, source=source)
-
-        # 2. Hot Memory (alle pinned Punkte)
-        hot = self.store.list_pinned()
-
-        # 3. Cold Memory (Top-K semantic)
-        try:
-            qvec = self.embedder.embed(user_message)
-            cold = self.store.search(qvec, k=self.cold_k, exclude_pinned=True)
-        except Exception as exc:
-            logger.warning("Cold-Search fehlgeschlagen: %s", exc)
-            cold = []
-
-        # 4. Aktive Skills holen + Tool-Liste bauen
-        all_skills = skills_mod.list_skills(active_only=False)
-        active_skills = [s for s in all_skills if s.get("active", True)]
-        tools = list(META_TOOLS) + [_skill_to_tool(s) for s in active_skills]
-
-        # Trigger-Liste + Variablen-Info fuer den System-Prompt
-        all_triggers = triggers_mod.list_triggers(active_only=False)
-        condition_vars = watcher_mod.describe_variables()
-
-        # 5. System-Prompt + Window-Messages
-        system_prompt = build_system_prompt(hot, cold, skills=all_skills,
-                                            triggers=all_triggers,
-                                            condition_vars=condition_vars)
-        messages = [ProxyMessage(role="system", content=system_prompt)]
-        for t in self.conversation.window():
-            messages.append(ProxyMessage(role=t.role, content=t.content))
-
-        logger.info("chat: pinned=%d cold=%d skills=%d/%d window=%d prompt_chars=%d",
-                    len(hot), len(cold), len(active_skills), len(all_skills),
-                    len(self.conversation.window()), len(system_prompt))
-
-        # 6. Tool-Use-Loop
-        final_reply = ""
-        for iteration in range(self.MAX_TOOL_ITERATIONS):
-            result = self.proxy.chat_full(messages, tools=tools)
-            if result.tool_calls:
-                # Assistant-Turn mit tool_calls in messages anhaengen (nicht in Conversation!)
-                messages.append(ProxyMessage(
-                    role="assistant",
-                    content=result.content or None,
-                    tool_calls=[{
-                        "id": tc["id"], "type": "function",
-                        "function": {"name": tc["name"], "arguments": json.dumps(tc["arguments"])},
-                    } for tc in result.tool_calls],
-                ))
-                # Tools ausfuehren + Ergebnis als role=tool zurueck
-                for tc in result.tool_calls:
-                    tool_result = self._dispatch_tool(tc["name"], tc["arguments"])
-                    messages.append(ProxyMessage(
-                        role="tool",
-                        tool_call_id=tc["id"],
-                        name=tc["name"],
-                        content=tool_result[:8000],
-                    ))
-                continue  # next iteration mit Tool-Results
-            # Kein Tool-Call mehr → final reply
-            final_reply = (result.content or "").strip()
-            break
-        else:
-            # Loop-Limit erreicht
-            final_reply = "[Tool-Loop-Limit erreicht — ARIA hat zu viele Tool-Calls gemacht ohne fertig zu werden]"
-            logger.warning("Tool-Loop hit MAX_TOOL_ITERATIONS=%d", self.MAX_TOOL_ITERATIONS)
-
-        if not final_reply:
-            raise RuntimeError("Leerer Reply vom Proxy")
-
-        # 7. Assistant-Turn (final reply) in die Conversation
-        self.conversation.add("assistant", final_reply)
-        return final_reply
-
-    # ── Tool-Dispatcher ───────────────────────────────────────
-
-    def _dispatch_tool(self, name: str, arguments: dict) -> str:
-        """Fuehrt einen Tool-Call aus und gibt ein kurzes Text-Resultat zurueck.
-        Niemals werfen — Fehler werden als Text-Resultat reportet damit Claude
-        weitermachen kann."""
-        try:
-            if name == "skill_create":
-                # ARIA-Skills sind immer Python — execution ist nicht mehr im Schema
-                manifest = skills_mod.create_skill(
-                    name=arguments["name"],
-                    description=arguments["description"],
-                    execution="local-venv",
-                    entry_code=arguments["entry_code"],
-                    readme=arguments.get("readme", ""),
-                    args=arguments.get("args", []),
-                    pip_packages=arguments.get("pip_packages", []),
-                    author="aria",
-                )
-                # Side-Channel-Event: Stefan soll sehen wenn ARIA was anlegt
-                self._pending_events.append({
-                    "type": "skill_created",
-                    "skill": {
-                        "name": manifest["name"],
-                        "description": manifest.get("description", ""),
-                        "execution": manifest.get("execution", ""),
-                        "active": manifest.get("active", True),
-                        "setup_error": manifest.get("setup_error"),
-                    },
-                })
-                return f"OK — Skill '{manifest['name']}' erstellt (active={manifest['active']})."
-            if name == "skill_list":
-                items = skills_mod.list_skills(active_only=False)
-                if not items:
-                    return "(keine Skills vorhanden)"
-                return "\n".join(
-                    f"- {s['name']} ({s['execution']}) {'aktiv' if s.get('active', True) else 'DEAKTIVIERT'}: {s.get('description', '')}"
-                    for s in items
-                )
-            if name.startswith("run_"):
-                skill_name = name[len("run_"):]
-                res = skills_mod.run_skill(skill_name, args=arguments)
-                snippet = (res.get("stdout") or "")[:2000] or "(kein stdout)"
-                err = (res.get("stderr") or "")[:500]
-                marker = "OK" if res["ok"] else f"FEHLER (exit={res['exit_code']})"
-                out = f"{marker} · {res['duration_sec']}s\nstdout:\n{snippet}"
-                if err:
-                    out += f"\nstderr:\n{err}"
-                return out
-            if name == "trigger_timer":
-                t = triggers_mod.create_timer(
-                    name=arguments["name"],
-                    fires_at_iso=arguments["fires_at"],
-                    message=arguments["message"],
-                    author="aria",
-                )
-                self._pending_events.append({
-                    "type": "trigger_created",
-                    "trigger": {"name": t["name"], "type": "timer",
-                                "fires_at": t["fires_at"], "message": t["message"]},
-                })
-                return f"OK — Timer '{t['name']}' angelegt, feuert um {t['fires_at']}."
-            if name == "trigger_watcher":
-                t = triggers_mod.create_watcher(
-                    name=arguments["name"],
-                    condition=arguments["condition"],
-                    message=arguments["message"],
-                    check_interval_sec=int(arguments.get("check_interval_sec", 300)),
-                    throttle_sec=int(arguments.get("throttle_sec", 3600)),
-                    author="aria",
-                )
-                self._pending_events.append({
-                    "type": "trigger_created",
-                    "trigger": {"name": t["name"], "type": "watcher",
-                                "condition": t["condition"], "message": t["message"]},
-                })
-                return f"OK — Watcher '{t['name']}' angelegt: feuert wenn '{t['condition']}'."
-            if name == "trigger_cancel":
-                try:
-                    triggers_mod.delete(arguments["name"])
-                    return f"OK — Trigger '{arguments['name']}' geloescht."
-                except ValueError as e:
-                    return f"FEHLER: {e}"
-            if name == "trigger_list":
-                items = triggers_mod.list_triggers(active_only=False)
-                if not items:
-                    return "(keine Trigger vorhanden)"
-                lines = []
-                for t in items:
-                    state = "aktiv" if t.get("active", True) else "DEAKTIVIERT"
-                    if t["type"] == "timer":
-                        lines.append(f"- {t['name']} (timer, {state}): feuert {t.get('fires_at')} — \"{t.get('message','')[:50]}\"")
-                    elif t["type"] == "watcher":
-                        lines.append(f"- {t['name']} (watcher, {state}): cond=\"{t.get('condition')}\", throttle={t.get('throttle_sec')}s")
-                    else:
-                        lines.append(f"- {t['name']} ({t['type']}, {state})")
-                return "\n".join(lines)
-            return f"Unbekanntes Tool: {name}"
-        except Exception as exc:
-            logger.exception("Tool '%s' fehlgeschlagen", name)
-            return f"FEHLER: {exc}"
-
-    # ── Memory-Destillat (laeuft im Hintergrund) ──────────────
-
-    def distill_old_turns(self) -> dict:
-        """Nimmt die N aeltesten Turns und destilliert sie zu fact-Memories.
-
-        Pattern: separater Claude-Call, lieferte 3-7 JSON-Facts, die als
-        type=fact, source=distilled gespeichert werden. Erfolgreiches
-        Schreiben → Turns aus dem Window entfernen.
-        """
-        if not self.conversation.needs_distill():
-            return {"distilled": 0, "reason": "kein Bedarf"}
-
-        old_turns = self.conversation.take_oldest_for_distill()
-        if not old_turns:
-            return {"distilled": 0, "reason": "keine alten Turns"}
-
-        # Konversation als Klartext bauen
-        transcript = "\n".join(
-            f"[{t.role.upper()}] {t.content}" for t in old_turns
-        )[:30000]  # Cap auf 30k Zeichen damit der Prompt nicht explodiert
-
-        system = (
-            "Du extrahierst aus einer Konversation zwischen Stefan und ARIA die "
-            "wichtigsten dauerhaft relevanten Fakten — keine Smalltalk-Details, "
-            "keine flüchtigen Zustände. Antworte AUSSCHLIESSLICH mit gültigem JSON "
-            "im Format: {\"facts\": [{\"title\": \"kurz, max 80 Zeichen\", "
-            "\"content\": \"1-3 Sätze, konkret und nützlich\"}]}. "
-            "Mindestens 0, höchstens 7 Facts. Wenn nichts wichtig genug ist: leeres Array."
-        )
-        user = (
-            "Hier ist der Konversations-Abschnitt:\n\n"
-            f"{transcript}\n\n"
-            "Extrahiere die wichtigsten Fakten als JSON."
-        )
-
-        try:
-            raw = self.proxy.chat([
-                ProxyMessage(role="system", content=system),
-                ProxyMessage(role="user", content=user),
-            ])
-        except Exception as exc:
-            logger.warning("Destillat-Call fehlgeschlagen: %s — Turns bleiben", exc)
-            return {"distilled": 0, "error": str(exc)}
-
-        facts = self._parse_facts(raw)
-        if facts is None:
-            logger.warning("Destillat lieferte unparsbares JSON: %r", raw[:200])
-            return {"distilled": 0, "error": "JSON parse failed", "raw": raw[:200]}
-
-        # Facts in die DB schreiben
-        created = 0
-        for f in facts:
-            content = (f.get("content") or "").strip()
-            if not content:
-                continue
-            title = (f.get("title") or "").strip()[:120] or "Fakt"
-            point = MemoryPoint(
-                id="",
-                type="fact",
-                title=title,
-                content=content,
-                pinned=False,
-                category="konversation",
-                source="distilled",
-                tags=[],
-            )
-            try:
-                vec = self.embedder.embed(content)
-                self.store.upsert(point, vec)
-                created += 1
-            except Exception as exc:
-                logger.warning("Fakt schreiben fehlgeschlagen: %s", exc)
-
-        # Erst nach erfolgreichem Schreiben aus dem Window entfernen
-        last_ts = old_turns[-1].ts
-        self.conversation.commit_distill(last_ts)
-        logger.info("Destillat: %d Facts geschrieben, %d Turns aus Window entfernt",
-                    created, len(old_turns))
-        return {"distilled": created, "removed_turns": len(old_turns)}
-
-    @staticmethod
-    def _parse_facts(raw: str) -> Optional[list]:
-        if not raw:
-            return None
-        # JSON robust extrahieren — Claude kann Code-Fences setzen
-        cleaned = raw.strip()
-        if cleaned.startswith("```"):
-            # ```json oder ``` rauswerfen
-            cleaned = cleaned.split("\n", 1)[1] if "\n" in cleaned else cleaned[3:]
-            if cleaned.endswith("```"):
-                cleaned = cleaned[: -3]
-            cleaned = cleaned.strip()
-        # Erstes { bis letztes }
-        start = cleaned.find("{")
-        end = cleaned.rfind("}")
-        if start == -1 or end == -1 or end < start:
-            return None
-        try:
-            obj = json.loads(cleaned[start: end + 1])
-        except Exception:
-            return None
-        facts = obj.get("facts") if isinstance(obj, dict) else None
-        if not isinstance(facts, list):
-            return None
-        return facts

aria-brain/background.py

@@ -1,169 +0,0 @@
-"""
-Background-Loop fuer Triggers.
-
-Laeuft alle TICK_SEC Sekunden in einem asyncio Task, geht ueber alle
-active Triggers und entscheidet ob sie feuern muessen.
-
-Feuern bedeutet:
-  1. Trigger-Manifest update (fire_count++, last_fired_at, ggf. deaktivieren)
-  2. Log-Eintrag schreiben
-  3. agent.chat() mit einem system-Praefix aufrufen (NICHT als 'user'!)
-     → ARIA bekommt das wie eine Push-Nachricht und kann antworten
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from datetime import datetime, timezone
-from typing import Optional
-
-import triggers as triggers_mod
-import watcher as watcher_mod
-
-logger = logging.getLogger(__name__)
-
-TICK_SEC = 30
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def _parse_iso(s: str) -> Optional[datetime]:
-    if not s:
-        return None
-    try:
-        return datetime.fromisoformat(s.replace("Z", "+00:00"))
-    except Exception:
-        return None
-
-
-def _should_fire(trigger: dict, vars_: dict, now: datetime) -> bool:
-    if not trigger.get("active", True):
-        return False
-    t = trigger.get("type", "")
-
-    if t == "timer":
-        fires_at = _parse_iso(trigger.get("fires_at", ""))
-        if not fires_at:
-            return False
-        if fires_at.tzinfo is None:
-            fires_at = fires_at.replace(tzinfo=timezone.utc)
-        return now >= fires_at
-
-    if t == "watcher":
-        # Check-Interval respektieren (sonst pollen wir zu hektisch)
-        check_interval = int(trigger.get("check_interval_sec", 300))
-        last_checked = _parse_iso(trigger.get("last_checked_at", ""))
-        if last_checked:
-            if last_checked.tzinfo is None:
-                last_checked = last_checked.replace(tzinfo=timezone.utc)
-            if (now - last_checked).total_seconds() < check_interval:
-                return False
-        # Throttle: erst feuern wenn last_fired lange genug her ist
-        last_fired = _parse_iso(trigger.get("last_fired_at", ""))
-        throttle = int(trigger.get("throttle_sec", 3600))
-        if last_fired:
-            if last_fired.tzinfo is None:
-                last_fired = last_fired.replace(tzinfo=timezone.utc)
-            if (now - last_fired).total_seconds() < throttle:
-                return False
-        # Condition pruefen
-        cond = (trigger.get("condition") or "").strip()
-        if not cond:
-            return False
-        try:
-            return watcher_mod.evaluate(cond, vars_)
-        except Exception as e:
-            logger.warning("Trigger %s: Condition '%s' fehlerhaft: %s",
-                           trigger.get("name"), cond, e)
-            return False
-
-    if t == "cron":
-        # TODO: später, wenn jemand Bock auf Cron-Parser hat
-        return False
-
-    return False
-
-
-async def _fire(trigger: dict, agent_factory) -> None:
-    """Ruft ARIA mit einer System-Praefix-Nachricht auf."""
-    name = trigger.get("name", "?")
-    message = trigger.get("message") or "(ohne Nachricht)"
-    ttype = trigger.get("type", "?")
-
-    # Manifest updaten
-    try:
-        triggers_mod.mark_fired(name)
-    except Exception as e:
-        logger.warning("mark_fired %s: %s", name, e)
-
-    # Log
-    triggers_mod.append_log(name, {"event": "fired", "type": ttype, "message": message})
-
-    # System-Nachricht an ARIA: nicht als User, sondern als Hinweis
-    prompt = (
-        f"[Trigger ausgelöst: '{name}', Typ: {ttype}] "
-        f"Geplante Nachricht: \"{message}\". "
-        f"Sage Stefan jetzt diese Information, in deinem Stil. "
-        f"Wenn der Trigger ein Watcher war (Bedingung wurde erfuellt), "
-        f"erwaehne kurz worum es geht. Antworte direkt, keine Rueckfrage."
-    )
-
-    try:
-        agent = agent_factory()
-        reply = agent.chat(prompt, source="trigger")
-        logger.info("[trigger] %s gefeuert → ARIA-Reply: %s", name, reply[:80])
-        triggers_mod.append_log(name, {"event": "reply", "text": reply[:500]})
-    except Exception as e:
-        logger.exception("Trigger %s feuern fehlgeschlagen: %s", name, e)
-        triggers_mod.append_log(name, {"event": "error", "error": str(e)[:300]})
-
-
-async def _tick(agent_factory) -> None:
-    """Ein Pruefdurchlauf. Geht ueber alle Triggers, feuert was zu feuern ist."""
-    try:
-        all_triggers = triggers_mod.list_triggers(active_only=True)
-    except Exception as e:
-        logger.warning("triggers.list: %s", e)
-        return
-    if not all_triggers:
-        return
-    now = datetime.now(timezone.utc)
-    # Variablen einmal pro Tick sammeln (nicht pro Trigger — Disk-Stat ist teuer)
-    try:
-        vars_ = watcher_mod.collect_variables()
-    except Exception as e:
-        logger.warning("collect_variables: %s", e)
-        vars_ = {}
-
-    # Watcher: last_checked_at jetzt updaten (auch wenn nicht gefeuert wird,
-    # damit der Check-Interval respektiert wird)
-    for t in all_triggers:
-        if t.get("type") == "watcher":
-            try:
-                t["last_checked_at"] = _now_iso()
-                triggers_mod.write(t["name"], t)
-            except Exception:
-                pass
-
-    for trigger in all_triggers:
-        try:
-            if _should_fire(trigger, vars_, now):
-                # Feuern als eigener Task — wenn ARIA langsam antwortet,
-                # darf der naechste Tick nicht blockieren
-                asyncio.create_task(_fire(trigger, agent_factory))
-        except Exception as e:
-            logger.warning("Trigger-Check %s: %s", trigger.get("name"), e)
-
-
-async def run_loop(agent_factory) -> None:
-    """Endlosschleife — wird vom main lifespan gestartet + gestoppt."""
-    logger.info("Trigger-Loop gestartet (TICK_SEC=%d)", TICK_SEC)
-    while True:
-        try:
-            await _tick(agent_factory)
-        except Exception as e:
-            logger.exception("Tick-Fehler: %s", e)
-        await asyncio.sleep(TICK_SEC)

aria-brain/conversation.py

@@ -1,130 +0,0 @@
-"""
-Conversation-State — ein einziger Rolling-Window-State fuer ARIAs
-laufendes Gespraech mit Stefan.
-
-Stefan-Entscheidung: KEINE Sessions, KEIN Multi-Thread. EIN Strang,
-intern rollend. Was rausfaellt, wird ggf. destilliert und landet
-als type=fact Memory in der Vector-DB.
-
-Persistenz: append-only JSONL unter /data/conversation.jsonl.
-Bei Restart wird die letzte N gelesen (komplett vermeidet Memory-
-Overhead bei sehr langen Verlaeufen).
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-from dataclasses import dataclass, field, asdict
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import List, Optional
-
-logger = logging.getLogger(__name__)
-
-CONVERSATION_FILE = Path(os.environ.get("CONVERSATION_FILE", "/data/conversation.jsonl"))
-
-
-@dataclass
-class Turn:
-    role: str         # "user" | "assistant"
-    content: str
-    ts: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
-    source: str = ""  # "app" / "diagnostic" / "stt" — optional
-
-
-class Conversation:
-    """In-Memory Rolling Window, mit JSONL-Persistenz."""
-
-    def __init__(self, max_window: int = 50, distill_threshold: int = 60,
-                 distill_count: int = 30):
-        self.max_window = max_window
-        self.distill_threshold = distill_threshold
-        self.distill_count = distill_count
-        self.turns: List[Turn] = []
-        self._load()
-
-    def _load(self):
-        if not CONVERSATION_FILE.exists():
-            return
-        try:
-            lines = CONVERSATION_FILE.read_text(encoding="utf-8").splitlines()
-        except Exception as exc:
-            logger.warning("Konversation laden fehlgeschlagen: %s", exc)
-            return
-        loaded: List[Turn] = []
-        for line in lines:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                obj = json.loads(line)
-            except Exception:
-                continue
-            if obj.get("op") == "distill":
-                # Marker: bis hierhin wurde alles destilliert
-                drop_until_ts = obj.get("ts", "")
-                if drop_until_ts:
-                    loaded = [t for t in loaded if t.ts > drop_until_ts]
-                continue
-            role = obj.get("role")
-            content = obj.get("content")
-            if role in ("user", "assistant") and isinstance(content, str):
-                loaded.append(Turn(role=role, content=content,
-                                   ts=obj.get("ts", ""),
-                                   source=obj.get("source", "")))
-        self.turns = loaded
-        logger.info("Konversation geladen: %d Turns aus %s", len(self.turns), CONVERSATION_FILE)
-
-    def _append_to_file(self, record: dict):
-        try:
-            CONVERSATION_FILE.parent.mkdir(parents=True, exist_ok=True)
-            with CONVERSATION_FILE.open("a", encoding="utf-8") as f:
-                f.write(json.dumps(record, ensure_ascii=False) + "\n")
-        except Exception as exc:
-            logger.warning("Konversation persist fehlgeschlagen: %s", exc)
-
-    def add(self, role: str, content: str, source: str = "") -> Turn:
-        t = Turn(role=role, content=content, source=source)
-        self.turns.append(t)
-        self._append_to_file({
-            "ts": t.ts, "role": t.role, "content": t.content, "source": t.source,
-        })
-        return t
-
-    def window(self) -> List[Turn]:
-        """Die letzten max_window Turns — gehen in den LLM-Prompt."""
-        return self.turns[-self.max_window:]
-
-    def needs_distill(self) -> bool:
-        return len(self.turns) > self.distill_threshold
-
-    def take_oldest_for_distill(self) -> List[Turn]:
-        """Gibt die N aeltesten Turns zurueck — fuer den Destillat-Call.
-        Entfernt sie NICHT — das macht commit_distill nach erfolgreichem Call."""
-        return self.turns[: self.distill_count]
-
-    def commit_distill(self, last_distilled_ts: str):
-        """Schreibt einen Distill-Marker, entfernt aus dem In-Memory-Window."""
-        self._append_to_file({"op": "distill", "ts": last_distilled_ts})
-        self.turns = [t for t in self.turns if t.ts > last_distilled_ts]
-        logger.info("Distill commit bei ts=%s — Window jetzt %d Turns", last_distilled_ts, len(self.turns))
-
-    def reset(self):
-        """Hardes Reset — verwende vorsichtig (Diagnostic-Button)."""
-        try:
-            if CONVERSATION_FILE.exists():
-                CONVERSATION_FILE.unlink()
-        except Exception:
-            pass
-        self.turns = []
-        logger.warning("Konversation komplett zurueckgesetzt")
-
-    def stats(self) -> dict:
-        return {
-            "turns": len(self.turns),
-            "max_window": self.max_window,
-            "distill_threshold": self.distill_threshold,
-            "needs_distill": self.needs_distill(),
-        }

aria-brain/main.py

@@ -1,647 +0,0 @@
-"""
-ARIA Brain — FastAPI-Einstieg.
-
-Phase B Punkt 1: nur Skeleton.
-- /health                        → Liveness
-- /memory/list                   → alle Punkte (gefiltert)
-- /memory/pinned                 → Hot Memory
-- /memory/search?q=...&k=5       → semantische Suche
-- /memory/save                   → neuen Punkt anlegen
-- /memory/update/{id}            → Punkt aendern (re-embed wenn content geaendert)
-- /memory/delete/{id}            → Punkt loeschen
-- /memory/stats                  → Anzahl Punkte pro Type
-
-/chat (Conversation-Loop) und /skills/* kommen in spaeteren Phasen.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from typing import List, Optional
-
-import asyncio
-from contextlib import asynccontextmanager
-
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Request
-from fastapi.responses import Response
-from pydantic import BaseModel, Field
-
-from memory import Embedder, VectorStore, MemoryPoint
-from conversation import Conversation
-from proxy_client import ProxyClient
-from agent import Agent
-import skills as skills_mod
-import metrics as metrics_mod
-import triggers as triggers_mod
-import watcher as watcher_mod
-import background as background_mod
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
-logger = logging.getLogger("aria-brain")
-
-QDRANT_HOST = os.environ.get("QDRANT_HOST", "aria-qdrant")
-QDRANT_PORT = int(os.environ.get("QDRANT_PORT", "6333"))
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Beim Brain-Start: Trigger-Background-Loop anwerfen. Beim Shutdown: stoppen."""
-    task = asyncio.create_task(background_mod.run_loop(agent))
-    logger.info("Lifespan: Trigger-Loop gestartet")
-    try:
-        yield
-    finally:
-        task.cancel()
-        try:
-            await task
-        except asyncio.CancelledError:
-            pass
-        logger.info("Lifespan: Trigger-Loop gestoppt")
-
-
-app = FastAPI(title="ARIA Brain", version="0.1.0", lifespan=lifespan)
-
-_embedder: Optional[Embedder] = None
-_store: Optional[VectorStore] = None
-_conversation: Optional[Conversation] = None
-_proxy: Optional[ProxyClient] = None
-_agent: Optional[Agent] = None
-
-
-def embedder() -> Embedder:
-    global _embedder
-    if _embedder is None:
-        _embedder = Embedder()
-    return _embedder
-
-
-def store() -> VectorStore:
-    global _store
-    if _store is None:
-        _store = VectorStore(host=QDRANT_HOST, port=QDRANT_PORT)
-    return _store
-
-
-def conversation() -> Conversation:
-    global _conversation
-    if _conversation is None:
-        _conversation = Conversation()
-    return _conversation
-
-
-def proxy_client() -> ProxyClient:
-    global _proxy
-    if _proxy is None:
-        _proxy = ProxyClient()
-    return _proxy
-
-
-def agent() -> Agent:
-    global _agent
-    if _agent is None:
-        _agent = Agent(store(), embedder(), conversation(), proxy_client())
-    return _agent
-
-
-# ─── Pydantic-Schemas ─────────────────────────────────────────────────
-
-class MemoryIn(BaseModel):
-    type: str = Field(..., description="identity|rule|preference|tool|skill|fact|conversation|reminder")
-    title: str
-    content: str
-    pinned: bool = False
-    category: str = ""
-    source: str = "manual"
-    tags: List[str] = Field(default_factory=list)
-    conversation_id: Optional[str] = None
-
-
-class MemoryUpdate(BaseModel):
-    title: Optional[str] = None
-    content: Optional[str] = None
-    pinned: Optional[bool] = None
-    category: Optional[str] = None
-    tags: Optional[List[str]] = None
-
-
-class MemoryOut(BaseModel):
-    id: str
-    type: str
-    title: str
-    content: str
-    pinned: bool
-    category: str
-    source: str
-    tags: List[str]
-    created_at: str
-    updated_at: str
-    conversation_id: Optional[str] = None
-    score: Optional[float] = None
-
-    @classmethod
-    def from_point(cls, p: MemoryPoint) -> "MemoryOut":
-        return cls(**p.__dict__)
-
-
-# ─── Health ───────────────────────────────────────────────────────────
-
-@app.get("/health")
-def health():
-    try:
-        n = store().count()
-        return {"status": "ok", "memory_count": n, "qdrant": f"{QDRANT_HOST}:{QDRANT_PORT}"}
-    except Exception as exc:
-        return {"status": "degraded", "error": str(exc), "qdrant": f"{QDRANT_HOST}:{QDRANT_PORT}"}
-
-
-# ─── Memory-Endpoints ─────────────────────────────────────────────────
-
-@app.get("/memory/stats")
-def memory_stats():
-    s = store()
-    points = s.list_all()
-    by_type = {}
-    pinned = 0
-    for p in points:
-        by_type[p.type] = by_type.get(p.type, 0) + 1
-        if p.pinned:
-            pinned += 1
-    return {"total": len(points), "pinned": pinned, "by_type": by_type}
-
-
-@app.get("/memory/list", response_model=List[MemoryOut])
-def memory_list(type: Optional[str] = None, limit: int = 200):
-    s = store()
-    points = s.list_by_type(type, limit=limit) if type else s.list_all(limit=limit)
-    return [MemoryOut.from_point(p) for p in points]
-
-
-@app.get("/memory/pinned", response_model=List[MemoryOut])
-def memory_pinned():
-    return [MemoryOut.from_point(p) for p in store().list_pinned()]
-
-
-@app.get("/memory/search", response_model=List[MemoryOut])
-def memory_search(q: str, k: int = 5, type: Optional[str] = None, include_pinned: bool = False):
-    vec = embedder().embed(q)
-    points = store().search(vec, k=k, type_filter=type, exclude_pinned=not include_pinned)
-    return [MemoryOut.from_point(p) for p in points]
-
-
-@app.post("/memory/save", response_model=MemoryOut)
-def memory_save(body: MemoryIn):
-    s = store()
-    vec = embedder().embed(body.content)
-    point = MemoryPoint(
-        id="",
-        type=body.type,
-        title=body.title,
-        content=body.content,
-        pinned=body.pinned,
-        category=body.category,
-        source=body.source,
-        tags=body.tags,
-        conversation_id=body.conversation_id,
-    )
-    pid = s.upsert(point, vec)
-    saved = s.get(pid)
-    return MemoryOut.from_point(saved)
-
-
-@app.patch("/memory/update/{point_id}", response_model=MemoryOut)
-def memory_update(point_id: str, body: MemoryUpdate):
-    s = store()
-    existing = s.get(point_id)
-    if not existing:
-        raise HTTPException(404, f"Memory {point_id} nicht gefunden")
-
-    content_changed = body.content is not None and body.content != existing.content
-    if body.title is not None:
-        existing.title = body.title
-    if body.content is not None:
-        existing.content = body.content
-    if body.pinned is not None:
-        existing.pinned = body.pinned
-    if body.category is not None:
-        existing.category = body.category
-    if body.tags is not None:
-        existing.tags = body.tags
-
-    vec = embedder().embed(existing.content) if content_changed else None
-    if vec is None:
-        # Vektor unveraendert lassen — nur Payload neu schreiben
-        from qdrant_client.http import models as qm
-        from memory.vector_store import COLLECTION
-        s.client.set_payload(
-            collection_name=COLLECTION,
-            payload=existing.to_payload() | {"updated_at": __import__("datetime").datetime.now(__import__("datetime").timezone.utc).isoformat()},
-            points=[point_id],
-        )
-        saved = s.get(point_id)
-    else:
-        s.upsert(existing, vec)
-        saved = s.get(point_id)
-    return MemoryOut.from_point(saved)
-
-
-@app.delete("/memory/delete/{point_id}")
-def memory_delete(point_id: str):
-    s = store()
-    if not s.get(point_id):
-        raise HTTPException(404, f"Memory {point_id} nicht gefunden")
-    s.delete(point_id)
-    return {"deleted": point_id}
-
-
-# ─── Migration aus brain-import/ ──────────────────────────────────────
-
-IMPORT_DIR = os.environ.get("IMPORT_DIR", "/import")
-
-
-@app.post("/memory/migrate")
-def memory_migrate():
-    """Liest /import/*.md und schreibt atomare Memory-Punkte in die DB.
-    Idempotent: bei Re-Run werden Punkte mit gleicher migration_key ersetzt."""
-    from pathlib import Path
-    from migration import run_migration
-    s = store()
-    e = embedder()
-    result = run_migration(Path(IMPORT_DIR), s, e)
-    return result
-
-
-@app.get("/memory/import-files")
-def memory_import_files():
-    """Listet was unter /import/ liegt — fuer die Diagnostic-UI."""
-    from pathlib import Path
-    d = Path(IMPORT_DIR)
-    if not d.exists():
-        return {"import_dir": str(d), "exists": False, "files": []}
-    out = []
-    for p in sorted(d.iterdir()):
-        if p.is_file():
-            try:
-                out.append({"name": p.name, "size": p.stat().st_size})
-            except Exception:
-                pass
-    return {"import_dir": str(d), "exists": True, "files": out}
-
-
-# ─── Bootstrap-Snapshot ───────────────────────────────────────────────
-# "Bootstrap" = alle pinned Memories. Export/Import zum schnellen
-# Wiederherstellen einer schlanken ARIA nach Wipe.
-
-@app.get("/memory/export-bootstrap")
-def memory_export_bootstrap():
-    """Gibt alle pinned Memories als JSON zurueck — fuer Browser-Download."""
-    s = store()
-    pinned = s.list_pinned()
-    return {
-        "version": 1,
-        "exported_at": __import__("datetime").datetime.now(
-            __import__("datetime").timezone.utc
-        ).isoformat(),
-        "count": len(pinned),
-        "memories": [
-            {
-                "type": p.type,
-                "title": p.title,
-                "content": p.content,
-                "pinned": True,
-                "category": p.category,
-                "source": p.source,
-                "tags": p.tags,
-            }
-            for p in pinned
-        ],
-    }
-
-
-class BootstrapBundle(BaseModel):
-    version: int = 1
-    memories: List[dict]
-
-
-@app.post("/memory/import-bootstrap")
-def memory_import_bootstrap(body: BootstrapBundle):
-    """Loescht alle pinned Memories und importiert die im Bundle.
-    Cold Memory (unpinned) bleibt unangetastet.
-
-    Wenn keine Memories im Bundle: nur loeschen ist NICHT erlaubt — der
-    Caller soll erst exportieren und dann importieren.
-    """
-    if not body.memories:
-        raise HTTPException(400, "Bundle hat keine memories — Abbruch zur Sicherheit")
-
-    s = store()
-    e = embedder()
-
-    # Alle aktuell pinned Punkte loeschen
-    from qdrant_client.http import models as qm
-    from memory.vector_store import COLLECTION
-    s.client.delete(
-        collection_name=COLLECTION,
-        points_selector=qm.FilterSelector(filter=qm.Filter(must=[
-            qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True))
-        ])),
-    )
-
-    # Neue Punkte einspeisen
-    created = 0
-    for m in body.memories:
-        content = (m.get("content") or "").strip()
-        if not content:
-            continue
-        point = MemoryPoint(
-            id="",
-            type=m.get("type", "fact"),
-            title=m.get("title", "(ohne Titel)"),
-            content=content,
-            pinned=True,
-            category=m.get("category", ""),
-            source=m.get("source", "bootstrap-import"),
-            tags=list(m.get("tags", [])),
-        )
-        vec = e.embed(content)
-        s.upsert(point, vec)
-        created += 1
-
-    return {"created": created, "deleted_previous_pinned": True}
-
-
-# ─── Conversation-Loop ──────────────────────────────────────────────
-
-class ChatIn(BaseModel):
-    message: str
-    source: str = ""  # "app" / "diagnostic" / "stt" — optional
-
-
-class ChatOut(BaseModel):
-    reply: str
-    turns: int
-    distilling: bool
-    events: list = Field(default_factory=list)
-
-
-@app.post("/chat", response_model=ChatOut)
-def chat(body: ChatIn, background: BackgroundTasks):
-    """Hauptpfad. Antwort kommt synchron. Memory-Destillat laeuft
-    im Hintergrund nachdem die Response rausging."""
-    a = agent()
-    try:
-        reply = a.chat(body.message, source=body.source)
-    except ValueError as exc:
-        raise HTTPException(400, str(exc))
-    except RuntimeError as exc:
-        logger.error("chat fehlgeschlagen: %s", exc)
-        raise HTTPException(502, str(exc))
-
-    needs_distill = a.conversation.needs_distill()
-    if needs_distill:
-        background.add_task(a.distill_old_turns)
-    return ChatOut(
-        reply=reply,
-        turns=len(a.conversation.turns),
-        distilling=needs_distill,
-        events=a.pop_events(),
-    )
-
-
-@app.get("/conversation/stats")
-def conversation_stats():
-    return conversation().stats()
-
-
-@app.post("/conversation/reset")
-def conversation_reset():
-    """Hardes Reset — der Rolling-Window-Verlauf wird komplett geleert.
-    Destillierte facts bleiben in der DB."""
-    conversation().reset()
-    return {"ok": True, "turns": 0}
-
-
-@app.post("/conversation/distill")
-def conversation_distill_now():
-    """Manueller Trigger fuer Destillat — fuer Tests oder vor einem
-    bewussten Reset."""
-    return agent().distill_old_turns()
-
-
-# ─── Call-Metrics (Token / Quota-Monitoring) ────────────────────────
-
-@app.get("/metrics/calls")
-def metrics_calls():
-    """Liefert Aggregate fuer 1h / 5h / 24h / 30d.
-    Jedes Window: {window_seconds, calls, tokens_in, tokens_out, by_model}."""
-    return metrics_mod.stats()
-
-
-# ─── Triggers (passive Aufweck-Quellen) ─────────────────────────────
-
-class TriggerTimerBody(BaseModel):
-    name: str
-    fires_at: str  # ISO timestamp
-    message: str
-    author: str = "stefan"
-
-
-class TriggerWatcherBody(BaseModel):
-    name: str
-    condition: str
-    message: str
-    check_interval_sec: int = 300
-    throttle_sec: int = 3600
-    author: str = "stefan"
-
-
-class TriggerPatch(BaseModel):
-    active: bool | None = None
-    message: str | None = None
-    condition: str | None = None
-    throttle_sec: int | None = None
-    check_interval_sec: int | None = None
-    fires_at: str | None = None
-
-
-@app.get("/triggers/list")
-def triggers_list(active_only: bool = False):
-    return {"triggers": triggers_mod.list_triggers(active_only=active_only)}
-
-
-@app.get("/triggers/conditions")
-def triggers_conditions():
-    """Verfuegbare Variablen fuer Watcher-Conditions (mit aktuellen Werten)."""
-    return {
-        "variables": watcher_mod.describe_variables(),
-        "current": watcher_mod.collect_variables(),
-    }
-
-
-@app.get("/triggers/{name}")
-def triggers_get(name: str):
-    t = triggers_mod.read(name)
-    if t is None:
-        raise HTTPException(404, f"Trigger '{name}' nicht gefunden")
-    return t
-
-
-@app.get("/triggers/{name}/logs")
-def triggers_get_logs(name: str, limit: int = 50):
-    return {"logs": triggers_mod.list_logs(name, limit=limit)}
-
-
-@app.post("/triggers/timer")
-def triggers_create_timer(body: TriggerTimerBody):
-    try:
-        return triggers_mod.create_timer(
-            name=body.name, fires_at_iso=body.fires_at,
-            message=body.message, author=body.author,
-        )
-    except ValueError as exc:
-        raise HTTPException(400, str(exc))
-
-
-@app.post("/triggers/watcher")
-def triggers_create_watcher(body: TriggerWatcherBody):
-    try:
-        return triggers_mod.create_watcher(
-            name=body.name, condition=body.condition,
-            message=body.message,
-            check_interval_sec=body.check_interval_sec,
-            throttle_sec=body.throttle_sec,
-            author=body.author,
-        )
-    except ValueError as exc:
-        raise HTTPException(400, str(exc))
-
-
-@app.patch("/triggers/{name}")
-def triggers_patch(name: str, body: TriggerPatch):
-    patch = {k: v for k, v in body.model_dump().items() if v is not None}
-    try:
-        return triggers_mod.update(name, patch)
-    except ValueError as exc:
-        raise HTTPException(404, str(exc))
-
-
-@app.delete("/triggers/{name}")
-def triggers_delete(name: str):
-    try:
-        triggers_mod.delete(name)
-    except ValueError as exc:
-        raise HTTPException(404, str(exc))
-    return {"deleted": name}
-
-
-# ─── Skills ─────────────────────────────────────────────────────────
-
-class SkillCreate(BaseModel):
-    name: str
-    description: str
-    execution: str  # local-venv | local-bin | bash
-    entry_code: str
-    readme: str = ""
-    args: list = Field(default_factory=list)
-    requires: dict = Field(default_factory=dict)
-    pip_packages: list = Field(default_factory=list)
-    author: str = "stefan"
-
-
-class SkillRun(BaseModel):
-    name: str
-    args: dict = Field(default_factory=dict)
-    timeout_sec: int = 300
-
-
-class SkillPatch(BaseModel):
-    description: str | None = None
-    active: bool | None = None
-    args: list | None = None
-
-
-@app.get("/skills/list")
-def skills_list(active_only: bool = False):
-    return {"skills": skills_mod.list_skills(active_only=active_only)}
-
-
-@app.get("/skills/{name}")
-def skills_get(name: str):
-    m = skills_mod.read_manifest(name)
-    if m is None:
-        raise HTTPException(404, f"Skill '{name}' nicht gefunden")
-    readme = skills_mod.read_readme(name)
-    return {"manifest": m, "readme": readme}
-
-
-@app.post("/skills/create")
-def skills_create(body: SkillCreate):
-    try:
-        return skills_mod.create_skill(
-            name=body.name,
-            description=body.description,
-            execution=body.execution,
-            entry_code=body.entry_code,
-            readme=body.readme,
-            args=body.args,
-            requires=body.requires,
-            pip_packages=body.pip_packages,
-            author=body.author,
-        )
-    except ValueError as exc:
-        raise HTTPException(400, str(exc))
-
-
-@app.post("/skills/run")
-def skills_run(body: SkillRun):
-    try:
-        return skills_mod.run_skill(body.name, args=body.args, timeout_sec=body.timeout_sec)
-    except ValueError as exc:
-        raise HTTPException(400, str(exc))
-
-
-@app.patch("/skills/{name}")
-def skills_patch(name: str, body: SkillPatch):
-    patch = {k: v for k, v in body.model_dump().items() if v is not None}
-    try:
-        return skills_mod.update_skill(name, patch)
-    except ValueError as exc:
-        raise HTTPException(404, str(exc))
-
-
-@app.delete("/skills/{name}")
-def skills_delete(name: str):
-    try:
-        skills_mod.delete_skill(name)
-    except ValueError as exc:
-        raise HTTPException(404, str(exc))
-    return {"deleted": name}
-
-
-@app.get("/skills/{name}/logs")
-def skills_logs(name: str, limit: int = 50):
-    return {"logs": skills_mod.list_logs(name, limit=limit)}
-
-
-@app.get("/skills/{name}/export")
-def skills_export(name: str):
-    try:
-        data = skills_mod.export_skill(name)
-    except ValueError as exc:
-        raise HTTPException(404, str(exc))
-    return Response(
-        content=data,
-        media_type="application/gzip",
-        headers={"Content-Disposition": f'attachment; filename="skill-{name}.tar.gz"'},
-    )
-
-
-@app.post("/skills/import")
-async def skills_import(request: Request, overwrite: bool = False):
-    data = await request.body()
-    if not data:
-        raise HTTPException(400, "Leerer Body")
-    try:
-        manifest = skills_mod.import_skill(data, overwrite=overwrite)
-    except ValueError as exc:
-        raise HTTPException(400, str(exc))
-    return {"imported": manifest}

aria-brain/memory/__init__.py

@@ -1,4 +0,0 @@
-from .embedder import Embedder
-from .vector_store import VectorStore, MemoryPoint, MemoryType
-
-__all__ = ["Embedder", "VectorStore", "MemoryPoint", "MemoryType"]

aria-brain/memory/embedder.py

@@ -1,42 +0,0 @@
-"""
-Lokaler Embedder fuer Memory-Texte.
-
-Nutzt sentence-transformers (paraphrase-multilingual-MiniLM-L12-v2):
-- Deutsch + Englisch
-- 384-dimensionale Vektoren
-- Laeuft auf CPU, ~30ms pro kurzer Text
-- Modell wird beim ersten Aufruf in /data/_models gecached
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import List
-
-logger = logging.getLogger(__name__)
-
-MODEL_NAME = "paraphrase-multilingual-MiniLM-L12-v2"
-VECTOR_DIM = 384
-
-
-class Embedder:
-    def __init__(self, model_name: str = MODEL_NAME):
-        self.model_name = model_name
-        self._model = None
-
-    def _load(self):
-        if self._model is None:
-            logger.info("Lade Embedding-Modell %s ...", self.model_name)
-            from sentence_transformers import SentenceTransformer
-            self._model = SentenceTransformer(self.model_name)
-            logger.info("Embedding-Modell geladen.")
-
-    def embed(self, text: str) -> List[float]:
-        self._load()
-        vec = self._model.encode(text, convert_to_numpy=True, normalize_embeddings=True)
-        return vec.tolist()
-
-    def embed_batch(self, texts: List[str]) -> List[List[float]]:
-        self._load()
-        vecs = self._model.encode(texts, convert_to_numpy=True, normalize_embeddings=True)
-        return vecs.tolist()

aria-brain/memory/vector_store.py

@@ -1,209 +0,0 @@
-"""
-Vector-Store-Wrapper um Qdrant.
-
-Eine Collection "aria_memory" haelt ALLE Memory-Punkte.
-Trennung nach Type/Pinned-Status via Payload-Filter.
-
-Punkt-Schema (Payload):
-    type      — identity | rule | preference | tool | skill | fact | conversation | reminder
-    category  — frei, fuer UI-Gruppierung
-    title     — kurze Ueberschrift
-    content   — eigentlicher Text (wird embedded)
-    pinned    — bool, True = Hot Memory (immer in Prompt)
-    source    — import | conversation | manual
-    tags      — Liste von Strings
-    created_at, updated_at — ISO-Strings
-    conversation_id — optional, nur fuer type=conversation
-"""
-
-from __future__ import annotations
-
-import logging
-import uuid
-from dataclasses import dataclass, field
-from datetime import datetime, timezone
-from enum import Enum
-from typing import List, Optional
-
-from qdrant_client import QdrantClient
-from qdrant_client.http import models as qm
-
-from .embedder import VECTOR_DIM
-
-logger = logging.getLogger(__name__)
-
-COLLECTION = "aria_memory"
-
-
-class MemoryType(str, Enum):
-    IDENTITY = "identity"
-    RULE = "rule"
-    PREFERENCE = "preference"
-    TOOL = "tool"
-    SKILL = "skill"
-    FACT = "fact"
-    CONVERSATION = "conversation"
-    REMINDER = "reminder"
-
-
-@dataclass
-class MemoryPoint:
-    id: str
-    type: str
-    title: str
-    content: str
-    pinned: bool = False
-    category: str = ""
-    source: str = "manual"
-    tags: List[str] = field(default_factory=list)
-    created_at: str = ""
-    updated_at: str = ""
-    conversation_id: Optional[str] = None
-    score: Optional[float] = None  # nur bei Search gesetzt
-
-    def to_payload(self) -> dict:
-        p = {
-            "type": self.type,
-            "title": self.title,
-            "content": self.content,
-            "pinned": self.pinned,
-            "category": self.category,
-            "source": self.source,
-            "tags": self.tags,
-            "created_at": self.created_at,
-            "updated_at": self.updated_at,
-        }
-        if self.conversation_id:
-            p["conversation_id"] = self.conversation_id
-        return p
-
-    @classmethod
-    def from_qdrant(cls, point) -> "MemoryPoint":
-        payload = point.payload or {}
-        return cls(
-            id=str(point.id),
-            type=payload.get("type", "fact"),
-            title=payload.get("title", ""),
-            content=payload.get("content", ""),
-            pinned=payload.get("pinned", False),
-            category=payload.get("category", ""),
-            source=payload.get("source", "manual"),
-            tags=payload.get("tags", []),
-            created_at=payload.get("created_at", ""),
-            updated_at=payload.get("updated_at", ""),
-            conversation_id=payload.get("conversation_id"),
-            score=getattr(point, "score", None),
-        )
-
-
-def _now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class VectorStore:
-    def __init__(self, host: str, port: int = 6333):
-        self.client = QdrantClient(host=host, port=port)
-        self._ensure_collection()
-
-    def _ensure_collection(self):
-        existing = [c.name for c in self.client.get_collections().collections]
-        if COLLECTION not in existing:
-            logger.info("Erstelle Collection %s ...", COLLECTION)
-            self.client.create_collection(
-                collection_name=COLLECTION,
-                vectors_config=qm.VectorParams(size=VECTOR_DIM, distance=qm.Distance.COSINE),
-            )
-            # Indexe fuer typische Filter-Felder
-            for field_name in ("type", "pinned", "category", "source", "migration_key"):
-                self.client.create_payload_index(
-                    collection_name=COLLECTION,
-                    field_name=field_name,
-                    field_schema=qm.PayloadSchemaType.KEYWORD if field_name != "pinned"
-                    else qm.PayloadSchemaType.BOOL,
-                )
-
-    # ─── Schreib-Operationen ─────────────────────────────────────────
-
-    def upsert(self, point: MemoryPoint, vector: List[float]) -> str:
-        if not point.id:
-            point.id = str(uuid.uuid4())
-        if not point.created_at:
-            point.created_at = _now()
-        point.updated_at = _now()
-
-        self.client.upsert(
-            collection_name=COLLECTION,
-            points=[qm.PointStruct(id=point.id, vector=vector, payload=point.to_payload())],
-        )
-        return point.id
-
-    def delete(self, point_id: str):
-        self.client.delete(
-            collection_name=COLLECTION,
-            points_selector=qm.PointIdsList(points=[point_id]),
-        )
-
-    # ─── Lese-Operationen ────────────────────────────────────────────
-
-    def get(self, point_id: str) -> Optional[MemoryPoint]:
-        result = self.client.retrieve(collection_name=COLLECTION, ids=[point_id], with_payload=True)
-        if not result:
-            return None
-        return MemoryPoint.from_qdrant(result[0])
-
-    def list_pinned(self) -> List[MemoryPoint]:
-        """Alle pinned Punkte — Hot Memory."""
-        return self._scroll(filter=qm.Filter(must=[
-            qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True))
-        ]))
-
-    def list_by_type(self, type_: str, limit: int = 100) -> List[MemoryPoint]:
-        return self._scroll(
-            filter=qm.Filter(must=[
-                qm.FieldCondition(key="type", match=qm.MatchValue(value=type_))
-            ]),
-            limit=limit,
-        )
-
-    def list_all(self, limit: int = 1000) -> List[MemoryPoint]:
-        return self._scroll(filter=None, limit=limit)
-
-    def _scroll(self, filter, limit: int = 1000) -> List[MemoryPoint]:
-        points, _ = self.client.scroll(
-            collection_name=COLLECTION,
-            scroll_filter=filter,
-            limit=limit,
-            with_payload=True,
-            with_vectors=False,
-        )
-        return [MemoryPoint.from_qdrant(p) for p in points]
-
-    def search(
-        self,
-        query_vector: List[float],
-        k: int = 5,
-        type_filter: Optional[str] = None,
-        exclude_pinned: bool = True,
-    ) -> List[MemoryPoint]:
-        """Semantische Search. Standard: pinned-Punkte ausgeschlossen
-        (die kommen separat via list_pinned in den Prompt)."""
-        must = []
-        must_not = []
-        if type_filter:
-            must.append(qm.FieldCondition(key="type", match=qm.MatchValue(value=type_filter)))
-        if exclude_pinned:
-            must_not.append(qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True)))
-
-        flt = qm.Filter(must=must or None, must_not=must_not or None)
-
-        results = self.client.search(
-            collection_name=COLLECTION,
-            query_vector=query_vector,
-            query_filter=flt if (must or must_not) else None,
-            limit=k,
-            with_payload=True,
-        )
-        return [MemoryPoint.from_qdrant(p) for p in results]
-
-    def count(self) -> int:
-        return self.client.count(collection_name=COLLECTION, exact=True).count

aria-brain/metrics.py

@@ -1,133 +0,0 @@
-"""
-Call-Metrics fuer den Proxy-Client.
-
-Pro Claude-Call wird ein Eintrag in /data/metrics.jsonl angehaengt:
-
-  {"ts": <ms>, "model": "...", "in": <tokens_in_estimate>, "out": <tokens_out_estimate>}
-
-Tokens-Schaetzung: characters / 4 (Anthropic-Default-Heuristik). Nicht exakt
-aber gut genug fuer Quota-Monitoring. Wir summieren nicht in-memory weil
-der Brain-Container neugestartet werden kann — alles auf Disk.
-
-Auswertung via aggregate(window_seconds) — liefert {calls, tokens_in, tokens_out}
-fuer die letzten N Sekunden. Lazy gelesen, keine grossen Datenmengen erwartet
-(bei 1000 Calls/Tag ~70 KB pro Monat).
-
-Auto-Rotate: bei > 50k Zeilen werden die aeltesten 25k weggeschnitten.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import time
-from pathlib import Path
-from typing import List
-
-logger = logging.getLogger(__name__)
-
-METRICS_FILE = Path(os.environ.get("METRICS_FILE", "/data/metrics.jsonl"))
-ROTATE_AT = 50_000
-ROTATE_KEEP = 25_000
-
-
-def _estimate_tokens(text: str) -> int:
-    """Anthropic-Default: ~4 chars pro Token. Grob genug."""
-    if not text:
-        return 0
-    return max(1, len(text) // 4)
-
-
-def _messages_tokens(messages: list) -> int:
-    total = 0
-    for m in messages:
-        # Pydantic-Model oder dict
-        if hasattr(m, "content"):
-            total += _estimate_tokens(m.content or "")
-        elif isinstance(m, dict):
-            c = m.get("content") or ""
-            if isinstance(c, str):
-                total += _estimate_tokens(c)
-    return total
-
-
-def log_call(model: str, messages_in: list, reply_text: str = "") -> None:
-    """Eine Call-Metric anhaengen. Robust gegen Fehler (silent fail)."""
-    try:
-        tokens_in = _messages_tokens(messages_in)
-        tokens_out = _estimate_tokens(reply_text)
-        line = json.dumps({
-            "ts": int(time.time() * 1000),
-            "model": model,
-            "in": tokens_in,
-            "out": tokens_out,
-        })
-        METRICS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        with METRICS_FILE.open("a", encoding="utf-8") as f:
-            f.write(line + "\n")
-        # Sanftes Rotate ohne hohe IO-Kosten — nur alle 1000 Calls checken
-        if (tokens_in + tokens_out) % 1000 < 4:
-            _maybe_rotate()
-    except Exception as exc:
-        logger.warning("metrics.log_call: %s", exc)
-
-
-def _maybe_rotate() -> None:
-    try:
-        if not METRICS_FILE.exists():
-            return
-        with METRICS_FILE.open("r", encoding="utf-8") as f:
-            lines = f.readlines()
-        if len(lines) > ROTATE_AT:
-            keep = lines[-ROTATE_KEEP:]
-            METRICS_FILE.write_text("".join(keep), encoding="utf-8")
-            logger.info("metrics rotated: %d → %d Zeilen", len(lines), len(keep))
-    except Exception as exc:
-        logger.warning("metrics rotate: %s", exc)
-
-
-def aggregate(window_seconds: int) -> dict:
-    """Aggregiert die Calls der letzten N Sekunden."""
-    now_ms = int(time.time() * 1000)
-    cutoff_ms = now_ms - (window_seconds * 1000)
-    calls = 0
-    tokens_in = 0
-    tokens_out = 0
-    by_model: dict[str, int] = {}
-    if METRICS_FILE.exists():
-        try:
-            for raw in METRICS_FILE.read_text(encoding="utf-8").splitlines():
-                raw = raw.strip()
-                if not raw:
-                    continue
-                try:
-                    obj = json.loads(raw)
-                except Exception:
-                    continue
-                if obj.get("ts", 0) < cutoff_ms:
-                    continue
-                calls += 1
-                tokens_in += int(obj.get("in") or 0)
-                tokens_out += int(obj.get("out") or 0)
-                m = obj.get("model", "?")
-                by_model[m] = by_model.get(m, 0) + 1
-        except Exception as exc:
-            logger.warning("metrics aggregate: %s", exc)
-    return {
-        "window_seconds": window_seconds,
-        "calls": calls,
-        "tokens_in": tokens_in,
-        "tokens_out": tokens_out,
-        "by_model": by_model,
-    }
-
-
-def stats() -> dict:
-    """Komplett-Snapshot mit den drei wichtigsten Fenstern."""
-    return {
-        "h1": aggregate(3600),
-        "h5": aggregate(5 * 3600),
-        "h24": aggregate(24 * 3600),
-        "d30": aggregate(30 * 24 * 3600),
-    }

aria-brain/migration.py

@@ -1,399 +0,0 @@
-"""
-Migration aus aria-data/brain-import/ → Vector-DB.
-
-Parst die mitgelieferten Markdown-Dateien (AGENT.md, USER.md, TOOLING.md)
-und zerlegt sie in atomare Memory-Punkte. Jeder Punkt bekommt:
-
-  source       = "import"
-  migration_key = stabiler Identifier (z.B. "agent.md/rule-1") fuer Idempotenz
-  pinned       = True
-
-Beim Re-Run werden vorhandene Punkte mit gleicher migration_key entfernt
-und neu geschrieben.
-
-Mapping pro Datei:
-
-  AGENT.md
-    "Identitaet"                    → 1 Punkt type=identity
-    "Persoenlichkeit" (Intro)       → 1 Punkt type=identity
-    "Kern-Eigenschaften" (Liste)    → 1 Punkt pro Bullet  type=identity
-    "Tool-Freigaben"                → 1 Punkt type=tool
-    "Sicherheitsregeln" (Liste)     → 1 Punkt pro Bullet  type=rule
-    "Arbeitsprinzipien" (Liste)     → 1 Punkt pro Bullet  type=rule
-    "Dateien an Stefan zurueckgeben"→ 1 Punkt type=skill
-    "Stimme"                        → 1 Punkt type=tool
-
-  USER.md
-    "Allgemein" (Liste)             → 1 Punkt pro Bullet  type=preference
-    "Bestaetigung erforderlich"     → 1 Punkt type=preference
-    "Autonomes Arbeiten OK fuer"    → 1 Punkt type=preference
-    "Tools & Infrastruktur"         → 1 Punkt type=preference
-
-  TOOLING.md
-    gesamter Inhalt                 → 1 Punkt type=tool, title="Tooling-Stack"
-
-BOOTSTRAP.md ist eine Variante von AGENT.md — wird (vorerst) ignoriert
-damit keine doppelten Punkte landen.
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List, Optional
-
-from memory import Embedder, VectorStore, MemoryPoint
-from memory.vector_store import COLLECTION
-from qdrant_client.http import models as qm
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class _Block:
-    title: str
-    content: str
-
-
-def _split_h2(md: str) -> List[_Block]:
-    """Zerlegt Markdown in H2-Bloecke. Inhalt vor dem ersten H2 wird verworfen."""
-    blocks: List[_Block] = []
-    current: Optional[_Block] = None
-    for line in md.splitlines():
-        m = re.match(r"^##\s+(.+?)\s*$", line)
-        if m and not line.startswith("### "):
-            if current:
-                blocks.append(current)
-            current = _Block(title=m.group(1).strip(), content="")
-            continue
-        if current is not None:
-            current.content += line + "\n"
-    if current:
-        blocks.append(current)
-    return blocks
-
-
-def _split_h3(content: str) -> List[_Block]:
-    """Zerlegt einen H2-Block in H3-Untersektionen + 'header'-Block davor."""
-    blocks: List[_Block] = []
-    header_lines: List[str] = []
-    current: Optional[_Block] = None
-    for line in content.splitlines():
-        m = re.match(r"^###\s+(.+?)\s*$", line)
-        if m:
-            if current is None and header_lines:
-                blocks.append(_Block(title="_intro", content="\n".join(header_lines).strip()))
-            if current:
-                blocks.append(current)
-            current = _Block(title=m.group(1).strip(), content="")
-            continue
-        if current is None:
-            header_lines.append(line)
-        else:
-            current.content += line + "\n"
-    if current:
-        blocks.append(current)
-    elif header_lines:
-        blocks.append(_Block(title="_intro", content="\n".join(header_lines).strip()))
-    return blocks
-
-
-def _extract_bullets(content: str) -> List[tuple[str, str]]:
-    """Findet "- **Title** — Body" oder "N. **Title** — Body" Bullets.
-
-    Returns: Liste von (title, full_bullet_text).
-    """
-    bullets: List[tuple[str, str]] = []
-    current_lines: List[str] = []
-    current_title: Optional[str] = None
-
-    def flush():
-        if current_title and current_lines:
-            bullets.append((current_title, "\n".join(current_lines).strip()))
-
-    for line in content.splitlines():
-        m = re.match(r"^\s*(?:[-*]|\d+\.)\s+\*\*([^*]+?)\*\*\s*[—\-:]?\s*(.*)$", line)
-        if m:
-            flush()
-            current_title = m.group(1).strip()
-            current_lines = [line]
-            continue
-        # Folge-Zeilen mit Einrueckung gehoeren zum aktuellen Bullet
-        if current_title and (line.startswith(" ") or line.startswith("\t") or not line.strip()):
-            current_lines.append(line)
-            continue
-        if current_title and not re.match(r"^\s*(?:[-*]|\d+\.)\s+", line):
-            current_lines.append(line)
-            continue
-        # Neuer Bullet ohne **Title** Format
-        if re.match(r"^\s*(?:[-*]|\d+\.)\s+", line):
-            flush()
-            text = re.sub(r"^\s*(?:[-*]|\d+\.)\s+", "", line).strip()
-            short_title = (text[:60] + "…") if len(text) > 60 else text
-            bullets.append((short_title, line.strip()))
-            current_title = None
-            current_lines = []
-    flush()
-    return bullets
-
-
-# ─── Pro Datei eine Parser-Funktion ──────────────────────────────────
-
-def _parse_agent_md(md: str, source_file: str) -> List[MemoryPoint]:
-    points: List[MemoryPoint] = []
-    h2_blocks = _split_h2(md)
-    for h2 in h2_blocks:
-        title = h2.title
-        content = h2.content.strip()
-        if not content:
-            continue
-
-        if title.lower() == "identitaet" or title.lower() == "identität":
-            points.append(_mk(
-                type_="identity", title="ARIA — Identitaet",
-                content=f"## {title}\n\n{content}",
-                category="persoenlichkeit",
-                migration_key=f"{source_file}/identity",
-            ))
-
-        elif title.lower() == "persoenlichkeit" or title.lower() == "persönlichkeit":
-            # Intro-Absatz + Kern-Eigenschaften-Liste trennen
-            sub = _split_h3(content)
-            for s in sub:
-                if s.title == "_intro" and s.content.strip():
-                    points.append(_mk(
-                        type_="identity", title="Persoenlichkeit — Grundsatz",
-                        content=s.content.strip(),
-                        category="persoenlichkeit",
-                        migration_key=f"{source_file}/personality-intro",
-                    ))
-                elif s.title.lower().startswith("kern"):
-                    for idx, (btitle, btext) in enumerate(_extract_bullets(s.content), 1):
-                        points.append(_mk(
-                            type_="identity", title=f"Eigenschaft: {btitle}",
-                            content=btext, category="persoenlichkeit",
-                            migration_key=f"{source_file}/personality-trait-{idx}",
-                        ))
-
-        elif "sicherheitsregel" in title.lower():
-            for idx, (btitle, btext) in enumerate(_extract_bullets(content), 1):
-                points.append(_mk(
-                    type_="rule", title=f"Sicherheit: {btitle}",
-                    content=btext, category="sicherheit",
-                    migration_key=f"{source_file}/security-{idx}",
-                ))
-
-        elif "arbeitsprinzipien" in title.lower() or "arbeitsprinzip" in title.lower():
-            for idx, (btitle, btext) in enumerate(_extract_bullets(content), 1):
-                points.append(_mk(
-                    type_="rule", title=f"Prinzip: {btitle}",
-                    content=btext, category="arbeitsweise",
-                    migration_key=f"{source_file}/work-principle-{idx}",
-                ))
-
-        elif "tool-freigaben" in title.lower() or "tool freigaben" in title.lower():
-            points.append(_mk(
-                type_="tool", title="Tool-Freigaben — Vollzugriff",
-                content=content, category="infrastruktur",
-                migration_key=f"{source_file}/tool-access",
-            ))
-
-        elif "dateien an stefan" in title.lower() or "dateien zurueckgeben" in title.lower() or "dateien zur" in title.lower():
-            points.append(_mk(
-                type_="skill", title="Dateien an User zurueckgeben",
-                content=content, category="ausgabe",
-                migration_key=f"{source_file}/file-return-skill",
-            ))
-
-        elif title.lower() == "stimme":
-            points.append(_mk(
-                type_="tool", title="Stimme (F5-TTS)",
-                content=content, category="infrastruktur",
-                migration_key=f"{source_file}/voice",
-            ))
-
-        # Permanente Freigaben (in BOOTSTRAP) — als rule
-        elif "freigaben" in title.lower():
-            points.append(_mk(
-                type_="rule", title=title,
-                content=content, category="freigaben",
-                migration_key=f"{source_file}/permissions",
-            ))
-
-        else:
-            # Unbekannter Block: als generischer fact ablegen, NICHT pinned
-            logger.info("Unbekannter H2-Block '%s' in %s — als fact (unpinned)", title, source_file)
-            points.append(_mk(
-                type_="fact", title=f"{source_file}: {title}",
-                content=content, pinned=False,
-                migration_key=f"{source_file}/section-{title.lower().replace(' ', '-')}",
-            ))
-    return points
-
-
-def _parse_user_md(md: str, source_file: str) -> List[MemoryPoint]:
-    points: List[MemoryPoint] = []
-    for h2 in _split_h2(md):
-        title = h2.title
-        content = h2.content.strip()
-        if not content:
-            continue
-        # Template-Platzhalter herausfiltern: Beispiel-Zeilen mit <Tag>
-        if "<Beispiel-Tool>" in content or "<Username>" in title:
-            continue
-        if title.lower() == "allgemein":
-            for idx, (btitle, btext) in enumerate(_extract_bullets(content), 1):
-                # Template-Platzhalter ueberspringen
-                if "<z.B." in btext or "<XYZ>" in btext:
-                    continue
-                points.append(_mk(
-                    type_="preference", title=f"User: {btitle}",
-                    content=btext, category="allgemein",
-                    migration_key=f"{source_file}/general-{idx}",
-                ))
-        else:
-            cat_key = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-") or "allgemein"
-            points.append(_mk(
-                type_="preference", title=title,
-                content=content, category=cat_key,
-                migration_key=f"{source_file}/{cat_key}",
-            ))
-    return points
-
-
-def _parse_tooling_md(md: str, source_file: str) -> List[MemoryPoint]:
-    md = md.strip()
-    if not md:
-        return []
-    return [_mk(
-        type_="tool", title="Tooling-Stack (VM)",
-        content=md, category="infrastruktur",
-        migration_key=f"{source_file}/tooling-full",
-    )]
-
-
-# ─── Helper ─────────────────────────────────────────────────────────
-
-def _mk(
-    type_: str,
-    title: str,
-    content: str,
-    migration_key: str,
-    pinned: bool = True,
-    category: str = "",
-) -> MemoryPoint:
-    p = MemoryPoint(
-        id="",
-        type=type_,
-        title=title,
-        content=content.strip(),
-        pinned=pinned,
-        category=category,
-        source="import",
-        tags=[],
-    )
-    # migration_key wird ueber Payload-Index angesprochen — in to_payload manuell anhaengen
-    setattr(p, "_migration_key", migration_key)
-    return p
-
-
-# ─── Eintrittspunkt ─────────────────────────────────────────────────
-
-def run_migration(
-    import_dir: Path,
-    store: VectorStore,
-    embedder: Embedder,
-) -> dict:
-    """Liest alle .md-Dateien aus import_dir, parst sie, schreibt in DB.
-
-    Idempotent: vorhandene Punkte mit gleicher migration_key werden geloescht
-    und neu geschrieben.
-
-    Returns: {"created": int, "updated": int, "skipped": int, "files": [...]}
-    """
-    if not import_dir.exists():
-        return {"created": 0, "updated": 0, "skipped": 0, "files": [], "error": f"{import_dir} nicht gefunden"}
-
-    parsers = {
-        "AGENT.md": _parse_agent_md,
-        "BOOTSTRAP.md": _parse_agent_md,  # gleicher Parser, ggf. ueberlappende Eintraege
-        "USER.md": _parse_user_md,
-        "USER.md.example": _parse_user_md,
-        "TOOLING.md": _parse_tooling_md,
-        "TOOLING.md.example": _parse_tooling_md,
-    }
-
-    # USER.md hat Vorrang vor USER.md.example
-    file_priority = ["AGENT.md", "BOOTSTRAP.md", "USER.md", "USER.md.example",
-                     "TOOLING.md", "TOOLING.md.example"]
-    seen_kinds: set[str] = set()  # "USER" / "TOOLING" — nur einmal
-
-    points: List[MemoryPoint] = []
-    processed_files: List[str] = []
-
-    for fname in file_priority:
-        fp = import_dir / fname
-        if not fp.exists():
-            continue
-        kind = fname.split(".")[0]  # "AGENT", "BOOTSTRAP", "USER", "TOOLING"
-        # USER.md.example nur wenn USER.md fehlt
-        if kind in ("USER", "TOOLING") and kind in seen_kinds:
-            continue
-        seen_kinds.add(kind)
-        parser = parsers.get(fname)
-        if not parser:
-            continue
-        try:
-            md = fp.read_text(encoding="utf-8")
-            file_points = parser(md, fname)
-            points.extend(file_points)
-            processed_files.append(f"{fname} ({len(file_points)})")
-            logger.info("Migration: %s → %d Punkte", fname, len(file_points))
-        except Exception as exc:
-            logger.exception("Migration: %s fehlgeschlagen", fname)
-            processed_files.append(f"{fname} (FEHLER: {exc})")
-
-    if not points:
-        return {"created": 0, "updated": 0, "skipped": 0, "files": processed_files}
-
-    # Erst alte Migration-Punkte mit gleicher migration_key loeschen
-    migration_keys = [getattr(p, "_migration_key", None) for p in points]
-    migration_keys = [k for k in migration_keys if k]
-    if migration_keys:
-        store.client.delete(
-            collection_name=COLLECTION,
-            points_selector=qm.FilterSelector(filter=qm.Filter(must=[
-                qm.FieldCondition(key="migration_key", match=qm.MatchAny(any=migration_keys))
-            ])),
-        )
-        logger.info("Migration: %d alte Punkte mit gleicher migration_key entfernt", len(migration_keys))
-
-    # Embed in Batches
-    texts = [p.content for p in points]
-    vectors = embedder.embed_batch(texts)
-
-    created = 0
-    for p, vec in zip(points, vectors):
-        payload = p.to_payload()
-        mkey = getattr(p, "_migration_key", None)
-        if mkey:
-            payload["migration_key"] = mkey
-        from datetime import datetime, timezone
-        import uuid as _uuid
-        pid = str(_uuid.uuid4())
-        now = datetime.now(timezone.utc).isoformat()
-        payload["created_at"] = now
-        payload["updated_at"] = now
-        store.client.upsert(
-            collection_name=COLLECTION,
-            points=[qm.PointStruct(id=pid, vector=vec, payload=payload)],
-        )
-        created += 1
-
-    return {
-        "created": created,
-        "files": processed_files,
-        "import_dir": str(import_dir),
-    }

aria-brain/prompts.py

@@ -1,168 +0,0 @@
-"""
-System-Prompt-Bau aus Memory-Punkten.
-
-Strategie:
-  1. Alle pinned Punkte (Hot Memory) — gruppiert nach Type — in den
-     System-Prompt schreiben. IMMER drin.
-  2. Top-K semantisch aehnliche Punkte (Cold Memory) zur aktuellen
-     User-Nachricht — als "Moeglicherweise relevant" eingehaengt.
-  3. Aktive Skills als kompakte Liste (nur Name + Description) — damit
-     ARIA weiss was sie hat.
-
-Phase B Punkt 1: nur Hot-Memory-Bau, Skills + Cold-Search kommen
-mit dem Conversation-Loop in spaeteren Phasen.
-"""
-
-from __future__ import annotations
-
-from typing import List
-
-from memory import MemoryPoint
-
-TYPE_HEADINGS = {
-    "identity": "## Wer du bist",
-    "rule": "## Sicherheitsregeln & Prinzipien",
-    "preference": "## Benutzer-Praeferenzen",
-    "tool": "## Tool-Freigaben",
-    "skill": "## Deine Skills",
-}
-
-
-def build_hot_memory_section(pinned: List[MemoryPoint]) -> str:
-    """Baue den 'IMMER-im-Prompt'-Block aus pinned Punkten."""
-    grouped: dict[str, List[MemoryPoint]] = {}
-    for p in pinned:
-        grouped.setdefault(p.type, []).append(p)
-
-    parts: List[str] = []
-    # Sortier-Reihenfolge: identity → rule → preference → tool → skill → Rest
-    order = ["identity", "rule", "preference", "tool", "skill"]
-    for t in order:
-        items = grouped.pop(t, [])
-        if not items:
-            continue
-        parts.append(TYPE_HEADINGS.get(t, f"## {t}"))
-        for p in items:
-            parts.append(f"### {p.title}")
-            parts.append(p.content.strip())
-            parts.append("")
-
-    # uebrige Types (falls jemand was anderes als pinned markiert)
-    for t, items in grouped.items():
-        parts.append(f"## {t}")
-        for p in items:
-            parts.append(f"### {p.title}")
-            parts.append(p.content.strip())
-            parts.append("")
-
-    return "\n".join(parts).strip()
-
-
-def build_cold_memory_section(matches: List[MemoryPoint]) -> str:
-    """Baue 'Moeglicherweise relevant'-Block aus Search-Treffern."""
-    if not matches:
-        return ""
-    lines = ["## Moeglicherweise relevant (aus Gedaechtnis)"]
-    for p in matches:
-        score = f" [score={p.score:.2f}]" if p.score is not None else ""
-        lines.append(f"- **{p.title}**{score}")
-        lines.append(f"  {p.content.strip()}")
-    return "\n".join(lines)
-
-
-def build_skills_section(skills: List[dict]) -> str:
-    """Listet alle Skills (aktiv + deaktiviert) damit ARIA weiss was es gibt
-    und keine doppelt baut. Plus klare Schwelle wann ein Skill sich lohnt."""
-    lines = ["## Deine Skills"]
-    if skills:
-        for s in skills:
-            active = s.get("active", True)
-            marker = "" if active else " [DEAKTIVIERT — kann nicht aufgerufen werden]"
-            lines.append(f"- **{s.get('name', '?')}**{marker} — {s.get('description', '(ohne Beschreibung)')}")
-        lines.append("")
-        lines.append("Wenn ein vorhandener Skill zur Aufgabe passt: nutze ihn via Tool-Call.")
-    else:
-        lines.append("(noch keine Skills vorhanden)")
-
-    lines.append("")
-    lines.append("### Wann lohnt sich ein neuer Skill?")
-    lines.append("")
-    lines.append("**Skills sind IMMER Python** — eigene venv pro Skill mit den noetigen "
-                 "pip-Paketen. Kein apt im Skill, kein systemweiter Install. Python deckt "
-                 "in der Regel alles ab (yt-dlp, requests, pypdf, pillow, openpyxl, "
-                 "static-ffmpeg, beautifulsoup4, …). Falls etwas WIRKLICH nur via apt geht: "
-                 "Stefan fragen ob es ins Brain-Dockerfile soll.")
-    lines.append("")
-    lines.append("**Harte Regel — IMMER Skill anlegen wenn:** die Loesung erfordert eine "
-                 "pip-Library. Begruendung: Brain-Container hat keinen persistenten State "
-                 "ausser /data/skills/. Ohne Skill wuerde der Install bei jedem "
-                 "Container-Restart wiederholt.")
-    lines.append("")
-    lines.append("**Sonst — Skill nur wenn alle vier zutreffen:**")
-    lines.append("")
-    lines.append("1. **Wiederkehrend** — die Aufgabe wird realistisch nochmal gestellt. "
-                 "Einmal-Faelle (\"wie spaet ist es jetzt\") kein Skill.")
-    lines.append("2. **Nicht-trivial** — mehrere Schritte. Ein einzelner Shell-Befehl "
-                 "(`date`, `hostname`, `ls`) ist KEIN Skill — das macht Bash direkt.")
-    lines.append("3. **Parametrisierbar** — der Skill nimmt Eingaben (URL, Datei, Suchbegriff) "
-                 "und gibt ein nuetzliches Ergebnis zurueck.")
-    lines.append("4. **Wiederverwendbar als ganzes** — Stefan wuerde es zukuenftig per Name "
-                 "ansprechen (\"mach mir den YouTube zu MP3\") statt jedes Mal zu erklaeren.")
-    lines.append("")
-    lines.append("Wenn nichts installiert werden muss UND nicht alle vier zutreffen: einfach "
-                 "die Aufgabe loesen ohne Skill anzulegen. Stefan kann jederzeit sagen "
-                 "'bau daraus einen Skill'.")
-    return "\n".join(lines)
-
-
-def build_triggers_section(triggers: List[dict], condition_vars: List[dict]) -> str:
-    """Triggers (passive Aufweck-Quellen) + verfuegbare Condition-Variablen."""
-    lines = ["## Trigger (passive Aufweck-Quellen)"]
-    lines.append("")
-    lines.append("Trigger sind ANDERS als Skills: das System ruft DICH wenn ein Event passiert. "
-                 "Du legst sie an wenn Stefan sagt 'erinner mich an X' oder 'sag bescheid wenn Y'.")
-    lines.append("")
-    if triggers:
-        lines.append("### Aktuelle Trigger")
-        for t in triggers:
-            active = t.get("active", True)
-            mark = "" if active else " [INAKTIV]"
-            if t["type"] == "timer":
-                lines.append(f"- **{t['name']}**{mark} (timer) feuert {t.get('fires_at')}: \"{t.get('message','')[:80]}\"")
-            elif t["type"] == "watcher":
-                lines.append(f"- **{t['name']}**{mark} (watcher) cond=`{t.get('condition')}`: \"{t.get('message','')[:80]}\"")
-        lines.append("")
-    lines.append("### Verfuegbare Condition-Variablen (fuer Watcher)")
-    for v in condition_vars:
-        lines.append(f"- `{v['name']}` ({v['type']}) — {v['desc']}")
-    lines.append("")
-    lines.append("Operatoren in Conditions: `<` `>` `<=` `>=` `==` `!=` `and` `or` `not`. "
-                 "Beispiel: `disk_free_gb < 5 and hour_of_day >= 8`. "
-                 "String-Werte in Quotes: `day_of_week == \"mon\"`.")
-    lines.append("")
-    lines.append("### Wann welcher Typ?")
-    lines.append("- **Timer** fuer einmalige Erinnerungen mit konkreter Zeit ('in 10min', 'um 14:30').")
-    lines.append("- **Watcher** fuer 'wenn X passiert' (Disk voll, bestimmte Tageszeit).")
-    lines.append("- ARIA legt Trigger NUR auf Stefan-Wunsch an, nicht eigenmaechtig.")
-    return "\n".join(lines)
-
-
-def build_system_prompt(
-    pinned: List[MemoryPoint],
-    cold: List[MemoryPoint] | None = None,
-    skills: List[dict] | None = None,
-    triggers: List[dict] | None = None,
-    condition_vars: List[dict] | None = None,
-) -> str:
-    """Kompletter System-Prompt: Hot + Cold + Skills + Triggers."""
-    parts = [build_hot_memory_section(pinned)]
-    if skills:
-        parts.append("")
-        parts.append(build_skills_section(skills))
-    if condition_vars:
-        parts.append("")
-        parts.append(build_triggers_section(triggers or [], condition_vars))
-    if cold:
-        parts.append("")
-        parts.append(build_cold_memory_section(cold))
-    return "\n".join(parts).strip()

aria-brain/proxy_client.py

@@ -1,149 +0,0 @@
-"""
-Claude-Aufruf ueber den lokalen Proxy.
-
-Der Proxy (claude-max-api-proxy) bietet eine OpenAI-kompatible API
-unter http://proxy:3456/v1/chat/completions. Wir nutzen non-streaming
-mit einem laengeren Timeout — Claude Code spawnt pro Anfrage einen
-neuen CLI-Prozess (Cold-Start), das dauert.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-from pathlib import Path
-from typing import List, Optional
-
-import httpx
-from pydantic import BaseModel
-
-import metrics
-
-logger = logging.getLogger(__name__)
-
-RUNTIME_CONFIG_FILE = Path("/shared/config/runtime.json")
-ENV_MODEL = os.environ.get("BRAIN_MODEL", "claude-sonnet-4")
-PROXY_URL = os.environ.get("PROXY_URL", "http://proxy:3456")
-PROXY_TIMEOUT_SEC = float(os.environ.get("PROXY_TIMEOUT_SEC", "300"))
-
-
-def _read_model_from_runtime() -> str:
-    """Liest brainModel aus runtime.json. Fallback: ENV BRAIN_MODEL."""
-    try:
-        if RUNTIME_CONFIG_FILE.exists():
-            data = json.loads(RUNTIME_CONFIG_FILE.read_text(encoding="utf-8"))
-            m = (data.get("brainModel") or "").strip()
-            if m:
-                return m
-    except Exception as exc:
-        logger.warning("runtime.json lesen fehlgeschlagen: %s", exc)
-    return ENV_MODEL
-
-
-DEFAULT_MODEL = _read_model_from_runtime()
-
-
-class Message(BaseModel):
-    role: str  # "system" | "user" | "assistant" | "tool"
-    content: Optional[str] = None
-    tool_calls: Optional[list] = None
-    tool_call_id: Optional[str] = None
-    name: Optional[str] = None  # nur fuer role=tool
-
-
-class ProxyResult(BaseModel):
-    content: str = ""
-    tool_calls: list = []  # je: {"id", "name", "arguments" (dict)}
-    finish_reason: str = ""
-
-
-class ProxyClient:
-    def __init__(self, base_url: str = PROXY_URL, model: str = DEFAULT_MODEL):
-        self.base_url = base_url.rstrip("/")
-        self.model = model
-        # Persistente Client-Connection — vermeidet TCP-Handshake bei jedem Call
-        self._client = httpx.Client(timeout=PROXY_TIMEOUT_SEC)
-
-    def chat(self, messages: List[Message], model: Optional[str] = None) -> str:
-        """Convenience: einfacher Chat ohne Tools. Gibt nur den Reply-String zurueck."""
-        result = self.chat_full(messages, tools=None, model=model)
-        if not result.content:
-            raise RuntimeError("Proxy lieferte leeren content")
-        return result.content
-
-    def chat_full(
-        self,
-        messages: List[Message],
-        tools: Optional[list] = None,
-        model: Optional[str] = None,
-    ) -> ProxyResult:
-        """Full chat — kann Tool-Calls liefern (wenn tools mitgegeben).
-
-        tools-Format ist OpenAI-Style:
-          [{"type":"function","function":{"name":..,"description":..,"parameters":{...}}}, ...]
-        """
-        url = f"{self.base_url}/v1/chat/completions"
-        # Pydantic-Dumps mit exclude_none damit role=tool ohne tool_calls geht
-        payload = {
-            "model": model or self.model,
-            "messages": [m.model_dump(exclude_none=True) for m in messages],
-        }
-        if tools:
-            payload["tools"] = tools
-        logger.info("Proxy → %s (%d Messages, %d tools, model=%s)",
-                    url, len(messages), len(tools or []), payload["model"])
-        try:
-            r = self._client.post(url, json=payload)
-        except httpx.RequestError as exc:
-            raise RuntimeError(f"Proxy unreachable: {exc}") from exc
-        if r.status_code != 200:
-            raise RuntimeError(f"Proxy HTTP {r.status_code}: {r.text[:300]}")
-        try:
-            data = r.json()
-        except Exception as exc:
-            raise RuntimeError(f"Proxy invalid JSON: {exc}") from exc
-
-        choices = data.get("choices") or []
-        if not choices:
-            raise RuntimeError(f"Proxy ohne choices: {str(data)[:300]}")
-
-        msg = choices[0].get("message") or {}
-        finish_reason = choices[0].get("finish_reason", "")
-
-        content = msg.get("content") or ""
-        if isinstance(content, list):
-            content = "".join(
-                part.get("text", "") for part in content if isinstance(part, dict) and part.get("type") == "text"
-            )
-
-        tool_calls_raw = msg.get("tool_calls") or []
-        tool_calls = []
-        import json as _json
-        for tc in tool_calls_raw:
-            fn = tc.get("function") or {}
-            args_raw = fn.get("arguments", "{}")
-            args: dict
-            if isinstance(args_raw, dict):
-                args = args_raw
-            else:
-                try:
-                    args = _json.loads(args_raw)
-                except Exception:
-                    args = {"_raw": args_raw}
-            tool_calls.append({
-                "id": tc.get("id", ""),
-                "name": fn.get("name", ""),
-                "arguments": args,
-            })
-
-        # Call-Metric anhaengen — Token-Schaetzung fuer Quota-Monitoring
-        metrics.log_call(payload["model"], messages, content or "")
-
-        return ProxyResult(content=content or "", tool_calls=tool_calls, finish_reason=finish_reason)
-
-    def close(self):
-        try:
-            self._client.close()
-        except Exception:
-            pass

aria-brain/requirements.txt

@@ -1,14 +0,0 @@
-fastapi==0.115.0
-uvicorn[standard]==0.32.0
-pydantic==2.9.2
-httpx==0.27.2
-websockets==13.1
-
-# Vector-DB
-qdrant-client==1.12.1
-
-# Embeddings (laeuft auf CPU, ~120MB Modell)
-sentence-transformers==3.2.1
-
-# Utility
-python-multipart==0.0.12

aria-brain/skills.py

@@ -1,373 +0,0 @@
-"""
-Skill-Manager — Filesystem-Layer fuer ARIAs Faehigkeiten.
-
-Layout:
-  /data/skills/<name>/
-    skill.json   - Manifest
-    README.md    - Beschreibung (vom Stil her: was, wann, wie aufrufen)
-    run.sh       - Entry-Point (sh, python -m, was auch immer)
-    requirements.txt        - optional, fuer local-venv
-    venv/        - automatisch erzeugt bei local-venv
-    bin/         - statische Binaries (fuer local-bin)
-    logs/        - <ts>.json Run-Logs (append-only pro Run)
-
-Manifest (skill.json):
-  {
-    "name": "youtube2mp3",
-    "description": "Konvertiert YouTube-Video-URL zu MP3",
-    "execution": "local-venv" | "local-bin" | "bash",
-    "entry": "run.sh",
-    "args": [{"name": "url", "required": true}, ...],
-    "requires": {"pip": [...], "binaries": [...]},
-    "active": true,
-    "created_at": "ISO",
-    "updated_at": "ISO",
-    "last_used": null | "ISO",
-    "use_count": 0,
-    "version": "1.0",
-    "author": "aria" | "stefan"
-  }
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-import shutil
-import subprocess
-import time
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-SKILLS_DIR = Path(os.environ.get("SKILLS_DIR", "/data/skills"))
-SHARED_UPLOADS = Path("/shared/uploads")
-
-VALID_EXECUTIONS = {"local-venv", "local-bin", "bash"}
-NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{2,60}$")
-
-
-def _now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def _safe_name(name: str) -> str:
-    if not isinstance(name, str) or not NAME_RE.match(name):
-        raise ValueError(f"Ungültiger Skill-Name: {name!r}")
-    return name
-
-
-def _skill_dir(name: str) -> Path:
-    return SKILLS_DIR / _safe_name(name)
-
-
-# ─── Listing ────────────────────────────────────────────────────────
-
-def list_skills(active_only: bool = False) -> list[dict]:
-    out: list[dict] = []
-    if not SKILLS_DIR.exists():
-        return out
-    for entry in sorted(SKILLS_DIR.iterdir()):
-        if not entry.is_dir():
-            continue
-        manifest = read_manifest(entry.name)
-        if manifest is None:
-            continue
-        if active_only and not manifest.get("active", True):
-            continue
-        out.append(manifest)
-    return out
-
-
-def read_manifest(name: str) -> Optional[dict]:
-    try:
-        path = _skill_dir(name) / "skill.json"
-        if not path.exists():
-            return None
-        return json.loads(path.read_text(encoding="utf-8"))
-    except Exception as exc:
-        logger.warning("Manifest lesen %s: %s", name, exc)
-        return None
-
-
-def write_manifest(name: str, manifest: dict) -> None:
-    d = _skill_dir(name)
-    d.mkdir(parents=True, exist_ok=True)
-    manifest["updated_at"] = _now()
-    (d / "skill.json").write_text(json.dumps(manifest, indent=2, ensure_ascii=False), encoding="utf-8")
-
-
-def read_readme(name: str) -> str:
-    path = _skill_dir(name) / "README.md"
-    return path.read_text(encoding="utf-8") if path.exists() else ""
-
-
-# ─── Create / Update / Delete ────────────────────────────────────────
-
-def create_skill(
-    name: str,
-    description: str,
-    execution: str,
-    entry_code: str,
-    readme: str = "",
-    args: Optional[list] = None,
-    requires: Optional[dict] = None,
-    pip_packages: Optional[list[str]] = None,
-    author: str = "aria",
-) -> dict:
-    """Legt einen neuen Skill an. Wirft ValueError bei ungueltigen Inputs.
-
-    entry_code wird je nach execution in run.sh oder run.py geschrieben.
-    Bei local-venv wird sofort eine venv erzeugt + pip_packages installiert.
-    """
-    name = _safe_name(name)
-    if execution not in VALID_EXECUTIONS:
-        raise ValueError(f"execution muss eines von {VALID_EXECUTIONS} sein")
-    d = _skill_dir(name)
-    if d.exists():
-        raise ValueError(f"Skill '{name}' existiert bereits — erst loeschen oder updaten")
-
-    d.mkdir(parents=True)
-    (d / "logs").mkdir()
-
-    # Entry-File: run.sh oder run.py
-    if execution == "local-venv":
-        entry_path = d / "run.py"
-        entry_path.write_text(entry_code, encoding="utf-8")
-        entry_name = "run.py"
-        (d / "requirements.txt").write_text("\n".join(pip_packages or []) + "\n", encoding="utf-8")
-    else:
-        entry_path = d / "run.sh"
-        # Shebang ergaenzen wenn nicht da
-        content = entry_code if entry_code.startswith("#!") else "#!/usr/bin/env bash\nset -euo pipefail\n" + entry_code
-        entry_path.write_text(content, encoding="utf-8")
-        entry_path.chmod(0o755)
-        entry_name = "run.sh"
-
-    # README
-    (d / "README.md").write_text(readme or f"# {name}\n\n{description}\n", encoding="utf-8")
-
-    manifest = {
-        "name": name,
-        "description": description,
-        "execution": execution,
-        "entry": entry_name,
-        "args": args or [],
-        "requires": requires or {},
-        "active": True,
-        "created_at": _now(),
-        "updated_at": _now(),
-        "last_used": None,
-        "use_count": 0,
-        "version": "1.0",
-        "author": author,
-    }
-    write_manifest(name, manifest)
-
-    # venv aufbauen bei local-venv
-    if execution == "local-venv":
-        try:
-            _setup_venv(d, pip_packages or [])
-        except Exception as exc:
-            # venv-Aufbau fehlgeschlagen → Skill steht trotzdem im Repo, aber inaktiv
-            manifest["active"] = False
-            manifest["setup_error"] = str(exc)[:500]
-            write_manifest(name, manifest)
-            logger.warning("Skill %s: venv-Setup fehlgeschlagen → deaktiviert: %s", name, exc)
-
-    logger.info("Skill erstellt: %s (%s)", name, execution)
-    return manifest
-
-
-def _setup_venv(skill_dir: Path, pip_packages: list[str]) -> None:
-    venv = skill_dir / "venv"
-    logger.info("venv erstellen: %s", venv)
-    subprocess.run(["python", "-m", "venv", str(venv)], check=True, timeout=120)
-    pip = venv / "bin" / "pip"
-    if pip_packages:
-        subprocess.run([str(pip), "install", "--no-cache-dir", *pip_packages], check=True, timeout=600)
-
-
-def update_skill(name: str, patch: dict) -> dict:
-    manifest = read_manifest(name)
-    if manifest is None:
-        raise ValueError(f"Skill '{name}' nicht gefunden")
-    allowed = {"description", "args", "requires", "active", "version", "entry"}
-    for k, v in patch.items():
-        if k in allowed:
-            manifest[k] = v
-    write_manifest(name, manifest)
-    return manifest
-
-
-def delete_skill(name: str) -> None:
-    d = _skill_dir(name)
-    if not d.exists():
-        raise ValueError(f"Skill '{name}' nicht gefunden")
-    shutil.rmtree(d)
-    logger.info("Skill geloescht: %s", name)
-
-
-# ─── Run ────────────────────────────────────────────────────────────
-
-def run_skill(name: str, args: Optional[dict] = None, timeout_sec: int = 300) -> dict:
-    """Fuehrt einen Skill aus. Args werden als ENV-Vars uebergeben
-    (Praefix ARG_, z.B. ARG_URL fuer args["url"]).
-
-    Returns: {ok, exit_code, stdout, stderr, duration_sec, log_path}
-    """
-    manifest = read_manifest(name)
-    if manifest is None:
-        raise ValueError(f"Skill '{name}' nicht gefunden")
-    if not manifest.get("active", True):
-        raise ValueError(f"Skill '{name}' ist deaktiviert")
-
-    d = _skill_dir(name)
-    entry = manifest.get("entry", "run.sh")
-    exec_mode = manifest.get("execution", "bash")
-
-    env = os.environ.copy()
-    # Skill-Args als ENV-Vars
-    for k, v in (args or {}).items():
-        if not re.match(r"^[a-zA-Z][a-zA-Z0-9_]*$", k):
-            continue
-        env[f"ARG_{k.upper()}"] = str(v)
-    env["SKILL_DIR"] = str(d)
-    env["SHARED_UPLOADS"] = str(SHARED_UPLOADS)
-
-    # Command bauen
-    if exec_mode == "local-venv":
-        python = d / "venv" / "bin" / "python"
-        cmd = [str(python), str(d / entry)]
-    elif exec_mode == "local-bin":
-        # Skill bringt seine bin/ mit — wir prepended sie an den PATH
-        env["PATH"] = f"{d / 'bin'}:{env.get('PATH', '')}"
-        cmd = [str(d / entry)]
-    else:  # bash
-        cmd = [str(d / entry)]
-
-    log_id = f"{int(time.time())}-{uuid.uuid4().hex[:8]}"
-    log_path = d / "logs" / f"{log_id}.json"
-
-    t0 = time.time()
-    try:
-        proc = subprocess.run(
-            cmd, env=env, cwd=str(d),
-            capture_output=True, text=True, timeout=timeout_sec,
-        )
-        out_text = proc.stdout
-        err_text = proc.stderr
-        exit_code = proc.returncode
-        timed_out = False
-    except subprocess.TimeoutExpired as exc:
-        out_text = exc.stdout or ""
-        err_text = (exc.stderr or "") + f"\n[TIMEOUT {timeout_sec}s]"
-        exit_code = -1
-        timed_out = True
-    duration = time.time() - t0
-
-    # Log schreiben (gekuerzt damit es nicht explodiert)
-    record = {
-        "ts": _now(),
-        "args": args or {},
-        "exit_code": exit_code,
-        "duration_sec": round(duration, 2),
-        "stdout": (out_text or "")[:8000],
-        "stderr": (err_text or "")[:8000],
-        "timed_out": timed_out,
-    }
-    try:
-        log_path.write_text(json.dumps(record, indent=2, ensure_ascii=False), encoding="utf-8")
-    except Exception:
-        pass
-
-    # Stats updaten
-    manifest["last_used"] = _now()
-    manifest["use_count"] = int(manifest.get("use_count", 0)) + 1
-    write_manifest(name, manifest)
-
-    record["ok"] = exit_code == 0
-    record["log_path"] = str(log_path)
-    return record
-
-
-def list_logs(name: str, limit: int = 50) -> list[dict]:
-    d = _skill_dir(name) / "logs"
-    if not d.exists():
-        return []
-    files = sorted(d.glob("*.json"), reverse=True)[:limit]
-    out: list[dict] = []
-    for f in files:
-        try:
-            data = json.loads(f.read_text(encoding="utf-8"))
-            data["log_id"] = f.stem
-            out.append(data)
-        except Exception:
-            continue
-    return out
-
-
-# ─── Export / Import ────────────────────────────────────────────────
-
-def export_skill(name: str) -> bytes:
-    """Packt einen Skill als tar.gz und gibt die Bytes zurueck.
-    venv und logs werden ausgeschlossen (werden beim Import neu gebaut)."""
-    import io
-    import tarfile
-    d = _skill_dir(name)
-    if not d.exists():
-        raise ValueError(f"Skill '{name}' nicht gefunden")
-    buf = io.BytesIO()
-    with tarfile.open(fileobj=buf, mode="w:gz") as tar:
-        for path in d.iterdir():
-            if path.name in ("venv", "logs", "__pycache__"):
-                continue
-            tar.add(path, arcname=f"{name}/{path.name}")
-    return buf.getvalue()
-
-
-def import_skill(tar_bytes: bytes, overwrite: bool = False) -> dict:
-    """Importiert einen Skill aus tar.gz. Liefert das Manifest zurueck."""
-    import io
-    import tarfile
-    SKILLS_DIR.mkdir(parents=True, exist_ok=True)
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:gz") as tar:
-        # Erst Root-Name finden (= Skill-Name)
-        members = tar.getmembers()
-        if not members:
-            raise ValueError("Leeres Archiv")
-        root = members[0].name.split("/", 1)[0]
-        name = _safe_name(root)
-        d = _skill_dir(name)
-        if d.exists():
-            if not overwrite:
-                raise ValueError(f"Skill '{name}' existiert bereits — overwrite=true setzen")
-            shutil.rmtree(d)
-        # Extrahieren — Path-Traversal verhindern
-        for m in members:
-            target = SKILLS_DIR / m.name
-            if not str(target.resolve()).startswith(str(SKILLS_DIR.resolve())):
-                raise ValueError(f"Unsicherer Pfad im Archiv: {m.name}")
-        tar.extractall(SKILLS_DIR)
-    # logs-Verzeichnis anlegen falls fehlte
-    (d / "logs").mkdir(exist_ok=True)
-    # venv neu bauen falls local-venv
-    manifest = read_manifest(name) or {}
-    if manifest.get("execution") == "local-venv":
-        req_file = d / "requirements.txt"
-        pip_packages: list[str] = []
-        if req_file.exists():
-            pip_packages = [l.strip() for l in req_file.read_text().splitlines() if l.strip() and not l.startswith("#")]
-        try:
-            _setup_venv(d, pip_packages)
-        except Exception as exc:
-            logger.warning("Skill-Import %s: venv-Setup fehlgeschlagen: %s", name, exc)
-            manifest["active"] = False
-            manifest["setup_error"] = str(exc)[:500]
-            write_manifest(name, manifest)
-    return manifest

aria-brain/triggers.py

@@ -1,229 +0,0 @@
-"""
-Triggers — passive Aufweck-Quellen fuer ARIA.
-
-Skills sind aktiv (ARIA ruft sie). Triggers sind passiv — das System ruft
-ARIA wenn ein Event passiert. Drei Typen:
-
-  timer    Einmalig zu einem festen Zeitpunkt
-  watcher  Recurring: Condition pruefen, bei True → feuern (mit Throttle)
-  cron     Cron-Expression (vorerst nicht implementiert, Platzhalter)
-
-Layout:
-  /data/triggers/<name>.json    Manifest pro Trigger
-  /data/triggers/logs/<name>.jsonl   Append-only Log pro Feuerung
-
-Polling-Kosten: Brain-internes Background-Polling (kein LLM-Call).
-ARIA wird nur aufgeweckt wenn ein Trigger tatsaechlich feuert.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-import shutil
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-TRIGGERS_DIR = Path(os.environ.get("TRIGGERS_DIR", "/data/triggers"))
-LOGS_DIR = TRIGGERS_DIR / "logs"
-NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{2,60}$")
-VALID_TYPES = {"timer", "watcher", "cron"}
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def _safe_name(name: str) -> str:
-    if not isinstance(name, str) or not NAME_RE.match(name):
-        raise ValueError(f"Ungueltiger Trigger-Name: {name!r}")
-    return name
-
-
-def _path(name: str) -> Path:
-    return TRIGGERS_DIR / f"{_safe_name(name)}.json"
-
-
-def _ensure_dirs():
-    TRIGGERS_DIR.mkdir(parents=True, exist_ok=True)
-    LOGS_DIR.mkdir(parents=True, exist_ok=True)
-
-
-# ─── CRUD ───────────────────────────────────────────────────────────
-
-def list_triggers(active_only: bool = False) -> list[dict]:
-    if not TRIGGERS_DIR.exists():
-        return []
-    out: list[dict] = []
-    for f in sorted(TRIGGERS_DIR.glob("*.json")):
-        try:
-            data = json.loads(f.read_text(encoding="utf-8"))
-            if active_only and not data.get("active", True):
-                continue
-            out.append(data)
-        except Exception as e:
-            logger.warning("Trigger lesen %s: %s", f, e)
-    return out
-
-
-def read(name: str) -> Optional[dict]:
-    p = _path(name)
-    if not p.exists():
-        return None
-    try:
-        return json.loads(p.read_text(encoding="utf-8"))
-    except Exception as e:
-        logger.warning("Trigger %s lesen: %s", name, e)
-        return None
-
-
-def write(name: str, data: dict) -> None:
-    _ensure_dirs()
-    data["updated_at"] = _now_iso()
-    p = _path(name)
-    tmp = p.with_suffix(".tmp")
-    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
-    tmp.replace(p)
-
-
-def delete(name: str) -> None:
-    p = _path(name)
-    if not p.exists():
-        raise ValueError(f"Trigger '{name}' nicht gefunden")
-    p.unlink()
-    # Logs auch wegraeumen
-    log_file = LOGS_DIR / f"{_safe_name(name)}.jsonl"
-    if log_file.exists():
-        log_file.unlink()
-
-
-def update(name: str, patch: dict) -> dict:
-    data = read(name)
-    if data is None:
-        raise ValueError(f"Trigger '{name}' nicht gefunden")
-    allowed = {"active", "message", "condition", "throttle_sec",
-               "check_interval_sec", "fires_at"}
-    for k, v in patch.items():
-        if k in allowed:
-            data[k] = v
-    write(name, data)
-    return data
-
-
-# ─── Create-Helpers (typ-spezifisch) ────────────────────────────────
-
-def create_timer(
-    name: str,
-    fires_at_iso: str,
-    message: str,
-    author: str = "aria",
-) -> dict:
-    _safe_name(name)
-    if _path(name).exists():
-        raise ValueError(f"Trigger '{name}' existiert schon")
-    # ISO validieren
-    try:
-        datetime.fromisoformat(fires_at_iso.replace("Z", "+00:00"))
-    except Exception:
-        raise ValueError(f"fires_at_iso ungueltig: {fires_at_iso}")
-    data = {
-        "name": name,
-        "type": "timer",
-        "active": True,
-        "author": author,
-        "created_at": _now_iso(),
-        "fires_at": fires_at_iso,
-        "message": message,
-        "fire_count": 0,
-        "last_fired_at": None,
-    }
-    write(name, data)
-    logger.info("Trigger angelegt: %s (timer, fires_at=%s)", name, fires_at_iso)
-    return data
-
-
-def create_watcher(
-    name: str,
-    condition: str,
-    message: str,
-    check_interval_sec: int = 300,
-    throttle_sec: int = 3600,
-    author: str = "aria",
-) -> dict:
-    _safe_name(name)
-    if _path(name).exists():
-        raise ValueError(f"Trigger '{name}' existiert schon")
-    # Condition parsen-pruefen (wirft bei Syntax-Fehler)
-    from watcher import parse_condition
-    parse_condition(condition)  # nur Validate
-    if check_interval_sec < 30:
-        check_interval_sec = 30  # nicht oefter als alle 30s pruefen
-    if throttle_sec < 0:
-        throttle_sec = 0
-    data = {
-        "name": name,
-        "type": "watcher",
-        "active": True,
-        "author": author,
-        "created_at": _now_iso(),
-        "condition": condition,
-        "check_interval_sec": int(check_interval_sec),
-        "throttle_sec": int(throttle_sec),
-        "message": message,
-        "fire_count": 0,
-        "last_fired_at": None,
-        "last_checked_at": None,
-    }
-    write(name, data)
-    logger.info("Trigger angelegt: %s (watcher, cond='%s')", name, condition)
-    return data
-
-
-# ─── Feuern + Log ───────────────────────────────────────────────────
-
-def mark_fired(name: str) -> dict:
-    data = read(name)
-    if data is None:
-        raise ValueError(f"Trigger '{name}' nicht gefunden")
-    data["fire_count"] = int(data.get("fire_count", 0)) + 1
-    data["last_fired_at"] = _now_iso()
-    # Timer: nach Feuern auto-deaktivieren (one-shot)
-    if data.get("type") == "timer":
-        data["active"] = False
-    write(name, data)
-    return data
-
-
-def append_log(name: str, entry: dict) -> None:
-    _ensure_dirs()
-    log_file = LOGS_DIR / f"{_safe_name(name)}.jsonl"
-    record = {"ts": _now_iso()}
-    record.update(entry)
-    try:
-        with log_file.open("a", encoding="utf-8") as f:
-            f.write(json.dumps(record, ensure_ascii=False) + "\n")
-    except Exception as e:
-        logger.warning("Trigger-Log append %s: %s", name, e)
-
-
-def list_logs(name: str, limit: int = 50) -> list[dict]:
-    log_file = LOGS_DIR / f"{_safe_name(name)}.jsonl"
-    if not log_file.exists():
-        return []
-    try:
-        lines = log_file.read_text(encoding="utf-8").splitlines()
-        out: list[dict] = []
-        for line in lines[-limit:]:
-            try:
-                out.append(json.loads(line))
-            except Exception:
-                pass
-        return out
-    except Exception:
-        return []

aria-brain/watcher.py

@@ -1,150 +0,0 @@
-"""
-Built-in Condition-Variablen + sicherer Mini-Parser fuer Watcher-Triggers.
-
-Erlaubte Variablen kommen aus diesem Modul. Condition-Ausdruck ist ein
-sicheres Subset von Python (kein eval, kein exec): nur Vergleiche und
-Boolean-Operatoren, nur die hier deklarierten Variablen, nur Zahlen +
-String-Literale als rechte Seite.
-
-Beispiele:
-  disk_free_gb < 5
-  hour_of_day == 8 and day_of_week == "mon"
-  rvs_connected == False
-  (disk_free_pct < 10 and uptime_sec > 3600)
-"""
-
-from __future__ import annotations
-
-import ast
-import logging
-import os
-import shutil
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-# ─── Variablen-Quellen ──────────────────────────────────────────────
-
-def _disk_stats() -> tuple[float, float]:
-    """Returns (free_gb, free_pct). Schaut /shared (geteiltes Volume) — sonst /."""
-    target = "/shared" if os.path.exists("/shared") else "/"
-    try:
-        st = shutil.disk_usage(target)
-        free_gb = st.free / (1024 ** 3)
-        free_pct = 100.0 * st.free / st.total if st.total else 0.0
-        return free_gb, free_pct
-    except Exception as e:
-        logger.warning("disk_usage: %s", e)
-        return 0.0, 0.0
-
-
-def _uptime_sec() -> int:
-    try:
-        with open("/proc/uptime", "r") as f:
-            return int(float(f.read().split()[0]))
-    except Exception:
-        return 0
-
-
-def _rvs_connected() -> bool:
-    """Liest /shared/config/runtime.json oder ein Bridge-State-File.
-    Aktuell: wir koennen das nicht zuverlaessig aus dem Brain-Container
-    bestimmen — gibt False als sicheren Default zurueck.
-    Spaeter: Bridge schreibt einen Heartbeat-File den wir hier lesen."""
-    return False
-
-
-_DAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
-
-
-def collect_variables() -> dict[str, Any]:
-    """Liefert aktuellen Snapshot aller Built-in-Variablen."""
-    free_gb, free_pct = _disk_stats()
-    now = datetime.now()
-    # Memory-Count aus der Vector-DB (importiert lazy um zirkulaere Imports
-    # zu vermeiden — beim Modul-Load gibt's noch keinen Store)
-    memory_count = 0
-    try:
-        from main import store  # type: ignore
-        s = store()
-        memory_count = s.count()
-    except Exception:
-        pass
-
-    return {
-        "disk_free_gb":   round(free_gb, 2),
-        "disk_free_pct":  round(free_pct, 1),
-        "uptime_sec":     _uptime_sec(),
-        "hour_of_day":    now.hour,
-        "day_of_week":    _DAYS[now.weekday()],
-        "rvs_connected":  _rvs_connected(),
-        "memory_count":   memory_count,
-    }
-
-
-def describe_variables() -> list[dict]:
-    """Liste der verfuegbaren Variablen + Beschreibung — fuer System-Prompt + UI."""
-    return [
-        {"name": "disk_free_gb",   "type": "number", "desc": "freier Plattenplatz in GB (auf /shared)"},
-        {"name": "disk_free_pct",  "type": "number", "desc": "freier Plattenplatz in Prozent"},
-        {"name": "uptime_sec",     "type": "number", "desc": "Sekunden seit Brain-Start"},
-        {"name": "hour_of_day",    "type": "number", "desc": "0..23, lokale Zeit"},
-        {"name": "day_of_week",    "type": "string", "desc": "mon|tue|wed|thu|fri|sat|sun"},
-        {"name": "rvs_connected",  "type": "bool",   "desc": "True wenn RVS-Verbindung steht"},
-        {"name": "memory_count",   "type": "number", "desc": "Anzahl Memories in der Vector-DB"},
-    ]
-
-
-# ─── Sicherer Condition-Parser ──────────────────────────────────────
-
-_ALLOWED_NODES = (
-    ast.Expression, ast.BoolOp, ast.UnaryOp, ast.Compare,
-    ast.Name, ast.Constant, ast.Load,
-    ast.And, ast.Or, ast.Not,
-    ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE,
-)
-
-
-def parse_condition(expr: str) -> ast.Expression:
-    """Parst einen Condition-Ausdruck und validiert ihn gegen das Safe-Subset.
-    Wirft ValueError bei verbotenen Konstrukten."""
-    expr = (expr or "").strip()
-    if not expr:
-        raise ValueError("Leere Condition")
-    if len(expr) > 500:
-        raise ValueError("Condition zu lang (>500 Zeichen)")
-    try:
-        tree = ast.parse(expr, mode="eval")
-    except SyntaxError as e:
-        raise ValueError(f"Condition Syntax-Fehler: {e}")
-    # Whitelist-Walk
-    allowed_names = {v["name"] for v in describe_variables()}
-    for node in ast.walk(tree):
-        if not isinstance(node, _ALLOWED_NODES):
-            raise ValueError(f"Verbotener Ausdruck: {type(node).__name__}")
-        if isinstance(node, ast.Name):
-            if node.id not in allowed_names and node.id not in ("True", "False"):
-                raise ValueError(f"Unbekannte Variable: {node.id}")
-        if isinstance(node, ast.Constant):
-            if not isinstance(node.value, (int, float, str, bool)) and node.value is not None:
-                raise ValueError(f"Verbotener Konstant-Typ: {type(node.value).__name__}")
-    return tree
-
-
-def evaluate(expr: str, variables: dict[str, Any] | None = None) -> bool:
-    """Evaluiert die Condition gegen die aktuellen Variablen.
-    Returns bool. Bei Fehler in Variablen → False (defensiv)."""
-    tree = parse_condition(expr)
-    vars_ = variables if variables is not None else collect_variables()
-    code = compile(tree, "<condition>", "eval")
-    # Globals leer, locals nur die erlaubten Variablen → kein Builtin-Zugriff
-    try:
-        result = eval(code, {"__builtins__": {}}, vars_)
-    except Exception as e:
-        logger.warning("Condition '%s' eval-Fehler: %s", expr, e)
-        return False
-    return bool(result)

aria-data/config/AGENT.md

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

aria-data/config/BOOTSTRAP.md

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

aria-data/config/USER.md

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

aria-data/config/aria.env.example

@@ -0,0 +1,14 @@
+# Bridge → aria-core (OpenClaw Gateway)
+# Bridge teilt Netzwerk mit aria-core (network_mode: service:aria)
+# → localhost ist aria-core
+ARIA_CORE_WS=ws://127.0.0.1:18789
+
+# 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

aria-data/config/openclaw-auth.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "profiles": {
+    "openai-proxy": {
+      "provider": "openai",
+      "default": true,
+      "apiKey": "not-needed",
+      "baseUrl": "http://proxy:3456/v1"
+    }
+  }
+}

aria-data/config/openclaw.env

@@ -0,0 +1,6 @@
+# OpenClaw (aria-core) Konfiguration
+# Diese Datei wird als /workspace/.env in den Container gemountet
+#
+# WICHTIG: ANTHROPIC_API_KEY und ANTHROPIC_BASE_URL absichtlich NICHT gesetzt!
+# OpenClaw wuerde sonst die echte Anthropic API direkt anrufen (401 weil kein API Key).
+# Stattdessen nur den OpenAI-kompatiblen Proxy nutzen.

aria-data/docs/tool-permissions.md

@@ -0,0 +1,137 @@
+# OpenClaw Tool-Permissions — Stand 2026-03-15
+
+## Das Problem (GELÖST)
+
+ARIA hat ZWEI Tool-Systeme gleichzeitig: Claude Code Tools UND OpenClaw-native Tools.
+Das Model hat aber nur Zugriff auf **Claude Code Tools** (über den Proxy), nicht auf OpenClaw-native Tools.
+
+### Root Cause: DREI Probleme gleichzeitig
+
+```
+OpenClaw (aria-core) → API Request → claude-max-api-proxy (aria-proxy) → Claude Code CLI (--print Mode)
+                                                                          ↓
+                                                                    Tools: WebFetch, Bash, etc. (Claude Code)
+                                                                    NICHT: web_fetch, exec (OpenClaw-nativ)
+```
+
+**Problem 1: Proxy benutzt `--print` Modus**
+- `claude-max-api-proxy` ruft Claude Code CLI mit `--print --output-format stream-json` auf
+- Der Prompt wird als einziger String übergeben, keine Tool-Definitionen von OpenClaw
+- Das Model sieht NUR Claude Code's eingebaute Tools (WebFetch, Bash, etc.)
+- OpenClaw-native Tools (web_fetch, exec) existieren NUR auf Gateway-Ebene, kommen nie beim Model an
+
+**Problem 2: BOOTSTRAP.md hat die falschen Tools angewiesen**
+- BOOTSTRAP.md sagte: "NIEMALS WebFetch benutzen, stattdessen web_fetch"
+- Aber web_fetch existiert nicht im Claude Code CLI Kontext
+- Und WebFetch war das einzige Tool das funktioniert hätte
+- → Model hatte keine Tools die es benutzen "durfte"
+
+**Problem 3: settings.json im Proxy war leer**
+- `/root/.claude/settings.json` enthielt nur `{}` (keine Permissions)
+- Claude Code CLI im headless-Modus kann keine Tool-Genehmigungen erteilen
+- → Selbst wenn das Model WebFetch benutzen wollte, war es nicht vorab genehmigt
+
+## Die Lösung
+
+### Fix 1: BOOTSTRAP.md + AGENT.md umgeschrieben
+
+**Vorher (FALSCH):**
+- "NIEMALS WebFetch benutzen — hat Permission-Probleme"
+- "Benutze web_fetch (OpenClaw-nativ)"
+
+**Nachher (KORREKT):**
+- "WebFetch — URLs abrufen, Webseiten lesen, APIs aufrufen, Wetter abfragen"
+- "Bash — Shell-Befehle ausfuehren (curl, ssh, docker, etc.)"
+- "Niemals sagen 'ich habe keinen Zugriff' — du hast Zugriff auf alles"
+
+### Fix 2: `CLAUDE_CODE_BUBBLEWRAP=1` + `--dangerously-skip-permissions`
+
+**Der Schlüssel-Fix.** Zwei Zeilen in `docker-compose.yml`:
+
+```yaml
+# 1. sed-Patch: --dangerously-skip-permissions in manager.js einfügen
+sed -i 's/"--no-session-persistence",/"--no-session-persistence","--dangerously-skip-permissions",/' $$DIST/subprocess/manager.js &&
+
+# 2. Environment-Variable: Root-Check umgehen
+environment:
+  - CLAUDE_CODE_BUBBLEWRAP=1
+```
+
+**Warum beides nötig:**
+- `--dangerously-skip-permissions` umgeht alle Tool-Permission-Checks in Claude Code CLI
+- Aber: Claude Code CLI blockiert dieses Flag wenn es als root läuft
+- `CLAUDE_CODE_BUBBLEWRAP=1` überspringt den Root-Check (gefunden im minifizierten `cli.js`)
+- Proxy-Container (`node:22-alpine`) läuft als root → ohne BUBBLEWRAP geht's nicht
+
+**Resultierende CLI-Argumente:**
+```
+claude --print --output-format stream-json --verbose --include-partial-messages \
+  --model opus --no-session-persistence --dangerously-skip-permissions "prompt"
+```
+
+## Wie der Proxy intern funktioniert
+
+```
+openai-to-cli.js:  OpenAI Messages → einzelner Prompt-String
+                    system → <system>...</system>
+                    user → direkt
+                    assistant → <previous_response>...</previous_response>
+
+subprocess/manager.js:  Spawnt `claude --print ... --dangerously-skip-permissions "{prompt}"`
+
+cli-to-openai.js:  Claude CLI JSON-Stream → OpenAI Chat Completion Chunks
+```
+
+Der Proxy leitet KEINE Tool-Definitionen von OpenClaw weiter.
+Tool-Calls passieren INTERN in der Claude Code CLI und sind für OpenClaw transparent.
+
+## Permission-Architektur
+
+**Granulare Tool-Kontrolle ist NICHT möglich.** Es ist Alles-oder-Nichts:
+- `--dangerously-skip-permissions` AN → ARIA kann alle Claude Code Tools benutzen
+- `--dangerously-skip-permissions` AUS → ARIA kann keine Tools benutzen
+
+OpenClaw's eigene Permissions (`tools.allow/deny` in `openclaw.json`) haben **keinen Effekt** auf die
+Claude Code Tools — die laufen komplett auf Proxy-Seite.
+
+## Was NICHT funktioniert hat (17 Versuche)
+
+1. **settings.json in aria-core** — OpenClaw benutzt NICHT Claude Code's settings.json
+2. **tools.allow mit PascalCase** (WebFetch, Grep) — OpenClaw kennt diese Namen nicht
+3. **tools.allow mit snake_case** (web_fetch) — Nur exec, read, write, edit erkannt
+4. **tools.allow mit Wildcard** `["*"]` — Hat nicht geholfen
+5. **tools.allow leer + tools.profile: "full"** — Nur ohne andere Fehler
+6. **System-Prompt Anweisung allein** — Reicht nicht wenn Tools blockiert sind
+7. **exec-approvals Wildcard allein** — Reicht nicht bei Config-Validation-Error
+8. **`openclaw config unset tools.exec.ask`** — CLI kennt den Pfad nicht
+9. **BOOTSTRAP.md mit OpenClaw-Tool-Namen** — Tools existieren nur auf Gateway-Ebene
+10. **settings.json im Proxy ohne BOOTSTRAP.md Fix** — BOOTSTRAP.md verbot die Tools
+11. **tools.byProvider.proxy.profile full** — Kein Effekt
+12. **settings.json + BOOTSTRAP.md ohne --dangerously-skip-permissions** — `--print` ignoriert settings.json
+13. **Manuelles `docker exec sed`** — Wird bei jedem Restart überschrieben
+14. **`--dangerously-skip-permissions` ohne BUBBLEWRAP** — Root-Check blockiert
+15. **`--allowedTools`** — Variadisches Argument frisst den Prompt
+16. **`--permission-mode bypassPermissions`** — Gleicher Root-Check
+17. **Non-Root User (`su node`)** — Auth-Pfad-Probleme, Credentials unerreichbar
+
+## Wichtige Pfade
+
+### aria-core (OpenClaw)
+- `/home/node/.openclaw/openclaw.json` — OpenClaw Haupt-Config
+- `/home/node/.openclaw/exec-approvals.json` — Exec Approvals
+- `/tmp/openclaw/openclaw-YYYY-MM-DD.log` — Tages-Log
+
+### aria-proxy (Claude Code CLI)
+- `/root/.claude/.credentials.json` — Auth Credentials (NICHT in /root/.config/claude/)
+- `/usr/local/lib/node_modules/claude-max-api-proxy/dist/` — Proxy Source
+- `/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js` — Claude Code CLI (enthält Root-Check)
+
+## OpenClaw CLI Referenz
+
+```bash
+openclaw config get/set/unset <path>    # Config verwalten
+openclaw approvals get                  # Exec-Approvals anzeigen
+openclaw approvals allowlist add        # Exec-Pattern freigeben
+openclaw doctor [--fix]                 # Health Check
+openclaw gateway status                 # Gateway-Status
+```

aria-setup.sh

@@ -1,23 +1,104 @@
 #!/bin/bash
 # ════════════════════════════════════════════════
 #  ARIA — Ersteinrichtung nach docker compose up
-#
-#  OpenClaw (aria-core) ist abgerissen — das Setup macht jetzt
-#  nur noch den SSH-Key fuer den Zugriff auf die VM (aria-wohnung).
-#  Brain + Proxy teilen sich denselben Key, beide haben aria-data/ssh
-#  als Volume gemountet.
+#  Einmalig ausfuehren, danach persistiert alles.
 # ════════════════════════════════════════════════
 set -e
 
+echo "=== ARIA Setup ==="
+echo ""
+
+# Warten bis aria-core laeuft
+echo "[1/7] Warte auf aria-core..."
+until docker inspect -f '{{.State.Running}}' aria-core 2>/dev/null | grep -q true; do
+  sleep 2
+  echo "  ... warte..."
+done
+echo "  aria-core laeuft."
+
+# Permissions fixen — Docker-Volumes gehoeren root, OpenClaw laeuft als node
+echo ""
+echo "[2/7] Fixe Permissions auf /home/node/.openclaw und /home/node/.claude..."
+docker exec -u root aria-core chown -R node:node /home/node/.openclaw
+docker exec -u root aria-core chown -R node:node /home/node/.claude 2>/dev/null || true
+docker exec -u root aria-core chmod 700 /home/node/.openclaw
+echo "  Permissions OK."
+
+# OpenClaw Config schreiben — Custom Provider fuer claude-max-api-proxy
+echo ""
+echo "[3/7] Schreibe openclaw.json (Proxy-Provider + Model + Tools)..."
+docker exec aria-core sh -c 'cat > /home/node/.openclaw/openclaw.json << '"'"'INNEREOF'"'"'
+{
+  "meta": {
+    "lastTouchedVersion": "2026.3.8"
+  },
+  "gateway": {
+    "mode": "local"
+  },
+  "agents": {
+    "defaults": {
+      "model": {
+        "primary": "proxy/claude-sonnet-4"
+      },
+      "compaction": {
+        "mode": "safeguard"
+      },
+      "timeoutSeconds": 900,
+      "maxConcurrent": 4,
+      "subagents": {
+        "maxConcurrent": 8
+      }
+    }
+  },
+  "models": {
+    "providers": {
+      "proxy": {
+        "api": "openai-completions",
+        "baseUrl": "http://proxy:3456/v1",
+        "apiKey": "not-needed",
+        "models": [
+          { "id": "claude-sonnet-4", "name": "claude-sonnet-4" },
+          { "id": "claude-opus-4", "name": "claude-opus-4" }
+        ]
+      }
+    }
+  },
+  "tools": {
+    "profile": "full",
+    "web": {
+      "fetch": {
+        "enabled": true
+      }
+    },
+    "exec": {
+      "host": "gateway"
+    }
+  },
+  "messages": {
+    "ackReactionScope": "all"
+  },
+  "commands": {
+    "native": "auto",
+    "nativeSkills": "auto",
+    "restart": true,
+    "ownerDisplay": "raw"
+  }
+}
+INNEREOF'
+echo "  Config geschrieben."
+
+# Exec-Approvals Wildcard — erlaubt Tool-Ausfuehrung im headless-Modus
+echo ""
+echo "[4/7] Setze exec-approvals Wildcard..."
+docker exec aria-core openclaw approvals allowlist add --agent "*" "*" 2>/dev/null || true
+echo "  Approvals gesetzt."
+
+# SSH-Key generieren fuer VM-Zugriff
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 SSH_DIR="$SCRIPT_DIR/aria-data/ssh"
-
-echo "=== ARIA Setup ==="
-
-mkdir -p "$SSH_DIR"
-
+echo ""
+echo "[5/7] SSH-Key fuer VM-Zugriff..."
 if [ ! -f "$SSH_DIR/id_ed25519" ]; then
-  echo "Generiere SSH-Key fuer aria-wohnung..."
   ssh-keygen -t ed25519 -f "$SSH_DIR/id_ed25519" -N "" -C "aria@aria-wohnung"
   cat > "$SSH_DIR/config" << 'SSHEOF'
 Host aria-wohnung
@@ -27,26 +108,34 @@ Host aria-wohnung
   StrictHostKeyChecking accept-new
 SSHEOF
   chmod 600 "$SSH_DIR/id_ed25519"
-  chmod 644 "$SSH_DIR/id_ed25519.pub" "$SSH_DIR/config"
-
-  # Public Key direkt in /root/.ssh/authorized_keys eintragen
-  # (Script laeuft als root auf der VM aria-wohnung)
-  if [ -w /root/.ssh ] || [ -w /root ]; then
-    mkdir -p /root/.ssh
-    chmod 700 /root/.ssh
-    cat "$SSH_DIR/id_ed25519.pub" >> /root/.ssh/authorized_keys
-    chmod 600 /root/.ssh/authorized_keys
-    echo "  Public Key in /root/.ssh/authorized_keys eingetragen."
-  else
-    echo "  Hinweis: konnte /root/.ssh/authorized_keys nicht schreiben."
-    echo "  Pubkey manuell eintragen:"
-    cat "$SSH_DIR/id_ed25519.pub"
-  fi
+  chmod 644 "$SSH_DIR/id_ed25519.pub"
+  chmod 644 "$SSH_DIR/config"
+  echo "  Key generiert."
+  # Public Key direkt in root's authorized_keys eintragen (Script laeuft als root auf der VM)
+  mkdir -p /root/.ssh
+  chmod 700 /root/.ssh
+  cat "$SSH_DIR/id_ed25519.pub" >> /root/.ssh/authorized_keys
+  chmod 600 /root/.ssh/authorized_keys
+  echo "  Public Key in /root/.ssh/authorized_keys eingetragen."
 else
-  echo "SSH-Key existiert bereits — uebersprungen."
+  echo "  Key existiert bereits."
 fi
 
+# Permissions im Container fixen
+echo ""
+echo "[6/7] Fixe SSH-Permissions..."
+docker exec -u root aria-core chown -R node:node /home/node/.ssh 2>/dev/null || true
+
+# Neustart damit Gateway die Config laedt
+echo ""
+echo "[7/7] Starte aria-core neu..."
+docker restart aria-core
+
+echo ""
 echo "=== Setup fertig ==="
 echo ""
-echo "Naechster Schritt: docker compose up -d"
-echo "Test:              docker exec aria-brain ssh aria-wohnung hostname"
+echo "Teste mit: docker logs aria-core --tail 20"
+echo "Erwartete Zeile: 'agent model: proxy/claude-sonnet-4'"
+echo ""
+echo "SSH-Test:  docker exec aria-core ssh aria-wohnung hostname"
+echo "Tool-Test: Neue Session anlegen, dann 'Wie wird das Wetter in Bremen?' fragen"

bridge/requirements.txt

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

diagnostic/Dockerfile

@@ -1,7 +1,5 @@
 FROM node:22-alpine
 WORKDIR /app
-# zip fuer Multi-Datei-Downloads (Brain-Export nutzt tar.gz, Datei-Manager zip)
-RUN apk add --no-cache zip
 COPY package.json ./
 RUN npm install --production
 COPY . .

docker-compose.yml

@@ -9,7 +9,7 @@ services:
     command: >-
       sh -c "apk add --no-cache openssh-client bash curl &&
       npm install -g @anthropic-ai/claude-code claude-max-api-proxy &&
-      DIST=$$(find /usr/local/lib -path '*/claude-max-api-proxy/dist' -type d | head -1) &&
+      DIST=$(find /usr/local/lib -path '*/claude-max-api-proxy/dist' -type d | head -1) &&
       sed -i 's/startServer({ port })/startServer({ port, host: process.env.HOST || \"127.0.0.1\" })/' $$DIST/server/standalone.js &&
       sed -i 's/if (model\.includes/if ((model||\"claude-sonnet-4\").includes/g' $$DIST/adapter/cli-to-openai.js &&
       sed -i '1i\\function _t(c){return typeof c===\"string\"?c:Array.isArray(c)?c.filter(function(b){return b.type===\"text\"}).map(function(b){return b.text||\"\"}).join(\"\"):String(c)}' $$DIST/adapter/openai-to-cli.js &&
@@ -28,40 +28,38 @@ services:
     networks:
       - aria-net
 
-  # ─── Qdrant (Vector-DB fuer ARIAs Gedaechtnis) ────────
-  # Storage liegt im Repo-Bind-Mount aria-data/brain/qdrant.
-  # Damit Backup/Export/Import komplett ueber das Filesystem gehen.
-  qdrant:
-    image: qdrant/qdrant:latest
-    container_name: aria-qdrant
-    volumes:
-      - ./aria-data/brain/qdrant:/qdrant/storage
-    restart: unless-stopped
-    networks:
-      - aria-net
-
-  # ─── ARIA Brain (Agent + Memory) ─────────────────────────
-  # Loest das alte aria-core (OpenClaw) ab. Vector-DB-basiertes
-  # Memory, eigener Agent-Loop, SSH zur aria-wohnung-VM.
-  brain:
-    build: ./aria-brain
-    container_name: aria-brain
-    hostname: aria-wohnung-brain                    # damit ssh known_hosts stabil bleibt
+  # ─── OpenClaw (ARIA Gehirn) ─────────────────────────────
+  aria:
+    image: ghcr.io/openclaw/openclaw:latest
+    container_name: aria-core
+    hostname: aria-wohnung
+    privileged: true                               # ARIAs Wohnung — sie hat die Schlüssel
     extra_hosts:
       - "host.docker.internal:host-gateway"        # Zugriff auf die VM via SSH
     depends_on:
-      - qdrant
       - proxy
+    ports:
+      - "3001:3001"                                # Diagnostic Web-UI (laeuft im shared network)
     environment:
-      - QDRANT_HOST=aria-qdrant
-      - QDRANT_PORT=6333
-      - PROXY_URL=http://proxy:3456
-      - ARIA_AUTH_TOKEN=${ARIA_AUTH_TOKEN:-}
+      - CANVAS_HOST=127.0.0.1
+      - OPENCLAW_GATEWAY_TOKEN=${ARIA_AUTH_TOKEN}
+      - DEFAULT_MODEL=proxy/claude-sonnet-4
+      - RATE_LIMIT_PER_USER=30
+      - DISPLAY=:0
     volumes:
-      - ./aria-data/brain/data:/data                # Memory-Cache + Skills + Models (bind-mount fuer Export)
-      - ./aria-data/brain-import:/import:ro         # Quell-MDs fuer den initialen Memory-Import (read-only)
-      - ./aria-data/ssh:/root/.ssh                  # SSH-Keys fuer aria-wohnung (geteilt mit Proxy)
-      - aria-shared:/shared                         # gleicher Austausch-Speicher wie Bridge
+      - openclaw-config:/home/node/.openclaw       # OpenClaw Config (persistiert Model + Auth)
+      - ./aria-data/brain:/home/node/.openclaw/workspace/memory
+      - ./aria-data/skills:/home/node/.openclaw/workspace/skills
+      - ./aria-data/config/AGENT.md:/home/node/.openclaw/workspace/AGENT.md
+      - ./aria-data/config/USER.md:/home/node/.openclaw/workspace/USER.md
+      - ./aria-data/config/BOOTSTRAP.md:/home/node/.openclaw/workspace/BOOTSTRAP.md
+      - ./aria-data/config/BOOTSTRAP.md:/home/node/.openclaw/workspace/CLAUDE.md
+      - ./aria-data/config/openclaw.env:/home/node/.openclaw/workspace/.env
+      - claude-config:/home/node/.claude               # Claude Code Settings (Permissions)
+      - ./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
@@ -71,13 +69,11 @@ services:
     build: ./bridge
     container_name: aria-bridge
     depends_on:
-      - brain
-    networks:
-      - aria-net
-    ports:
-      - "3001:3001"                                # Diagnostic Web-UI (Diagnostic teilt Netzwerk mit Bridge)
+      - aria
+    network_mode: "service:aria"                   # Teilt Netzwerk mit aria-core → localhost:18789
     volumes:
-      - aria-shared:/shared                        # Shared Volume fuer Datei-Austausch
+      - ./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
@@ -85,7 +81,6 @@ services:
       - /dev/snd
     environment:
       - PULSE_SERVER=unix:/run/user/1000/pulse/native
-      - BRAIN_URL=http://aria-brain:8080
       - ARIA_AUTH_TOKEN=${ARIA_AUTH_TOKEN:-}
       - RVS_HOST=${RVS_HOST:-}
       - RVS_PORT=${RVS_PORT:-443}
@@ -95,23 +90,19 @@ services:
     restart: unless-stopped
 
   # ─── Diagnostic (Selbstcheck-UI und Einstellungen) ────
-  # Teilt Netzwerk mit Bridge, damit der Diagnostic-Server die
-  # Bridge auf localhost erreichen kann.
   diagnostic:
     build: ./diagnostic
     container_name: aria-diagnostic
     depends_on:
-      - bridge
-    network_mode: "service:bridge"
+      - aria
+    network_mode: "service:aria"                   # Teilt Netzwerk mit aria-core → localhost:18789
     volumes:
-      - /var/run/docker.sock:/var/run/docker.sock      # Container Restart + Brain-Export/Import
+      - /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 + Voices)
-      - ./aria-data/brain:/brain                       # Brain-Export/Import (tar.gz aus Bind-Mount)
+      - aria-shared:/shared                            # Shared Volume (Uploads + Config)
     environment:
       - ARIA_AUTH_TOKEN=${ARIA_AUTH_TOKEN:-}
       - PROXY_URL=http://proxy:3456
-      - BRAIN_URL=http://aria-brain:8080
       - RVS_HOST=${RVS_HOST:-}
       - RVS_PORT=${RVS_PORT:-443}
       - RVS_TLS=${RVS_TLS:-true}
@@ -120,7 +111,9 @@ services:
     restart: unless-stopped
 
 volumes:
-  aria-shared:                                     # Datei-Austausch zwischen Bridge / Brain / Diagnostic
+  openclaw-config:                                 # Persistiert ~/.openclaw (Model, Auth, Sessions)
+  claude-config:                                   # Persistiert ~/.claude (Permissions, Settings)
+  aria-shared:                                     # Datei-Austausch zwischen Bridge und Core
 
 networks:
   aria-net:

init.sh

@@ -1,31 +0,0 @@
-#!/bin/bash
-# ════════════════════════════════════════════════════════════
-#  ARIA — Setup-Script
-#
-#  Aktuell nur noch der .env-Bootstrap (Tokens + RVS). Alle weiteren
-#  Settings landen ueber die Diagnostic in /shared/config/runtime.json
-#  (persistent in der "Datenbank").
-#
-#  Im Phase-A-Cleanup-Status: System-Prompt-Files liegen unter
-#  aria-data/brain-import/ und werden vom neuen Agent-Framework
-#  spaeter importiert. OpenClaw laeuft noch ohne Persoenlichkeit.
-# ════════════════════════════════════════════════════════════
-
-set -e
-cd "$(dirname "$0")"
-
-if [ ! -f .env ]; then
-    if [ -f .env.example ]; then
-        cp .env.example .env
-        echo "✓ .env erstellt aus .env.example — Tokens jetzt eintragen!"
-    else
-        echo "⚠ Keine .env.example gefunden — manuell anlegen."
-    fi
-else
-    echo ".env existiert bereits — uebersprungen."
-fi
-
-# ── Brain-Verzeichnisse anlegen (Bind-Mounts fuer aria-brain + aria-qdrant)
-# Inhalt ist gitignored — wird ueber Diagnostic-Export/Import gesichert.
-mkdir -p aria-data/brain/data aria-data/brain/qdrant
-echo "✓ aria-data/brain/{data,qdrant} bereit"

issue.md

@@ -1,123 +1,7 @@
 # ARIA Issues & Features
 
-## Audio-Verhalten in der App
-
-So sollte die App in den verschiedenen Phasen mit fremden Audio-Apps
-(Spotify, YouTube, Podcasts etc.) und dem eigenen Mikro umgehen.
-Wenn was anders ist, ist's ein Bug.
-
-| Phase                        | Andere App (Spotify) | ARIA-Mikro          | Hintergrund-Service |
-|------------------------------|----------------------|---------------------|---------------------|
-| Idle / Ohr aus               | spielt frei          | aus                 | aus                 |
-| Wake-Word lauscht (armed)    | spielt frei          | passiv (openWakeWord) | aktiv ('wake')    |
-| User-Aufnahme laeuft         | pausiert (EXCLUSIVE) | Recording           | aktiv ('rec')       |
-| Aufnahme zu Ende             | resumed              | aus                 | (rec released)      |
-| ARIA denkt/schreibt (~20s)   | spielt frei          | aus                 | (kein Slot)         |
-| TTS startet                  | pausiert (DUCK)      | aus (oder barge)    | aktiv ('tts')       |
-| TTS spielt (auch GPU-Pausen) | bleibt pausiert      | barge wenn Wake-Word| aktiv               |
-| TTS zu Ende                  | nach 800ms resumed   | (Conversation-Window)| (tts released)     |
-| Eingehender Anruf (auch VoIP)| —                    | Mikro pausiert      | aus                 |
-| Anruf vorbei                 | —                    | Mikro wieder armed  | aktiv ('wake')      |
-| Anruf vorbei (Auto-Resume)   | pausiert wieder       | aus                 | aktiv ('tts')       |
-| Neue Frage waehrend Anruf    | —                    | Mikro pausiert      | (rec waehrend Anruf nicht) |
-| Anruf vorbei nach neuer Frage | (siehe TTS-Phasen)   | (siehe TTS-Phasen)  | (tts gewinnt, alter Resume verworfen) |
-
-Wichtige Mechanismen:
-- **Underrun-Schutz** im PcmStreamPlayer fuettert Stille rein wenn die
-  Bridge in Render-Pausen liefert — Spotify bleibt durchgehend pausiert,
-  auch zwischen den Saetzen einer langen Antwort.
-- **Conversation-Focus** (nur bei Wake-Word 'conversing') haelt den
-  AudioFocus dauerhaft. Bei reinem Tap-to-Talk oder Text-Chat greift's
-  nicht — Spotify darf in der Denk-Phase ruhig weiterspielen.
-- **Foreground-Service** (mediaPlayback|microphone) haelt App-Prozess
-  am Leben damit TTS/Mikro/Wake-Word auch bei minimierter App weiter-
-  laufen. Notification zeigt aktuellen Status ("ARIA spricht/hoert
-  zu/bereit").
-- **Anruf-Erkennung** ueber TelephonyManager (klassisch) + AudioFocus-
-  Loss-Listener mit Polling-Fallback (VoIP wie WhatsApp/Signal/Discord).
-- **Auto-Resume nach Anruf**: beim Halt wird die Wiedergabe-Position
-  gemerkt (Date.now() - playbackStart - leadingSilence). Nach Auflegen
-  wartet die App bis zu 30s auf den WAV-Cache und spielt dann ab der
-  gemerkten Position weiter. Wenn das Telefonat länger als die Antwort
-  dauerte, ist der Cache schon fertig — instant Resume.
-- **Neue Frage waehrend Anruf** (Text-Chat geht trotz Telefonat): die
-  neue Antwort ueberschreibt den pending Resume. _handlePcmChunkImpl
-  stoppt einen ggf. laufenden resumeSound und setzt pausedMessageId
-  zurueck wenn die neue Stream-messageId abweicht. Die letzte Antwort
-  gewinnt immer.
-- **Audio-Ausgabe trotz aktivem Telefonat**: ARIA antwortet auch waehrend
-  eines Telefonats per Lautsprecher (Telefon-Audio geht ueber separaten
-  Stream zur Gegenseite). haltAllPlayback wird nur beim STATE-WECHSEL
-  ringing/offhook gerufen — wenn der Anruf schon laeuft (offhook→offhook),
-  triggert eine neue Frage keinen Halt mehr.
-
 ## Erledigt
 
-### Bugs / Fixes
-
-- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen
-- [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
-- [x] Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
-- [x] Voice-Auswahl funktioniert wieder: speaker_wav als Basename statt Pfad fuer daswer123 local-Mode
-- [x] Diagnostic-Voice-Wechsel resettet alle App-lokalen Voice-Overrides via type "config"
-- [x] Streaming TTS Stop-Race: Writer wartet auf playbackHeadPosition vor stop()/release() — keine abgeschnittenen Saetze mehr
-- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
-- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
-- [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
-- [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
-- [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
-- [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
-- [x] Wake-Word Embedding rank-4 Fix (Pipeline-Bug der das Triggern verhinderte) + Frame-Count aus Modell-Metadaten lesen
-- [x] PCM-Underrun-Schutz: Stille-Fill in Render-Pausen verhindert Spotify-Auto-Resume nach 10s Stillstand
-- [x] Conversation-Focus-Lifecycle: AudioFocus haengt am Wake-Word-State 'conversing' statt an einzelnen Streams — Spotify bleibt durchgehend gepaust, auch zwischen mehreren Antworten
-- [x] Voice-Override behaelt Stimme ueber alle TTS-Calls einer Antwort (vorher: nach erstem TTS-Call zurueck auf Default)
-- [x] Sprachnachricht-Bubble defensiv: STT-Result fuegt neue Bubble hinzu wenn Placeholder fehlt (Race-Schutz)
-- [x] Bild + Text als EINE Anfrage: Bridge buffert files 800ms, merged mit folgendem chat-Text zu einem send_to_core (statt zwei getrennten ARIA-Antworten)
-- [x] Diagnostic→App: persistente RVS-Connection statt frische pro Send (Race-Probleme mit Zombie-WS geloest)
-- [x] Textauswahl in Bubbles wieder funktional (nested Text+onPress raus, dataDetectorType="all" macht Links automatisch klickbar)
-- [x] **Placeholder-Race bei parallelen Sprachnachrichten geloest**: jede Aufnahme bekommt eine eindeutige audioRequestId, Bridge gibt sie ans STT-Result zurueck — App matcht jetzt punktgenau die richtige Bubble statt per Substring
-- [x] Mikro-Offen-Toast "🎤 sprich jetzt" erscheint erst wenn audioService.startRecording wirklich erfolgreich war (statt ~400ms vorher beim Wake-Word-Detect)
-- [x] Sprachnachrichten ohne STT-Result werden nach 60s+Aufnahmedauer automatisch entfernt (sicher genug fuer 5-30min-Aufnahmen, schnell genug fuer leere Wake-Word-Echos)
-- [x] VAD adaptive Baseline robuster: minimum statt avg + Cap auf -50dB bis -28dB (Stille) / -40dB bis -18dB (Speech) — keine "tote" VAD-Konfiguration mehr bei lauter Umgebung oder Wake-Word-Echo
-- [x] Push-to-Talk raus, nur noch Tap-to-Talk (verhinderte Touch-Race-Probleme)
-- [x] Manueller Mikro-Stop beendet Wake-Word-Konversation: Tap auf Mikro-Knopf waehrend conversing → audio raus + zurueck zu armed (= Wake-Word lauscht wieder, kein Auto-Mikro nach ARIAs Antwort). VAD-Auto-Stop bleibt bei Multi-Turn
-- [x] **Wake-Word pausiert bei Anruf**: phoneCall ruft pauseForCall (openWakeWord.stop) bei RINGING/OFFHOOK, resumeFromCall bei IDLE. Pre-Call-State wird gemerkt — armed bleibt armed, conversing degraded zu armed (User soll nicht in halbem Dialog landen)
-- [x] **App-Resume-Cooldown**: Wechsel von Background → Foreground triggert keinen falschen Wake-Word-Trigger mehr. AppState-Listener setzt 1.5s Cooldown in dem onWakeDetected-Events ignoriert werden (Audio-Pegel-Spike beim AudioFocus-Switch sonst als Wake-Word interpretiert)
-- [x] Background-Mikro robust: acquireBackgroundAudio('rec'/'wake') wird jetzt VOR AudioRecord.startRecording gerufen — Foreground-Service mit foregroundServiceType=microphone muss aktiv sein bevor das Mikro greift, sonst blockiert Android ab 11+ den Background-Zugriff
-- [x] **Stille-Pegel manuell setzbar** (Settings → Spracheingabe): Override-Wert in dB von -55 bis -15, default "automatisch". Info-Button mit Modal erklaert die Skala (niedriger = sensibler, hoeher = robuster gegen Hintergrundlaerm). Bei manuell gesetztem Wert wird die adaptive Baseline ignoriert
-- [x] **Kurze TTS-Texte (1-3 Worte) spielen jetzt ab** — auf OnePlus A12 stallte AudioTrack mit `pos=0` weil der Default-Start-Threshold `bufferSize/2` (= 2s) bei kurzen Streams nie ueberschritten wurde. Fix: `setStartThresholdInFrames(100ms)` direkt nach dem Track-Build (API 31+). Buffer auf 4s entkoppelt von Pre-Roll, `play()` wird beim allerersten data-chunk gerufen
-- [x] **Mute-Button stoppt jetzt auch laufenden PCM-Stream** — `pcmStreamActive` wurde beim isFinal-Chunk schon false gesetzt, der AudioTrack spielte aber noch sekundenlang aus seinem Buffer. `stopPlayback()` uebersprang darum `PcmStreamPlayer.stop()`. Fix: stop() immer rufen (ist idempotent), kein Flag-Check mehr
-- [x] **GPS-Permission im Manifest + Runtime-Request** beim Settings-Toggle — vorher fehlten ACCESS_COARSE_LOCATION / ACCESS_FINE_LOCATION komplett. `Geolocation.getCurrentPosition` schlug lautlos fehl, App sendete nie ein location-Feld
-- [x] **GPS-Position auch im STT-Payload an Diagnostic** — die App sendet location einmal im audio-Payload. Die Bridge nutzte sie zwar (ging in aria-core's Kontext rein), reichte sie aber nicht im STT-broadcast an Diagnostic durch. Diagnostic zeigte darum bei Spracheingaben nie den GPS-Block, obwohl der "GPS einblenden"-Toggle aktiv war
-- [x] **Auto-Resume nach Anruf — pcmBuffer bleibt erhalten**: `haltAllPlayback` leerte den pcmBuffer mid-Anruf, isFinal schrieb dann eine leere WAV. Neue `pauseForCall`-Methode statt `haltAllPlayback`: AudioTrack stoppt + Focus released, `pcmBuffer` und `pcmMessageId` bleiben — chunks werden weiter gesammelt damit isFinal die WAV schreibt und resumeFromInterruption sie findet. Plus `captureInterruption` idempotent gemacht (ringing → offhook ueberschreibt nicht)
-- [x] **Replay-Resume nach Anruf**: `_firePlaybackStarted` ueberschrieb `currentPlaybackMsgId` mit leerem pcmMessageId — captureInterruption hatte nichts zu merken. Plus Regex `[0-9a-f-]+\.wav` matchte nicht alle Dateinamen. Plus `_playFromPathAtPosition` aktualisiert jetzt das Tracking damit ein zweiter Anruf in derselben Antwort auch funktioniert
-- [x] **`pauseForCall` setzt `isPlaying` zurueck**: vorher haengten weitere Play-Button-Klicks nach Anruf, weil `playAudio` bei `isPlaying=true` den `_playNext`-Pfad ueberspringt
-- [x] **Play-Button rendert neu wenn Cache-Datei weg ist**: vorher checkte der Button nur `if (item.audioPath)` — auf eine geloeschte Cache-Datei zeigte das aber stillschweigend ins Leere. Jetzt RNFS.exists-Check mit Fallback auf `tts_request` an die Bridge → F5-TTS rendert neu, WAV wandert zurueck in den Cache
-- [x] **Bridge WebSocket max_size 50 MB**: Python `websockets.connect` hat 1 MiB Default — Stefan's 4MB JPEG (5.78 MB Base64) sprengte das, Bridge-Connection wurde silent gedroppt. f5tts/whisper-bridges hatten max_size schon, nur aria_bridge war vergessen
-- [x] **Bridge resized Bilder >2 MB serverseitig auf 1568px**: Claude-Vision-API hat ~5 MB Base64-Limit. Galerie-Bilder via `react-native-image-picker` sind clientseitig schon klein, Buroklammer/DocumentPicker reichte das rohe File durch — Claude lieferte leere Antwort. Pillow im Bridge-Container, nur fuer JPEG/PNG/WebP/GIF (PDFs/ZIPs/SVGs unangetastet)
-- [x] **Bridge `chat:error` liest auch `errorMessage`**: OpenClaw legt bei state=error den Text dort statt in `error` ab → Bridge meldete generisches "[Fehler] Unbekannt", echter Fehler nur in Container-Logs. Plus: `chat:final` ohne text wird jetzt mit Hinweis-Bubble an die App gemeldet (statt stumm), z.B. wenn Vision das Bild silent ablehnt
-- [x] **Cache-Cleanup beim App-Start** — orphane `aria_tts_*.wav` Files (>5 min) im CachesDirectoryPath werden weggeraeumt, sammeln sich sonst an wenn Sound mid-playback gestoppt wird (Anruf, Mute, Barge-In) und der completion-Callback nicht feuert. Plus neuer Settings-Button "TTS-Cache leeren" mit Live-Groessenanzeige
-- [x] **Verbose-Logging-Toggle in Settings → Protokoll**: `console.log` global stummschaltbar (warn/error bleiben aktiv) — spart adb-logcat-Speicher wenn alles laeuft
-- [x] **800 ms-Delay vor Anruf-Auto-Resume**: ARIA's neuer Focus-Request kollidierte sonst mit Spotify's Auto-Resume nach Anruf-Ende. System haengt noch im IN_CALL→NORMAL-Mode-Uebergang, Spotify sieht Loss → Loss und bleibt pausiert. Mit Delay schafft Spotify den Resume-Schritt, dann pausiert ARIA wieder ordnungsgemaess
-- [x] **Mute-Button = Stop fuer aktuelle Antwort**: vorher startete eine NEUE PCM-Chunk-Sequenz nach Mute-aus die alte Antwort weiter wo sie war (funktionierte 2x, dann nicht mehr weil isFinal schon kam). Jetzt mit `_stoppedMessageId`-Tracking: bei Mute wird die aktive msgId gemerkt, alle weiteren chunks dieser msgId bleiben silent — auch wenn Mute zurueckgenommen wird. Reset bei neuer msgId, neue Antworten spielen normal
-- [x] **Spotify resumed nach Mute-Stop**: `stopPlayback` released seinen TRANSIENT-Focus (USAGE_ASSISTANT) sauber → Spotify bekommt GAIN-Event und resumed automatisch. Ein zwischenzeitlich eingebauter `kickReleaseMedia` (USAGE_MEDIA + GAIN) verhinderte das Auto-Resume sogar (Spotify interpretierte es als "user-action stopp") — wieder rausgenommen
-- [x] **ARIA kann Dateien an User zurueckgeben** (PDFs, Bilder, Office-Docs, Markdown, ZIPs, ...): ARIA setzt am Antwort-Ende `[FILE: /shared/uploads/aria_<name>.<ext>]` Marker, Bridge parsed sie raus (TTS liest's nicht vor) und sendet `file_from_aria`-Event ueber RVS. App zeigt Anhang-Bubble + Klick oeffnet via Android-Intent-Picker (`FileOpenerModule`, FileProvider), Diagnostic zeigt Bubble + PDFs/Bilder neuer Tab, andere als Download. Mehrere Marker = mehrere Bubbles, nicht-existente Marker werden mit Hinweis an User gemeldet (statt silent gedroppt)
-- [x] **External Bilder/Dateien werden serverseitig persistiert**: ARIA laed externe URLs (Wikipedia, Wiki Commons) mit curl runter und gibt sie via `[FILE: ...]`-Marker zurueck — bleibt permanent im Chat auch wenn die Online-Quelle stirbt. System-Prompt instruiert sie das Pattern zu nutzen
-- [x] **ARIA-Datei-Bubbles ueberleben Browser-Refresh**: Diagnostic-Server parsed beim `load_chat_history` die Marker aus dem OpenClaw-Session-File und schickt `aria_file`-Eintraege mit, sodass die Anhang-Bubbles nach F5 wiederhergestellt werden. Plus: `/shared/uploads/`-Bildpfade werden im History-Render auch als Inline-Image gerendert (vorher nur in live-Bubbles)
-- [x] **"ARIA reparieren"-Button** in App + Diagnostic: triggert `openclaw doctor --fix` ueber RVS → Bridge → Diagnostic HTTP-API. Fix fuer stuck Runs ohne SSH
-- [x] **"ARIA hart neu starten"-Button**: docker compose-Restart ueber Docker-Socket-API im Diagnostic-Server. Mit Confirmation in der App, fuer Faelle wo doctor nicht reicht (alive aber haengender Run)
-- [x] **Auto-Compact nach N Messages**: bei zu langer Session wirft Linux beim Subprocess-spawn E2BIG (Argument list too long, ~128KB-2MB Limit). Bridge zaehlt User-Messages; bei `COMPACT_AFTER_MESSAGES` (env, default 140) werden Sessions geleert + Container neu gestartet, User bekommt Hinweis-Bubble. Plus manueller "🧹 Konversation komprimieren"-Button in App-Settings und Diagnostic
-- [x] **`[FILE: ...]`-Marker-Filter ueberall in Diagnostic**: Filter direkt in `addChat` damit er fuer alle Code-Pfade greift (chat_final, proxy_result, History-Load, ...) — vorher rutschten Marker als Text durch wenn sie nicht ueber chat_final kamen
-- [x] **Mehrere `[FILE: ...]`-Marker in einer Antwort**: Bridge zerlegt sauber in mehrere file_from_aria-Events, ARIA muss nicht selbst zwei Antworten posten. Bei nicht-existenten Files erscheint ein User-Hinweis statt silent skip
-- [x] **Inline-Bilder in Chat-Nachrichten** (App): `![alt](url)`- und plain-`https://image.png`-URLs werden als Image-Vorschau unter dem Text gerendert. Mit `react-native-svg` auch SVG-URLs inline
-- [x] **SVG-Anhaenge** werden korrekt gerendert: ChatImage-Komponente erkennt `.svg`-Endung und nutzt SvgUri statt Image (RN-Image kann SVG nicht). Vollbild-Modal genauso, mit `preserveAspectRatio="xMidYMid meet"` damit SVGs nicht gestreckt werden
-- [x] **Pinch-Zoom + Pan im Vollbild-Modal** (App): neue `ZoomableImage`-Komponente, reine RN-Implementation mit PanResponder+Animated, ohne externe Lib. 2-Finger-Pinch 1x..5x, 1-Finger-Pan wenn gezoomt, Doppel-Tap toggelt 1x↔2.5x. Plus ✕-Close-Button damit Tap-to-Close nicht mit Pan-Gesten kollidiert
-- [x] **ARIA-Abkuerzung ausgeschrieben**: in App → Einstellungen → Ueber und Diagnostic → Einstellungen ist jetzt erklaert: "ARIA — Autonomous Reasoning & Intelligence Assistant"
-- [x] **`init.sh`** legt fehlende Config-Dateien aus *.example-Vorlagen an — frischer Clone laeuft ohne Anleitung an
-- [x] **`USER.md` privat**: aus dem Repo genommen (enthielt interne Tool-Liste mit Gitea-URL etc.). Vorlage als `USER.md.example` checked-in, lokales File via `.gitignore` ausgeschlossen
-
-### App Features
-
 - [x] Bildupload funktioniert (Shared Volume /shared/uploads/)
 - [x] Sprachnachrichten werden als Text angezeigt (STT → Chat-Bubble)
 - [x] Cache leeren + Auto-Download von Anhaengen
@@ -127,9 +11,13 @@ Wichtige Mechanismen:
 - [x] Ohr-Button → Gespraechsmodus (Auto-Aufnahme nach ARIA-Antwort)
 - [x] Play-Button in ARIA-Nachrichten fuer Sprachwiedergabe
 - [x] Chat-Suche in der App (Lupe in Statusleiste)
+- [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
 - [x] Abbrechen-Button im Diagnostic Chat
+- [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
+- [x] Grosse Nachrichten satzweise aufteilen fuer TTS
+- [x] RVS Nachrichten vom Smartphone gehen durch
 - [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed pro Stimme — durch XTTS/F5-TTS ersetzt)
-- [x] Highlight-Trigger konfigurierbar in Diagnostic (spaeter komplett entfernt — war Piper-Relikt)
+- [x] Highlight-Trigger konfigurierbar in Diagnostic
 - [x] XTTS v2 Integration (Gaming-PC, GPU, Voice Cloning) — durch F5-TTS ersetzt
 - [x] XTTS Voice Cloning (Audio-Samples hochladen, eigene Stimme)
 - [x] TTS Engine waehlbar (Piper/XTTS) — Piper raus, XTTS raus, jetzt nur F5-TTS
@@ -137,19 +25,23 @@ Wichtige Mechanismen:
 - [x] Auto-Update: APK-Installation via FileProvider
 - [x] Auto-Update: "Auf Updates pruefen" Button in App-Einstellungen
 - [x] Audio-Queue (sequentielle Wiedergabe, kein Ueberlappen)
+- [x] Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
 - [x] Mehrere Anhaenge + Text vor dem Senden (Pending-Vorschau)
 - [x] Paste-Support fuer Bilder in Diagnostic Chat
 - [x] Markdown-Bereinigung fuer TTS (fett, kursiv, code, links, etc.)
+- [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
 - [x] Diagnostic: Sessions als Markdown exportieren (Download-Button)
 - [x] Speech Gate: Aufnahme wird verworfen wenn keine Sprache erkannt
 - [x] Session-Persistenz: Gewaehlte Session bleibt ueber Container-Restarts erhalten
+- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen
+- [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
 - [x] Whisper STT: Model-Auswahl in Diagnostic (tiny/base/small/medium/large-v3), Hot-Reload
 - [x] App: Audio-Aufnahme explizit 16kHz mono (spart Resample, optimal fuer Whisper)
 - [x] Streaming TTS: PCM-Stream → AudioTrack MODE_STREAM, keine WAV-Gaps
 - [x] Piper komplett entfernt
 - [x] Gespraechsmodus: Speech-Gate strenger (-28dB / 500ms)
 - [x] Diagnostic: Archivierte Session-Versionen (.reset.*) angezeigt + exportierbar
-- [x] tools/export-jsonl-to-md.js: CLI-Konverter fuer Session-JSONL zu Markdown (mit OpenClaw raus)
+- [x] tools/export-jsonl-to-md.js: CLI-Konverter fuer Session-JSONL zu Markdown
 - [x] NO_REPLY-Filter in Bridge + Diagnostic
 - [x] Audio-Ducking + Exklusiv-Focus (Kotlin AudioFocusModule)
 - [x] TTS-Cleanup serverseitig: Code-Bloecke raus, Einheiten ausgeschrieben, Abkuerzungen buchstabiert, URLs zu "ein Link"
@@ -159,11 +51,14 @@ Wichtige Mechanismen:
 - [x] Disk-Voll Banner in Diagnostic: rotes Overlay + copy-baren Cleanup-Befehlen (safe + aggressiv)
 - [x] cleanup.sh: kombinierter Docker-Aufraeum-Befehl (safe / --full)
 - [x] Streaming TTS Pre-Roll: AudioTrack play() startet erst wenn 2.5s gepuffert sind
+- [x] Streaming TTS Stop-Race: Writer wartet auf playbackHeadPosition vor stop()/release() — keine abgeschnittenen Saetze mehr
 - [x] Leading-Silence (200ms) am Stream-Anfang — AudioTrack faehrt sauber an
 - [x] Pre-Roll-Buffer einstellbar in App-Settings (1.0-6.0s, Default 3.5s)
 - [x] Fade-In auf erstem PCM-Chunk (120ms) — versteckt XTTS/F5-TTS Warmup-Glitches
 - [x] Decimal-zu-Worte fuer TTS (0.1 → null komma eins, mit IP-Schutz-Lookahead)
 - [x] Generic Acronym-Buchstabieren (XTTS → X T T S, USB → U S B, ueber expliziter Liste)
+- [x] Voice-Auswahl funktioniert wieder: speaker_wav als Basename statt Pfad fuer daswer123 local-Mode
+- [x] Diagnostic-Voice-Wechsel resettet alle App-lokalen Voice-Overrides via type "config"
 - [x] voice_preload/voice_ready: Stille Mini-Render bei Voice-Wechsel + Toast/Status "bereit"
 - [x] Whisper STT auf die Gamebox ausgelagert (faster-whisper CUDA, float16) — neuer aria-whisper-bridge Container
 - [x] aria-bridge: STT primaer remote (Gamebox), Fallback lokal nach 45s Timeout
@@ -171,108 +66,31 @@ Wichtige Mechanismen:
 - [x] **F5-TTS ersetzt XTTS komplett** — neuer aria-f5tts-bridge Container, Voice Cloning, satzweises Streaming
 - [x] Voice-Upload mit Whisper-Auto-Transkription — User muss keinen Referenz-Text eintippen
 - [x] Audio-Pause statt Ducking: Spotify/YouTube pausieren komplett waehrend TTS (TRANSIENT statt MAY_DUCK)
+- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
 - [x] VAD-Stille einstellbar in App-Settings (1.0-8.0s, Default 2.8s)
 - [x] MAX_RECORDING auf 120s — laengere Erklaerungen moeglich
-- [x] F5-TTS: Referenz-WAV-Preprocessing — Loudness-Normalisierung -16 LUFS + Silence-Trim + 10s Clip fuer konsistente Cloning-Quali
-- [x] F5-TTS: deutsches Fine-Tune (aihpi/F5-TTS-German, Vocos-Variante) via hf:// Pfad in Diagnostic konfigurierbar
-- [x] Dynamischer STT-Timeout in aria-bridge: 300s waehrend whisper-bridge 'loading', 45s wenn 'ready'
-- [x] service_status Broadcasts: f5tts/whisper melden Lade-Status, Banner in Diagnostic (unten rechts) + App (oben)
-- [x] config_request Pattern: Bridges fragen beim Connect die aktuelle Voice-Config an, aria-bridge antwortet
-- [x] F5-TTS Tuning via Diagnostic (Modell-ID, Checkpoint, cfg_strength, nfe_step) statt ENV-Vars — Hot-Reload bei Modell-Wechsel
-- [x] Conversation-Window: Gespraechsmodus endet nach X Sekunden Stille (1.0-20.0s, Default 8s, einstellbar in Settings)
-- [x] Porcupine Wake-Word-Integration in der App (durch openWakeWord ersetzt)
-- [x] HF-Cache als Bind-Mount statt Docker Volume — kein .vhdx-Bloat auf Docker Desktop / Windows
-- [x] cleanup-windows.ps1 / .bat: VHDX-Cleanup via diskpart (ohne Hyper-V) mit Self-Elevation
-- [x] App Text-Rendering: Nachrichten selektierbar + Autolink fuer URLs/E-Mails/Telefonnummern (Browser/Mail/Dialer)
-- [x] TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings → 0.5-2.0x in 0.1-Schritten, Default 1.0)
-- [x] Diagnostic: Voice-Preview-Modal (Play-Icon vor Delete-X, Textfeld mit Default, WAV im Browser abspielen)
-- [x] **Wake-Word komplett on-device via openWakeWord (ONNX Runtime)** — Porcupine raus, kein API-Key/keine Lizenzgebuehren mehr. Mitgelieferte Keywords: hey_jarvis, computer, alexa, hey_mycroft, hey_rhasspy
-- [x] APK ABI-Split auf arm64-v8a — von ~136 MB auf ~35 MB, Auto-Update-Downloads aufs Phone deutlich kleiner
-- [x] PhoneStateListener: TTS pausiert bei eingehendem Anruf (READ_PHONE_STATE Permission)
-- [x] **VoIP-Anrufe** (WhatsApp/Signal/Discord/Teams) erkannt via AudioFocus-Loss-Listener + getMode-Polling-Fallback (alle 3s)
-- [x] **Auto-Resume nach Anruf**: ARIAs unterbrochene Antwort spielt nach dem Auflegen ab der gemerkten Position weiter (Date.now()-Tracking + WAV-Cache, 30s-Wartezeit auf final-Marker bei kurzem Telefonat)
-- [x] **Neue Frage waehrend Telefonat** ueberschreibt pending Auto-Resume — letzte Antwort gewinnt, alter resumeSound wird gestoppt
-- [x] **Audio-Ausgabe waehrend aktivem Telefonat** funktioniert (haltAllPlayback nur bei state-Wechsel idle→ringing/offhook, nicht bei offhook→offhook)
-- [x] **PcmPlaybackFinished-Event** im Native: AudioFocus wird erst released wenn AudioTrack wirklich durch ist (vorher: end()-Cap nach 0.5s → Spotify spielte 32s parallel zu ARIA)
-- [x] **APK-Cache-Cleanup robuster**: durchsucht jetzt CachesDirectoryPath + DocumentDirectoryPath + ExternalCachesDirectoryPath + ExternalDirectoryPath statt nur Caches. Plus manueller Button "Update-Cache leeren" in Settings → Speicher mit Live-Anzeige der aktuellen Groesse
-- [x] Diagnostic-Chat: bubblige Formatierung, mehrzeiliges Eingabefeld (textarea, Enter sendet, Shift+Enter neue Zeile)
-- [x] Adaptive VAD-Schwelle: Baseline aus den ersten 500ms Mic-Pegel, Stille = baseline+6dB / Sprache = baseline+12dB
-- [x] Max-Aufnahmedauer konfigurierbar in Settings (1-30 min, Default 5 min) — laengere Diktate moeglich
-- [x] Barge-In: User kann ARIA waehrend Antwort/Tool-Use unterbrechen, alte Aktivitaet wird abgebrochen, Bridge gibt aria-core einen Kontext-Hint dass es eine Korrektur ist
-- [x] Settings-Sub-Screens: 8 Kategorien (Verbindung, Allgemein, Spracheingabe, Wake-Word, Sprachausgabe, Speicher, Protokoll, Ueber) statt langer Liste
-- [x] **Bereit-Sound (Airplane Ding-Dong) wenn Mikro nach Wake-Word offen** — akustische Bestaetigung statt nur Toast. Toggle in Settings → Wake-Word, default aktiv
-- [x] **Wake-Word parallel zu TTS** mit AcousticEchoCanceler: User sagt "Computer" waehrend ARIA spricht → TTS verstummt sofort, neue Aufnahme startet
-- [x] **GPS-Position mitsenden**: Toggle in Settings → Allgemein → Standort, persistiert in AsyncStorage. Wenn aktiv wird lat/lon mit jeder chat/audio-Message mitgegeben. Bridge prefixed den Text fuer aria-core mit GPS-Hint (mit Anweisung dass die Position nur bei Bedarf erwaehnt wird)
-- [x] **Background Audio Service**: TTS, Wake-Word-Lauschen UND Aufnahme laufen auch bei minimierter App weiter. Foreground-Service mit foregroundServiceType=mediaPlayback|microphone, persistente Notification mit dynamischem Text ("ARIA spricht" / "ARIA hoert zu" / "ARIA bereit")
-
-### Infrastruktur
-
-- [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
-- [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
-- [x] RVS Nachrichten vom Smartphone gehen durch
-- [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
-
-## Brain — Phase B (komplett)
-
-Der grosse Refactor weg von OpenClaw zu eigener Brain-Architektur — alle 4 Punkte
-durch. ARIA hat jetzt eigenes Gedaechtnis (Vector-DB), eigenen Loop, eigene
-Skills mit Tool-Use.
-
-### Infrastruktur
-
-- [x] aria-brain Container (FastAPI + Qdrant + sentence-transformers, MiniLM multilingual)
-- [x] aria-core (OpenClaw) abgerissen — Tag `v0.1.2.0` als Archiv
-- [x] docker-compose komplett umgebaut: brain + qdrant + bridge + diagnostic + proxy
-- [x] Voice-Bridge: aria-core-Logik raus (doctor_fix, aria_restart, compact_after) → durch Brain-HTTP-Call ersetzt
-- [x] Sprachmodell-Setting in runtime.json (brainModel) — Diagnostic kann Modell live wechseln, Brain-Restart noetig
-
-### Memory / Vector-DB
-
-- [x] Memory CRUD via Diagnostic-Gehirn-Tab (Add/Edit/Delete + Suche + Type/Pinned-Filter)
-- [x] **Migration aus brain-import/** (Phase B Punkt 2) — Parser fuer AGENT.md/USER.md/TOOLING.md, atomare Punkte mit migration_key (idempotent)
-- [x] **Bootstrap-Snapshot** (Phase B Punkt 2) — Export/Import nur pinned Memories als JSON
-- [x] **Komplettes Gehirn** Export/Import als tar.gz (Memories + Skills + Qdrant)
-
-### Conversation-Loop (Phase B Punkt 3)
-
-- [x] Single-Chat UI + Rolling Window (50 Turns)
-- [x] Memory-Destillat: bei >60 Turns automatisch 30 aelteste → fact-Memories via Claude-Call
-- [x] Hot Memory (pinned) + Cold Memory (Top-5 semantisch) im System-Prompt
-- [x] Manueller Destillat-Trigger + Konversation-Reset (Brain + Diagnostic chat_backup gleichzeitig)
-- [x] Bridge schreibt chat_backup.jsonl bei jedem Turn (User + ARIA + ARIA-Files)
-- [x] App-Chat-Sync: kompletter Server-Sync bei Reconnect (Server = Source of Truth). Wenn Server leer → App leert auch. Lokal-only Bubbles (Skill-Notifications, laufende Voice ohne STT) bleiben erhalten. Plus chat_cleared Live-Update wenn Diagnostic die History wiped.
-
-### Skills-System (Phase B Punkt 4)
-
-- [x] Python-only Skills (local-venv pro Skill, eigene pip-Pakete)
-- [x] Tool-Use im Brain: skill_create als Meta-Tool, dynamische run_<skill> pro aktivem Skill
-- [x] Harte Schwelle dokumentiert: pip-Install → IMMER Skill (Brain hat keinen Persistenz ausser /data/skills/)
-- [x] Diagnostic Skills-Tab: Liste, README, Logs pro Run, Activate/Deactivate/Delete, Export/Import als tar.gz
-- [x] skill_created Live-Notification: gelbe Bubble in App + Diagnostic sobald ARIA selbst einen Skill anlegt
-
-### Diagnostic / App Features (drumherum)
-
-- [x] Datei-Manager (Diagnostic + App-Modal): /shared/uploads/ verwalten, Multi-Select + Select-All + Bulk-Download als ZIP + Bulk-Delete
-- [x] Wipe-All-Button (Memory + Stimmen + Settings)
-- [x] Voice Export/Import pro Stimme (Diagnostic + XTTS-Bridge auf Gamebox)
-- [x] F5/Whisper-Settings als JSON-Bundle Export/Import
-- [x] App Chat-Suche umgebaut: Highlight + Next/Prev statt Filter
-- [x] App Pinch-Zoom in Bildern rewriten (Multi-Touch-Race-Bugs)
-- [x] Info-Buttons mit Modal-Erklaerungen im Gehirn-Tab
-- [x] Token/Call-Metrics + Subscription-Quota-Tracking: pro Claude-Call ein Log-Eintrag mit Token-Schaetzung (chars/4). Gehirn-Tab zeigt 1h/5h/24h/30d-Aggregat + Progress-Bar gegen Plan-Limit (Pro=45/5h, Max 5x=225/5h, Max 20x=900/5h, Custom). Warn-Schwelle 80%, kritisch 90%.
+- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
 
 ## Offen
 
+### Bugs
+- [ ] NO_REPLY wird als "NO" im Chat angezeigt — sollte still verworfen werden (Token nicht gesaeubert)
+
 ### App Features
+- [ ] Wake Word on-device (Porcupine "ARIA" Keyword, Phase 2 — passives Lauschen)
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
-- [ ] Custom-Wake-Word-Upload via Diagnostic (eigene .onnx-Files ohne App-Rebuild)
+- [ ] Background Audio Service (TTS auch bei minimierter App)
+
+### TTS / Audio
+- [ ] Audio-Normalisierung (Lautstaerke zwischen Saetzen/Chunks angleichen)
+- [ ] F5-TTS: Streaming-Inferenz testen (nativ statt satzweise) wenn ein passendes Backend kommt
+- [ ] F5-TTS: Optional Deepspeed-Beschleunigung pruefen
 
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
+- [ ] Auto-Compacting und Memory/Brain Verwaltung (SQLite?)
 - [ ] Diagnostic: System-Info Tab (Container-Status, Disk, RAM, CPU)
 - [ ] RVS Zombie-Connections endgueltig loesen
+- [ ] Alle .env-Variablen ueber Diagnostic konfigurierbar machen (Fallback .env bleibt fuer initialen Bootstrap)
 - [ ] Gamebox: kleine Web-Oberflaeche fuer Credentials/Server-Config oder zentral aus Diagnostic per RVS push
-- [ ] Erste Skills bauen lassen (yt-dlp, pdf-extract, image-resize, etc.) — durch normale Anfragen, ARIA legt sie selbst an
-- [ ] Tool-Use-Verifikation: Live-Test ob claude-max-api-proxy `tools` und `tool_calls` sauber durchreicht
-- [ ] Heartbeat (periodische Selbst-Checks)
-- [ ] Lokales LLM als Waechter (Triage vor Claude-Call)
+- [ ] Root-Cause OpenClaw Session-Reset: Herausfinden warum Sessions beim ersten chat.send nach Container-Restart verworfen werden

rvs/server.js

@@ -18,22 +18,10 @@ const ALLOWED_TYPES = new Set([
   "update_check", "update_available", "update_download", "update_data",
   "agent_activity", "cancel_request",
   "audio_pcm",
-  "file_from_aria",
-  "container_restart",
-  "file_list_request", "file_list_response",
-  "file_delete_request", "file_deleted",
-  "xtts_export_voice", "xtts_voice_exported",
-  "xtts_import_voice", "xtts_voice_imported",
-  "skill_created",
-  "trigger_created",
-  "chat_history_request", "chat_history_response", "chat_cleared",
-  "file_delete_batch_request", "file_delete_batch_response",
-  "file_zip_request", "file_zip_response",
   "xtts_delete_voice",
   "voice_preload", "voice_ready",
   "stt_request", "stt_response",
   "service_status",
-  "config_request",
 ]);
 
 // Token-Raum: token -> { clients: Set<ws> }

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

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

xtts/.gitignore

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

xtts/docker-compose.yml

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

xtts/f5tts/bridge.py

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

xtts/whisper/bridge.py

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