release: bump version to 0.1.2.7

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

.env.example

@@ -0,0 +1,50 @@
+# ════════════════════════════════════════════════
+#  ARIA — Umgebungsvariablen
+#  Kopieren nach .env und Werte eintragen
+# ════════════════════════════════════════════════
+
+# ── ARIA Auth Token ──────────────────────────────
+# Authentifizierung fuer den OpenClaw Gateway (aria-core).
+# Wird von Diagnostic, Bridge und App genutzt um sich am Gateway anzumelden.
+# Alle Services die mit aria-core kommunizieren brauchen diesen Token.
+# Generieren: openssl rand -hex 32
+ARIA_AUTH_TOKEN=change-me-to-a-long-random-string
+
+# ── RVS — Rendezvous-Server ─────────────────────
+# Der RVS ist ein WebSocket-Relay im Rechenzentrum.
+# App, Bridge, Diagnostic und XTTS-Bridge verbinden sich hierueber.
+# Alle muessen den gleichen Host, Port und Token nutzen.
+
+# Hostname des RVS-Servers (z.B. rvs.example.de oder mobil.hacker-net.de)
+RVS_HOST=rvs.example.de
+
+# Port auf dem der RVS laeuft (muss mit rvs/docker-compose.yml uebereinstimmen)
+RVS_PORT=443
+
+# TLS (wss://) verwenden? true = verschluesselt, false = unverschluesselt (ws://)
+RVS_TLS=true
+
+# Bei TLS-Fehler automatisch auf ws:// (ohne TLS) fallback?
+# Nuetzlich wenn kein TLS-Zertifikat vorhanden (z.B. Entwicklung)
+RVS_TLS_FALLBACK=true
+
+# Pairing-Token: Wer den gleichen Token hat, landet im gleichen RVS-Room.
+# Wird von generate-token.sh automatisch generiert und hier eingetragen.
+# Die Android App bekommt den Token per QR-Code beim Pairing.
+# WICHTIG: Muss auf ARIA-VM, Gaming-PC (xtts/.env) und App identisch sein!
+# Generieren: ./generate-token.sh (traegt den Token automatisch ein)
+RVS_TOKEN=
+
+# ── Gitea — Release-Verwaltung ───────────────────
+# Wird von release.sh genutzt um APKs auf Gitea zu veroeffentlichen.
+# Kennwort wird beim Release interaktiv abgefragt (nicht in .env!).
+GITEA_URL=https://git.hacker-net.de
+GITEA_REPO=Hacker-Software/ARIA-AGENT
+GITEA_USER=duffyduck
+
+# ── Auto-Update — APK auf RVS-Server kopieren ───
+# SSH-Ziel fuer scp: release.sh kopiert die APK dorthin.
+# Der RVS-Server stellt sie dann per WebSocket an die App bereit.
+# Format: user@host (z.B. root@aria-rvs oder root@rvs.example.de)
+# Leer lassen = Auto-Update ueberspringen, APK manuell auf RVS kopieren.
+RVS_UPDATE_HOST=

.gitignore

@@ -9,14 +9,19 @@
 .env.*
 !.env.example
 !.env.*.example
-aria-data/config/*.env
-!aria-data/config/*.env.example
 
-# ── ARIAs Gedächtnis (nur per tar gesichert) ────
-aria-data/brain/
+# 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
 
-# ── Stimmen (große Binärdateien) ─────────────────
-aria-data/voices/
+# ── 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/
 
 # ── Node / npm ──────────────────────────────────
 node_modules/
@@ -28,9 +33,14 @@ yarn-error.log*
 android/build/
 android/.gradle/
 android/app/build/
+android/android/.gradle/
+android/android/app/build/
+android/android/local.properties
 android/local.properties
+android/package-lock.json
 *.apk
 *.aab
+rvs/updates/*.apk
 
 # ── Tauri / Desktop Build ───────────────────────
 desktop/src-tauri/target/
@@ -40,7 +50,6 @@ desktop/dist/
 __pycache__/
 *.pyc
 *.pyo
-bridge/__pycache__/
 
 # ── macOS ────────────────────────────────────────
 .DS_Store

CHANGELOG.md

@@ -0,0 +1,244 @@
+# ARIA — Changelog
+
+Alle Änderungen am Projekt. Format: [Keep a Changelog](https://keepachangelog.com/de/1.1.0/)
+
+---
+
+## [0.0.0.5] — 2026-03-13
+
+### Hinzugefügt
+
+**Diagnostic — Pipeline-Tab**
+- Neuer "Pipeline"-Tab im Log-Bereich — zeigt den kompletten Nachrichtenfluss wenn eine Chat-Nachricht über die Diagnostic-UI gesendet wird
+- Tracking aller Schritte: Senden → Gateway ACK → Streaming Deltas → Finale Antwort (oder Fehler)
+- Zeitmessung: Jeder Schritt zeigt Elapsed-Time seit Pipeline-Start
+- Farbcodierung: Blau (Schritte), Grün (Erfolg), Rot (Fehler)
+- 60s Timeout — markiert Pipeline als fehlgeschlagen wenn keine Antwort kommt
+- Funktioniert für Gateway-direkt und RVS-Nachrichten
+
+### Behoben
+
+**OpenClaw Gateway Event-Format — ARIA antwortet jetzt**
+- OpenClaw sendet `event: "agent"` (Streaming-Deltas in `payload.data.delta`) und `event: "chat"` mit `payload.state: "delta"|"final"|"error"` — **nicht** `chat:delta`/`chat:final`/`chat:error` wie angenommen
+- Antworttext steckt in `payload.message.content[0].text` (Array von Content-Blöcken, nicht flacher String) — `text.slice is not a function` Fehler behoben
+- `ackReactionScope` von `"group-mentions"` auf `"all"` geändert — Agent reagierte nur auf @mentions, nicht auf direkte Nachrichten
+- Diagnostic Server und Bridge auf neues Event-Format umgestellt
+- Legacy-Event-Namen (`chat:delta`, `chat:final`, `chat:error`) als Fallback beibehalten
+
+### Geändert
+
+**OpenClaw Config — Custom Provider Format**
+- `openclaw.json` nutzt `models.providers` (Object, nicht Array) mit `api: "openai-completions"`
+- Model-Einträge brauchen sowohl `id` als auch `name` Feld
+- `aria-setup.sh` schreibt korrekte Config mit Heredoc-Pattern (`'"'"'INNEREOF'"'"'`)
+- `DEFAULT_MODEL=proxy/claude-sonnet-4` — mit Provider-Prefix für Custom Provider
+- `OPENAI_BASE_URL` und `OPENAI_API_KEY` entfernt — OpenClaw ignoriert diese Env-Vars, nutzt nur `models.providers` Config
+
+---
+
+## [0.0.0.4] — 2026-03-11 / 2026-03-12
+
+### Hinzugefügt
+
+**Diagnostic Container — Selbstcheck-UI**
+- Neuer Container `aria-diagnostic` mit Web-UI auf Port 3001
+- Status-Karten: OpenClaw Gateway, RVS, Claude Proxy — jeweils mit Dot-Indicator
+- Claude Proxy Test: Prüft Erreichbarkeit (`/v1/models`) und sendet Test-Prompt an Claude — zeigt verfügbare Modelle als Tags + `DEFAULT_MODEL` Hinweis für docker-compose.yml
+- Auth-Check: "Auth prüfen" Button durchsucht alle bekannten Credential-Pfade im Proxy-Container (`/root/.config/claude/`, `/root/.claude/`, `/root/.claude/auth/`) rekursiv — zeigt gefundene Dateien und deren Inhalt
+- Claude Login via UI: "Login starten" Button öffnet interaktives Terminal (xterm.js) in einem Modal-Overlay — führt `claude login` im Proxy-Container aus, volle TUI-Unterstützung (kein ANSI-Stripping mehr nötig)
+- xterm.js Terminal: Bidirektionaler Stream über Docker Exec API mit `Tty: true` + HTTP Upgrade auf Raw-TCP-Socket — echtes interaktives Terminal im Browser
+- UTF-8 Fix: Eingehende Daten werden als `Uint8Array` an xterm.write() übergeben (statt `atob()` → Latin-1 String, der Multi-Byte UTF-8 zerstört), ausgehende Daten über `TextEncoder` UTF-8-safe kodiert
+- Credentials manuell einfügen: "Credentials einfügen" Button — JSON von einem eingeloggten Rechner kopieren und direkt in den Container schreiben (schreibt in beide mögliche Pfade: `.config/claude/` und `.claude/`)
+- Docker Exec API: Generische `dockerExec()` (nicht-interaktiv, multiplexed stream) + `attachTerminal()` (interaktiv, Tty, raw TCP socket) für Befehle in laufenden Containern (via Docker Socket)
+- Chat-Test: Nachrichten direkt über Gateway oder via RVS senden
+- Tabbed Logs: Separate Tabs für Alle, Gateway, RVS, Proxy, Server — mit Zähler pro Tab
+- Autoscroll-Pause: Automatisch wenn hochgescrollt, "Nach unten" Button zum Fortsetzen
+- TLS Fallback für RVS-Verbindung (wie Bridge und App)
+
+### Geändert
+
+**Bridge → aria-core: OpenClaw Gateway Protokoll**
+- Bridge nutzt jetzt das echte OpenClaw Gateway WebSocket-Protokoll (Port 18789 statt 8080)
+- Vollständiger Handshake: `connect.challenge` → `connect` Request (mit Auth-Token) → `hello-ok`
+- Nachrichten über `chat.send` Method mit `message` und `idempotencyKey`
+- Antworten über `chat:final` Events (statt custom JSON)
+- Streaming-Support vorbereitet (`chat:delta` Events werden empfangen)
+- Fehlerbehandlung für `chat:error` Events — werden an die App weitergeleitet
+- Client-ID: `gateway-client` / Mode: `backend` (OpenClaw akzeptiert nur bestimmte Werte)
+
+**Docker-Compose Überarbeitung**
+- Bridge + Diagnostic nutzen `network_mode: "service:aria"` — teilen Netzwerk mit aria-core, kein separates Netz nötig
+- `ANTHROPIC_API_KEY` + `ANTHROPIC_BASE_URL` entfernt — OpenClaw rief damit die echte Anthropic API direkt an (401 `invalid x-api-key`), statt den Proxy zu nutzen. Nur noch `OPENAI_*` Vars aktiv
+- `DEFAULT_MODEL=openai/claude-sonnet-4-6` — mit `openai/` Prefix, damit OpenClaw den OpenAI-Provider und somit den Proxy nutzt
+- `openclaw.env` erstellt — Volume-Mount schlug fehl weil die Datei nicht existierte (Docker erstellte stattdessen ein leeres Verzeichnis)
+- `OPENCLAW_GATEWAY_TOKEN` statt `AUTH_TOKEN` — korrekter Env-Var-Name
+- `ARIA_AUTH_TOKEN` an Bridge und Diagnostic durchgereicht
+- Port 3001 auf aria-Service gemappt (für Diagnostic Web-UI)
+- Proxy Claude-Config Volume `:ro` → `:rw` — Login via Diagnostic-UI braucht Schreibzugriff
+
+**OpenClaw Config-Persistenz**
+- Named Docker Volume `openclaw-config` für `/home/node/.openclaw` — OpenClaw-Konfiguration (Model, Auth, Sessions) überlebt Container-Neustarts
+- `aria-setup.sh` — Einmaliges Setup-Skript: wartet auf aria-core, setzt Model auf `openai/claude-sonnet-4-6`, startet Container neu
+
+### Behoben
+
+- Handshake fehlgeschlagen `[object Object]` — Fehlermeldung wurde nicht korrekt stringifiziert
+- `client.id` und `client.mode` im Connect-Request — OpenClaw akzeptiert nur vordefinierte Werte (`cli`, `gateway-client`, `webchat` etc.)
+- `chat.send` nutzt `message` statt `text` als Parameter — OpenClaw Schema-Validierung
+- **Claude Proxy bindet auf 0.0.0.0** — `claude-max-api-proxy` bindet hardcoded auf `127.0.0.1`, nicht erreichbar im Docker-Netz. Fix: `standalone.js` wird beim Start gepatcht, liest jetzt `HOST` Env-Var (Upstream-Bug: `startServer()` unterstützt `host`, aber CLI übergibt es nicht)
+- **Claude Proxy Crash bei Chat-Completion** — `normalizeModelName()` in `cli-to-openai.js` crasht wenn `model` undefined ist (`TypeError: Cannot read properties of undefined`). Fix: Null-Guard-Patch mit Fallback auf `claude-sonnet-4`
+- **OpenClaw 401 `invalid x-api-key`** — OpenClaw rief mit `ANTHROPIC_BASE_URL` + `ANTHROPIC_API_KEY=not-needed` die echte Anthropic API an, nicht den Proxy. Fix: Anthropic-Vars entfernt, nur OpenAI-Provider aktiv (`OPENAI_BASE_URL=http://proxy:3456/v1`). Proxy unterstützt nur `/v1/chat/completions` (OpenAI-Format), nicht `/v1/messages` (Anthropic-Format)
+- **App Echo-Bug** — Chat-Nachrichten von RVS wurden ohne Sender-Prüfung als ARIA-Nachricht angezeigt. Bei Ghost-Clients (Doppel-Connections nach Reconnect) erschien die eigene Nachricht nochmals. Fix: `message.payload.sender` wird geprüft, Nachrichten von `user` und `diagnostic` werden ignoriert
+
+---
+
+## [0.0.0.3] — 2026-03-09
+
+### Geändert
+
+**RVS — Architektur-Umbau**
+- RVS ist jetzt reiner Relay — kennt keine Tokens, keine Expiry, leitet nur durch
+- `TOKEN_EXPIRY` und `RVS_PUBLIC_HOST`/`RVS_PUBLIC_PORT` entfernt
+- Rooms leben solange Clients verbunden sind (statt fester Ablaufzeit)
+- Multi-Instanz: Mehrere ARIA-VMs können denselben RVS nutzen (z.B. Stefan + Papa)
+
+**Token-Erzeugung auf ARIA-VM statt RVS**
+- `generate-token.js` aus `rvs/` entfernt
+- Neues `generate-token.sh` im Hauptverzeichnis (läuft auf ARIA-VM)
+- Token wird automatisch in `.env` geschrieben
+- `./generate-token.sh show` zeigt bestehendes Token als QR nochmal an
+
+**Konfiguration vereinfacht**
+- `RVS_URL` ersetzt durch `RVS_HOST`, `RVS_PORT`, `RVS_TLS` (klare Einzelfelder)
+- Port einmal in `.env` ändern → wirkt auf RVS docker-compose, Bridge und QR-Code
+- `rvs/docker-compose.yml` nutzt `${RVS_PORT:-443}` statt hardcoded Port
+
+**Android App — QR-Code Scanner**
+- Echter QR-Code Scanner statt Platzhalter-Alert (`react-native-camera-kit`)
+- Vollbild-Kamera mit Overlay, Validierung des QR-Formats
+- Kamera-Berechtigung (Android Runtime Permission)
+- `AndroidManifest.xml` — `CAMERA` Permission hinzugefügt
+
+**Voice Bridge — RVS-Anbindung**
+- Bridge verbindet sich jetzt parallel zu aria-core (lokal) UND zum RVS (öffentlich)
+- Nachrichten von der App werden über RVS → Bridge → aria-core weitergeleitet
+- Antworten von aria-core werden über Bridge → RVS → App zurückgeschickt
+- Auto-Reconnect mit Exponential Backoff für beide WebSocket-Verbindungen
+- Neue Message-Handler: chat, mode, location, file, audio
+
+**Android Build-Fixes**
+- `kotlin_version` (snake_case) in `build.gradle` hinzugefügt — `react-native-camera-kit` braucht beide Varianten
+- `build.sh` schreibt `org.gradle.java.home` dynamisch in `gradle.properties` — verhindert dass Gradle kaputte JVM-Pfade findet (`/usr/lib/jvm/openjdk-17` ohne bin/java)
+- `minSdkVersion` 21 → 23 — `react-native-camera-kit` braucht mindestens API 23
+
+**Android App — Credentials Persistenz**
+- Verbindungsdaten (Host, Port, Token) werden nach QR-Scan in AsyncStorage gespeichert
+- Beim App-Start automatisch geladen und verbunden — einmal scannen, nie wieder
+- Neue Dependency: `@react-native-async-storage/async-storage`
+
+**Docker & Infrastruktur**
+- OpenClaw Image fix: `openclaw/openclaw:latest` → `ghcr.io/openclaw/openclaw:latest`
+- Proxy fix: Binary heißt `claude-max-api`, braucht `@anthropic-ai/claude-code` als Peer-Dependency
+- Proxy Binary-Name fix: `claude-max-api-proxy` → `claude-max-api` (npm-Paket heißt anders als die Binary)
+- `libportaudio2` in Bridge Dockerfile hinzugefügt — `sounddevice` braucht PortAudio
+- `aria-data/config/aria.env.example` hinzugefügt — Voice Bridge Konfigurationsvorlage
+
+**Wake-Word Fix (openwakeword)**
+- `WakeWordDetector` umgebaut — sucht Custom-Modell `/voices/wake_aria.onnx`, Fallback auf eingebautes `hey_jarvis`
+- Alter Code crashte: `wakeword_models=["aria"]` erwartet Dateipfad, kein Keyword
+
+**TLS Fallback (Bridge → RVS)**
+- Bridge versucht zuerst `wss://` (TLS), bei `ssl.SSLError` automatisch Fallback auf `ws://`
+- Konfigurierbar über `RVS_TLS_FALLBACK=true` in `.env`
+- Loggt deutlich wenn TLS gewollt aber nicht verfügbar ist
+
+**Audio-Rendering für App (Piper TTS via RVS)**
+- Bridge rendert Piper TTS → WAV → base64, sendet Text UND Audio gleichzeitig über RVS
+- App spielt Audio ab und zeigt Text parallel — Modus entscheidet ob Sprache oder nur Text
+- Voice Engine initialisiert IMMER (auch ohne Soundkarte in der VM)
+- STT/Wake-Word nur wenn Audio-Hardware vorhanden — graceful degradation
+- Neue Dependency: `react-native-fs` (base64 → temp WAV → Sound abspielen)
+
+**Chat-Persistenz (Android App)**
+- Chat-Verlauf wird in AsyncStorage gespeichert (letzte 500 Nachrichten)
+- Beim App-Start automatisch geladen — Konversation bleibt erhalten
+- Linearer 1:1 Chat, keine Threads
+
+**TLS Fallback + Verbindungslog (Android App)**
+- App versucht zuerst `wss://`, bei Fehler automatisch Fallback auf `ws://`
+- `network_security_config.xml` hinzugefuegt — Android 9+ blockiert sonst `ws://` (Cleartext)
+- Verbindungslog im Settings-Tab — zeigt jeden Verbindungsversuch, Fehler, Fallback (scrollbar, max 200px)
+- Gespeicherte Config wird beim Start in die Einstellungsfelder geladen
+- Fix: TLS-Fallback erzeugte Doppel-Verbindungen (onerror + onclose beide reconnected)
+
+**RVS — Ghost-Client Fix**
+- Heartbeat-Intervall 30s → 15s, Cleanup 60s → 30s — tote Clients werden schneller entfernt
+- `heartbeat` als erlaubter Nachrichtentyp hinzugefuegt — App-Heartbeats halten Verbindung lebendig
+- App-seitiger JSON-Heartbeat zaehlt als Lebenszeichen (zusaetzlich zu WebSocket Ping/Pong)
+
+**Neues Script: `get-voices.sh`**
+- Lädt Piper Stimmen (Ramona + Thorsten) von HuggingFace herunter
+- Neuer Installationsschritt in README
+
+**ARIA Persönlichkeit**
+- `AGENT.md` überarbeitet — ARIA ist jetzt Partnerin auf Augenhöhe (Claude-Charakter)
+- Direkt, ehrlich, humorvoll, lösungsorientiert, kein Theater
+
+---
+
+## [0.0.0.2] — 2026-03-08
+
+### Geändert
+
+**Build-Fixes**
+- `CI=true` in `build.sh` — verhindert EMFILE durch Metro File-Watcher im Release-Build
+- `setup.sh` erstellt Metro-Config-Dateien automatisch (metro.config.js, babel.config.js, .watchmanconfig)
+
+**Release-Script**
+- `release.sh` komplett umgebaut — Kennwort wird interaktiv abgefragt statt Token in `.env`
+- Gitea-Upload fix: `-F` multipart statt `--data-binary`
+- Login-Test vor Release, CHANGELOG.md-Integration für Release Notes
+
+---
+
+## [0.0.0.1] — 2026-03-08
+
+### Hinzugefügt
+
+**Infrastruktur**
+- `docker-compose.yml` — ARIA-VM mit Proxy, OpenClaw, Voice Bridge
+- `.env.example` — Konfigurationsvorlage (ohne Secrets)
+- `release.sh` — Automatisiertes Release (Build, Tag, Gitea Upload mit Kennwort-Abfrage)
+
+**RVS (Rendezvous-Server)**
+- WebSocket Relay Server (`rvs/server.js`) — Token-Rooms, Heartbeat, Message Types
+- Docker Setup (`rvs/Dockerfile`, `rvs/docker-compose.yml`)
+
+**Token & Pairing**
+- `generate-token.sh` — Token-Generator mit QR-Code (läuft auf ARIA-VM, schreibt Token in `.env`)
+
+**Voice Bridge**
+- Python Voice Bridge (`bridge/aria_bridge.py`) — Whisper STT, Piper TTS, Wake-Word
+- 5 Betriebsmodi (`bridge/modes.py`) — Normal, DND, Whisper, Hangar, Gaming
+- Docker Setup (`bridge/Dockerfile`, `bridge/requirements.txt`)
+
+**Android App (ARIA Cockpit)**
+- Chat-Screen mit Texteingabe, Voice-Button, Datei/Kamera-Upload
+- Settings-Screen mit Verbindungsstatus, Token-Eingabe, Modus-Auswahl, GPS-Toggle, Log-Viewer
+- WebSocket-Service mit Auto-Reconnect und Exponential Backoff
+- Audio-Service (Mikrofon-Aufnahme, TTS-Wiedergabe)
+- Push-to-Talk Button mit Puls-Animation
+- Modus-Selektor (5 Modi)
+- Build-Tooling: `setup.sh` (7-Schritt Dev-Setup), `build.sh` (Release/Debug APK)
+- Metro-Config, Babel-Config, Watchman-Config
+
+**Konfiguration & Daten**
+- `aria-data/config/AGENT.md` — ARIAs Persönlichkeit und Sicherheitsregeln
+- `aria-data/config/USER.md` — Stefans Präferenzen
+- `aria-data/config/TOOLING.md` — VM-Tooling Liste
+- `aria-data/skills/README.md` — Skill-Bauanleitung
+
+### Bekannte Probleme
+- Android Release-Build: `EMFILE: too many open files` — Fix: `CI=true` in `build.sh`
+- JDK 21 inkompatibel mit AGP 8.1 — Fix: Automatischer Fallback auf JDK 17
+- `react-native-screens` > 3.27.0 inkompatibel mit RN 0.73.4 — Fix: Version gepinnt

android/.watchmanconfig

@@ -0,0 +1 @@
+{}

android/App.tsx

@@ -0,0 +1,145 @@
+/**
+ * ARIA Cockpit - Haupteinstiegspunkt
+ *
+ * Stefans primaere Schnittstelle zu ARIA.
+ * Bottom-Tab-Navigation mit Chat und Einstellungen.
+ */
+
+import React, { useEffect } from 'react';
+import { StatusBar, StyleSheet } from 'react-native';
+import { NavigationContainer, DefaultTheme } from '@react-navigation/native';
+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 ---
+
+const Tab = createBottomTabNavigator();
+
+// Dunkles Theme fuer die gesamte App
+const DarkTheme = {
+  ...DefaultTheme,
+  dark: true,
+  colors: {
+    ...DefaultTheme.colors,
+    primary: '#0096FF',
+    background: '#0D0D1A',
+    card: '#12122A',
+    text: '#FFFFFF',
+    border: '#1E1E2E',
+    notification: '#FF3B30',
+  },
+};
+
+// Tab-Icons (Text-basiert, kein Icon-Paket noetig)
+const TAB_ICONS: Record<string, { active: string; inactive: string }> = {
+  Chat: { active: '\uD83D\uDCAC', inactive: '\uD83D\uDCAC' },
+  Einstellungen: { active: '\u2699\uFE0F', inactive: '\u2699\uFE0F' },
+};
+
+// --- App ---
+
+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) {
+        rvs.setConfig(config);
+        rvs.connect();
+      }
+    };
+    initConnection();
+
+    // Beim Beenden: Verbindung sauber trennen
+    return () => {
+      rvs.disconnect();
+    };
+  }, []);
+
+  return (
+    <>
+      <StatusBar barStyle="light-content" backgroundColor="#0D0D1A" />
+      <NavigationContainer theme={DarkTheme}>
+        <Tab.Navigator
+          screenOptions={({ route }) => ({
+            headerStyle: styles.header,
+            headerTitleStyle: styles.headerTitle,
+            headerTintColor: '#FFFFFF',
+            tabBarStyle: styles.tabBar,
+            tabBarActiveTintColor: '#0096FF',
+            tabBarInactiveTintColor: '#555570',
+            tabBarIcon: ({ focused }) => {
+              const icons = TAB_ICONS[route.name];
+              return (
+                <React.Fragment>
+                  {/* Emoji als Icon */}
+                  {React.createElement(
+                    require('react-native').Text,
+                    {
+                      style: {
+                        fontSize: 22,
+                        opacity: focused ? 1 : 0.5,
+                      },
+                    },
+                    icons ? (focused ? icons.active : icons.inactive) : '?',
+                  )}
+                </React.Fragment>
+              );
+            },
+          })}
+        >
+          <Tab.Screen
+            name="Chat"
+            component={ChatScreen}
+            options={{
+              title: 'ARIA Chat',
+              headerTitle: 'ARIA Cockpit',
+            }}
+          />
+          <Tab.Screen
+            name="Einstellungen"
+            component={SettingsScreen}
+            options={{
+              title: 'Einstellungen',
+            }}
+          />
+        </Tab.Navigator>
+      </NavigationContainer>
+    </>
+  );
+};
+
+// --- Styles ---
+
+const styles = StyleSheet.create({
+  header: {
+    backgroundColor: '#12122A',
+    elevation: 0,
+    shadowOpacity: 0,
+    borderBottomWidth: 1,
+    borderBottomColor: '#1E1E2E',
+  },
+  headerTitle: {
+    color: '#FFFFFF',
+    fontSize: 18,
+    fontWeight: '700',
+  },
+  tabBar: {
+    backgroundColor: '#12122A',
+    borderTopColor: '#1E1E2E',
+    borderTopWidth: 1,
+    height: 60,
+    paddingBottom: 6,
+    paddingTop: 4,
+  },
+});
+
+export default App;

android/README.md

@@ -0,0 +1,192 @@
+# ARIA Cockpit — Android App
+
+Stefans primäre Schnittstelle zu ARIA. Gebaut mit React Native + TypeScript.
+
+---
+
+## Schnellstart
+
+```bash
+# 1. Abhängigkeiten installieren (einmalig)
+./setup.sh
+
+# 2. Release-APK bauen (standalone, kein Dev-Server nötig)
+./build.sh
+
+# 3. APK aufs Handy kopieren und installieren
+adb install ARIA-Cockpit-release.apk
+```
+
+Fertig. APK liegt als `ARIA-Cockpit-release.apk` im Verzeichnis.
+
+---
+
+## Debug vs Release — was ist der Unterschied?
+
+| | Debug | Release |
+|---|---|---|
+| **JS-Bundle** | Wird von Metro Dev-Server geladen (localhost:8081) | In die APK eingebaut — läuft standalone |
+| **Verwendung** | Entwicklung am PC mit Hot-Reload | Installation aufs Handy |
+| **Dev-Server nötig?** | Ja — `npx react-native start` muss laufen | Nein — App startet sofort |
+| **Größe** | Kleiner (Code wird live geladen) | Größer (alles eingebaut) |
+
+**Für aufs Handy installieren immer Release bauen:**
+```bash
+./build.sh release    # oder einfach: ./build.sh
+```
+
+**Debug nur zum Entwickeln am PC:**
+```bash
+# Terminal 1: Metro Dev-Server starten
+npx react-native start
+
+# Terminal 2: Debug-APK bauen und auf verbundenes Gerät/Emulator deployen
+./build.sh debug
+```
+
+> Wenn du eine Debug-APK aufs Handy kopierst ohne Metro-Server, siehst du den roten
+> "Could not connect to development server" Fehler. Das ist normal — Debug braucht den Server.
+
+---
+
+## Scripts
+
+### `setup.sh` — Entwicklungsumgebung einrichten
+
+Installiert automatisch alles was zum Bauen nötig ist:
+
+| Was | Version | Details |
+|-----|---------|---------|
+| **Basis-Tools** | — | curl, unzip, git |
+| **Node.js** | >= 18 | Via NodeSource (falls nicht vorhanden) |
+| **JDK** | 17 (vollständig) | OpenJDK mit jlink (nicht nur JRE!) |
+| **Android SDK** | API 34 | Command Line Tools + Build Tools + Platform Tools |
+| **Metro-Config** | — | metro.config.js, babel.config.js, .watchmanconfig (falls fehlend) |
+| **Node Packages** | — | Räumt alte node_modules auf + `npm install` |
+| **Natives Android-Projekt** | — | React Native Gradle-Projekt generieren |
+| **Gradle Config** | — | compileSdk-Warning unterdrücken, Build-Cache aufräumen |
+
+Das Script erkennt automatisch dein OS (Debian, Fedora, Arch, macOS) und benutzt den passenden Paketmanager.
+
+**ANDROID_HOME** wird automatisch gesetzt und in dein Shell-Profil (`.bashrc`/`.zshrc`) eingetragen.
+
+**JDK-Hinweis:** React Native 0.73 + Android Gradle Plugin 8.1 braucht exakt JDK 17 — nicht 21 oder neuer. Falls du JDK 21 als Standard hast, ist das kein Problem: `build.sh` setzt `JAVA_HOME` automatisch auf JDK 17 (wenn installiert).
+
+```bash
+./setup.sh
+```
+
+> Nach dem Setup einmalig Shell neu starten oder `source ~/.bashrc` ausführen.
+
+### `build.sh` — APK bauen
+
+Baut die Android APK in einem Schritt:
+
+```bash
+./build.sh              # Release-APK (Standard) — fürs Handy
+./build.sh release      # Release-APK (explizit)
+./build.sh debug        # Debug-APK (nur mit Metro Dev-Server)
+```
+
+**Was das Script macht:**
+1. Prüft ob Node, npm, Java vorhanden sind (sonst Fehler mit Hinweis auf `setup.sh`)
+2. Erkennt automatisch JDK 21 und wechselt auf JDK 17 (inkl. jlink-Prüfung)
+3. Sucht automatisch nach dem Android SDK (typische Pfade)
+4. Prüft ob das native Android-Projekt existiert (sonst Hinweis auf `setup.sh`)
+5. Installiert/updated Node Dependencies falls nötig
+6. Baut die APK via Gradle
+7. Kopiert die fertige APK als `ARIA-Cockpit-<modus>.apk` ins Hauptverzeichnis
+
+**Ausgabe-Dateien:**
+- `ARIA-Cockpit-release.apk` — fertige APK (Hauptverzeichnis)
+- `android/app/build/outputs/apk/release/app-release.apk` — Original-Pfad
+
+---
+
+## Auf dem Handy installieren
+
+```bash
+# Via ADB (USB-Kabel oder WiFi)
+adb install ARIA-Cockpit-release.apk
+
+# Oder: APK aufs Handy kopieren und dort öffnen
+# Oder: Via Gitea Release herunterladen (siehe release.sh im Root)
+```
+
+---
+
+## Erstverbindung (Pairing)
+
+1. App starten
+2. Tab **Einstellungen** öffnen
+3. QR-Code scannen (vom RVS generiert) oder Token manuell eingeben
+4. Verbindungsstatus prüfen (grüner Punkt = verbunden)
+
+Der QR-Code enthält alles was die App braucht:
+```json
+{
+  "host": "rvs.hackersoft.de",
+  "port": 443,
+  "token": "a3f8b2c9d1e4..."
+}
+```
+
+Einmal scannen, nie wieder manuell tippen.
+
+---
+
+## Projektstruktur
+
+```
+android/
+├── setup.sh                    ← Dev-Umgebung einrichten (einmalig)
+├── build.sh                    ← APK bauen
+├── index.js                    ← React Native Entry Point
+├── app.json                    ← App-Name Konfiguration
+├── App.tsx                     ← Haupt-Komponente, Navigation
+├── package.json                ← Dependencies
+├── tsconfig.json               ← TypeScript Config
+├── metro.config.js             ← Metro Bundler Config
+├── babel.config.js             ← Babel Transpiler Config
+├── .watchmanconfig             ← Watchman Config
+│
+├── src/
+│   ├── services/
+│   │   ├── rvs.ts              ← WebSocket-Verbindung zum Rendezvous Server
+│   │   └── audio.ts            ← Mikrofon-Aufnahme und TTS-Wiedergabe
+│   │
+│   ├── screens/
+│   │   ├── ChatScreen.tsx      ← Hauptchat mit ARIA
+│   │   └── SettingsScreen.tsx  ← Verbindung, Modus, Logs
+│   │
+│   └── components/
+│       ├── VoiceButton.tsx     ← Push-to-Talk Button
+│       ├── ModeSelector.tsx    ← Betriebsmodus-Auswahl
+│       ├── FileUpload.tsx      ← Datei-Versand
+│       └── CameraUpload.tsx    ← Foto-Aufnahme / Galerie
+│
+└── android/                    ← Generiertes Gradle-Projekt (nach setup)
+    ├── gradlew                 ← Gradle Wrapper
+    ├── gradle.properties       ← Gradle Config (compileSdk etc.)
+    └── app/build.gradle        ← App Build Config
+```
+
+---
+
+## Fehlerbehebung
+
+| Problem | Lösung |
+|---------|--------|
+| **"Could not connect to development server"** | Das ist eine Debug-APK. Für standalone: `./build.sh release` |
+| `ANDROID_HOME nicht gesetzt` | `./setup.sh` ausführen, Shell neu starten |
+| `gradlew: Permission denied` | `chmod +x android/gradlew` |
+| `SDK not found` | `./setup.sh` — installiert Android SDK automatisch |
+| `JDK nicht gefunden` | `./setup.sh` — installiert OpenJDK 17 |
+| `jlink does not exist` | Nur JRE installiert, nicht voller JDK: `sudo apt install openjdk-17-jdk` |
+| `JdkImageTransform` Fehler | JDK 21 aktiv, aber JDK 17 nötig — `build.sh` löst das automatisch |
+| `BaseReactPackage` Fehler | `react-native-screens` Version zu neu — auf 3.27.0 pinnen |
+| `react-native-camera` Flavor-Fehler | Paket entfernt (deprecated), wird nicht gebraucht |
+| `EMFILE: too many open files` | `build.sh` setzt `CI=true` automatisch — Metro startet keinen File-Watcher |
+| `No Metro config found` | `./setup.sh` erstellt metro.config.js, babel.config.js, .watchmanconfig automatisch |
+| Build hängt bei `assembleRelease` | Signing Config prüfen (siehe React Native Docs) |
+| `node_modules` Probleme | `./setup.sh` — räumt alles auf und installiert frisch |

android/android/app/build.gradle

@@ -0,0 +1,137 @@
+apply plugin: "com.android.application"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+/**
+ * This is the configuration block to customize your React Native Android app.
+ * By default you don't need to apply any configuration, just uncomment the lines you need.
+ */
+react {
+    /* Folders */
+    //   The root of your project, i.e. where "package.json" lives. Default is '..'
+    // root = file("../")
+    //   The folder where the react-native NPM package is. Default is ../node_modules/react-native
+    // reactNativeDir = file("../node_modules/react-native")
+    //   The folder where the react-native Codegen package is. Default is ../node_modules/@react-native/codegen
+    // codegenDir = file("../node_modules/@react-native/codegen")
+    //   The cli.js file which is the React Native CLI entrypoint. Default is ../node_modules/react-native/cli.js
+    // cliFile = file("../node_modules/react-native/cli.js")
+
+    /* Variants */
+    //   The list of variants to that are debuggable. For those we're going to
+    //   skip the bundling of the JS bundle and the assets. By default is just 'debug'.
+    //   If you add flavors like lite, prod, etc. you'll have to list your debuggableVariants.
+    // debuggableVariants = ["liteDebug", "prodDebug"]
+
+    /* Bundling */
+    //   A list containing the node command and its flags. Default is just 'node'.
+    // nodeExecutableAndArgs = ["node"]
+    //
+    //   The command to run when bundling. By default is 'bundle'
+    // bundleCommand = "ram-bundle"
+    //
+    //   The path to the CLI configuration file. Default is empty.
+    // bundleConfig = file(../rn-cli.config.js)
+    //
+    //   The name of the generated asset file containing your JS bundle
+    // bundleAssetName = "MyApplication.android.bundle"
+    //
+    //   The entry file for bundle generation. Default is 'index.android.js' or 'index.js'
+    // entryFile = file("../js/MyApplication.android.js")
+    //
+    //   A list of extra flags to pass to the 'bundle' commands.
+    //   See https://github.com/react-native-community/cli/blob/main/docs/commands.md#bundle
+    // extraPackagerArgs = []
+
+    /* Hermes Commands */
+    //   The hermes compiler command to run. By default it is 'hermesc'
+    // hermesCommand = "$rootDir/my-custom-hermesc/bin/hermesc"
+    //
+    //   The list of flags to pass to the Hermes compiler. By default is "-O", "-output-source-map"
+    // hermesFlags = ["-O", "-output-source-map"]
+}
+
+/**
+ * Set this to true to Run Proguard on Release builds to minify the Java bytecode.
+ */
+def enableProguardInReleaseBuilds = false
+
+/**
+ * The preferred build flavor of JavaScriptCore (JSC)
+ *
+ * For example, to use the international variant, you can use:
+ * `def jscFlavor = 'org.webkit:android-jsc-intl:+'`
+ *
+ * The international variant includes ICU i18n library and necessary data
+ * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
+ * give correct results when using with locales other than en-US. Note that
+ * this variant is about 6MiB larger per architecture than default.
+ */
+def jscFlavor = 'org.webkit:android-jsc:+'
+
+android {
+    ndkVersion rootProject.ext.ndkVersion
+    buildToolsVersion rootProject.ext.buildToolsVersion
+    compileSdk rootProject.ext.compileSdkVersion
+
+    namespace "com.ariacockpit"
+    defaultConfig {
+        applicationId "com.ariacockpit"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 10207
+        versionName "0.1.2.7"
+        // Fallback fuer Libraries mit Product Flavors
+        missingDimensionStrategy 'react-native-camera', 'general'
+    }
+    signingConfigs {
+        debug {
+            storeFile file('debug.keystore')
+            storePassword 'android'
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+        }
+    }
+    buildTypes {
+        debug {
+            signingConfig signingConfigs.debug
+        }
+        release {
+            // Caution! In production, you need to generate your own keystore file.
+            // see https://reactnative.dev/docs/signed-apk-android.
+            signingConfig signingConfigs.debug
+            minifyEnabled enableProguardInReleaseBuilds
+            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 {
+    // The version of react-native is set by the React Native Gradle Plugin
+    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 {
+        implementation jscFlavor
+    }
+}
+
+apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project)

android/android/app/proguard-rules.pro

@@ -0,0 +1,10 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:

android/android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <application
+        android:usesCleartextTraffic="true"
+        tools:targetApi="28"
+        tools:ignore="GoogleAppIndexingWarning"/>
+</manifest>

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

@@ -0,0 +1,57 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+    <!-- Anruf-State lesen damit TTS bei klingelndem Telefon pausiert -->
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <!-- 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"
+      android:label="@string/app_name"
+      android:icon="@mipmap/ic_launcher"
+      android:roundIcon="@mipmap/ic_launcher_round"
+      android:allowBackup="false"
+      android:networkSecurityConfig="@xml/network_security_config"
+      android:theme="@style/AppTheme">
+      <activity
+        android:name=".MainActivity"
+        android:label="@string/app_name"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+        android:launchMode="singleTask"
+        android:windowSoftInputMode="adjustResize"
+        android:exported="true">
+        <intent-filter>
+            <action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.LAUNCHER" />
+        </intent-filter>
+      </activity>
+
+      <provider
+        android:name="androidx.core.content.FileProvider"
+        android:authorities="${applicationId}.fileprovider"
+        android:exported="false"
+        android:grantUriPermissions="true">
+        <meta-data
+          android:name="android.support.FILE_PROVIDER_PATHS"
+          android:resource="@xml/file_paths" />
+      </provider>
+
+      <service
+        android:name=".AriaPlaybackService"
+        android:exported="false"
+        android:foregroundServiceType="mediaPlayback|microphone" />
+    </application>
+</manifest>

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

@@ -0,0 +1,44 @@
+package com.ariacockpit
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import androidx.core.content.FileProvider
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import java.io.File
+
+class ApkInstallerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "ApkInstaller"
+
+    @ReactMethod
+    fun install(filePath: String, promise: Promise) {
+        try {
+            val file = File(filePath)
+            if (!file.exists()) {
+                promise.reject("FILE_NOT_FOUND", "APK nicht gefunden: $filePath")
+                return
+            }
+
+            val context = reactApplicationContext
+            val uri: Uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
+            } else {
+                Uri.fromFile(file)
+            }
+
+            val intent = Intent(Intent.ACTION_VIEW).apply {
+                setDataAndType(uri, "application/vnd.android.package-archive")
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            }
+
+            context.startActivity(intent)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("INSTALL_ERROR", e.message, e)
+        }
+    }
+}

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

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

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

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

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

@@ -0,0 +1,212 @@
+package com.ariacockpit
+
+import android.content.Context
+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.
+ *
+ * - 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) {
+            promise.reject("NO_AUDIO_MANAGER", "AudioManager nicht verfuegbar")
+            return
+        }
+
+        release()
+
+        val result: Int = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val attrs = AudioAttributes.Builder()
+                .setUsage(usage)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                .build()
+            val req = AudioFocusRequest.Builder(durationHint)
+                .setAudioAttributes(attrs)
+                .setOnAudioFocusChangeListener(focusListener)
+                .build()
+            currentRequest = req
+            am.requestAudioFocus(req)
+        } else {
+            @Suppress("DEPRECATION")
+            am.requestAudioFocus(focusListener, AudioManager.STREAM_MUSIC, durationHint)
+        }
+
+        promise.resolve(result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
+    }
+
+    /** Andere Apps werden pausiert (TTS spricht).
+     *
+     *  TRANSIENT (statt TRANSIENT_MAY_DUCK): Spotify/YouTube pausieren komplett
+     *  statt nur leiser zu werden. Verhindert auch das "kommt-wieder-hoch"-
+     *  Problem mit MAY_DUCK, wo das System nach kurzer Zeit den Duck-Effekt
+     *  wieder aufgehoben hat obwohl wir den Fokus noch hielten.
+     */
+    @ReactMethod
+    fun requestDuck(promise: Promise) {
+        requestFocus(
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT,
+            AudioAttributes.USAGE_ASSISTANT,
+            promise,
+        )
+    }
+
+    /** Andere Apps werden pausiert (Mikrofon-Aufnahme / Gespraech). */
+    @ReactMethod
+    fun requestExclusive(promise: Promise) {
+        requestFocus(
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE,
+            AudioAttributes.USAGE_VOICE_COMMUNICATION,
+            promise,
+        )
+    }
+
+    /** Focus abgeben — andere Apps duerfen wieder volle Lautstaerke. */
+    @ReactMethod
+    fun release(promise: Promise) {
+        release()
+        promise.resolve(true)
+    }
+
+    /** 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)
+        }
+        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/AudioFocusPackage.kt

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+
+class MainActivity : ReactActivity() {
+
+  /**
+   * Returns the name of the main component registered from JavaScript. This is used to schedule
+   * rendering of the component.
+   */
+  override fun getMainComponentName(): String = "AriaCockpit"
+
+  /**
+   * Returns the instance of the [ReactActivityDelegate]. We use [DefaultReactActivityDelegate]
+   * which allows you to enable New Architecture with a single boolean flags [fabricEnabled]
+   */
+  override fun createReactActivityDelegate(): ReactActivityDelegate =
+      DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled)
+}

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

@@ -0,0 +1,49 @@
+package com.ariacockpit
+
+import android.app.Application
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+import com.facebook.react.defaults.DefaultReactNativeHost
+import com.facebook.react.flipper.ReactNativeFlipper
+import com.facebook.soloader.SoLoader
+
+class MainApplication : Application(), ReactApplication {
+
+  override val reactNativeHost: ReactNativeHost =
+      object : DefaultReactNativeHost(this) {
+        override fun getPackages(): List<ReactPackage> =
+            PackageList(this).packages.apply {
+              add(ApkInstallerPackage())
+              add(AudioFocusPackage())
+              add(PcmStreamPlayerPackage())
+              add(OpenWakeWordPackage())
+              add(PhoneCallPackage())
+              add(BackgroundAudioPackage())
+            }
+
+        override fun getJSMainModuleName(): String = "index"
+
+        override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+
+        override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+      }
+
+  override val reactHost: ReactHost
+    get() = getDefaultReactHost(this.applicationContext, reactNativeHost)
+
+  override fun onCreate() {
+    super.onCreate()
+    SoLoader.init(this, false)
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      // If you opted-in for the New Architecture, we load the native entry point for this app.
+      load()
+    }
+    ReactNativeFlipper.initializeFlipper(this, reactNativeHost.reactInstanceManager)
+  }
+}

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

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

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

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

@@ -0,0 +1,374 @@
+package com.ariacockpit
+
+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
+
+/**
+ * Streamt PCM-s16le Audio direkt via AudioTrack MODE_STREAM mit Pre-Roll.
+ *
+ * Pre-Roll: AudioTrack wird zwar direkt gebaut und gefuttert, aber play()
+ * wird erst aufgerufen wenn PREROLL_SECONDS Audio im Buffer ist. So hat
+ * der Stream Zeit einen Vorrat aufzubauen — wenn XTTS mit RTF>1 rendert
+ * (langsamer als Echtzeit), laeuft der Buffer trotzdem nicht leer.
+ *
+ * Flow:
+ *   JS: start(sampleRate, channels) → öffnet AudioTrack (noch nicht play())
+ *   JS: writeChunk(base64)           → dekodiert, queued, Writer schreibt
+ *   Writer: spielt los sobald PREROLL erreicht ist
+ *   JS: end()                         → wartet bis Queue leer, schließt
+ *   JS: stop()                        → Hart stoppen (Cancel)
+ */
+class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    companion object {
+        private const val TAG = "PcmStreamPlayer"
+        // Fallback wenn JS keinen Wert uebergibt.
+        private const val DEFAULT_PREROLL_SECONDS = 3.5
+        // 0.0 = sofortige Wiedergabe — play() direkt beim ersten Chunk.
+        // Macht Sinn fuer F5-TTS weil Render so schnell ist dass ein Puffer
+        // unnoetig ist und bei kurzen Saetzen sogar stoeren kann.
+        private const val MIN_PREROLL_SECONDS = 0.0
+        private const val MAX_PREROLL_SECONDS = 10.0
+        // Stille am Stream-Anfang, damit AudioTrack sauber anfaehrt und die
+        // ersten Samples nicht abgeschnitten werden (XTTS-Warmup + play()-Latenz).
+        private const val LEADING_SILENCE_SECONDS = 0.3
+        // Stille am Ende — puffert das Hardware-Flushen damit die letzten
+        // echten Samples garantiert ausgespielt werden bevor stop() kommt.
+        private const val TRAILING_SILENCE_SECONDS = 0.3
+    }
+
+    override fun getName() = "PcmStreamPlayer"
+
+    private var track: AudioTrack? = null
+    private val queue = LinkedBlockingQueue<ByteArray>()
+    private var writerThread: Thread? = null
+    @Volatile private var writerShouldStop = false
+    @Volatile private var endRequested = false
+    @Volatile private var prerollBytes: Int = 0
+    @Volatile private var playbackStarted = false
+    @Volatile private var bytesBuffered: Long = 0
+    @Volatile private var streamBytesPerFrame: Int = 2 // mono s16le default
+
+    // ── Lifecycle ──
+
+    @ReactMethod
+    fun start(sampleRate: Int, channels: Int, prerollSeconds: Double, promise: Promise) {
+        try {
+            // Alte Session beenden falls vorhanden
+            stopInternal()
+
+            // Nur NaN/Inf → Default. 0.0 ist gueltig (= sofortige Wiedergabe).
+            val prerollSec = if (prerollSeconds.isFinite() && prerollSeconds >= 0.0) {
+                prerollSeconds.coerceIn(MIN_PREROLL_SECONDS, MAX_PREROLL_SECONDS)
+            } else {
+                DEFAULT_PREROLL_SECONDS
+            }
+
+            val channelConfig = if (channels == 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
+            val encoding = AudioFormat.ENCODING_PCM_16BIT
+            val minBuf = AudioTrack.getMinBufferSize(sampleRate, channelConfig, encoding)
+            val bytesPerSecond = sampleRate * channels * 2 // 16-bit = 2 bytes
+            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)
+            prerollBytes = prerollTarget
+            bytesBuffered = 0
+            playbackStarted = false
+            streamBytesPerFrame = channels * 2 // s16 = 2 bytes per sample
+
+            val newTrack = AudioTrack.Builder()
+                .setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_ASSISTANT)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                        .build(),
+                )
+                .setAudioFormat(
+                    AudioFormat.Builder()
+                        .setSampleRate(sampleRate)
+                        .setChannelMask(channelConfig)
+                        .setEncoding(encoding)
+                        .build(),
+                )
+                .setBufferSizeInBytes(bufferSize)
+                .setTransferMode(AudioTrack.MODE_STREAM)
+                .build()
+
+            // 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}")
+                }
+            }
+
+            track = newTrack
+            queue.clear()
+            writerShouldStop = false
+            endRequested = false
+
+            writerThread = Thread({
+                val t = track ?: return@Thread
+                try {
+                    // Leading-Silence in den Buffer — gibt AudioTrack Zeit anzufahren.
+                    val leadingBytes = ((sampleRate * channels * 2) * LEADING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
+                    if (leadingBytes > 0) {
+                        val silence = ByteArray(leadingBytes)
+                        var silOff = 0
+                        while (silOff < silence.size && !writerShouldStop) {
+                            val w = t.write(silence, silOff, silence.size - silOff)
+                            if (w <= 0) break
+                            silOff += w
+                        }
+                        bytesBuffered += silence.size
+                    }
+                    // Bei preroll=0: play() SOFORT nach Leading-Silence aufrufen,
+                    // nicht erst bei Ankunft des ersten echten Chunks. Android's
+                    // AudioTrack haelt den Play-State und wartet auf neue Samples.
+                    // So verschluckt es keine Worte wenn der erste Chunk erst
+                    // nach play()-Startup-Latenz eintrifft.
+                    if (prerollBytes == 0 && !playbackStarted) {
+                        try {
+                            t.play()
+                            playbackStarted = true
+                            Log.i(TAG, "Playback sofort gestartet (preroll=0, ${bytesBuffered}B silence)")
+                        } catch (e: Exception) {
+                            Log.w(TAG, "play() sofort failed: ${e.message}")
+                        }
+                    }
+                    // Idle-Cutoff: wenn endRequested NICHT kam aber 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) {
+                            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.
+                                if (!playbackStarted) {
+                                    try { t.play(); playbackStarted = true } catch (_: Exception) {}
+                                }
+                                break@mainLoop
+                            }
+                            // Underrun-Schutz: Stille reinfuettern wenn der AudioTrack-
+                            // Puffer leerzulaufen droht. Spotify resumed sonst nach
+                            // ~10s Pause auf eigene Faust, obwohl wir den Fokus halten.
+                            if (playbackStarted) {
+                                val framesWritten = bytesBuffered / streamBytesPerFrame
+                                val framesPlayed = t.playbackHeadPosition.toLong()
+                                val framesInBuffer = framesWritten - framesPlayed
+                                if (framesInBuffer < underrunGuardFrames) {
+                                    val fillBytes = silenceFillFrames * streamBytesPerFrame
+                                    val silence = ByteArray(fillBytes)
+                                    var silOff = 0
+                                    while (silOff < silence.size && !writerShouldStop) {
+                                        val w = t.write(silence, silOff, silence.size - silOff)
+                                        if (w <= 0) break
+                                        silOff += w
+                                    }
+                                    bytesBuffered += silence.size
+                                }
+                            }
+                            idleMs += 50L
+                            if (idleMs >= maxIdleMs) {
+                                Log.w(TAG, "Idle-Cutoff: ${maxIdleMs}ms keine Daten — Stream wird beendet")
+                                break@mainLoop
+                            }
+                            continue@mainLoop
+                        }
+                        idleMs = 0L
+
+                        // 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) {
+                            try {
+                                t.play()
+                                playbackStarted = true
+                                Log.i(TAG, "Playback gestartet beim 1. Chunk (${bytesBuffered}B leading + ${data.size}B data)")
+                            } catch (e: Exception) {
+                                Log.w(TAG, "play() failed: ${e.message}")
+                            }
+                        }
+
+                        var offset = 0
+                        while (offset < data.size && !writerShouldStop) {
+                            val written = t.write(data, offset, data.size - offset)
+                            if (written <= 0) break
+                            offset += written
+                        }
+                        bytesBuffered += data.size
+                    }
+                    // Trailing-Silence damit die letzten echten Samples garantiert
+                    // durch das Hardware-Buffering kommen bevor stop() sie abschneidet
+                    val trailingBytes = ((sampleRate * channels * 2) * TRAILING_SILENCE_SECONDS).toInt() and 0x7FFFFFFE
+                    if (trailingBytes > 0 && !writerShouldStop) {
+                        val silence = ByteArray(trailingBytes)
+                        var silOff = 0
+                        while (silOff < silence.size && !writerShouldStop) {
+                            val w = t.write(silence, silOff, silence.size - silOff)
+                            if (w <= 0) break
+                            silOff += w
+                        }
+                        bytesBuffered += silence.size
+                    }
+                } catch (e: Exception) {
+                    Log.w(TAG, "Writer-Thread Fehler: ${e.message}")
+                } finally {
+                    // Warten bis alle geschriebenen Samples tatsaechlich abgespielt sind,
+                    // sonst cuttet t.release() die letzten Sekunden ab.
+                    try {
+                        val totalFrames = (bytesBuffered / streamBytesPerFrame).toInt()
+                        var lastPos = -1
+                        var stalledCount = 0
+                        var retried = false
+                        while (!writerShouldStop) {
+                            val pos = t.playbackHeadPosition
+                            if (pos >= totalFrames) break
+                            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
+                                }
+                            } else {
+                                stalledCount = 0
+                                lastPos = pos
+                            }
+                            Thread.sleep(50)
+                        }
+                        Log.i(TAG, "Playback fertig: frames=$totalFrames pos=${t.playbackHeadPosition}")
+                    } catch (_: Exception) {}
+                    try { t.stop() } catch (_: Exception) {}
+                    try { t.release() } catch (_: Exception) {}
+                    // 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() }
+
+            Log.i(TAG, "Stream gestartet: ${sampleRate}Hz ch=$channels buf=${bufferSize}B preroll=${prerollBytes}B (${prerollSec}s)")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "start fehlgeschlagen", e)
+            promise.reject("START_FAILED", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun writeChunk(base64Pcm: String, promise: Promise) {
+        try {
+            if (base64Pcm.isEmpty()) {
+                promise.resolve(true)
+                return
+            }
+            val bytes = Base64.decode(base64Pcm, Base64.DEFAULT)
+            queue.put(bytes)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("WRITE_FAILED", e.message, e)
+        }
+    }
+
+    /** Signalisiert: keine weiteren Chunks. Writer spielt aus, dann stoppt.
+     *  Das Promise resolved erst wenn der Writer-Thread fertig ist —
+     *  wichtig damit der Aufrufer den AudioFocus erst NACH dem letzten
+     *  abgespielten Sample wieder freigibt (sonst dreht Spotify hoch
+     *  waehrend das Pre-Roll noch ausspielt).
+     */
+    @ReactMethod
+    fun end(promise: Promise) {
+        endRequested = true
+        val t = writerThread
+        if (t == null || !t.isAlive) {
+            promise.resolve(true)
+            return
+        }
+        // Im Hintergrund auf den Writer warten — kein Threading-Block fuer JS-Bridge
+        Thread({
+            try {
+                t.join(15_000) // hartes Cap, falls Writer haengt
+            } catch (_: InterruptedException) {}
+            promise.resolve(true)
+        }, "PcmStreamEndWaiter").start()
+    }
+
+    /** Harter Stop (Cancel) — Queue verwerfen. */
+    @ReactMethod
+    fun stop(promise: Promise) {
+        stopInternal()
+        promise.resolve(true)
+    }
+
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+
+    private fun stopInternal() {
+        writerShouldStop = true
+        endRequested = true
+        queue.clear()
+        writerThread?.interrupt()
+        writerThread = null
+        val t = track
+        if (t != null) {
+            try { t.stop() } catch (_: Exception) {}
+            try { t.release() } catch (_: Exception) {}
+        }
+        track = null
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        stopInternal()
+        super.onCatalystInstanceDestroy()
+    }
+}

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2014 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<inset xmlns:android="http://schemas.android.com/apk/res/android"
+       android:insetLeft="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetRight="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetTop="@dimen/abc_edit_text_inset_top_material"
+       android:insetBottom="@dimen/abc_edit_text_inset_bottom_material">
+
+    <selector>
+        <!--
+          This file is a copy of abc_edit_text_material (https://bit.ly/3k8fX7I).
+          The item below with state_pressed="false" and state_focused="false" causes a NullPointerException.
+          NullPointerException:tempt to invoke virtual method 'android.graphics.drawable.Drawable android.graphics.drawable.Drawable$ConstantState.newDrawable(android.content.res.Resources)'
+
+          <item android:state_pressed="false" android:state_focused="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
+
+          For more info, see https://bit.ly/3CdLStv (react-native/pull/29452) and https://bit.ly/3nxOMoR.
+        -->
+        <item android:state_enabled="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
+        <item android:drawable="@drawable/abc_textfield_activated_mtrl_alpha"/>
+    </selector>
+
+</inset>

android/android/app/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">ARIA</string>
+</resources>

android/android/app/src/main/res/values/styles.xml

@@ -0,0 +1,9 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.DayNight.NoActionBar">
+        <!-- Customize your theme here. -->
+        <item name="android:editTextBackground">@drawable/rn_edit_text_material</item>
+    </style>
+
+</resources>

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

@@ -0,0 +1,8 @@
+<?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/android/app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Network Security Config fuer ARIA Cockpit
+  Erlaubt Cleartext (ws://) zum RVS als TLS-Fallback.
+  Ohne diese Config blockiert Android 9+ alle ws:// Verbindungen.
+-->
+<network-security-config>
+    <base-config cleartextTrafficPermitted="true">
+        <trust-anchors>
+            <certificates src="system" />
+        </trust-anchors>
+    </base-config>
+</network-security-config>

android/android/build.gradle

@@ -0,0 +1,24 @@
+buildscript {
+    ext {
+        buildToolsVersion = "34.0.0"
+        // 24 = Android 7.0 (Nougat). Verlangt von Porcupine (Picovoice).
+        // Realistisch eh das Minimum: alles unter 7.0 hat <1% Marktanteil.
+        minSdkVersion = 24
+        compileSdkVersion = 34
+        targetSdkVersion = 34
+        ndkVersion = "25.1.8937393"
+        kotlinVersion = "1.8.0"
+        kotlin_version = "1.8.0"
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.android.tools.build:gradle")
+        classpath("com.facebook.react:react-native-gradle-plugin")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin")
+    }
+}
+
+apply plugin: "com.facebook.react.rootproject"

android/android/gradle.properties

@@ -0,0 +1,48 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx512m -XX:MaxMetaspaceSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Automatically convert third-party libraries to use AndroidX
+android.enableJetifier=true
+
+# Use this property to specify which architecture you want to build.
+# You can also override it from the CLI using
+# ./gradlew <task> -PreactNativeArchitectures=x86_64
+reactNativeArchitectures=armeabi-v7a,arm64-v8a,x86,x86_64
+
+# Use this property to enable support to the new architecture.
+# This will allow you to use TurboModules and the Fabric render in
+# your application. You should enable this flag either if you want
+# to write custom TurboModules/Fabric components OR use libraries that
+# are providing them.
+newArchEnabled=false
+
+# Use this property to enable or disable the Hermes JS engine.
+# If set to false, you will be using JSC instead.
+hermesEnabled=true
+
+# ARIA: compileSdk-Warnung unterdrücken (AGP 8.1 vs SDK 35)
+android.suppressUnsupportedCompileSdk=35
+
+
+# ARIA: JDK 17 Pfad (gesetzt von build.sh)
+org.gradle.java.home=/usr/lib/jvm/java-17-openjdk-amd64

android/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-all.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

android/android/gradlew

@@ -0,0 +1,249 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

android/android/gradlew.bat

@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

android/android/settings.gradle

@@ -0,0 +1,4 @@
+rootProject.name = 'AriaCockpit'
+apply from: file("../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesSettingsGradle(settings)
+include ':app'
+includeBuild('../node_modules/@react-native/gradle-plugin')

android/app.json

@@ -0,0 +1,4 @@
+{
+  "name": "AriaCockpit",
+  "displayName": "ARIA Cockpit"
+}

android/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+};

android/build.sh

@@ -0,0 +1,225 @@
+#!/bin/bash
+# ════════════════════════════════════════════════
+#  ARIA Cockpit — Android Build Script
+#  Verwendung: ./build.sh [debug|release]
+# ════════════════════════════════════════════════
+
+set -e
+
+MODE="${1:-release}"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# ── Farben ────────────────────────────────────
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+echo -e "${YELLOW}╔═══════════════════════════════════════╗${NC}"
+echo -e "${YELLOW}║   ARIA Cockpit — Android Build        ║${NC}"
+echo -e "${YELLOW}║   Modus: ${MODE}$(printf '%*s' $((27 - ${#MODE})) '')║${NC}"
+echo -e "${YELLOW}╚═══════════════════════════════════════╝${NC}"
+
+# ── Voraussetzungen prüfen ────────────────────
+MISSING=0
+
+check_cmd() {
+    if ! command -v "$1" &> /dev/null; then
+        echo -e "  ${RED}✗ $1 nicht gefunden${NC}"
+        MISSING=1
+    else
+        echo -e "  ${GREEN}✓${NC} $1 — $(command -v "$1")"
+    fi
+}
+
+echo ""
+echo -e "${CYAN}Voraussetzungen prüfen...${NC}"
+check_cmd node
+check_cmd npm
+check_cmd npx
+check_cmd java
+
+if [ "$MISSING" -eq 1 ]; then
+    echo ""
+    echo -e "${RED}Fehlende Abhängigkeiten! Bitte zuerst ausführen:${NC}"
+    echo -e "${RED}  ./setup.sh${NC}"
+    exit 1
+fi
+
+# ── JDK 17 erzwingen (AGP 8.1 + Gradle 8.3 braucht JDK 17, nicht 21+) ──
+echo ""
+echo -e "${CYAN}Java-Version prüfen...${NC}"
+
+CURRENT_JAVA_MAJOR=$(java -version 2>&1 | head -1 | cut -d'"' -f2 | cut -d'.' -f1)
+
+if [ "$CURRENT_JAVA_MAJOR" -gt 17 ] 2>/dev/null; then
+    echo -e "  ${YELLOW}JDK $CURRENT_JAVA_MAJOR erkannt — React Native 0.73 braucht JDK 17${NC}"
+    echo -e "  ${YELLOW}Suche JDK 17...${NC}"
+
+    JDK17_FOUND=""
+    for JDK_PATH in \
+        /usr/lib/jvm/java-17-openjdk-amd64 \
+        /usr/lib/jvm/temurin-17-jdk-amd64 \
+        /usr/lib/jvm/java-17-openjdk \
+        /usr/lib/jvm/jdk-17 \
+        /usr/lib/jvm/zulu-17 \
+        /opt/java/jdk-17 \
+        /Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home \
+        /Library/Java/JavaVirtualMachines/openjdk-17.jdk/Contents/Home; do
+        if [ -x "$JDK_PATH/bin/java" ]; then
+            JDK17_FOUND="$JDK_PATH"
+            break
+        fi
+    done
+
+    if [ -n "$JDK17_FOUND" ] && [ -x "$JDK17_FOUND/bin/jlink" ]; then
+        export JAVA_HOME="$JDK17_FOUND"
+        export PATH="$JAVA_HOME/bin:$PATH"
+        # Gradle muss den Pfad auch kennen (verhindert dass es kaputte JVM-Verzeichnisse findet)
+        GRADLE_PROPS="android/gradle.properties"
+        if [ -f "$GRADLE_PROPS" ]; then
+            if grep -q "^org.gradle.java.home=" "$GRADLE_PROPS" 2>/dev/null; then
+                sed -i "s|^org.gradle.java.home=.*|org.gradle.java.home=$JDK17_FOUND|" "$GRADLE_PROPS"
+            else
+                echo "" >> "$GRADLE_PROPS"
+                echo "# ARIA: JDK 17 Pfad (gesetzt von build.sh)" >> "$GRADLE_PROPS"
+                echo "org.gradle.java.home=$JDK17_FOUND" >> "$GRADLE_PROPS"
+            fi
+        fi
+        echo -e "  ${GREEN}✓${NC} JAVA_HOME → $JDK17_FOUND"
+    elif [ -n "$JDK17_FOUND" ]; then
+        echo -e "  ${RED}JDK 17 gefunden aber unvollständig (jlink fehlt — nur JRE installiert)${NC}"
+        echo -e "  ${RED}Installieren: sudo apt install openjdk-17-jdk${NC}"
+        exit 1
+    else
+        echo -e "  ${RED}JDK 17 nicht gefunden!${NC}"
+        echo -e "  ${RED}Installieren: sudo apt install openjdk-17-jdk${NC}"
+        echo -e "  ${RED}Oder: ./setup.sh${NC}"
+        exit 1
+    fi
+else
+    echo -e "  ${GREEN}✓${NC} JDK $CURRENT_JAVA_MAJOR — passt"
+fi
+
+# ── Natives Android-Projekt prüfen ───────────
+if [ ! -f "android/gradlew" ]; then
+    echo ""
+    echo -e "${RED}Kein natives Android-Projekt gefunden (android/gradlew fehlt).${NC}"
+    echo -e "${RED}Bitte zuerst ausführen:${NC}"
+    echo -e "${RED}  ./setup.sh${NC}"
+    exit 1
+fi
+
+# ── ANDROID_HOME prüfen / automatisch finden ─
+if [ -z "$ANDROID_HOME" ] && [ -z "$ANDROID_SDK_ROOT" ]; then
+    for SDK_PATH in \
+        "$HOME/Android/Sdk" \
+        "$HOME/android-sdk" \
+        "/opt/android-sdk" \
+        "$HOME/Library/Android/sdk"; do
+        if [ -d "$SDK_PATH" ]; then
+            export ANDROID_HOME="$SDK_PATH"
+            export ANDROID_SDK_ROOT="$SDK_PATH"
+            echo -e "  ${YELLOW}ANDROID_HOME automatisch gefunden: ${SDK_PATH}${NC}"
+            break
+        fi
+    done
+
+    if [ -z "$ANDROID_HOME" ]; then
+        echo -e "  ${YELLOW}Warnung: ANDROID_HOME nicht gesetzt.${NC}"
+        echo -e "  ${YELLOW}Falls der Build fehlschlägt: ./setup.sh ausführen${NC}"
+    fi
+fi
+
+# ── Node Dependencies ────────────────────────
+echo ""
+echo -e "${GREEN}[1/3] Node Dependencies...${NC}"
+if [ ! -d "node_modules" ]; then
+    npm install
+elif [ "package.json" -nt "node_modules" ]; then
+    echo "      package.json geändert — update..."
+    npm install
+else
+    echo "      node_modules aktuell"
+fi
+
+# ── File-Descriptor-Limit erhöhen (Metro braucht viele offene Dateien) ──
+CURRENT_ULIMIT=$(ulimit -n)
+if [ "$CURRENT_ULIMIT" -lt 8192 ] 2>/dev/null; then
+    ulimit -n 8192 2>/dev/null || ulimit -n 4096 2>/dev/null || true
+    NEW_ULIMIT=$(ulimit -n)
+    if [ "$NEW_ULIMIT" -gt "$CURRENT_ULIMIT" ]; then
+        echo -e "  ${YELLOW}ulimit -n: ${CURRENT_ULIMIT} → ${NEW_ULIMIT} (Metro braucht viele offene Dateien)${NC}"
+    fi
+fi
+
+# ── APK bauen ─────────────────────────────────
+echo ""
+echo -e "${GREEN}[2/3] APK bauen (${MODE})...${NC}"
+
+cd android
+chmod +x gradlew 2>/dev/null || true
+
+# CI=true verhindert dass Metro einen File-Watcher startet (EMFILE-Fix)
+export CI=true
+
+if [ "$MODE" = "debug" ]; then
+    ./gradlew assembleDebug
+    OUT_DIR="app/build/outputs/apk/debug"
+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
+fi
+
+cd ..
+
+# ── Ergebnis ──────────────────────────────────
+echo ""
+if [ -f "android/$APK_PATH" ]; then
+    APK_SIZE=$(du -h "android/$APK_PATH" | cut -f1)
+    NICE_NAME="ARIA-Cockpit-${MODE}.apk"
+    cp "android/$APK_PATH" "$NICE_NAME"
+
+    echo -e "${GREEN}[3/3] Fertig!${NC}"
+    echo ""
+    echo -e "${GREEN}╔═══════════════════════════════════════════════╗${NC}"
+    echo -e "${GREEN}║   APK erfolgreich gebaut!                     ║${NC}"
+    echo -e "${GREEN}╠═══════════════════════════════════════════════╣${NC}"
+    echo -e "${GREEN}║${NC}   Datei:  ${NICE_NAME}"
+    echo -e "${GREEN}║${NC}   Größe:  ${APK_SIZE}"
+    echo -e "${GREEN}║${NC}   Pfad:   android/${APK_PATH}"
+    echo -e "${GREEN}╚═══════════════════════════════════════════════╝${NC}"
+    echo ""
+    echo "Installieren:"
+    echo "  adb install $NICE_NAME"
+    echo ""
+    echo "Oder APK direkt aufs Handy kopieren."
+else
+    echo -e "${RED}╔═══════════════════════════════════════════════╗${NC}"
+    echo -e "${RED}║   Build fehlgeschlagen!                       ║${NC}"
+    echo -e "${RED}╠═══════════════════════════════════════════════╣${NC}"
+    echo -e "${RED}║${NC}   APK nicht gefunden."
+    echo -e "${RED}║${NC}   Prüfe die Gradle-Ausgabe oben."
+    echo -e "${RED}║${NC}"
+    echo -e "${RED}║${NC}   Häufige Ursachen:"
+    echo -e "${RED}║${NC}   - Android SDK fehlt    → ./setup.sh"
+    echo -e "${RED}║${NC}   - JDK 17 fehlt         → ./setup.sh"
+    echo -e "${RED}║${NC}   - Signing Config fehlt  (Release-Build)"
+    echo -e "${RED}╚═══════════════════════════════════════════════╝${NC}"
+    exit 1
+fi

android/index.js

@@ -0,0 +1,5 @@
+import { AppRegistry } from 'react-native';
+import App from './App';
+import { name as appName } from './app.json';
+
+AppRegistry.registerComponent(appName, () => App);

android/metro.config.js

@@ -0,0 +1,9 @@
+const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+
+/**
+ * Metro configuration
+ * https://reactnative.dev/docs/metro
+ */
+const config = {};
+
+module.exports = mergeConfig(getDefaultConfig(__dirname), config);

android/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "aria-cockpit",
+  "version": "0.1.2.7",
+  "private": true,
+  "scripts": {
+    "android": "react-native run-android",
+    "start": "react-native start",
+    "test": "jest",
+    "lint": "eslint . --ext .ts,.tsx",
+    "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-native-document-picker": "^9.1.1",
+    "react-native-fs": "^2.20.0",
+    "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"
+  },
+  "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",
+    "@types/react": "^18.2.48",
+    "@types/react-native": "^0.73.0",
+    "jest": "^29.7.0",
+    "metro-react-native-babel-preset": "^0.77.0",
+    "typescript": "^5.3.3"
+  }
+}

android/setup.sh

@@ -0,0 +1,425 @@
+#!/bin/bash
+# ════════════════════════════════════════════════
+#  ARIA Cockpit — Android Dev Setup
+#  Installiert alle Abhängigkeiten für den Build
+#  und generiert das native Android-Projekt.
+#  Verwendung: ./setup.sh
+# ════════════════════════════════════════════════
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# ── Farben ────────────────────────────────────
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+echo -e "${CYAN}╔═══════════════════════════════════════╗${NC}"
+echo -e "${CYAN}║   ARIA Cockpit — Dev Setup            ║${NC}"
+echo -e "${CYAN}╚═══════════════════════════════════════╝${NC}"
+echo ""
+
+# ── Betriebssystem erkennen ───────────────────
+OS="unknown"
+PKG_INSTALL=""
+
+if [ -f /etc/debian_version ]; then
+    OS="debian"
+    PKG_INSTALL="sudo apt install -y"
+elif [ -f /etc/fedora-release ]; then
+    OS="fedora"
+    PKG_INSTALL="sudo dnf install -y"
+elif [ -f /etc/arch-release ]; then
+    OS="arch"
+    PKG_INSTALL="sudo pacman -S --noconfirm"
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+    OS="macos"
+    PKG_INSTALL="brew install"
+fi
+
+echo -e "${CYAN}System: ${OS}${NC}"
+echo ""
+
+# ── Hilfsfunktionen ──────────────────────────
+installed() {
+    command -v "$1" &> /dev/null
+}
+
+step() {
+    echo ""
+    echo -e "${GREEN}══════════════════════════════════════${NC}"
+    echo -e "${GREEN}  $1${NC}"
+    echo -e "${GREEN}══════════════════════════════════════${NC}"
+}
+
+skip() {
+    echo -e "  ${GREEN}✓${NC} $1 bereits vorhanden"
+}
+
+install_pkg() {
+    if [ -z "$PKG_INSTALL" ]; then
+        echo -e "${RED}  Kann $1 nicht automatisch installieren (unbekanntes OS).${NC}"
+        echo -e "${RED}  Bitte manuell installieren: $1${NC}"
+        return 1
+    fi
+    $PKG_INSTALL "$@"
+}
+
+# ══════════════════════════════════════════════
+#  1. Basis-Tools (curl, unzip, git)
+# ══════════════════════════════════════════════
+step "1/7 — Basis-Tools prüfen"
+
+NEED_TOOLS=()
+for TOOL in curl unzip git; do
+    if ! installed "$TOOL"; then
+        NEED_TOOLS+=("$TOOL")
+    else
+        skip "$TOOL"
+    fi
+done
+
+if [ ${#NEED_TOOLS[@]} -gt 0 ]; then
+    echo "  Installiere: ${NEED_TOOLS[*]}"
+    install_pkg "${NEED_TOOLS[@]}"
+fi
+
+# ══════════════════════════════════════════════
+#  2. Node.js
+# ══════════════════════════════════════════════
+step "2/7 — Node.js prüfen"
+
+if installed node; then
+    NODE_VERSION=$(node -v)
+    NODE_MAJOR=$(echo "$NODE_VERSION" | sed 's/v//' | cut -d. -f1)
+    if [ "$NODE_MAJOR" -ge 18 ]; then
+        skip "Node.js $NODE_VERSION"
+    else
+        echo -e "${YELLOW}  Node.js $NODE_VERSION ist zu alt (mindestens v18 nötig)${NC}"
+        echo -e "${YELLOW}  Bitte Node.js updaten: https://nodejs.org/${NC}"
+        exit 1
+    fi
+else
+    echo "  Node.js nicht gefunden — installiere..."
+    case "$OS" in
+        debian)
+            curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
+            sudo apt install -y nodejs
+            ;;
+        fedora)
+            curl -fsSL https://rpm.nodesource.com/setup_22.x | sudo bash -
+            sudo dnf install -y nodejs
+            ;;
+        arch)   install_pkg nodejs npm ;;
+        macos)  install_pkg node ;;
+        *)
+            echo -e "${RED}  Bitte Node.js manuell installieren: https://nodejs.org/${NC}"
+            exit 1
+            ;;
+    esac
+    echo -e "  ${GREEN}✓${NC} Node.js $(node -v) installiert"
+fi
+
+# ══════════════════════════════════════════════
+#  3. JDK 17
+# ══════════════════════════════════════════════
+step "3/7 — Java JDK 17 prüfen"
+
+# JDK 17 wird EXAKT benötigt — nicht 21, nicht 22.
+# Android Gradle Plugin 8.1 + Gradle 8.3 haben Probleme mit JDK 21+ (jlink-Bug).
+NEED_JDK=false
+JDK17_HOME=""
+
+# Prüfe ob JDK 17 bereits installiert ist (auch wenn JDK 21 der Default ist)
+for JDK_PATH in \
+    /usr/lib/jvm/java-17-openjdk-amd64 \
+    /usr/lib/jvm/temurin-17-jdk-amd64 \
+    /usr/lib/jvm/java-17-openjdk \
+    /usr/lib/jvm/jdk-17 \
+    /usr/lib/jvm/zulu-17 \
+    /Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home \
+    /Library/Java/JavaVirtualMachines/openjdk-17.jdk/Contents/Home; do
+    if [ -x "$JDK_PATH/bin/java" ]; then
+        JDK17_HOME="$JDK_PATH"
+        break
+    fi
+done
+
+# Prüfe ob es wirklich der volle JDK ist (nicht nur JRE) — jlink muss existieren
+if [ -n "$JDK17_HOME" ] && [ ! -x "$JDK17_HOME/bin/jlink" ]; then
+    echo -e "  ${YELLOW}JDK 17 gefunden in $JDK17_HOME, aber nur JRE (jlink fehlt)${NC}"
+    echo -e "  ${YELLOW}Installiere vollen JDK 17...${NC}"
+    JDK17_HOME=""
+fi
+
+if [ -n "$JDK17_HOME" ]; then
+    skip "JDK 17 (vollständig) in $JDK17_HOME"
+else
+    echo "  JDK 17 nicht gefunden — installiere..."
+    NEED_JDK=true
+    case "$OS" in
+        debian) install_pkg openjdk-17-jdk ;;
+        fedora) install_pkg java-17-openjdk-devel ;;
+        arch)   install_pkg jdk17-openjdk ;;
+        macos)  install_pkg openjdk@17 ;;
+        *)
+            echo -e "${RED}  Bitte JDK 17 manuell installieren${NC}"
+            exit 1
+            ;;
+    esac
+    # Nochmal suchen nach Installation
+    for JDK_PATH in \
+        /usr/lib/jvm/java-17-openjdk-amd64 \
+        /usr/lib/jvm/temurin-17-jdk-amd64 \
+        /usr/lib/jvm/java-17-openjdk; do
+        if [ -x "$JDK_PATH/bin/java" ]; then
+            JDK17_HOME="$JDK_PATH"
+            break
+        fi
+    done
+    echo -e "  ${GREEN}✓${NC} JDK 17 installiert"
+fi
+
+# Hinweis falls JDK 21+ der Default ist
+if installed java; then
+    CURRENT_JAVA=$(java -version 2>&1 | head -1 | cut -d'"' -f2 | cut -d'.' -f1)
+    if [ "$CURRENT_JAVA" -gt 17 ] 2>/dev/null && [ -n "$JDK17_HOME" ]; then
+        echo -e "  ${YELLOW}Hinweis: Standard-Java ist JDK $CURRENT_JAVA, aber Build nutzt JDK 17${NC}"
+        echo -e "  ${YELLOW}build.sh setzt JAVA_HOME automatisch auf $JDK17_HOME${NC}"
+    fi
+fi
+
+# ══════════════════════════════════════════════
+#  4. Android SDK (Command Line Tools)
+# ══════════════════════════════════════════════
+step "4/7 — Android SDK prüfen"
+
+ANDROID_SDK_DIR="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-$HOME/Android/Sdk}}"
+
+if [ -d "$ANDROID_SDK_DIR/platforms" ] && [ -d "$ANDROID_SDK_DIR/build-tools" ]; then
+    skip "Android SDK in $ANDROID_SDK_DIR"
+else
+    echo "  Android SDK nicht gefunden — installiere..."
+    echo ""
+
+    mkdir -p "$ANDROID_SDK_DIR"
+
+    # Command Line Tools herunterladen
+    CMDLINE_TOOLS_URL="https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip"
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        CMDLINE_TOOLS_URL="https://dl.google.com/android/repository/commandlinetools-mac-11076708_latest.zip"
+    fi
+
+    echo "  Lade Command Line Tools herunter..."
+    TEMP_ZIP="/tmp/android-cmdline-tools.zip"
+    curl -L -o "$TEMP_ZIP" "$CMDLINE_TOOLS_URL"
+
+    echo "  Entpacke..."
+    mkdir -p "$ANDROID_SDK_DIR/cmdline-tools"
+    unzip -q -o "$TEMP_ZIP" -d "$ANDROID_SDK_DIR/cmdline-tools"
+    mv "$ANDROID_SDK_DIR/cmdline-tools/cmdline-tools" "$ANDROID_SDK_DIR/cmdline-tools/latest" 2>/dev/null || true
+    rm -f "$TEMP_ZIP"
+
+    SDKMANAGER="$ANDROID_SDK_DIR/cmdline-tools/latest/bin/sdkmanager"
+
+    echo "  Akzeptiere Lizenzen..."
+    yes | "$SDKMANAGER" --licenses > /dev/null 2>&1 || true
+
+    echo "  Installiere SDK Komponenten (dauert ein paar Minuten)..."
+    "$SDKMANAGER" \
+        "platforms;android-34" \
+        "build-tools;34.0.0" \
+        "platform-tools"
+
+    echo -e "  ${GREEN}✓${NC} Android SDK installiert in $ANDROID_SDK_DIR"
+fi
+
+# ── ANDROID_HOME in Shell-Profil setzen ──────
+export ANDROID_HOME="$ANDROID_SDK_DIR"
+export ANDROID_SDK_ROOT="$ANDROID_SDK_DIR"
+export PATH="$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/latest/bin:$PATH"
+
+SHELL_PROFILE=""
+if [ -f "$HOME/.bashrc" ]; then
+    SHELL_PROFILE="$HOME/.bashrc"
+elif [ -f "$HOME/.zshrc" ]; then
+    SHELL_PROFILE="$HOME/.zshrc"
+fi
+
+if [ -n "$SHELL_PROFILE" ]; then
+    if ! grep -q "ANDROID_HOME" "$SHELL_PROFILE" 2>/dev/null; then
+        echo "" >> "$SHELL_PROFILE"
+        echo "# Android SDK (ARIA Setup)" >> "$SHELL_PROFILE"
+        echo "export ANDROID_HOME=\"$ANDROID_SDK_DIR\"" >> "$SHELL_PROFILE"
+        echo "export ANDROID_SDK_ROOT=\"\$ANDROID_HOME\"" >> "$SHELL_PROFILE"
+        echo 'export PATH="$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/latest/bin:$PATH"' >> "$SHELL_PROFILE"
+        echo -e "  ${CYAN}→ ANDROID_HOME in $SHELL_PROFILE eingetragen${NC}"
+    fi
+fi
+
+# ══════════════════════════════════════════════
+#  5. Node Dependencies
+# ══════════════════════════════════════════════
+step "5/7 — Node Dependencies & Metro-Config"
+
+# Metro-Config-Dateien prüfen/erstellen (nötig für JS-Bundle im Release-Build)
+if [ ! -f "metro.config.js" ]; then
+    echo "  Erstelle metro.config.js..."
+    cat > metro.config.js << 'METROEOF'
+const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+
+/**
+ * Metro configuration
+ * https://reactnative.dev/docs/metro
+ */
+const config = {};
+
+module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+METROEOF
+    echo -e "  ${GREEN}✓${NC} metro.config.js erstellt"
+else
+    skip "metro.config.js"
+fi
+
+if [ ! -f "babel.config.js" ]; then
+    echo "  Erstelle babel.config.js..."
+    cat > babel.config.js << 'BABELEOF'
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+};
+BABELEOF
+    echo -e "  ${GREEN}✓${NC} babel.config.js erstellt"
+else
+    skip "babel.config.js"
+fi
+
+if [ ! -f ".watchmanconfig" ]; then
+    echo "  Erstelle .watchmanconfig..."
+    echo '{}' > .watchmanconfig
+    echo -e "  ${GREEN}✓${NC} .watchmanconfig erstellt"
+else
+    skip ".watchmanconfig"
+fi
+
+# Alte node_modules aufräumen falls vorhanden (verhindert veraltete/korrupte Pakete)
+if [ -d "node_modules" ]; then
+    echo "  Räume alte node_modules auf..."
+    rm -rf node_modules
+fi
+
+npm install
+
+# ══════════════════════════════════════════════
+#  6. React Native — natives Android-Projekt
+# ══════════════════════════════════════════════
+step "6/7 — React Native Android-Projekt generieren"
+
+if [ -f "android/gradlew" ]; then
+    skip "Natives Android-Projekt (android/gradlew)"
+else
+    echo "  Generiere natives Android-Projekt..."
+    echo "  (React Native init in Temp-Verzeichnis → kopiere android/ Ordner)"
+    echo ""
+
+    TEMP_DIR="/tmp/aria-rn-init-$$"
+    rm -rf "$TEMP_DIR"
+
+    # React Native Projekt in Temp-Verzeichnis erstellen
+    npx --yes @react-native-community/cli@latest init AriaCockpit \
+        --directory "$TEMP_DIR" \
+        --skip-git-init \
+        --install-pods false \
+        --version 0.73.4 \
+        2>&1 | while IFS= read -r line; do echo "    $line"; done
+
+    if [ -d "$TEMP_DIR/android" ]; then
+        # Natives Android-Verzeichnis kopieren
+        cp -r "$TEMP_DIR/android" ./android/
+
+        # App-Name in strings.xml anpassen
+        if [ -f "android/app/src/main/res/values/strings.xml" ]; then
+            sed -i 's/AriaCockpit/ARIA/g' "android/app/src/main/res/values/strings.xml"
+        fi
+
+        # Gradle Wrapper ausführbar machen
+        chmod +x android/gradlew 2>/dev/null || true
+
+        echo -e "  ${GREEN}✓${NC} Natives Android-Projekt erstellt in android/android/"
+    else
+        echo -e "${RED}  Fehler: React Native Init hat kein android/ Verzeichnis erzeugt.${NC}"
+        echo -e "${RED}  Temp-Verzeichnis zur Inspektion: $TEMP_DIR${NC}"
+        echo ""
+        echo -e "${YELLOW}  Manueller Fallback:${NC}"
+        echo -e "${YELLOW}    cd /tmp${NC}"
+        echo -e "${YELLOW}    npx @react-native-community/cli@latest init AriaCockpit${NC}"
+        echo -e "${YELLOW}    cp -r /tmp/AriaCockpit/android $SCRIPT_DIR/android/${NC}"
+        exit 1
+    fi
+
+    # Temp aufräumen
+    rm -rf "$TEMP_DIR"
+fi
+
+# ══════════════════════════════════════════════
+#  7. Gradle konfigurieren & Cache aufräumen
+# ══════════════════════════════════════════════
+step "7/7 — Gradle konfigurieren & Cache aufräumen"
+
+# gradle.properties: compileSdk-Warnung unterdrücken
+if [ -f "android/gradle.properties" ]; then
+    if ! grep -q "android.suppressUnsupportedCompileSdk" "android/gradle.properties" 2>/dev/null; then
+        echo "" >> "android/gradle.properties"
+        echo "# ARIA: compileSdk-Warnung unterdrücken (AGP 8.1 vs SDK 35)" >> "android/gradle.properties"
+        echo "android.suppressUnsupportedCompileSdk=35" >> "android/gradle.properties"
+        echo -e "  ${GREEN}✓${NC} gradle.properties: suppressUnsupportedCompileSdk=35"
+    else
+        skip "gradle.properties bereits konfiguriert"
+    fi
+fi
+
+# Gradle Build-Cache aufräumen (verhindert Probleme nach Dependency-Wechsel)
+if [ -d "android/.gradle" ]; then
+    echo "  Räume Gradle Build-Cache auf..."
+    rm -rf android/.gradle
+    echo -e "  ${GREEN}✓${NC} Gradle-Cache gelöscht"
+fi
+
+if [ -d "android/app/build" ]; then
+    echo "  Räume alten Build auf..."
+    rm -rf android/app/build
+    echo -e "  ${GREEN}✓${NC} Alter Build gelöscht"
+fi
+
+# ══════════════════════════════════════════════
+#  Zusammenfassung
+# ══════════════════════════════════════════════
+echo ""
+echo -e "${GREEN}╔═══════════════════════════════════════════════════╗${NC}"
+echo -e "${GREEN}║   Setup abgeschlossen!                            ║${NC}"
+echo -e "${GREEN}╠═══════════════════════════════════════════════════╣${NC}"
+
+NODE_V=$(node -v 2>/dev/null || echo "?")
+JAVA_V=$(java -version 2>&1 | head -1 | cut -d'"' -f2 || echo "?")
+
+echo -e "${GREEN}║                                                   ║${NC}"
+echo -e "${GREEN}║   Node.js:      ${NC}${NODE_V}"
+echo -e "${GREEN}║   Java:         ${NC}${JAVA_V}"
+echo -e "${GREEN}║   Android SDK:  ${NC}${ANDROID_SDK_DIR}"
+echo -e "${GREEN}║   Gradle:       ${NC}$([ -f android/gradlew ] && echo '✓ vorhanden' || echo '✗ fehlt')"
+echo -e "${GREEN}║                                                   ║${NC}"
+echo -e "${GREEN}║   Nächster Schritt:                               ║${NC}"
+echo -e "${GREEN}║   ${NC}./build.sh          ${GREEN}(Release-APK bauen)${NC}"
+echo -e "${GREEN}║   ${NC}./build.sh debug    ${GREEN}(Debug-APK bauen)${NC}"
+echo -e "${GREEN}║                                                   ║${NC}"
+echo -e "${GREEN}╚═══════════════════════════════════════════════════╝${NC}"
+echo ""
+
+if [ -n "$SHELL_PROFILE" ] && grep -q "ANDROID_HOME" "$SHELL_PROFILE" 2>/dev/null; then
+    echo -e "${YELLOW}Hinweis: Shell neu starten oder ausführen:${NC}"
+    echo -e "${YELLOW}  source $SHELL_PROFILE${NC}"
+    echo ""
+fi

android/src/components/CameraUpload.tsx

@@ -0,0 +1,262 @@
+/**
+ * CameraUpload - Kamera-Foto oder Galerie-Auswahl
+ *
+ * Ermoeglicht das Aufnehmen eines Fotos mit der Geraetekamera
+ * oder die Auswahl aus der Galerie, mit Vorschau vor dem Senden.
+ */
+
+import React, { useState } from 'react';
+import {
+  View,
+  Text,
+  TouchableOpacity,
+  Image,
+  StyleSheet,
+  ActivityIndicator,
+  Platform,
+  PermissionsAndroid,
+} from 'react-native';
+import { launchCamera, launchImageLibrary, ImagePickerResponse } from 'react-native-image-picker';
+
+// --- Typen ---
+
+export interface PhotoData {
+  base64: string;
+  width: number;
+  height: number;
+  fileName: string;
+  type: string;
+  uri: string;
+}
+
+interface CameraUploadProps {
+  onPhotoSelected: (photo: PhotoData) => void;
+  onCancel: () => void;
+}
+
+// Komprimierungsoptionen
+const IMAGE_OPTIONS = {
+  mediaType: 'photo' as const,
+  maxWidth: 1920,
+  maxHeight: 1920,
+  quality: 0.8 as const,
+  includeBase64: true,
+};
+
+// --- Komponente ---
+
+const CameraUpload: React.FC<CameraUploadProps> = ({ onPhotoSelected, onCancel }) => {
+  const [preview, setPreview] = useState<ImagePickerResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  /** Kamera-Berechtigung pruefen (Android) */
+  const requestCameraPermission = async (): Promise<boolean> => {
+    if (Platform.OS !== 'android') return true;
+
+    try {
+      const granted = await PermissionsAndroid.request(
+        PermissionsAndroid.PERMISSIONS.CAMERA,
+        {
+          title: 'ARIA Cockpit - Kamera',
+          message: 'ARIA ben\u00F6tigt Zugriff auf die Kamera.',
+          buttonPositive: 'Erlauben',
+          buttonNegative: 'Ablehnen',
+        },
+      );
+      return granted === PermissionsAndroid.RESULTS.GRANTED;
+    } catch {
+      return false;
+    }
+  };
+
+  /** Foto mit Kamera aufnehmen */
+  const takePhoto = async () => {
+    const hasPermission = await requestCameraPermission();
+    if (!hasPermission) return;
+
+    launchCamera(IMAGE_OPTIONS, (response) => {
+      if (response.didCancel) {
+        // Benutzer hat abgebrochen
+        return;
+      }
+      if (response.errorCode) {
+        console.error('[CameraUpload] Kamera-Fehler:', response.errorMessage);
+        return;
+      }
+      setPreview(response);
+    });
+  };
+
+  /** Foto aus Galerie auswaehlen */
+  const pickFromGallery = async () => {
+    launchImageLibrary(IMAGE_OPTIONS, (response) => {
+      if (response.didCancel) return;
+      if (response.errorCode) {
+        console.error('[CameraUpload] Galerie-Fehler:', response.errorMessage);
+        return;
+      }
+      setPreview(response);
+    });
+  };
+
+  /** Ausgewaehltes Foto senden */
+  const sendPhoto = () => {
+    const asset = preview?.assets?.[0];
+    if (!asset) return;
+
+    setLoading(true);
+
+    const photoData: PhotoData = {
+      base64: asset.base64 || '',
+      width: asset.width || 0,
+      height: asset.height || 0,
+      fileName: asset.fileName || `foto_${Date.now()}.jpg`,
+      type: asset.type || 'image/jpeg',
+      uri: asset.uri || '',
+    };
+
+    onPhotoSelected(photoData);
+    setLoading(false);
+  };
+
+  const previewUri = preview?.assets?.[0]?.uri;
+
+  return (
+    <View style={styles.container}>
+      {!preview ? (
+        // Auswahl: Kamera oder Galerie
+        <View style={styles.optionsContainer}>
+          <TouchableOpacity
+            style={styles.optionButton}
+            onPress={takePhoto}
+            activeOpacity={0.7}
+          >
+            <Text style={styles.optionIcon}>{'\uD83D\uDCF7'}</Text>
+            <Text style={styles.optionText}>Foto aufnehmen</Text>
+          </TouchableOpacity>
+
+          <TouchableOpacity
+            style={styles.optionButton}
+            onPress={pickFromGallery}
+            activeOpacity={0.7}
+          >
+            <Text style={styles.optionIcon}>{'\uD83D\uDDBC\uFE0F'}</Text>
+            <Text style={styles.optionText}>Aus Galerie</Text>
+          </TouchableOpacity>
+
+          <TouchableOpacity style={styles.cancelLink} onPress={onCancel}>
+            <Text style={styles.cancelLinkText}>Abbrechen</Text>
+          </TouchableOpacity>
+        </View>
+      ) : (
+        // Vorschau
+        <View style={styles.previewContainer}>
+          {previewUri && (
+            <Image source={{ uri: previewUri }} style={styles.imagePreview} />
+          )}
+
+          <View style={styles.buttonRow}>
+            <TouchableOpacity
+              style={styles.retakeButton}
+              onPress={() => setPreview(null)}
+            >
+              <Text style={styles.retakeText}>Neu</Text>
+            </TouchableOpacity>
+
+            <TouchableOpacity
+              style={styles.sendButton}
+              onPress={sendPhoto}
+              disabled={loading}
+            >
+              {loading ? (
+                <ActivityIndicator color="#FFFFFF" size="small" />
+              ) : (
+                <Text style={styles.sendText}>Senden</Text>
+              )}
+            </TouchableOpacity>
+          </View>
+        </View>
+      )}
+    </View>
+  );
+};
+
+// --- Styles ---
+
+const styles = StyleSheet.create({
+  container: {
+    backgroundColor: '#1A1A2E',
+    borderRadius: 16,
+    padding: 20,
+    margin: 12,
+  },
+  optionsContainer: {
+    alignItems: 'center',
+    gap: 12,
+  },
+  optionButton: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#2A2A3E',
+    borderRadius: 12,
+    padding: 16,
+    width: '100%',
+  },
+  optionIcon: {
+    fontSize: 28,
+    marginRight: 14,
+  },
+  optionText: {
+    color: '#FFFFFF',
+    fontSize: 16,
+    fontWeight: '500',
+  },
+  cancelLink: {
+    marginTop: 8,
+    padding: 8,
+  },
+  cancelLinkText: {
+    color: '#666680',
+    fontSize: 14,
+  },
+  previewContainer: {
+    alignItems: 'center',
+  },
+  imagePreview: {
+    width: '100%',
+    height: 280,
+    borderRadius: 12,
+    resizeMode: 'contain',
+    marginBottom: 16,
+  },
+  buttonRow: {
+    flexDirection: 'row',
+    gap: 12,
+  },
+  retakeButton: {
+    paddingHorizontal: 24,
+    paddingVertical: 12,
+    borderRadius: 8,
+    backgroundColor: '#2A2A3E',
+  },
+  retakeText: {
+    color: '#8888AA',
+    fontSize: 14,
+    fontWeight: '600',
+  },
+  sendButton: {
+    paddingHorizontal: 32,
+    paddingVertical: 12,
+    borderRadius: 8,
+    backgroundColor: '#0096FF',
+    minWidth: 100,
+    alignItems: 'center',
+  },
+  sendText: {
+    color: '#FFFFFF',
+    fontSize: 14,
+    fontWeight: '700',
+  },
+});
+
+export default CameraUpload;

android/src/components/FileUpload.tsx

@@ -0,0 +1,261 @@
+/**
+ * FileUpload - Datei-Auswahl und -Versand
+ *
+ * Oeffnet den Dateimanager des Geraets, zeigt eine Vorschau
+ * und konvertiert die Datei zu Base64 fuer die Uebertragung.
+ */
+
+import React, { useState } from 'react';
+import {
+  View,
+  Text,
+  TouchableOpacity,
+  Image,
+  StyleSheet,
+  ActivityIndicator,
+} from 'react-native';
+import DocumentPicker, {
+  DocumentPickerResponse,
+} from 'react-native-document-picker';
+import RNFS from 'react-native-fs';
+
+// --- Typen ---
+
+export interface FileData {
+  name: string;
+  type: string;
+  size: number;
+  base64: string;
+  uri: string;
+}
+
+interface FileUploadProps {
+  onFileSelected: (file: FileData) => void;
+  onCancel: () => void;
+}
+
+// Unterstuetzte Dateitypen
+const SUPPORTED_TYPES = [
+  DocumentPicker.types.images,
+  DocumentPicker.types.pdf,
+  DocumentPicker.types.docx,
+  DocumentPicker.types.plainText,
+];
+
+// --- Komponente ---
+
+const FileUpload: React.FC<FileUploadProps> = ({ onFileSelected, onCancel }) => {
+  const [selectedFile, setSelectedFile] = useState<DocumentPickerResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const pickFile = async () => {
+    setError(null);
+    try {
+      const result = await DocumentPicker.pick({
+        type: SUPPORTED_TYPES,
+        copyTo: 'cachesDirectory',
+      });
+
+      if (result.length > 0) {
+        setSelectedFile(result[0]);
+      }
+    } catch (err) {
+      if (DocumentPicker.isCancel(err)) {
+        onCancel();
+      } else {
+        setError('Fehler beim Auswaehlen der Datei');
+        console.error('[FileUpload] Fehler:', err);
+      }
+    }
+  };
+
+  const sendFile = async () => {
+    if (!selectedFile) return;
+
+    setLoading(true);
+    try {
+      // Datei lesen und zu Base64 konvertieren
+      const filePath = selectedFile.fileCopyUri || selectedFile.uri;
+      // URI-Schema entfernen fuer RNFS (file:// → absoluter Pfad)
+      const cleanPath = filePath.replace('file://', '');
+      const base64 = await RNFS.readFile(cleanPath, 'base64');
+
+      const fileData: FileData = {
+        name: selectedFile.name || 'unbenannt',
+        type: selectedFile.type || 'application/octet-stream',
+        size: selectedFile.size || 0,
+        base64,
+        uri: selectedFile.uri,
+      };
+
+      onFileSelected(fileData);
+    } catch (err) {
+      setError('Fehler beim Verarbeiten der Datei');
+      console.error('[FileUpload] Verarbeitungsfehler:', err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const isImage = selectedFile?.type?.startsWith('image/');
+  const fileSizeFormatted = selectedFile?.size
+    ? selectedFile.size > 1024 * 1024
+      ? `${(selectedFile.size / (1024 * 1024)).toFixed(1)} MB`
+      : `${(selectedFile.size / 1024).toFixed(0)} KB`
+    : '';
+
+  return (
+    <View style={styles.container}>
+      {!selectedFile ? (
+        // Datei auswaehlen
+        <TouchableOpacity style={styles.pickButton} onPress={pickFile} activeOpacity={0.7}>
+          <Text style={styles.pickIcon}>{'\uD83D\uDCC1'}</Text>
+          <Text style={styles.pickText}>Datei ausw\u00E4hlen</Text>
+          <Text style={styles.pickHint}>JPG, PNG, PDF, DOCX, TXT</Text>
+        </TouchableOpacity>
+      ) : (
+        // Vorschau und Senden
+        <View style={styles.previewContainer}>
+          {isImage ? (
+            <Image source={{ uri: selectedFile.uri }} style={styles.imagePreview} />
+          ) : (
+            <View style={styles.filePreview}>
+              <Text style={styles.fileIcon}>{'\uD83D\uDCC4'}</Text>
+            </View>
+          )}
+
+          <Text style={styles.fileName} numberOfLines={1}>
+            {selectedFile.name}
+          </Text>
+          <Text style={styles.fileSize}>{fileSizeFormatted}</Text>
+
+          {error && <Text style={styles.errorText}>{error}</Text>}
+
+          <View style={styles.buttonRow}>
+            <TouchableOpacity
+              style={styles.cancelButton}
+              onPress={() => setSelectedFile(null)}
+            >
+              <Text style={styles.cancelButtonText}>Andere Datei</Text>
+            </TouchableOpacity>
+
+            <TouchableOpacity
+              style={styles.sendButton}
+              onPress={sendFile}
+              disabled={loading}
+            >
+              {loading ? (
+                <ActivityIndicator color="#FFFFFF" size="small" />
+              ) : (
+                <Text style={styles.sendButtonText}>Senden</Text>
+              )}
+            </TouchableOpacity>
+          </View>
+        </View>
+      )}
+    </View>
+  );
+};
+
+// --- Styles ---
+
+const styles = StyleSheet.create({
+  container: {
+    backgroundColor: '#1A1A2E',
+    borderRadius: 16,
+    padding: 20,
+    margin: 12,
+  },
+  pickButton: {
+    alignItems: 'center',
+    padding: 30,
+    borderWidth: 2,
+    borderColor: '#2A2A3E',
+    borderStyle: 'dashed',
+    borderRadius: 12,
+  },
+  pickIcon: {
+    fontSize: 40,
+    marginBottom: 10,
+  },
+  pickText: {
+    color: '#FFFFFF',
+    fontSize: 16,
+    fontWeight: '600',
+  },
+  pickHint: {
+    color: '#666680',
+    fontSize: 12,
+    marginTop: 4,
+  },
+  previewContainer: {
+    alignItems: 'center',
+  },
+  imagePreview: {
+    width: 200,
+    height: 200,
+    borderRadius: 12,
+    marginBottom: 12,
+    resizeMode: 'cover',
+  },
+  filePreview: {
+    width: 80,
+    height: 80,
+    borderRadius: 12,
+    backgroundColor: '#2A2A3E',
+    alignItems: 'center',
+    justifyContent: 'center',
+    marginBottom: 12,
+  },
+  fileIcon: {
+    fontSize: 36,
+  },
+  fileName: {
+    color: '#FFFFFF',
+    fontSize: 14,
+    fontWeight: '500',
+    maxWidth: 250,
+  },
+  fileSize: {
+    color: '#666680',
+    fontSize: 12,
+    marginTop: 2,
+  },
+  errorText: {
+    color: '#FF3B30',
+    fontSize: 12,
+    marginTop: 8,
+  },
+  buttonRow: {
+    flexDirection: 'row',
+    marginTop: 16,
+    gap: 12,
+  },
+  cancelButton: {
+    paddingHorizontal: 20,
+    paddingVertical: 10,
+    borderRadius: 8,
+    backgroundColor: '#2A2A3E',
+  },
+  cancelButtonText: {
+    color: '#8888AA',
+    fontSize: 14,
+    fontWeight: '600',
+  },
+  sendButton: {
+    paddingHorizontal: 28,
+    paddingVertical: 10,
+    borderRadius: 8,
+    backgroundColor: '#0096FF',
+    minWidth: 90,
+    alignItems: 'center',
+  },
+  sendButtonText: {
+    color: '#FFFFFF',
+    fontSize: 14,
+    fontWeight: '700',
+  },
+});
+
+export default FileUpload;

android/src/components/MessageText.tsx

@@ -0,0 +1,88 @@
+/**
+ * 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/ModeSelector.tsx

@@ -0,0 +1,245 @@
+/**
+ * ModeSelector - Modus-Auswahl fuer ARIA
+ *
+ * Zeigt den aktuellen Betriebsmodus an und ermoeglicht das Umschalten
+ * ueber ein Modal-Dropdown.
+ */
+
+import React, { useState } from 'react';
+import {
+  View,
+  Text,
+  TouchableOpacity,
+  Modal,
+  FlatList,
+  StyleSheet,
+} from 'react-native';
+import rvs from '../services/rvs';
+
+// --- Typen ---
+
+export interface Mode {
+  id: string;
+  label: string;
+  emoji: string;
+  description: string;
+}
+
+interface ModeSelectorProps {
+  currentModeId: string;
+  onModeChange: (modeId: string) => void;
+}
+
+// --- Verfuegbare Modi ---
+
+export const MODES: Mode[] = [
+  {
+    id: 'normal',
+    label: 'Normal',
+    emoji: '\uD83D\uDFE2',
+    description: 'Standardmodus - ARIA reagiert auf alle Eingaben',
+  },
+  {
+    id: 'nicht_stoeren',
+    label: 'Nicht st\u00F6ren',
+    emoji: '\uD83D\uDD34',
+    description: 'Nur kritische Benachrichtigungen',
+  },
+  {
+    id: 'fluester',
+    label: 'Fl\u00FCster',
+    emoji: '\uD83D\uDFE1',
+    description: 'Leise Antworten, reduzierte Aktivit\u00E4t',
+  },
+  {
+    id: 'hangar',
+    label: 'Hangar',
+    emoji: '\u2708\uFE0F',
+    description: 'Flugmodus - minimale Kommunikation',
+  },
+  {
+    id: 'gaming',
+    label: 'Gaming',
+    emoji: '\uD83C\uDFAE',
+    description: 'Spielmodus - nur dringende Meldungen',
+  },
+];
+
+// --- Komponente ---
+
+const ModeSelector: React.FC<ModeSelectorProps> = ({ currentModeId, onModeChange }) => {
+  const [modalVisible, setModalVisible] = useState(false);
+
+  const currentMode = MODES.find(m => m.id === currentModeId) || MODES[0];
+
+  const handleSelectMode = (mode: Mode) => {
+    setModalVisible(false);
+    onModeChange(mode.id);
+
+    // Moduswechsel an ARIA senden
+    rvs.send('mode', { mode: mode.id });
+  };
+
+  const renderModeItem = ({ item }: { item: Mode }) => {
+    const isActive = item.id === currentModeId;
+    return (
+      <TouchableOpacity
+        style={[styles.modeItem, isActive && styles.modeItemActive]}
+        onPress={() => handleSelectMode(item)}
+        activeOpacity={0.7}
+      >
+        <Text style={styles.modeEmoji}>{item.emoji}</Text>
+        <View style={styles.modeTextContainer}>
+          <Text style={[styles.modeLabel, isActive && styles.modeLabelActive]}>
+            {item.label}
+          </Text>
+          <Text style={styles.modeDescription}>{item.description}</Text>
+        </View>
+        {isActive && <Text style={styles.checkmark}>{'\u2713'}</Text>}
+      </TouchableOpacity>
+    );
+  };
+
+  return (
+    <View>
+      {/* Aktueller Modus - Tappen zum Oeffnen */}
+      <TouchableOpacity
+        style={styles.currentMode}
+        onPress={() => setModalVisible(true)}
+        activeOpacity={0.7}
+      >
+        <Text style={styles.currentEmoji}>{currentMode.emoji}</Text>
+        <Text style={styles.currentLabel}>{currentMode.label}</Text>
+        <Text style={styles.chevron}>{'\u25BC'}</Text>
+      </TouchableOpacity>
+
+      {/* Modus-Auswahl Modal */}
+      <Modal
+        visible={modalVisible}
+        transparent
+        animationType="slide"
+        onRequestClose={() => setModalVisible(false)}
+      >
+        <TouchableOpacity
+          style={styles.modalOverlay}
+          activeOpacity={1}
+          onPress={() => setModalVisible(false)}
+        >
+          <View style={styles.modalContent}>
+            <Text style={styles.modalTitle}>Modus w\u00E4hlen</Text>
+            <FlatList
+              data={MODES}
+              keyExtractor={item => item.id}
+              renderItem={renderModeItem}
+              scrollEnabled={false}
+            />
+            <TouchableOpacity
+              style={styles.cancelButton}
+              onPress={() => setModalVisible(false)}
+            >
+              <Text style={styles.cancelText}>Abbrechen</Text>
+            </TouchableOpacity>
+          </View>
+        </TouchableOpacity>
+      </Modal>
+    </View>
+  );
+};
+
+// --- Styles ---
+
+const styles = StyleSheet.create({
+  currentMode: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#1E1E2E',
+    borderRadius: 12,
+    padding: 14,
+    borderWidth: 1,
+    borderColor: '#2A2A3E',
+  },
+  currentEmoji: {
+    fontSize: 22,
+    marginRight: 10,
+  },
+  currentLabel: {
+    color: '#FFFFFF',
+    fontSize: 16,
+    fontWeight: '600',
+    flex: 1,
+  },
+  chevron: {
+    color: '#8888AA',
+    fontSize: 12,
+  },
+  modalOverlay: {
+    flex: 1,
+    backgroundColor: 'rgba(0, 0, 0, 0.6)',
+    justifyContent: 'flex-end',
+  },
+  modalContent: {
+    backgroundColor: '#1A1A2E',
+    borderTopLeftRadius: 20,
+    borderTopRightRadius: 20,
+    padding: 20,
+    paddingBottom: 40,
+  },
+  modalTitle: {
+    color: '#FFFFFF',
+    fontSize: 18,
+    fontWeight: '700',
+    textAlign: 'center',
+    marginBottom: 16,
+  },
+  modeItem: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    padding: 14,
+    borderRadius: 10,
+    marginBottom: 6,
+  },
+  modeItemActive: {
+    backgroundColor: 'rgba(0, 150, 255, 0.15)',
+  },
+  modeEmoji: {
+    fontSize: 26,
+    marginRight: 14,
+  },
+  modeTextContainer: {
+    flex: 1,
+  },
+  modeLabel: {
+    color: '#CCCCDD',
+    fontSize: 16,
+    fontWeight: '500',
+  },
+  modeLabelActive: {
+    color: '#0096FF',
+    fontWeight: '700',
+  },
+  modeDescription: {
+    color: '#666680',
+    fontSize: 12,
+    marginTop: 2,
+  },
+  checkmark: {
+    color: '#0096FF',
+    fontSize: 18,
+    fontWeight: '700',
+    marginLeft: 8,
+  },
+  cancelButton: {
+    marginTop: 12,
+    padding: 14,
+    borderRadius: 10,
+    backgroundColor: '#2A2A3E',
+    alignItems: 'center',
+  },
+  cancelText: {
+    color: '#8888AA',
+    fontSize: 16,
+    fontWeight: '600',
+  },
+});
+
+export default ModeSelector;

android/src/components/QRScanner.tsx

@@ -0,0 +1,223 @@
+/**
+ * QRScanner - Vollbild QR-Code Scanner fuer ARIA Pairing
+ *
+ * Scannt QR-Codes im Format:
+ * {"host": "rvs.hackersoft.de", "port": 443, "token": "a3f8b2c9..."}
+ */
+
+import React, { useState, useCallback } from 'react';
+import {
+  View,
+  Text,
+  TouchableOpacity,
+  StyleSheet,
+  Modal,
+  Alert,
+  Platform,
+  PermissionsAndroid,
+} from 'react-native';
+import { CameraScreen } from 'react-native-camera-kit';
+import { ConnectionConfig } from '../services/rvs';
+
+interface QRScannerProps {
+  visible: boolean;
+  onScan: (config: ConnectionConfig) => void;
+  onClose: () => void;
+}
+
+/** QR-Daten parsen und validieren */
+function parseQRData(data: string): ConnectionConfig | null {
+  try {
+    const parsed = JSON.parse(data);
+
+    if (!parsed.host || !parsed.token) {
+      return null;
+    }
+
+    return {
+      host: String(parsed.host),
+      port: Number(parsed.port) || 443,
+      token: String(parsed.token),
+      useTLS: parsed.tls !== false, // Standard: TLS an
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Kamera-Berechtigung anfordern (Android) */
+async function requestCameraPermission(): Promise<boolean> {
+  if (Platform.OS !== 'android') return true;
+
+  try {
+    const granted = await PermissionsAndroid.request(
+      PermissionsAndroid.PERMISSIONS.CAMERA,
+      {
+        title: 'Kamera-Zugriff',
+        message: 'ARIA Cockpit braucht Kamera-Zugriff um den QR-Code zu scannen.',
+        buttonPositive: 'Erlauben',
+        buttonNegative: 'Ablehnen',
+      },
+    );
+    return granted === PermissionsAndroid.RESULTS.GRANTED;
+  } catch {
+    return false;
+  }
+}
+
+const QRScanner: React.FC<QRScannerProps> = ({ visible, onScan, onClose }) => {
+  const [hasPermission, setHasPermission] = useState<boolean | null>(null);
+  const [scanned, setScanned] = useState(false);
+
+  // Berechtigung pruefen beim Oeffnen
+  React.useEffect(() => {
+    if (visible) {
+      setScanned(false);
+      requestCameraPermission().then(granted => {
+        setHasPermission(granted);
+        if (!granted) {
+          Alert.alert(
+            'Kamera blockiert',
+            'Bitte erlaube den Kamera-Zugriff in den Einstellungen.',
+            [{ text: 'OK', onPress: onClose }],
+          );
+        }
+      });
+    }
+  }, [visible, onClose]);
+
+  const handleBarcodeScan = useCallback(
+    (event: { nativeEvent: { codeStringValue: string } }) => {
+      if (scanned) return;
+
+      const data = event.nativeEvent.codeStringValue;
+      const config = parseQRData(data);
+
+      if (config) {
+        setScanned(true);
+        onScan(config);
+      } else {
+        // Ungueltig — einmal warnen, dann weiter scannen lassen
+        setScanned(true);
+        Alert.alert(
+          'Ungueltiger QR-Code',
+          'Der QR-Code hat nicht das erwartete ARIA-Format.\n\nErwartet: {"host": "...", "port": 443, "token": "..."}',
+          [{ text: 'Nochmal', onPress: () => setScanned(false) }],
+        );
+      }
+    },
+    [scanned, onScan],
+  );
+
+  if (!visible) return null;
+
+  return (
+    <Modal
+      visible={visible}
+      animationType="slide"
+      presentationStyle="fullScreen"
+      onRequestClose={onClose}
+    >
+      <View style={styles.container}>
+        {hasPermission ? (
+          <>
+            <CameraScreen
+              scanBarcode={true}
+              onReadCode={handleBarcodeScan}
+              showFrame={true}
+              frameColor="#0096FF"
+              laserColor="#0096FF"
+              colorForScannerFrame="#0096FF"
+            />
+
+            {/* Overlay oben */}
+            <View style={styles.topOverlay}>
+              <Text style={styles.title}>QR-Code scannen</Text>
+              <Text style={styles.subtitle}>
+                Richte die Kamera auf den QR-Code vom RVS
+              </Text>
+            </View>
+
+            {/* Abbrechen-Button unten */}
+            <View style={styles.bottomOverlay}>
+              <TouchableOpacity style={styles.cancelButton} onPress={onClose}>
+                <Text style={styles.cancelText}>Abbrechen</Text>
+              </TouchableOpacity>
+            </View>
+          </>
+        ) : (
+          <View style={styles.noPermission}>
+            <Text style={styles.noPermissionText}>Kamera-Zugriff wird benoetigt</Text>
+            <TouchableOpacity style={styles.cancelButton} onPress={onClose}>
+              <Text style={styles.cancelText}>Zurueck</Text>
+            </TouchableOpacity>
+          </View>
+        )}
+      </View>
+    </Modal>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#000000',
+  },
+  topOverlay: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    paddingTop: 60,
+    paddingBottom: 20,
+    paddingHorizontal: 20,
+    backgroundColor: 'rgba(0, 0, 0, 0.6)',
+    alignItems: 'center',
+  },
+  title: {
+    color: '#FFFFFF',
+    fontSize: 20,
+    fontWeight: '700',
+  },
+  subtitle: {
+    color: '#AAAACC',
+    fontSize: 14,
+    marginTop: 6,
+    textAlign: 'center',
+  },
+  bottomOverlay: {
+    position: 'absolute',
+    bottom: 0,
+    left: 0,
+    right: 0,
+    paddingBottom: 40,
+    paddingTop: 20,
+    backgroundColor: 'rgba(0, 0, 0, 0.6)',
+    alignItems: 'center',
+  },
+  cancelButton: {
+    backgroundColor: 'rgba(255, 255, 255, 0.15)',
+    paddingHorizontal: 40,
+    paddingVertical: 14,
+    borderRadius: 12,
+  },
+  cancelText: {
+    color: '#FFFFFF',
+    fontSize: 16,
+    fontWeight: '600',
+  },
+  noPermission: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+  },
+  noPermissionText: {
+    color: '#AAAACC',
+    fontSize: 16,
+    marginBottom: 20,
+    textAlign: 'center',
+  },
+});
+
+export default QRScanner;

android/src/components/VoiceButton.tsx

@@ -0,0 +1,269 @@
+/**
+ * VoiceButton - Push-to-Talk + Auto-Stop Aufnahmeknopf
+ *
+ * Zwei Modi:
+ * 1. Push-to-Talk: gedrueckt halten zum Aufnehmen, loslassen zum Senden
+ * 2. Tap-to-Talk: einmal tippen startet Aufnahme, VAD stoppt automatisch bei Stille
+ *    (auch genutzt fuer Wake-Word-getriggerte Aufnahme)
+ *
+ * Visuelles Feedback durch pulsierende Animation waehrend der Aufnahme.
+ */
+
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import {
+  View,
+  Text,
+  Animated,
+  StyleSheet,
+  Easing,
+  TouchableOpacity,
+  Pressable,
+} from 'react-native';
+import audioService, { RecordingResult } from '../services/audio';
+
+// --- Typen ---
+
+interface VoiceButtonProps {
+  /** Wird aufgerufen wenn die Aufnahme fertig ist */
+  onRecordingComplete: (result: RecordingResult) => void;
+  /** Button deaktivieren */
+  disabled?: boolean;
+  /** Wake-Word-Modus aktiv (zeigt Indikator) */
+  wakeWordActive?: boolean;
+}
+
+// --- Komponente ---
+
+const VoiceButton: React.FC<VoiceButtonProps> = ({
+  onRecordingComplete,
+  disabled = false,
+  wakeWordActive = false,
+}) => {
+  const [isRecording, setIsRecording] = useState(false);
+  const [durationMs, setDurationMs] = useState(0);
+  const [meterDb, setMeterDb] = useState(-160);
+  const pulseAnim = useRef(new Animated.Value(1)).current;
+  const durationTimer = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  // Puls-Animation starten/stoppen
+  useEffect(() => {
+    if (isRecording) {
+      const pulse = Animated.loop(
+        Animated.sequence([
+          Animated.timing(pulseAnim, {
+            toValue: 1.2,
+            duration: 600,
+            easing: Easing.inOut(Easing.ease),
+            useNativeDriver: true,
+          }),
+          Animated.timing(pulseAnim, {
+            toValue: 1,
+            duration: 600,
+            easing: Easing.inOut(Easing.ease),
+            useNativeDriver: true,
+          }),
+        ]),
+      );
+      pulse.start();
+      return () => pulse.stop();
+    } else {
+      pulseAnim.setValue(1);
+    }
+  }, [isRecording, pulseAnim]);
+
+  // Aufnahmedauer zaehlen + Metering
+  useEffect(() => {
+    if (isRecording) {
+      setDurationMs(0);
+      durationTimer.current = setInterval(() => {
+        setDurationMs(prev => prev + 100);
+      }, 100);
+
+      const unsubMeter = audioService.onMeterUpdate(setMeterDb);
+      return () => {
+        unsubMeter();
+        if (durationTimer.current) clearInterval(durationTimer.current);
+      };
+    } else {
+      if (durationTimer.current) {
+        clearInterval(durationTimer.current);
+        durationTimer.current = null;
+      }
+    }
+  }, [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]);
+  useEffect(() => {
+    const unsubSilence = audioService.onSilenceDetected(async () => {
+      if (audioService.getRecordingState() !== 'recording') return;
+      const result = await audioService.stopRecording();
+      setIsRecording(false);
+      if (result && result.durationMs > 500) {
+        onCompleteRef.current(result);
+      }
+    });
+    return unsubSilence;
+  }, []);
+
+  // 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) {
+      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);
+  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);
+        }
+      }
+      // 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;
+    }
+  };
+
+  // Expose startAutoRecording via ref fuer Wake Word
+  React.useImperativeHandle(
+    React.createRef(),
+    () => ({ startAutoRecording }),
+    [startAutoRecording],
+  );
+
+  const formatDuration = (ms: number): string => {
+    const seconds = Math.floor(ms / 1000);
+    const tenths = Math.floor((ms % 1000) / 100);
+    return `${seconds}.${tenths}s`;
+  };
+
+  // Meter-Visualisierung (0-1 Skala)
+  const meterLevel = Math.max(0, Math.min(1, (meterDb + 60) / 60));
+
+  return (
+    <View style={styles.container}>
+      {wakeWordActive && !isRecording && (
+        <View style={styles.wakeWordDot} />
+      )}
+      <Animated.View
+        style={[
+          styles.buttonOuter,
+          isRecording && styles.buttonOuterRecording,
+          { transform: [{ scale: pulseAnim }] },
+        ]}
+      >
+        <TouchableOpacity
+          activeOpacity={0.8}
+          onPress={handleTap}
+          disabled={disabled}
+          style={[styles.buttonInner, isRecording && styles.buttonInnerRecording]}
+        >
+          <Text style={styles.buttonIcon}>{isRecording ? '⏹' : '🎙'}</Text>
+        </TouchableOpacity>
+      </Animated.View>
+      {isRecording && (
+        <View style={styles.infoRow}>
+          <View style={[styles.meterBar, { width: `${meterLevel * 100}%` }]} />
+          <Text style={styles.durationText}>{formatDuration(durationMs)}</Text>
+        </View>
+      )}
+    </View>
+  );
+};
+
+// Expose startAutoRecording fuer externe Aufrufe (Wake Word)
+export type VoiceButtonHandle = { startAutoRecording: () => Promise<void> };
+
+// --- Styles ---
+
+const styles = StyleSheet.create({
+  container: {
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  wakeWordDot: {
+    position: 'absolute',
+    top: -4,
+    right: -4,
+    width: 10,
+    height: 10,
+    borderRadius: 5,
+    backgroundColor: '#34C759',
+    zIndex: 10,
+  },
+  buttonOuter: {
+    width: 64,
+    height: 64,
+    borderRadius: 32,
+    backgroundColor: 'rgba(0, 150, 255, 0.2)',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  buttonOuterRecording: {
+    backgroundColor: 'rgba(255, 59, 48, 0.3)',
+  },
+  buttonInner: {
+    width: 52,
+    height: 52,
+    borderRadius: 26,
+    backgroundColor: '#0096FF',
+    alignItems: 'center',
+    justifyContent: 'center',
+    elevation: 4,
+    shadowColor: '#0096FF',
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.4,
+    shadowRadius: 4,
+  },
+  buttonInnerRecording: {
+    backgroundColor: '#FF3B30',
+  },
+  buttonIcon: {
+    fontSize: 24,
+  },
+  infoRow: {
+    alignItems: 'center',
+    marginTop: 4,
+    width: 80,
+  },
+  meterBar: {
+    height: 3,
+    backgroundColor: '#FF3B30',
+    borderRadius: 2,
+    marginBottom: 2,
+  },
+  durationText: {
+    color: '#FF3B30',
+    fontSize: 12,
+    fontVariant: ['tabular-nums'],
+  },
+});
+
+export default VoiceButton;

android/src/components/VoiceCloneModal.tsx

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

android/src/components/ZoomableImage.tsx

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

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

android/src/services/gpsTracking.ts

@@ -0,0 +1,138 @@
+/**
+ * GPS-Tracking-Service.
+ *
+ * Wenn aktiv: pushed alle paar Sekunden die aktuelle Position als
+ * `location_update {lat, lon}` an den RVS-Server, damit Brain-Watcher
+ * mit `near()`-Conditions etwas zum Vergleichen haben.
+ *
+ * Default: AUS. Wird entweder vom User manuell in Settings angeschaltet
+ * oder von ARIA via location_tracking-RVS-Message (Brain-Tool
+ * `request_location_tracking`).
+ *
+ * Energie-Schutz: distanceFilter 30m, interval 15s. Echte Fahrt-Updates
+ * (Geschwindigkeit) kommen sauber durch, stationaer wird kaum gesendet.
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { PermissionsAndroid, Platform, ToastAndroid } from 'react-native';
+import Geolocation from '@react-native-community/geolocation';
+import rvs from './rvs';
+
+type Listener = (active: boolean) => void;
+
+class GpsTrackingService {
+  private watchId: number | null = null;
+  private active = false;
+  private listeners: Set<Listener> = new Set();
+  // Defensive: nicht zu schnell oeffentlich togglen
+  private lastChangeAt = 0;
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  onChange(cb: Listener): () => void {
+    this.listeners.add(cb);
+    return () => { this.listeners.delete(cb); };
+  }
+
+  private notify() {
+    for (const cb of this.listeners) {
+      try { cb(this.active); } catch {}
+    }
+  }
+
+  /** Beim App-Start: gespeicherten Zustand wiederherstellen (Default off). */
+  async restoreFromStorage(): Promise<void> {
+    try {
+      const v = await AsyncStorage.getItem('aria_gps_tracking');
+      if (v === 'true') {
+        console.log('[gps-track] Restore: war an, starte wieder');
+        this.start('Beim Start wiederhergestellt');
+      }
+    } catch {}
+  }
+
+  private async ensurePermission(): Promise<boolean> {
+    if (Platform.OS !== 'android') return true;
+    try {
+      const granted = await PermissionsAndroid.request(
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+        {
+          title: 'GPS-Tracking',
+          message: 'ARIA braucht laufende Standort-Updates damit GPS-Watcher (Blitzer-Warner, near()) funktionieren.',
+          buttonPositive: 'Erlauben',
+          buttonNegative: 'Abbrechen',
+        },
+      );
+      return granted === PermissionsAndroid.RESULTS.GRANTED;
+    } catch (e) {
+      console.warn('[gps-track] Permission-Fehler:', e);
+      return false;
+    }
+  }
+
+  async start(reason: string = ''): Promise<boolean> {
+    if (this.active) return true;
+    const ok = await this.ensurePermission();
+    if (!ok) {
+      ToastAndroid.show('GPS-Tracking: Berechtigung abgelehnt', ToastAndroid.LONG);
+      return false;
+    }
+    try {
+      this.watchId = Geolocation.watchPosition(
+        (pos) => {
+          const lat = pos.coords.latitude;
+          const lon = pos.coords.longitude;
+          rvs.send('location_update' as any, { lat, lon });
+        },
+        (err) => {
+          console.warn('[gps-track] watchPosition error:', err?.code, err?.message);
+        },
+        {
+          enableHighAccuracy: true,
+          distanceFilter: 30,     // erst senden wenn 30m gewandert
+          interval: 15000,        // (Android) gewuenschte Frequenz
+          fastestInterval: 10000, // (Android) max Frequenz
+        } as any,
+      );
+      this.active = true;
+      this.lastChangeAt = Date.now();
+      this.notify();
+      AsyncStorage.setItem('aria_gps_tracking', 'true').catch(() => {});
+      ToastAndroid.show(
+        reason ? `GPS-Tracking aktiv (${reason})` : 'GPS-Tracking aktiv',
+        ToastAndroid.SHORT,
+      );
+      console.log('[gps-track] gestartet', reason ? `(${reason})` : '');
+      return true;
+    } catch (e: any) {
+      console.warn('[gps-track] start fehlgeschlagen:', e?.message);
+      return false;
+    }
+  }
+
+  stop(reason: string = ''): void {
+    if (!this.active) return;
+    if (this.watchId !== null) {
+      try { Geolocation.clearWatch(this.watchId); } catch {}
+      this.watchId = null;
+    }
+    this.active = false;
+    this.lastChangeAt = Date.now();
+    this.notify();
+    AsyncStorage.setItem('aria_gps_tracking', 'false').catch(() => {});
+    ToastAndroid.show(
+      reason ? `GPS-Tracking aus (${reason})` : 'GPS-Tracking aus',
+      ToastAndroid.SHORT,
+    );
+    console.log('[gps-track] gestoppt', reason ? `(${reason})` : '');
+  }
+
+  async toggle(reason: string = ''): Promise<void> {
+    if (this.active) this.stop(reason);
+    else await this.start(reason);
+  }
+}
+
+export default new GpsTrackingService();

android/src/services/logger.ts

@@ -0,0 +1,41 @@
+/**
+ * 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

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

@@ -0,0 +1,330 @@
+/**
+ * RVS (Rendezvous Server) - WebSocket-Verbindungsmanager
+ *
+ * Verwaltet die persistente WebSocket-Verbindung zwischen der ARIA Cockpit App
+ * und dem Rendezvous Server. Unterstützt Auto-Reconnect, Heartbeat und
+ * typisierte Nachrichten.
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+// --- Typen ---
+
+export type ConnectionState = 'connecting' | 'connected' | 'disconnected';
+
+export type MessageType = 'chat' | 'audio' | 'file' | 'location' | 'mode' | 'log' | 'event' | 'update_available' | string;
+
+export interface RVSMessage {
+  type: MessageType;
+  payload: Record<string, unknown>;
+  timestamp: number;
+}
+
+export interface ConnectionConfig {
+  host: string;
+  port: number;
+  token: string;
+  useTLS: boolean;
+}
+
+type MessageCallback = (message: RVSMessage) => void;
+type StateCallback = (state: ConnectionState) => void;
+
+/** Einzelner Eintrag im Verbindungslog */
+export interface ConnectionLogEntry {
+  timestamp: number;
+  level: 'info' | 'warn' | 'error';
+  message: string;
+}
+
+type LogCallback = (entry: ConnectionLogEntry) => void;
+
+// --- Konstanten ---
+
+const HEARTBEAT_INTERVAL_MS = 25_000;
+const INITIAL_RECONNECT_DELAY_MS = 1_000;
+const MAX_RECONNECT_DELAY_MS = 30_000;
+const RECONNECT_BACKOFF_FACTOR = 2;
+const MAX_LOG_ENTRIES = 100;
+
+// --- RVS-Klasse ---
+
+class RVSConnection {
+  private ws: WebSocket | null = null;
+  private config: ConnectionConfig | null = null;
+  private state: ConnectionState = 'disconnected';
+
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private reconnectDelay: number = INITIAL_RECONNECT_DELAY_MS;
+  private shouldReconnect: boolean = false;
+
+  private messageListeners: MessageCallback[] = [];
+  private stateListeners: StateCallback[] = [];
+  private logListeners: LogCallback[] = [];
+  private connectionLog: ConnectionLogEntry[] = [];
+  private usingTLSFallback: boolean = false;
+
+  // --- Konfiguration ---
+
+  /** Verbindungsdaten setzen (z.B. nach QR-Scan) */
+  setConfig(config: ConnectionConfig): void {
+    this.config = config;
+    this.saveConfig(config);
+  }
+
+  getConfig(): ConnectionConfig | null {
+    return this.config;
+  }
+
+  getState(): ConnectionState {
+    return this.state;
+  }
+
+  // --- Verbindung ---
+
+  /** Verbindung zum RVS aufbauen */
+  connect(): void {
+    if (!this.config) {
+      this.log('warn', 'Keine Verbindungskonfiguration vorhanden');
+      return;
+    }
+
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.log('info', 'Bereits verbunden');
+      return;
+    }
+
+    this.shouldReconnect = true;
+    this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+    this.usingTLSFallback = false;
+    this.log('info', `Verbindungsaufbau zu ${this.config.host}:${this.config.port} (TLS: ${this.config.useTLS ? 'ja' : 'nein'})`);
+    this.establishConnection();
+  }
+
+  /** Verbindung trennen (kein Auto-Reconnect) */
+  disconnect(): void {
+    this.shouldReconnect = false;
+    this.clearTimers();
+
+    if (this.ws) {
+      this.ws.close(1000, 'Benutzer hat getrennt');
+      this.ws = null;
+    }
+
+    this.log('info', 'Verbindung getrennt (manuell)');
+    this.setState('disconnected');
+  }
+
+  /** Nachricht an den RVS senden */
+  send(type: MessageType, payload: Record<string, unknown>): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      console.warn('[RVS] Kann nicht senden - nicht verbunden');
+      return;
+    }
+
+    const message: RVSMessage = {
+      type,
+      payload,
+      timestamp: Date.now(),
+    };
+
+    this.ws.send(JSON.stringify(message));
+  }
+
+  // --- Event-Listener ---
+
+  /** Callback fuer eingehende Nachrichten registrieren */
+  onMessage(callback: MessageCallback): () => void {
+    this.messageListeners.push(callback);
+    // Gibt Unsubscribe-Funktion zurueck
+    return () => {
+      this.messageListeners = this.messageListeners.filter(cb => cb !== callback);
+    };
+  }
+
+  /** Callback fuer Verbindungsstatus-Aenderungen registrieren */
+  onStateChange(callback: StateCallback): () => void {
+    this.stateListeners.push(callback);
+    return () => {
+      this.stateListeners = this.stateListeners.filter(cb => cb !== callback);
+    };
+  }
+
+  /** Callback fuer Verbindungslog-Eintraege registrieren */
+  onLog(callback: LogCallback): () => void {
+    this.logListeners.push(callback);
+    return () => {
+      this.logListeners = this.logListeners.filter(cb => cb !== callback);
+    };
+  }
+
+  /** Gesamten Verbindungslog abrufen */
+  getConnectionLog(): ConnectionLogEntry[] {
+    return [...this.connectionLog];
+  }
+
+  // --- Interne Methoden ---
+
+  /** Eintrag ins Verbindungslog schreiben */
+  private log(level: ConnectionLogEntry['level'], message: string): void {
+    const entry: ConnectionLogEntry = { timestamp: Date.now(), level, message };
+    this.connectionLog = [...this.connectionLog.slice(-(MAX_LOG_ENTRIES - 1)), entry];
+    this.logListeners.forEach(cb => cb(entry));
+    const prefix = level === 'error' ? 'ERROR' : level === 'warn' ? 'WARN' : 'INFO';
+    console.log(`[RVS] [${prefix}] ${message}`);
+  }
+
+  private establishConnection(): void {
+    if (!this.config) return;
+
+    this.setState('connecting');
+
+    const useTLS = this.config.useTLS && !this.usingTLSFallback;
+    const protocol = useTLS ? 'wss' : 'ws';
+    const url = `${protocol}://${this.config.host}:${this.config.port}?token=${this.config.token}`;
+
+    this.log('info', `Verbinde: ${protocol}://${this.config.host}:${this.config.port}`);
+
+    try {
+      this.ws = new WebSocket(url);
+
+      this.ws.onopen = () => {
+        const tlsInfo = this.usingTLSFallback ? ' (TLS-Fallback: ws://)' : '';
+        this.log('info', `Verbunden${tlsInfo}`);
+        this.setState('connected');
+        this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+        this.startHeartbeat();
+      };
+
+      this.ws.onmessage = (event: WebSocketMessageEvent) => {
+        try {
+          const message: RVSMessage = JSON.parse(event.data as string);
+          this.notifyMessageListeners(message);
+        } catch (err) {
+          this.log('error', `Nachricht parsen fehlgeschlagen: ${err}`);
+        }
+      };
+
+      this.ws.onclose = (event) => {
+        this.log('info', `Verbindung geschlossen (Code: ${event.code}, Reason: ${event.reason || '-'})`);
+        this.clearTimers();
+        this.ws = null;
+        this.setState('disconnected');
+
+        if (this.shouldReconnect) {
+          this.scheduleReconnect();
+        }
+      };
+
+      this.ws.onerror = (error) => {
+        const errorMsg = (error as any)?.message || 'Unbekannter Fehler';
+        this.log('error', `WebSocket-Fehler: ${errorMsg}`);
+
+        // TLS-Fallback: Wenn wss:// fehlschlaegt, auf ws:// wechseln
+        if (this.config?.useTLS && !this.usingTLSFallback) {
+          this.usingTLSFallback = true;
+          // shouldReconnect kurz deaktivieren damit onclose keinen
+          // parallelen Reconnect ausloest — wir machen das selbst
+          this.shouldReconnect = false;
+          this.log('warn', 'TLS fehlgeschlagen — Fallback auf ws:// (ohne TLS)');
+          this.clearTimers();
+          if (this.ws) {
+            this.ws.onclose = null; // onclose-Handler entfernen um Doppel-Reconnect zu verhindern
+            try { this.ws.close(); } catch (_) {}
+          }
+          this.ws = null;
+          this.shouldReconnect = true;
+          this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+          this.establishConnection();
+          return;
+        }
+      };
+    } catch (err) {
+      this.log('error', `Verbindungsfehler: ${err}`);
+      this.setState('disconnected');
+
+      if (this.shouldReconnect) {
+        this.scheduleReconnect();
+      }
+    }
+  }
+
+  /** Reconnect mit exponentiellem Backoff planen */
+  private scheduleReconnect(): void {
+    this.log('info', `Reconnect in ${this.reconnectDelay / 1000}s...`);
+
+    this.reconnectTimer = setTimeout(() => {
+      this.establishConnection();
+    }, this.reconnectDelay);
+
+    // Exponentieller Backoff: 1s -> 2s -> 4s -> 8s -> ... -> max 30s
+    this.reconnectDelay = Math.min(
+      this.reconnectDelay * RECONNECT_BACKOFF_FACTOR,
+      MAX_RECONNECT_DELAY_MS,
+    );
+  }
+
+  /** Heartbeat starten (alle 25 Sekunden) */
+  private startHeartbeat(): void {
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: 'heartbeat', timestamp: Date.now() }));
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+
+  private clearTimers(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+
+  private setState(state: ConnectionState): void {
+    if (this.state !== state) {
+      this.state = state;
+      this.stateListeners.forEach(cb => cb(state));
+    }
+  }
+
+  private notifyMessageListeners(message: RVSMessage): void {
+    this.messageListeners.forEach(cb => cb(message));
+  }
+
+  // --- Persistenz ---
+
+  private static readonly STORAGE_KEY = 'rvs_config';
+
+  private async saveConfig(config: ConnectionConfig): Promise<void> {
+    try {
+      await AsyncStorage.setItem(RVSConnection.STORAGE_KEY, JSON.stringify(config));
+      console.log('[RVS] Konfiguration gespeichert');
+    } catch (err) {
+      console.error('[RVS] Fehler beim Speichern:', err);
+    }
+  }
+
+  async loadConfig(): Promise<ConnectionConfig | null> {
+    try {
+      const data = await AsyncStorage.getItem(RVSConnection.STORAGE_KEY);
+      if (data) {
+        this.config = JSON.parse(data);
+        console.log('[RVS] Konfiguration geladen');
+        return this.config;
+      }
+      return null;
+    } catch (err) {
+      console.error('[RVS] Fehler beim Laden:', err);
+      return null;
+    }
+  }
+}
+
+// Singleton-Instanz
+const rvs = new RVSConnection();
+export default rvs;

android/src/services/updater.ts

@@ -0,0 +1,232 @@
+/**
+ * Auto-Update Service — prueft und installiert App-Updates via RVS
+ *
+ * Flow:
+ * 1. App sendet "update_check" mit aktueller Version an RVS
+ * 2. RVS vergleicht → sendet "update_available" mit Download-URL
+ * 3. App zeigt Benachrichtigung → User bestaetigt → Download + Install
+ */
+
+import { Alert, Linking, Platform, NativeModules } from 'react-native';
+import RNFS from 'react-native-fs';
+import rvs, { RVSMessage } from './rvs';
+
+// Version aus package.json (wird beim Build eingebettet)
+const packageJson = require('../../package.json');
+const APP_VERSION = packageJson.version || '0.0.0.0';
+
+type UpdateCallback = (info: UpdateInfo) => void;
+
+export interface UpdateInfo {
+  version: string;
+  downloadUrl: string;
+  size: number;
+}
+
+class UpdateService {
+  private listeners: UpdateCallback[] = [];
+  private checking = false;
+  private downloading = false;
+
+  constructor() {
+    // Beim Start alte APK-Reste aus dem Cache wegraeumen — wenn diese App
+    // laeuft, sind frueher heruntergeladene APKs entweder schon installiert
+    // oder unvollstaendig gewesen. Spart sonst pro Update 20-30MB auf dem Handy.
+    this.cleanupOldApks().catch(() => {});
+
+    // Auf update_available Nachrichten lauschen
+    rvs.onMessage((msg: RVSMessage) => {
+      if (msg.type === 'update_available' as any) {
+        const info: UpdateInfo = {
+          version: (msg.payload.version as string) || '',
+          downloadUrl: (msg.payload.downloadUrl as string) || '',
+          size: (msg.payload.size as number) || 0,
+        };
+        if (info.version && this.isNewer(info.version)) {
+          console.log(`[Update] Neue Version verfuegbar: ${info.version} (aktuell: ${APP_VERSION})`);
+          this.listeners.forEach(cb => cb(info));
+        }
+      }
+    });
+  }
+
+  /** 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;
+    this.checking = true;
+
+    console.log(`[Update] Pruefe auf Updates (aktuell: ${APP_VERSION})`);
+    rvs.send('update_check' as any, { version: APP_VERSION });
+
+    setTimeout(() => { this.checking = false; }, 10000);
+  }
+
+  /** Callback registrieren */
+  onUpdateAvailable(callback: UpdateCallback): () => void {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter(cb => cb !== callback);
+    };
+  }
+
+  /** Update-Dialog anzeigen */
+  promptUpdate(info: UpdateInfo): void {
+    const sizeMB = (info.size / 1024 / 1024).toFixed(1);
+    Alert.alert(
+      'ARIA Update verfuegbar',
+      `Version ${info.version} (${sizeMB} MB)\n\nAktuell: ${APP_VERSION}\n\nJetzt herunterladen und installieren?`,
+      [
+        { text: 'Spaeter', style: 'cancel' },
+        {
+          text: 'Installieren',
+          onPress: () => this.downloadAndInstall(info),
+        },
+      ],
+    );
+  }
+
+  /** APK ueber WebSocket herunterladen und installieren */
+  async downloadAndInstall(info: UpdateInfo): Promise<void> {
+    if (this.downloading) return;
+    this.downloading = true;
+
+    try {
+      console.log(`[Update] Fordere APK v${info.version} an...`);
+      Alert.alert('Download gestartet', `Version ${info.version} wird ueber RVS heruntergeladen...`);
+
+      // APK ueber WebSocket anfordern
+      rvs.send('update_download' as any, {});
+
+      // Auf update_data warten (einmalig)
+      const apkData = await new Promise<{base64: string, fileName: string}>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Download-Timeout (60s)')), 60000);
+        const unsub = rvs.onMessage((msg: RVSMessage) => {
+          if ((msg.type as string) === 'update_data') {
+            clearTimeout(timeout);
+            unsub();
+            if (msg.payload.error) {
+              reject(new Error(msg.payload.error as string));
+            } else {
+              resolve({
+                base64: msg.payload.base64 as string,
+                fileName: msg.payload.fileName as string || `ARIA-${info.version}.apk`,
+              });
+            }
+          }
+        });
+      });
+
+      // Vor dem Schreiben alte APKs im Cache wegraeumen — falls mehrere
+      // Updates in einer Session gezogen werden
+      await this.cleanupOldApks();
+
+      // Base64 als APK-Datei speichern
+      const destPath = `${RNFS.CachesDirectoryPath}/${apkData.fileName}`;
+      await RNFS.writeFile(destPath, apkData.base64, 'base64');
+      const fileSize = await RNFS.stat(destPath);
+      console.log(`[Update] APK gespeichert: ${destPath} (${(parseInt(fileSize.size) / 1024 / 1024).toFixed(1)}MB)`);
+
+      // APK installieren via natives ApkInstaller Module (FileProvider + Intent)
+      if (Platform.OS === 'android') {
+        try {
+          const { ApkInstaller } = NativeModules;
+          await ApkInstaller.install(destPath);
+        } catch (installErr: any) {
+          Alert.alert(
+            'APK heruntergeladen',
+            `Version ${info.version} gespeichert.\n\nBitte manuell installieren:\nDateimanager → ${apkData.fileName} antippen.\n\n(${installErr.message})`,
+          );
+        }
+      }
+    } catch (err: any) {
+      console.error(`[Update] Fehler: ${err.message}`);
+      Alert.alert('Update fehlgeschlagen', err.message);
+    } finally {
+      this.downloading = false;
+    }
+  }
+
+  /** Versionsvergleich */
+  private isNewer(remote: string): boolean {
+    const r = remote.split('.').map(Number);
+    const l = APP_VERSION.split('.').map(Number);
+    for (let i = 0; i < Math.max(r.length, l.length); i++) {
+      const diff = (r[i] || 0) - (l[i] || 0);
+      if (diff > 0) return true;
+      if (diff < 0) return false;
+    }
+    return false;
+  }
+
+  getCurrentVersion(): string {
+    return APP_VERSION;
+  }
+}
+
+const updateService = new UpdateService();
+export default updateService;

android/src/services/wakeReadySound.ts

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

android/src/services/wakeword.ts

@@ -0,0 +1,414 @@
+/**
+ * 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),
+ *                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).
+ */
+
+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_KEYWORD_STORAGE = 'aria_wake_keyword';
+
+/** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
+ *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
+ *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
+ *  werden — Diagnostic-Upload ist Phase 2. */
+export const WAKE_KEYWORDS = [
+  'hey_jarvis',
+  'computer',
+  'alexa',
+  'hey_mycroft',
+  'hey_rhasspy',
+] as const;
+export type WakeKeyword = typeof WAKE_KEYWORDS[number];
+export const DEFAULT_KEYWORD: WakeKeyword = 'hey_jarvis';
+
+/** Hilfs-Mapping fuer die Anzeige im UI. */
+export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
+  hey_jarvis: 'Hey Jarvis',
+  computer: 'Computer',
+  alexa: 'Alexa',
+  hey_mycroft: 'Hey Mycroft',
+  hey_rhasspy: 'Hey Rhasspy',
+};
+
+// Detection-Tuning — kann in Settings spaeter konfigurierbar werden.
+const DEFAULT_THRESHOLD = 0.5;
+const DEFAULT_PATIENCE = 2;
+const DEFAULT_DEBOUNCE_MS = 1500;
+
+interface OpenWakeWordModule {
+  init(modelName: string, threshold: number, patience: number, debounceMs: number): Promise<boolean>;
+  start(): Promise<boolean>;
+  stop(): Promise<boolean>;
+  dispose(): Promise<boolean>;
+  isAvailable(): Promise<boolean>;
+}
+
+const { OpenWakeWord } = NativeModules as { OpenWakeWord?: OpenWakeWordModule };
+
+class WakeWordService {
+  private state: WakeWordState = 'off';
+  private wakeCallbacks: WakeWordCallback[] = [];
+  private stateCallbacks: StateCallback[] = [];
+  /** 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;
+  private initInProgress: Promise<boolean> | null = null;
+  private eventSub: { remove: () => void } | null = null;
+
+  /** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
+  async loadFromStorage(): Promise<void> {
+    try {
+      const w = await AsyncStorage.getItem(WAKE_KEYWORD_STORAGE);
+      const wt = (w || DEFAULT_KEYWORD).trim() as WakeKeyword;
+      this.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
+      await this.initNative();
+    } catch (err) {
+      console.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);
+
+    // 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;
+  }
+
+  private async initNative(): Promise<boolean> {
+    if (!OpenWakeWord) {
+      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
+      this.nativeReady = false;
+      return false;
+    }
+    if (this.initInProgress) return this.initInProgress;
+    this.initInProgress = (async () => {
+      try {
+        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
+        // Subscribe nur einmal
+        if (!this.eventSub) {
+          const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
+          this.eventSub = emitter.addListener('WakeWordDetected', () => {
+            console.log('[WakeWord] Native Detection-Event empfangen');
+            this.onWakeDetected().catch(err =>
+              console.warn('[WakeWord] onWakeDetected crashed:', err));
+          });
+        }
+        this.nativeReady = true;
+        console.log('[WakeWord] Init OK (model=%s)', this.keyword);
+        return true;
+      } catch (err: any) {
+        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
+        this.nativeReady = false;
+        return false;
+      } finally {
+        this.initInProgress = null;
+      }
+    })();
+    return this.initInProgress;
+  }
+
+  private async disposeNative(): Promise<void> {
+    if (!OpenWakeWord) return;
+    try { await OpenWakeWord.dispose(); } catch {}
+    this.nativeReady = false;
+  }
+
+  /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
+  async start(): Promise<boolean> {
+    if (this.state !== 'off') return true;
+    // Foreground-Service VOR dem Mic-Zugriff hochziehen damit Background-
+    // Lauschen funktioniert (Android braucht foregroundServiceType=microphone
+    // aktiv zum Zeitpunkt des AudioRecord.startRecording).
+    await acquireBackgroundAudio('wake');
+    if (this.nativeReady && OpenWakeWord) {
+      try {
+        await OpenWakeWord.start();
+        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
+        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        this.setState('armed');
+        return true;
+      } catch (err: any) {
+        console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
+                     err?.message || err);
+        ToastAndroid.show(
+          `Wake-Word-Start failed: ${err?.message || err}`,
+          ToastAndroid.LONG,
+        );
+      }
+    } else {
+      console.warn('[WakeWord] Native-Modul nicht bereit — Direkt-Aufnahme-Fallback');
+      ToastAndroid.show(
+        'Wake-Word nicht aktiv — direkte Aufnahme startet (Mikro hoert mit)',
+        ToastAndroid.LONG,
+      );
+    }
+    // Fallback: direkt in Konversation
+    console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
+    this.setState('conversing');
+    setTimeout(() => {
+      if (this.state === 'conversing') {
+        this.wakeCallbacks.forEach(cb => cb());
+      }
+    }, 500);
+    return true;
+  }
+
+  /** Komplett ausschalten (Ohr abschalten) */
+  async stop(): Promise<void> {
+    console.log('[WakeWord] Ohr deaktiviert');
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.bargeListening = false;
+    this.setState('off');
+  }
+
+  /** Cooldown setzen — alle Wake-Word-Detections in den naechsten ms ignorieren.
+   *  Wird beim App-Resume gerufen weil AppState-Wechsel Audio-Spikes erzeugen
+   *  die openWakeWord faelschlich als Trigger interpretiert. */
+  setResumeCooldown(ms: number = 1500): void {
+    this.cooldownUntilMs = Date.now() + ms;
+    console.log('[WakeWord] Cooldown aktiv fuer %dms', ms);
+  }
+
+  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
+  private async onWakeDetected(): Promise<void> {
+    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;
+    }
+    this.setState('conversing');
+    setTimeout(() => {
+      if (this.state === 'conversing') {
+        this.wakeCallbacks.forEach(cb => cb());
+      }
+    }, 200);
+  }
+
+  /** Wake-Word PARALLEL zur TTS-Wiedergabe lauschen lassen — User kann
+   *  "Computer" sagen waehrend ARIA noch redet, AcousticEchoCanceler im
+   *  Native-Modul verhindert dass ARIAs eigene Stimme triggert.
+   *  Voraussetzung: AudioRecorder muss frei sein (Recording aus). Wenn der
+   *  AudioRecorder gerade laeuft, hat der Vorrang — Wake-Word geht nicht. */
+  async startBargeListening(): Promise<void> {
+    if (!this.nativeReady || !OpenWakeWord) return;
+    if (this.state !== 'conversing') return;
+    if (this.bargeListening) return;
+    try {
+      await OpenWakeWord.start();
+      this.bargeListening = true;
+      console.log('[WakeWord] Barge-Listening aktiv (parallel zu TTS)');
+    } catch (err) {
+      console.warn('[WakeWord] Barge-Listening start fehlgeschlagen:', err);
+    }
+  }
+
+  /** Barge-Listening wieder aus — z.B. wenn der AudioRecorder fuer die
+   *  naechste Aufnahme das Mikro braucht. */
+  async stopBargeListening(): Promise<void> {
+    if (!this.bargeListening) return;
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.bargeListening = false;
+    console.log('[WakeWord] Barge-Listening aus');
+  }
+
+  /** Bei eingehendem Anruf: Wake-Word + Aufnahme stoppen, Pre-Call-State
+   *  merken. Telefonie-App belegt das Mikro waehrend des Anrufs, plus ARIA
+   *  soll nicht in laufende Telefonate reinhoeren. */
+  async pauseForCall(): Promise<void> {
+    if (this.callPaused) return;
+    this.preCallState = this.state;
+    if (this.state === 'off') {
+      this.callPaused = true;  // merken dass wir pausiert wurden
+      return;
+    }
+    this.callPaused = true;
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.bargeListening = false;
+    console.log('[WakeWord] Anruf — Wake-Word pausiert (war: %s)', this.preCallState);
+  }
+
+  /** Nach Auflegen: Pre-Call-State wiederherstellen. Aktive Konversation
+   *  geht zu armed zurueck (User soll nicht in einen halben Dialog springen). */
+  async resumeFromCall(): Promise<void> {
+    if (!this.callPaused) return;
+    const restoreTo = this.preCallState;
+    this.callPaused = false;
+    this.preCallState = 'off';
+    console.log('[WakeWord] Anruf zu Ende — restore state=%s', restoreTo);
+    if (restoreTo === 'off') return;
+    // Aktive Konversation war wahrscheinlich durch haltAllPlayback eh abgebrochen,
+    // sicher zu armed degraden.
+    if (restoreTo === 'conversing') this.setState('armed');
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.start(); } catch (err) {
+        console.warn('[WakeWord] Restore-Start fehlgeschlagen:', err);
+      }
+    }
+  }
+
+  /** Konversation beenden — User hat im Window nichts gesagt.
+   *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
+   *  Ohne: zurueck zu 'off'.
+   */
+  async endConversation(): Promise<void> {
+    if (this.state !== 'conversing') return;
+    if (this.nativeReady && OpenWakeWord) {
+      try {
+        await OpenWakeWord.start();
+        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
+        ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        this.setState('armed');
+        return;
+      } catch (err) {
+        console.warn('[WakeWord] re-arm fehlgeschlagen:', err);
+      }
+    }
+    console.log('[WakeWord] Konversation zu Ende — Ohr aus');
+    ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
+    this.setState('off');
+  }
+
+  /** Nach ARIA-Antwort (TTS fertig): naechste Aufnahme im Conversation-Window starten */
+  async resume(): Promise<void> {
+    if (this.state !== 'conversing') return;
+    // Kurze Pause damit TTS-Audio nicht ins Mikrofon geht
+    await new Promise(resolve => setTimeout(resolve, 800));
+    if (this.state === 'conversing') {
+      console.log('[WakeWord] TTS fertig — naechste Aufnahme im Conversation-Window');
+      this.wakeCallbacks.forEach(cb => cb());
+    }
+  }
+
+  /** True solange das Ohr aktiv ist (armed ODER conversing). */
+  isActive(): boolean {
+    return this.state !== 'off';
+  }
+
+  isConversing(): boolean {
+    return this.state === 'conversing';
+  }
+
+  hasWakeWord(): boolean {
+    return this.nativeReady;
+  }
+
+  getKeyword(): WakeKeyword {
+    return this.keyword;
+  }
+
+  // --- Callbacks ---
+
+  onWakeWord(callback: WakeWordCallback): () => void {
+    this.wakeCallbacks.push(callback);
+    return () => {
+      this.wakeCallbacks = this.wakeCallbacks.filter(cb => cb !== callback);
+    };
+  }
+
+  /** 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 () => {
+      this.stateCallbacks = this.stateCallbacks.filter(cb => cb !== callback);
+    };
+  }
+
+  getState(): WakeWordState {
+    return this.state;
+  }
+
+  private setState(state: WakeWordState): void {
+    if (this.state !== state) {
+      this.state = state;
+      this.stateCallbacks.forEach(cb => cb(state));
+    }
+  }
+}
+
+const wakeWordService = new WakeWordService();
+export default wakeWordService;

android/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "lib": ["es2020"],
+    "allowJs": true,
+    "jsx": "react-native",
+    "noEmit": true,
+    "strict": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "@services/*": ["src/services/*"],
+      "@screens/*": ["src/screens/*"],
+      "@components/*": ["src/components/*"]
+    }
+  },
+  "include": ["App.tsx", "src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "babel.config.js", "metro.config.js"]
+}

aria-brain/Dockerfile

@@ -0,0 +1,35 @@
+# ════════════════════════════════════════════════════════════
+#  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

@@ -0,0 +1,579 @@
+"""
+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 und ruft dich dann selbst auf "
+                "(Push-Nachricht an Stefan). Use-Case: 'erinnere mich in 10min', "
+                "'sag mir um 14:30 Bescheid'. Genau EINES von `in_seconds` ODER `fires_at` "
+                "muss gesetzt sein."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "kurzer kebab-case-Name, a-z 0-9 - _"},
+                    "in_seconds": {
+                        "type": "integer",
+                        "description": (
+                            "Relativ ab jetzt in Sekunden. Bevorzugt bei Angaben wie "
+                            "'in 2 Minuten' (=120), 'in 1 Stunde' (=3600). "
+                            "Server berechnet daraus den absoluten Feuer-Zeitpunkt."
+                        ),
+                    },
+                    "fires_at": {
+                        "type": "string",
+                        "description": (
+                            "Absoluter ISO-Timestamp UTC fuer feste Termine, z.B. "
+                            "'2026-05-12T14:30:00Z'. Die aktuelle Zeit findest du im "
+                            "System-Prompt unter '## Aktuelle Zeit'. Fuer relative Angaben "
+                            "lieber `in_seconds` nutzen."
+                        ),
+                    },
+                    "message": {"type": "string", "description": "Was soll bei der Erinnerung gesagt werden"},
+                },
+                "required": ["name", "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": {}},
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "request_location_tracking",
+            "description": (
+                "Bittet die App, das kontinuierliche GPS-Tracking zu aktivieren oder zu "
+                "deaktivieren. Default ist AUS (Akku-Schutz). Nutze das wenn du einen "
+                "GPS-basierten Watcher anlegst (z.B. `near(...)`), sonst hat die App "
+                "veraltete Position und der Watcher feuert nie. Auch wieder ausschalten "
+                "wenn der letzte GPS-Watcher geloescht wurde."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "on": {"type": "boolean", "description": "true = Tracking an, false = aus"},
+                    "reason": {"type": "string", "description": "Kurzer Grund (wird in App-Notification angezeigt)"},
+                },
+                "required": ["on"],
+            },
+        },
+    },
+]
+
+
+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()
+        condition_funcs = watcher_mod.describe_functions()
+
+        # 5. System-Prompt + Window-Messages
+        system_prompt = build_system_prompt(hot, cold, skills=all_skills,
+                                            triggers=all_triggers,
+                                            condition_vars=condition_vars,
+                                            condition_funcs=condition_funcs)
+        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":
+                fires_at_iso = arguments.get("fires_at")
+                in_seconds = arguments.get("in_seconds")
+                if not fires_at_iso and in_seconds is not None:
+                    from datetime import datetime as _dt, timezone as _tz, timedelta as _td
+                    try:
+                        secs = int(in_seconds)
+                    except (TypeError, ValueError):
+                        return "FEHLER: in_seconds muss eine ganze Zahl sein."
+                    if secs < 1:
+                        return "FEHLER: in_seconds muss >= 1 sein."
+                    fires_at_iso = (_dt.now(_tz.utc) + _td(seconds=secs)).isoformat(timespec="seconds")
+                if not fires_at_iso:
+                    return "FEHLER: entweder `in_seconds` ODER `fires_at` muss gesetzt sein."
+                t = triggers_mod.create_timer(
+                    name=arguments["name"],
+                    fires_at_iso=fires_at_iso,
+                    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 == "request_location_tracking":
+                on = bool(arguments.get("on", False))
+                reason = (arguments.get("reason") or "").strip()
+                self._pending_events.append({
+                    "type": "location_tracking",
+                    "on": on,
+                    "reason": reason,
+                })
+                return f"OK — Tracking-Request gesendet (on={on}). App wird in Kuerze umschalten."
+            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

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

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

@@ -0,0 +1,652 @@
+"""
+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 + Funktionen fuer Watcher-Conditions
+    (mit aktuellen Werten)."""
+    current = watcher_mod.collect_variables()
+    # near() ist ein callable in vars_ — fuer die UI rausfiltern
+    serializable = {k: v for k, v in current.items() if not callable(v)}
+    return {
+        "variables": watcher_mod.describe_variables(),
+        "functions": watcher_mod.describe_functions(),
+        "current": serializable,
+    }
+
+
+@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

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

aria-brain/memory/embedder.py

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

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

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

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

@@ -0,0 +1,214 @@
+"""
+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 datetime import datetime, timezone, timedelta
+from typing import List
+
+from memory import MemoryPoint
+
+
+def build_time_section() -> str:
+    """Aktueller Zeitstempel — damit ARIA Timer korrekt anlegen kann
+    und Watcher-Conditions mit hour_of_day etc. einordenbar bleiben."""
+    now_utc = datetime.now(timezone.utc)
+    # Europa/Berlin: Sommerzeit CEST = UTC+2, Winterzeit CET = UTC+1.
+    # Wir nehmen den simplen Fall (kein zoneinfo-Import noetig im Brain-Image):
+    # Stefans VM laeuft auf UTC, die Bridge in der Wohnung — Anzeige reicht.
+    local_offset_h = 2 if 3 <= now_utc.month <= 10 else 1
+    local = now_utc + timedelta(hours=local_offset_h)
+    lines = [
+        "## Aktuelle Zeit",
+        f"- UTC: {now_utc.isoformat(timespec='seconds')}",
+        f"- Lokal (Europa/Berlin, UTC+{local_offset_h}): "
+        f"{local.strftime('%Y-%m-%d %H:%M:%S')} ({local.strftime('%A')})",
+        "",
+        "Nutze das fuer Trigger-Timestamps und um Watcher-Conditions wie "
+        "`hour_of_day == 8` einzuordnen. Fuer relative Angaben "
+        "('in 10min', 'in 2 Stunden') nutze beim `trigger_timer` den "
+        "`in_seconds`-Parameter — Server rechnet dann selbst.",
+    ]
+    return "\n".join(lines)
+
+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],
+    condition_funcs: List[dict] | None = None,
+) -> str:
+    """Triggers (passive Aufweck-Quellen) + verfuegbare Condition-Variablen + Funktionen."""
+    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']}")
+    if condition_funcs:
+        lines.append("")
+        lines.append("### Verfuegbare Funktionen in Conditions")
+        for fn in condition_funcs:
+            lines.append(f"- `{fn['signature']}` — {fn['desc']}")
+    lines.append("")
+    lines.append("Operatoren in Conditions: `<` `>` `<=` `>=` `==` `!=` `and` `or` `not`. "
+                 "Beispiele: `disk_free_gb < 5 and hour_of_day >= 8`, "
+                 "`day_of_week == \"mon\"`, `near(53.123, 7.456, 500)`. "
+                 "Funktionen nur mit Konstanten als Argumenten (keine Variablen, "
+                 "keine geschachtelten Funktionen).")
+    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, GPS-Naehe).")
+    lines.append("- ARIA legt Trigger NUR auf Stefan-Wunsch an, nicht eigenmaechtig.")
+    lines.append("")
+    lines.append("### GPS-Watcher mit near()")
+    lines.append(
+        "Wenn du einen Watcher mit `near()` anlegst: die App sendet GPS-Position "
+        "nur kontinuierlich wenn Tracking AN ist (Default: AUS, Akku-Schutz). "
+        "Rufe dafuer `request_location_tracking(on=true, reason=\"...\")` auf "
+        "bevor oder gleich nach dem trigger_watcher. Sonst hat current_lat/lon "
+        "veraltete Werte und der Watcher feuert nie. "
+        "Beim Loeschen des letzten GPS-Watchers (trigger_cancel) wieder "
+        "`request_location_tracking(on=false)` aufrufen.")
+    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,
+    condition_funcs: List[dict] | None = None,
+) -> str:
+    """Kompletter System-Prompt: Hot + Cold + Skills + Triggers."""
+    parts = [build_hot_memory_section(pinned), "", build_time_section()]
+    if skills:
+        parts.append("")
+        parts.append(build_skills_section(skills))
+    if condition_vars:
+        parts.append("")
+        parts.append(build_triggers_section(triggers or [], condition_vars, condition_funcs))
+    if cold:
+        parts.append("")
+        parts.append(build_cold_memory_section(cold))
+    return "\n".join(parts).strip()

aria-brain/proxy_client.py

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

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

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