release: bump version to 0.2.6.2

HF hat keine Sternebewertung; es gibt Downloads (30 Tage, gesamt) und
Likes. Beide sagen 'viel benutzt', nicht 'gut' (viele Downloads sind
Automatik, Likes oft beim Entdecken). Angezeigt unter dem Modellnamen mit
Hinweis im Tooltip; beim Hinzufuegen sofort, beim taeglichen Abgleich
aufgefrischt. ℹ: Zeile Beliebtheit mit Einordnung.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.claude/settings.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(ssh root@10.0.0.1 \"ls -la /root/ARIA-AGENT/aria-shared/logs/\")"
-    ]
-  }
-}

.env.example

@@ -73,3 +73,10 @@ GITEA_USER=duffyduck
 # 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=
+
+# ── LLM-Cluster ───────────────────────────────────────────────────────
+# Die ARIA-Bridge verteilt Anfragen an die lokalen Modelle aller KI-Boxen
+# (llm_cluster_* ueber RVS). Wie lange sie auf eine Antwort wartet, bevor sie
+# eine andere Box versucht bzw. aufgibt:
+#CLUSTER_LLM_TIMEOUT_S=600
+# OpenAI-kompatible Programme (OpenHands & Co.): xtts/openai_rvs_wrapper

.gitignore

@@ -15,6 +15,8 @@
 # Werte pro Maschine selbst pflegen.
 .claude/*.env
 !.claude/*.env.example
+# Lokale Claude-Permission-Allowlist mit echten Server-IPs — nicht ins (oeffentliche) Repo.
+.claude/settings.json
 
 # brain-import/ ist nur ein Drop-Folder: Stefan packt MDs rein wenn er
 # was migrieren will, klickt im Diagnostic „Migration aus brain-import/",

CHANGELOG.md

@@ -10,6 +10,204 @@ Alle Änderungen am Projekt. Format: [Keep a Changelog](https://keepachangelog.c
 
 ---
 
+## [0.2.3.0] — 2026-07-19 — Satelliten: ARIAs Augen & Hände in fremden Netzen 🛰️
+
+### Hinzugefügt
+
+**Neuer eigenständiger Container `satellite/`** — ein Außenposten, den du in einem beliebigen Netz (Büro, Werkstatt …) deployst. Er verbindet sich als RVS-Client in deinen Raum und gibt ARIA Zugriff auf **genau dieses Netz**, ohne dass der Haupt-Stack dort steht.
+- **Entdeckung (Info):** mDNS/Zeroconf (Chromecast, AirPlay, Sonos, Drucker, NAS …), SSDP/UPnP + **DIAL** (Smart-TVs, Fire TV), ARP-Tabelle (rohe Hosts) → Live-Inventar.
+- **Steuerung (mit Guards):** **DIAL-App-Launch** (z.B. „ARIA, spiel YouTube-Video X auf dem Büro-Stick" → Fire TV), **Wake-on-LAN**, generisches **HTTP**. Nur wenn `CONTROL_ENABLED=true`, nur Aktionen aus der `CONTROL_ALLOWLIST`, alles geloggt, read-only per `.env` abschaltbar. Reagiert nur auf den eigenen RVS-Raum (Token). Keine offenen Ports.
+- **Adressierung** über `SATELLITE_LOCATION` (z.B. „Büro") — mehrere Satelliten im selben Raum, jeder mit eigenem Namen.
+
+**End-to-end verdrahtet:**
+- `satellite/`: eigener Stack (`docker compose` mit `network_mode: host`), `.env.example`, README.
+- RVS: neue Message-Typen `sat_hello / sat_discover / sat_devices / sat_command / sat_result`.
+- Bridge: Satelliten-Registry (`sat_hello`) + Future-Relay (`/internal/satellite`, `/internal/satellite-list`) analog zum flux-Muster.
+- Brain: Tools `satellite_list`, `satellite_devices`, `satellite_command` + Seed-Regel, die ARIA den Ablauf beibringt (erst list, dann devices, dann command).
+- **Diagnostic: neuer Tab „Satelliten"** — zeigt live welche Satelliten verbunden sind (online/offline, Standort, Capabilities, read-only vs. steuerbar) und pro Satellit ein „Geräte scannen" (löst `sat_discover` aus → erkannte Geräte mit Typ/IP/Modell/DIAL/MAC).
+
+### Deploy
+Satellit im Ziel-Netz: `cd satellite && cp .env.example .env && docker compose up -d --build`. Haupt-Stack: `git pull && docker compose up -d --build brain bridge` + RVS-Stack `up -d --build`. Kein APK-Rebuild.
+
+---
+
+## [0.2.2.3] — 2026-07-17 — ARIA liest andere Projekt-Chats wirklich (volle Historie)
+
+### Behoben
+
+- **`project_summary` fand fast nie Inhalte.** Es las nur ARIAs rollendes Kontextfenster (~50 Turns über ALLE Projekte) — ältere/andere Projekt-Chats sind da längst rausdistilliert. „Hol dir die Infos aus Projekt X" lieferte deshalb leere Ergebnisse, und ARIA wusste nicht, wie sie an die Historie kommt. Jetzt liest das Tool die **echte, volle Historie aus `chat_backup.jsonl`** (im Brain gemountet) — die letzten ~20 Turns des Zielprojekts, unabhängig davon wie lange man da nicht war. Standort-Hints in User-Turns werden rausgefiltert. Fallback aufs Fenster, falls das Backup fehlt. Tool-Beschreibung geschärft, damit ARIA es direkt aufruft.
+- Nebenbei bereinigt: `mac_os_update_fehler` war durch den alten `set_project_kind`-Bug (0.2.2.1) fälschlich `kind=code` — auf `chat` zurückgesetzt.
+
+### Deploy
+`git pull && docker compose up -d --build brain` (kein APK-Rebuild nötig).
+
+---
+
+## [0.2.2.2] — 2026-07-17 — Voice-Projektwechsel zurück — aber gerätelokal
+
+### Hinzugefügt
+
+- **„ARIA, geh in Projekt X" per Sprache wechselt wieder das Projekt** — aber **nur auf dem Gerät, das den Befehl gab**. Andere App-Instanzen und das Diagnostic bleiben in ihrem Projekt.
+- Umsetzung: Jedes Gerät merkt sich die IDs seiner eigenen Anfragen (Text-`clientMsgId` + Voice-`audioRequestId`). Der Brain/Voice-Router hängt an jedes `project_changed`-Event die auslösende `clientMsgId` an; die App folgt dem Wechsel nur, wenn die ID eine **eigene** ist. Deckt beide Voice-Pfade ab (ARIAs `project_enter`/`exit` via `send_to_core` **und** den Bridge-Voice-Router „für Projekt X: …" / „zurück zum Hauptchat").
+- Manuelles Umschalten bleibt wie gehabt gerätelokal über den Drawer.
+
+### Deploy
+`git pull && docker compose up -d --build bridge` + APK 0.2.2.2 (kein Brain-Rebuild nötig).
+
+---
+
+## [0.2.2.1] — 2026-07-17 — Projekt-Fokus wirklich pro Gerät unabhängig
+
+### Behoben
+
+- **`set_project_kind` markierte das falsche Projekt.** Es nutzte den **globalen** `active_project` (geräteübergreifend) statt des Projekts, in dem der aktuelle Request läuft. Folge: Obwohl auf der App „Basic os" aktiv war, bekam das global-aktive „Mac OS Update Fehler" `kind=code`. Jetzt wirkt das Tool auf die pro Request mitgesendete `project_id` (in `_dispatch_tool` durchgereicht) — jede App-/Diagnostic-Instanz markiert ihr eigenes Projekt.
+- **App wurde von fremden `project_changed`-Broadcasts ins andere Projekt gezogen.** Ein Projektwechsel/‑anlegen durch ARIA, das Diagnostic oder eine andere App-Instanz erzwang auf **allen** Geräten einen Fokuswechsel. Der Projekt-Fokus ist jetzt **rein gerätelokal**: Broadcasts aktualisieren nur Namen + Typ, wechseln aber nicht mehr das Projekt. Umschalten geht ausschließlich lokal über den Projekt-Drawer. So arbeitet jedes Gerät unabhängig in seinem eigenen Projekt (auch mehrere App-Instanzen).
+- Hinweis: „ARIA, geh in Projekt X" per Sprache wechselt das App-Projekt dadurch **nicht mehr** automatisch — bewusst, damit Geräte unabhängig bleiben. Wechseln über den Drawer.
+
+### Deploy
+`git pull && docker compose up -d --build brain` + APK 0.2.2.1 neu bauen.
+
+---
+
+## [0.2.2.0] — 2026-07-17 — Workbench: Taskleisten-Dock statt Zoom-Landkarte + bedienbare VNC-Konsole
+
+### Geändert
+
+**Cockpit-Navigation neu gedacht — Dock statt Pinch-Canvas**
+- Die Zoom-Landkarte (mit 2 Fingern rauszoomen, Kachel finden, reintippen) fühlte sich auf 5 Zoll fummelig an. Ersetzt durch eine **Taskleiste unten im Daumenbereich** (Chat · Code · Desktop): **ein Tap wechselt sofort** das Panel, ein animierter Indikator gleitet unter das aktive Icon. Desktop-*Umfang*, Handy-*Ergonomie*.
+- Jedes Panel ist **bildschirmfüllend** und Handy-optimiert; alle bleiben gemountet (nur das aktive ist sichtbar) → kein Remount, Chat behält RVS/Audio/Queue, WebViews ihren Zustand.
+- Das Dock **blendet bei offener Tastatur aus** (mehr Platz zum Tippen) und respektiert die Gesten-Navigationsleiste (Safe-Area).
+- **Aktivitäts-Punkte** am Dock: Code blau, sobald Dateien da sind; Desktop grün, wenn die VM verbunden ist.
+- Entfällt: Pinch/Pan-Canvas, Übersichts-Button im Header, die „Landkarten"-Thumbnails.
+
+**noVNC-Konsole endlich bedienbar**
+- Steuerungs-Leiste im Desktop-Panel: **⌨ Tastatur** (blendet die Handy-Tastatur ein, tippt direkt in die VM — inkl. Enter/Backspace/Pfeiltasten), **Strg+Alt+Entf**, und **⤢ Fit ↔ 1:1**. Tippen/Ziehen steuert weiterhin die Maus.
+
+### Deploy
+Nur **App neu bauen** (kein Backend). APK 0.2.2.0.
+
+---
+
+## [0.2.1.9] — 2026-07-17 — Kompakt ↔ Cockpit: Umschalter für den Kachel-Desktop
+
+### Hinzugefügt
+
+- **Ansichts-Umschalter im Header** („⧉ Kompakt" / „⧉ Cockpit"): Die App startet in **Kompakt** — der klassische Vollbild-Chat, **exakt wie vor dem Umbau** (Default, Mama-tauglich). Ein Tap auf den Button oben rechts schaltet auf **Cockpit** — den zoom-/verschiebbaren Kachel-Desktop. Persistiert über Neustart (`aria_view_mode`).
+- **Warum:** Nach dem 0.2.1.8-Deploy sah die App „unverändert" aus — korrekt, denn im normalen Chat gibt es nur eine Kachel (= Vollbild-Chat). Der Umschalter macht den Cockpit-Modus jetzt **explizit sichtbar/steuerbar**, statt nur bei Code-Projekten aufzutauchen.
+- Im Cockpit ist die **Übersicht jetzt immer erreichbar** (auch im Hauptchat): „⤢ Übersicht" sitzt **im Header links** (kollidiert nicht mehr mit dem Abbrechen-Button der „ARIA denkt"-Leiste), dazu 2-Finger-Pinch/Pan und Hardware-Back.
+- Im Cockpit werden **immer alle vier Kacheln** gezeigt (Chat/Editor/Desktop/Vorschau) — Editor/Desktop/Vorschau als Platzhalter mit Status-Untertitel („kein Code-Projekt" / „kein Desktop"), bis ARIA ein Code-Projekt startet bzw. eine VM läuft. Vorher wirkten sie „verschwunden", weil sie erst bei Code-Projekten auftauchten.
+
+---
+
+## [0.2.1.8] — 2026-07-17 — Desktop-Workspace: zoombarer Canvas, Live-Code-Editor, QEMU/VNC
+
+### Hinzugefügt
+
+**Zoom-/verschiebbarer Workspace-Canvas (App)**
+- Die App ist jetzt eine desktop-artige Arbeitsfläche: rausgezoomt sieht man eine **Landkarte aus Kacheln** (Chat, Editor, Desktop, Vorschau), die man mit **2 Fingern zoomt und verschiebt**. Tippt man eine Kachel an, zoomt sie voll auf und wird **echt bedienbar** („Übersicht + Fokus"). „⤢ Übersicht" bzw. der Hardware-Back führen zurück zur Landkarte.
+- Technisch: `react-native-gesture-handler` + `react-native-reanimated` (60 fps auf dem UI-Thread). Zwei Ebenen — eine skalierte Thumbnail-Welt und eine **Identity-Content-Ebene** (Scale 1), in der die schweren Inhalte (ChatScreen + WebViews) immer gemountet sind und nur die fokussierte sichtbar ist. Dadurch bleiben Touch-Koordinaten/Keyboard korrekt und nichts remountet beim Fokuswechsel. **Reiner Chat verhält sich exakt wie bisher** (eine Kachel, dauerhaft fokussiert).
+
+**Live-Code-Editor für Code-Projekte (App + Bridge + Proxy)**
+- Wird ein Projekt zum Code-Projekt (ARIA ruft `set_project_kind('code')`), erscheinen Editor- und Desktop-Kachel. Der Editor (WebView, selbstenthaltener Highlight-Editor, offline) **zeigt live, was ARIA schreibt** — und Stefan kann selbst editieren; Änderungen gehen zurück an ARIA.
+- Fluss: ARIAs `Write`/`Edit` unter `/shared/projects/<projekt-id>/` werden im Proxy abgefangen und als `code_file` über die Bridge/RVS an die App gespiegelt; Stefans Edits kommen als `code_file_edit` pfad-sicher zurück ins selbe Verzeichnis.
+
+**QEMU für alle Architekturen + Live-Desktop per VNC (Host + Bridge + App)**
+- ARIA kann jetzt VMs für **jede Architektur** bauen/testen (x86, ARM, MIPS, PPC, RISC-V, SPARC) — Host-Helper `aria-vm` (`create/boot/screenshot/list/stop`), installiert via `host-provisioning/qemu-setup.sh`. KVM für x86-Gäste, sonst TCG. Beispiel: ein Win-3.11-System bauen und in QEMU testen.
+- Der **VNC-Live-Desktop wird durch den RVS-Server getunnelt**: die Bridge brückt rohes RFB-TCP (QEMU `127.0.0.1:5901`) ↔ RVS (`vnc_data`/`vnc_input`, Base64-in-JSON), der noVNC-Client läuft in der App-WebView (`window.WebSocket`-Shim). Stefan bedient die VM **live mit Maus/Tastatur** in der Desktop-Kachel — NAT-sicher, kein offener Port am Host, kein websockify/noVNC auf dem Host nötig.
+
+**Kleineres**
+- Pro-Projekt-Layout: die zuletzt fokussierte Kachel wird pro Projekt gemerkt (`aria_workspace_layout`).
+- Projekt-Modell bekommt `kind` ('chat'|'code'); Seed-Regel lehrt ARIA den Code-Projekt-Workflow (Arbeitsverzeichnis `/shared/projects/<id>/`, `aria-vm`, VNC landet automatisch in der App).
+
+### Deploy
+`git pull && docker compose up -d --build brain bridge proxy` · RVS-Stack `up -d --build` · Host: `bash host-provisioning/qemu-setup.sh` (einmalig, als root) · APK neu bauen (nach `npm install` einmalig `npm start --reset-cache` + `gradlew clean`, wegen der neuen nativen Module).
+
+---
+
+## [0.2.1.5] — 2026-07-12 — Pro-Projekt-Queue mit Rückfrage-Loop
+
+### Hinzugefügt
+
+**Nachrichten-Queue pro Projekt (App + Diagnostic)**
+- Eine zweite Nachricht, während ARIA am aktuellen Task arbeitet, wird jetzt **angestellt** statt den laufenden Task abzubrechen (vorher: Barge-In-Cancel). Sie läuft der Reihe nach, **pro Projekt unabhängig** (paralleles Arbeiten in mehreren Projekten bleibt). Wartende Nachrichten zeigen als ⏸-Bubble — tippen entfernt sie aus der Warteschlange.
+- **Rückfrage-Loop:** Stellt ARIA eine echte, blockierende Rückfrage, **pausiert** die Queue und deine nächste Eingabe beantwortet sie — bis eine finale Antwort kommt, dann läuft der nächste Queue-Eintrag (gleiches Muster). Banner „❓ ARIA fragt nach — deine Eingabe beantwortet das". Der Stop-Button bricht den aktuellen Task ab und schaltet zum nächsten.
+- ARIA signalisiert eine Rückfrage über einen **unsichtbaren `[[AWAIT]]`-Marker** — wie speak/converse deklariert das Modell den Zustand selbst (kein „endet-mit-?"-Raten). Brain strippt ihn, gibt `awaiting_reply` durch `chat()` → `ChatOut` → Bridge-Chat-Payload. Local (tool-los) und Fast-Path markieren nie.
+
+**Pro-Projekt-Textfeld-Entwürfe (App + Diagnostic)**
+- Der Feldinhalt bleibt beim Projektwechsel erhalten: in Projekt X tippen, zu Y wechseln (leeres Feld), zurück zu X → dein Entwurf steht wieder da. In Storage persistiert.
+
+**TTS-Abspiel-Queue (App)**
+- Zwei fast gleichzeitig fertige Antworten sprechen jetzt garantiert **nacheinander** statt sich gegenseitig abzuschneiden. Vorher war das Timing-Glück (`PcmStreamPlayer.start()` ruft `stopInternal()` = flush/release, hätte die laufende gecuttet). Jetzt: „spielt hörbar" gilt bis zum echten `PcmPlaybackFinished` (nicht nur bis Stream-Ende); eine neue hörbare Antwort, die währenddessen ankommt, wird gepuffert und danach nachgespielt (Kette für 3, 4, …). Harter Stop/Barge-In/Mund-Button verwirft die Queue.
+
+### Geändert
+
+- **Voice bricht nicht mehr ab:** eine neue Sprachnachricht während ARIA arbeitet stoppt nur akustisch das TTS (sauberes Mikro) und wird über den Brain-Projekt-Lock serialisiert, statt den laufenden Task abzubrechen (passend zu „immer anstellen + Stop-Button"). Text-Senden erkennt Brain-busy als Fallback, damit auch nach einem voice-gestarteten Turn korrekt angestellt wird. Grenze: eine per Sprache gestartete Aufgabe erscheint nicht als löschbare ⏸-Bubble (Aufnahme wird live gestreamt, nicht app-seitig gepuffert).
+
+---
+
+## [0.2.1.4] — 2026-07-12 — Lokales LLM: der ehrliche Rückbau
+
+### Geändert
+
+**Lokales LLM wieder tool-los (B1a) — ein 8B ist ein schlechter Tool-Caller**
+- B1b hatte dem lokalen Modell Werkzeuge (`run_*`/`web_search`) gegeben — die gemeinsame Wurzel von **zwei** Problemen: (1) ein 8B erfindet mit Werkzeug in der Hand lieber eine plausible Antwort („der Song ist X") statt es zu rufen → Halluzination; (2) das erzwang per-Skill-Guards (skaliert nicht). Local ist jetzt wieder **tool-los** = reines Reden; alles mit Grundwahrheit (Fakt/Live-Zustand/Gedächtnis/Aktion) gehört an Claude oder den deterministischen Fast-Path. Kein Skill-Ergebnis mehr fälschbar
+- **Keine Input-Wortliste im Router:** eine kurz eingeführte `_LIVE_HINTS`-Blacklist (Wetter/Musik/… → Claude) wieder entfernt — aus offenem Freitext die Absicht per Wortliste zu raten ist nie vollständig, jeder Miss = ein Halo (nur von per-Skill auf per-Wort verschoben). Generisch = das Modell entscheidet **selbst** (`<<ESCALATE>>`); ein stärkeres lokales Modell übernimmt die Selbst-Erkennung später, bis dahin ist local per Einstellung abschaltbar (aus, nicht raus)
+- Expliziter Nutzer-Wunsch „nimm Claude/Clodi" wird im Router respektiert (geht nie lokal)
+
+### Behoben
+
+- **Info-Halluzination:** local nannte manchmal aktuellen Song/Restzeit/Skip-Titel ohne `run_spotify` zu rufen (mal echt, mal frei erfunden — „Midnight City von M83" nie aufgerufen). Neuer Output-Guard `_claims_live_media_state` eskaliert behauptete Live-Auskünfte ohne echten Skill-Call an Claude; Local-Prompt zusätzlich gehärtet (nie Titel/Zeit/Gerät ohne Tool-Ergebnis; bei „OK: next" keinen Titel erfinden)
+- **Leeres `<voice></voice>` machte TTS stumm:** Claude hängt reflexartig manchmal ein leeres Voice-Tag an → `clean_text_for_tts` nahm den leeren Inhalt → gar keine Sprachausgabe (Playlist „Fliegen" gesprochen, „Prodigy" stumm — reiner Claude-Output-Zufall, nicht Skill/Playlist-Name). Leeres/whitespace-Tag wird jetzt ignoriert, der normale Anzeigetext gelesen
+- **Datei-Anhang erschien erst nach Seitenwechsel:** die Live-`chat`-Payload trug keine `files` (Anhänge kamen nur als separates `file_from_aria`-Event) → an der Nachricht tauchte die Datei erst nach Reload aus `chat_backup` auf. Bridge schickt die `files` jetzt in der chat-Payload, App hängt sie live an die Text-Bubble (wie der Reload-Pfad) und entfernt die redundante Solo-Bubble
+- **TDZ-Zeitbombe (App):** `sendTextMessage` stand vor seinen Dependencies (`interruptAriaIfBusy`, `sendPendingAttachments`) im deps-Array — Temporal Dead Zone; lief nur dank Babels `const`→`var`-Hebung, ein strengerer Bundler hätte beim Mount weißgescreent. Deklaration hinter die Deps verschoben
+- **QRScanner tsc-clean:** toter Prop `colorForScannerFrame` (existiert in `react-native-camera-kit` v13 nicht) entfernt; die fehlerhaften Lib-Typen (optionale Props als required markiert) lokal + dokumentiert umgangen → **Projekt komplett tsc-clean (0 Fehler)**
+
+**Spotify-Skill — von ARIA live im Gespräch weiter geschärft**
+- Skip (`next`/`previous`) sagt jetzt den **echten** neuen Titel an (holt den Track nach dem Skip via API) statt local einen erfinden zu lassen
+- `playlist_play`/`search_and_play`/`play` nennen das **tatsächliche** Wiedergabegerät (aus `GET /v1/me/player`, kein Raten — verhinderte den Fehler, dass Claude ein falsch geratenes Gerät auch noch ansteuerte) und lesen konsistent vor; saubere „Sprach-Grammatik": Ansagen sprechen, Steuerbefehle (play/pause/transfer/volume) schweigen
+- `yt-dlp-download`-Skill um einen MP3-Modus erweitert — ARIA hat das fehlende Werkzeug **selbst gebaut**, als eine deutsche Titelmelodie nicht auf Spotify lag (Web-Suche → YouTube-Download → MP3 in den Chat, in <1 min)
+
+---
+
+## [0.2.1.3] — 2026-07-11
+
+### Hinzugefügt
+
+- **`skill_get`-Tool:** ARIA liest den echten Quellcode + Manifest + Readme eines Skills, **bevor** sie ihn ändert — kein Blind-Rewrite mehr (vorher wurde ein guter Skill durch eine schlechtere Neufassung ersetzt, weil das referenzierte `skill_get` gar nicht existierte)
+
+### Behoben
+
+- **`converse` folgt dem Skill (Fast-Path):** auch ein Fast-Path-Befehl kann einen Skill auslösen, nach dem noch etwas zu sagen ist — `converse` kommt jetzt aus Manifest/Skill-Output statt hart auf `False`
+- **Sprachnachricht-Bubble verschwand nach manuellem Stop:** bei „ohne Ohr" aufgenommener Sprachnachricht + Stop entfernte ein leeres stream-end-Endpoint die schon gefüllte Bubble; jetzt wird nur noch der unaufgelöste Platzhalter entfernt
+
+---
+
+## [0.2.1.2] — 2026-07-11 — Standort-Intelligenz + Skill steuert seine Ausgabe
+
+### Hinzugefügt
+
+**GPS → Ortsname im Standort-Präfix (keyless, keine Tokens)**
+- Reverse-Geocoding der Koordinaten in der Bridge (Nominatim zoom=18: Straße+Hausnr, PLZ+Ort, Bundesland; Straßen-Ref + Autobahn-km via Overpass) — damit das lokale Modell nicht „Berlin" für Oldenburg rät; Ortsname wird **vor** dem Präfix-Bau awaited (rechtzeitig für die erste Nachricht)
+- Fahrtrichtung als Himmelsrichtung **+ exakte Peilung in Grad** (Haversine/Bearing aus aufeinanderfolgenden Fixes, `MIN_MOVE_M`-Schwelle gegen Zittern)
+
+**Skill steuert seine Ausgabe selbst — `speak` + `converse` pro Aufruf**
+- Ein Skill entscheidet per JSON-Output `{speak, converse}` pro Operation, ob vorgelesen wird und ob danach 30 s weitergelauscht wird (Manifest-Default, Output überschreibt) — z. B. „was läuft" vorlesen aber kein Dialog, „nächstes Lied" stumm. In der Skill-Bauanleitung **mit dem WARUM** dokumentiert, damit die KI die Flags beim Bauen versteht (kein Hardcode im Brain)
+
+### Behoben / Geändert
+
+- **Generischer Skill-Prompt (kein Hardcode):** der Router beschreibt `run_*`-Skills generisch (weiß nicht mehr, welche „schwer" sind); ein Stop im 30-s-Lauschen beendet dieses jetzt wirklich (kein zweiter Gong / erneutes Öffnen)
+- **Anti-Halluzination:** behauptet local eine Steuerbefehl-Quittung („Spotify: …", „Playlist abspielen") ohne das Tool wirklich zu rufen → Eskalation an Claude statt erfundene Bestätigung durchzulassen
+
+---
+
+## [0.2.1.1] — 2026-07-11
+
+### Hinzugefügt
+
+- **Skill entscheidet selbst, ob vorgelesen wird (`manifest.speak`):** Grundlage der späteren `speak`/`converse`-Architektur — der `speak`-Flag greift sowohl im lokalen als auch im Claude-Pfad, statt am fragilen leeren `<voice></voice>`-Hack zu hängen
+
+---
+
 ## [0.2.0.6] — 2026-07-11
 
 ### Hinzugefügt
@@ -37,7 +235,7 @@ Alle Änderungen am Projekt. Format: [Keep a Changelog](https://keepachangelog.c
 
 ## [0.2.0.4 – 0.2.0.5] — 2026-07-11 — Plan B: Lokales LLM („Gemini-Feeling")
 
-Ein kleines, schnelles Modell (**Qwen3 8B** via llama.cpp/llama-swap auf der Gamebox-GPU) übernimmt einfache Turns in **<1 s**; alles Schwere/Technische/Werkzeug-artige reicht ein Router automatisch an **Claude** weiter. Ziel: schnelle Antworten ohne die Claude-Max-Subscription aufzugeben.
+Ein kleines, schnelles Modell (**Qwen3 8B** via llama.cpp/llama-swap auf der AI-Box-GPU) übernimmt einfache Turns in **<1 s**; alles Schwere/Technische/Werkzeug-artige reicht ein Router automatisch an **Claude** weiter. Ziel: schnelle Antworten ohne die Claude-Max-Subscription aufzugeben.
 
 ### Hinzugefügt
 

README.md

@@ -35,18 +35,17 @@ ARIA hat zwei Rollen:
             │ WebSocket Tunnel          │ WebSocket Tunnel
             ▼                           ▼
 ┌─────────────────────────────────┐
-│  Gamebox (Windows + WSL2)        │
-│  RTX 3060, Docker Desktop       │
+│  Compute-Node(s) (NVIDIA GPU)    │
+│  beliebig viele, je per .env     │
+│  konfiguriert (COMPOSE_PROFILES) │
 │  ┌──────────────────────────┐   │
-│  │ aria-f5tts-bridge        │   │
-│  │  F5-TTS Voice Cloning    │   │
-│  │  PCM-Streaming an die App │   │
-│  ├──────────────────────────┤   │
-│  │ aria-whisper-bridge      │   │
-│  │  Faster-Whisper CUDA     │   │
-│  │  STT in fast-Echtzeit    │   │
+│  │ aria-voxtral-bridge      │   │ Profil: voxtral (Default-STT)
+│  │ aria-f5tts-bridge        │   │ Profil: f5tts   (TTS)
+│  │ aria-llm-adapter+swap    │   │ Profil: llm     (lokales LLM)
+│  │ aria-whisper-bridge      │   │ Profil: whisper (STT-Fallback)
 │  └──────────────────────────┘   │
-│  Beide teilen ./voices Volume    │
+│  Aufteilbar: 1 Node pro Dienst   │
+│  ODER All-in-One. GPU per *_GPU. │
 │  xtts/docker-compose.yml        │
 └─────────────────────────────────┘
 ┌─────────────────────────────────────────────────────────┐
@@ -95,11 +94,18 @@ ARIA hat zwei Rollen:
 |-----|----|-----|
 | RVS | Rechenzentrum | `cd rvs && docker compose up -d` |
 | ARIA Brain/Bridge/Diagnostic | Debian 13 VM | `./init.sh && ./aria-setup.sh && docker compose up -d` |
-| Gamebox-Stack (F5-TTS + Whisper) | Gamebox (GPU) | `cd xtts && docker compose up -d` |
+| Compute-Node(s) (STT/TTS/LLM) | 1..n GPU-Rechner | `cd xtts && cp .env.example .env && docker compose up -d` |
+| Satellit(en) 🛰️ (optional) | Fremdes Netz (Büro …) | `cd satellite && cp .env.example .env && docker compose up -d --build` |
+| Host-Agent(en) 💻 (optional) | Direkt auf einem Rechner | `cd host-agent && ./build.sh` → Binary + `.env` auf den Rechner, starten (Details unten & in [`host-agent/README.md`](host-agent/README.md)) |
+| Android-Agent 📱📺 (optional) | Handy, Tablet, Fire TV | `cd host-agent/android && ./build.sh` → APK, oder per Satellit via ADB ausrollen (Details unten) |
 | Android App | Stefans Handy | APK installieren (Auto-Update via RVS) |
 
-> Der Gamebox-Stack ist optional: ohne ihn faellt STT auf lokales Whisper (CPU,
+> Compute-Nodes sind optional: ohne sie faellt STT auf lokales Whisper (CPU,
 > langsamer) zurueck; TTS bleibt aus (ARIA antwortet dann nur als Text).
+> Jeder Node startet per `COMPOSE_PROFILES` in seiner `.env` nur die Dienste,
+> die er anbieten soll (`voxtral`/`f5tts`/`llm`/`whisper`) — so laesst sich der
+> GPU-Stack auf mehrere Maschinen verteilen (STT-Box, TTS-Box, LLM-Box) oder
+> als All-in-One auf einer Kiste fahren (`voxtral,f5tts,llm`).
 
 ---
 
@@ -134,8 +140,8 @@ RVS_PORT=443
 RVS_TLS=true
 RVS_TLS_FALLBACK=true
 
-# Pairing-Token: Verbindet App, Bridge, Diagnostic und Gamebox im gleichen RVS-Room
-# MUSS auf allen Geraeten identisch sein (ARIA-VM, Gaming-PC, App)
+# Pairing-Token: Verbindet App, Bridge, Diagnostic und Compute-Nodes im gleichen RVS-Room
+# MUSS auf allen Geraeten identisch sein (ARIA-VM, Compute-Nodes, App)
 RVS_TOKEN=              # ./generate-token.sh
 ```
 
@@ -204,6 +210,37 @@ Die Diagnostic-UI hat sechs Top-Tabs:
 - **Dateien** — alle Dateien aus `/shared/uploads/` mit Multi-Select, Bulk-Download (ZIP) + Bulk-Delete
 - **Einstellungen** — Reparatur (Container-Restart), Wipe, Sprachausgabe, Whisper, Sprachmodell, Runtime-Config, App-Onboarding (QR), Komplett-Reset
 
+### 6. (Optional) Desktop-Workspace: QEMU auf dem Host
+
+Nur noetig, wenn ARIA VMs bauen/testen und du sie live in der Desktop-Kachel der
+App bedienen koennen sollst (Code-Projekte, z. B. ein Win-3.11-System). **Wird
+NICHT von `docker compose` mitinstalliert** — QEMU laeuft direkt auf dem Host
+(10.0.0.1), nicht in einem Container, weil dort KVM sitzt und die VNC binden
+kann. Einmalig als root:
+
+```bash
+sudo bash host-provisioning/qemu-setup.sh
+```
+
+Installiert `qemu-system-*` fuer **alle Architekturen** (x86/ARM/MIPS/PPC/SPARC/
+RISC-V), `qemu-utils`, Firmware, `socat`, `imagemagick` und den Helper
+`/usr/local/bin/aria-vm`. KVM-Beschleunigung gibt es nur fuer x86-Gaeste; andere
+Architekturen laufen emuliert (TCG). Danach testen:
+
+```bash
+aria-vm list
+```
+
+ARIA steuert VMs dann per `ssh aria-wohnung aria-vm ...` (create/boot/screenshot/
+list/stop). Der VNC-Desktop wird automatisch als RFB-Bytes durch die Bridge/RVS
+in die App getunnelt — **kein** Port am Host oeffnen, **kein** websockify/noVNC
+auf dem Host noetig (der noVNC-Client liegt in der App). Ohne diesen Schritt
+funktioniert alles andere normal; nur die Desktop-Kachel bleibt leer.
+
+> **App-Rebuild noetig** fuer den Workspace: die neuen nativen Module
+> (gesture-handler, reanimated, webview) brauchen nach `npm install` einmalig
+> `npm start --reset-cache` + `./gradlew clean`, dann APK neu bauen.
+
 ---
 
 ## Proxy — Wie funktioniert das?
@@ -272,28 +309,28 @@ Danach wird der Proxy gepatcht:
 
 ## Voice Bridge
 
-Die Bridge verbindet die Android App mit ARIA und orchestriert die GPU-Services
-auf der Gamebox.
+Die Bridge verbindet die Android App mit ARIA und orchestriert die GPU-Dienste
+auf den Compute-Nodes.
 
 **Nachrichtenfluss:**
 ```
 Text:   App → RVS → Bridge → aria-brain (HTTP)
-Audio:  App → RVS → Bridge → stt_request (RVS) → whisper-bridge (Gamebox)
-                          → stt_response → Bridge → aria-brain
+Audio:  App → RVS → STT-Node (voxtral/whisper) direkt (Streaming)
+                 → stt_endpoint/stt_stream_done → Bridge → aria-brain
         Fallback bei Timeout: lokales faster-whisper (CPU)
 Datei:  App → RVS → Bridge → /shared/uploads/ → aria-brain (mit Pfad)
 
 aria-brain → Antwort → Bridge → RVS → App
-                              → xtts_request (RVS) → f5tts-bridge
+                              → xtts_request (RVS) → f5tts-Node
                               → audio_pcm Stream → RVS → App AudioTrack
 ```
 
 ### Features
 
-- **STT primaer remote**: aria-bridge sendet `stt_request` an die Gamebox-Whisper
-  (faster-whisper CUDA, fast Echtzeit). 45s Timeout, dann Fallback auf lokales
-  CPU-Whisper. Modell-Wahl in Diagnostic, Hot-Swap via config-Broadcast.
-- **TTS via F5-TTS**: aria-f5tts-bridge auf der Gamebox. Voice Cloning mit
+- **STT primaer remote**: die App streamt Audio direkt an einen STT-Node
+  (Voxtral-3B default, faster-whisper Fallback-Profil), fast Echtzeit. Timeout →
+  Fallback auf lokales CPU-Whisper. Modell-Wahl in Diagnostic, Hot-Swap via config.
+- **TTS via F5-TTS**: aria-f5tts-bridge auf einem Compute-Node. Voice Cloning mit
   Referenz-Audio + automatisch transkribiertem Referenz-Text.
 - **Text-Cleanup**: `<voice>...</voice>` Tag bevorzugt; Markdown, Code,
   Einheiten und URLs werden TTS-gerecht aufbereitet. Dezimalzahlen werden
@@ -427,6 +464,44 @@ manueller Diagnostic-Klick) gehoeren seed_rules zum Brain-Code und werden
 mit jedem Deploy ausgerollt. Editieren = `SEED_RULES`-Liste anpassen,
 Brain neu starten.
 
+### Beispiel: `flugwetter`
+
+Zeigt gut, wie ein Skill mit Zugangsdaten und mehreren Quellen aussieht —
+Briefing fuer **EDWI** (Wilhelmshaven-Mariensiel, Piste 02/20), nur mit
+Python-Bordmitteln, keine pip-Pakete.
+
+| Was | Woher | Kosten |
+|---|---|---|
+| METAR/TAF | aviationweather.gov | frei |
+| Wind, Boeen | Open-Meteo **ICON-D2** | frei |
+| Bedeckung, Sicht | DWD **MOSMIX** Station 10125 | frei |
+| GAFOR, Karten | **ftp.pcmet.de** | Stefans pc_met-Konto |
+
+Die pc_met-Zugangsdaten stehen in der **Skill-Konfiguration**
+(`pcmet_user` / `pcmet_password`), nie im Chat. `ftp.pcmet.de` ist die vom DWD
+dokumentierte Kundenschnittstelle — kein Nachbauen des Browser-Logins noetig.
+`action=discover` listet, was auf dem Server liegt; `action=fetch` holt eine
+Karte nach `/shared/uploads` und gibt sie als `[FILE:]`-Marker zurueck, sodass
+ARIA sie anzeigen oder an einen Agenten schicken kann.
+
+Zwei Dinge, die den Unterschied machen:
+
+- **Seitenwind statt nur Wind.** Gerechnet gegen Piste 02/20 und gegen Stefans
+  15-kt-Grenze (`crosswind_limit_kt`), bewertet werden die **Boeen**.
+- **Jede Zahl nennt ihre Herkunft.** Die Wolkenuntergrenze ist entweder
+  *gemessen* (METAR), ein ausdruecklich markierter *Schaetzwert*
+  (Temp/Taupunkt, 400-ft-Regel) oder *nicht verfuegbar* — dann steht da, dass
+  man ins GAFOR schauen muss. `CAVOK` wird als eigene Aussage behandelt und
+  unterdrueckt die Schaetzung, die sonst direkt widersprechen wuerde.
+  Genau daran war ein Briefing vorher gescheitert: METAR meldete `NCD`
+  (AUTO-Station), das Bodenmodell meldete bedeckt, und niemand wusste, was gilt.
+
+Oben im Ergebnis steht eine **KURZFASSUNG in ganzen Saetzen zum Vorlesen**
+(„fuenftausend Fuss", nicht „5000 ft") — eine vorgelesene Tabelle versteht
+niemand. Fuer die Ausgabe auf einem Geraet kombiniert ARIA:
+`run_flugwetter` → optional `action=fetch` → `host_notify(text=<Kurzfassung>,
+image_path=<Karte>, mode='both', seconds=0)`.
+
 ---
 
 ## Diagnostic — Selbstcheck-UI und Einstellungen
@@ -435,8 +510,8 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 
 ### Tabs
 
-- **Main**: Brain/RVS/Proxy-Status, Chat-Test, "ARIA denkt..."-Indikator, **💭 Gedanken-Stream** (zentrales Modal, zeigt live alle Tool-Calls + Phasen mit Zeitstempel und Trennlinien bei langen Pausen), End-to-End-Trace, Container-Logs
-- **Gehirn**: Memory-Browser (Vector-DB), Suche mit zwei Modi (**📝 Wortlich** = Substring-Match Default + **🧠 Semantisch** mit Score-Threshold), **Advanced Search** (aufklappbares Panel, beliebig viele AND/OR-verknuepfte Felder, + Button fuer mehr Zeilen), Type+Pinned-Filter (greifen auch in der Suche), klappbare Type-Kategorien (Default eingeklappt), Add/Edit/Delete mit Category-Autosuggest, **📎 Anhaenge** pro Memory (Bilder/PDFs/...): Upload + Thumbnail-Vorschau + Lightbox + Lösch-Button, 📎N-Badge in der Liste, automatischer Cleanup beim Memory-Delete. ℹ-Info-Modal das erklaert welche Types FEST in den Prompt vs. Cold Memory wandern. **📄 Druckansicht** (Strg+P → PDF). Konversation-Status mit Destillat-Trigger, **Token/Call-Metrics mit Subscription-Quota-Tracking**, Bootstrap & Migration (3 Wiederherstellungs-Wege), Gehirn-Export/Import (tar.gz)
+- **Main**: Brain/RVS/Proxy-Status, Chat-Test mit **Kontext-Streifen** (Hauptchat + Projekte als Karten mit Status-Dot; Tap wechselt den Fokus, rechts daneben **„+ Projekt"** — legt an, aktiviert und fokussiert in einem Schritt, der Knopf steht ausserhalb des scrollenden Streifens damit er bei vielen Projekten erreichbar bleibt), "ARIA denkt..."-Indikator, **💭 Gedanken-Stream** (zentrales Modal, zeigt live alle Tool-Calls + Phasen mit Zeitstempel und Trennlinien bei langen Pausen), End-to-End-Trace, Container-Logs
+- **Gehirn**: Memory-Browser (Vector-DB), Suche mit zwei Modi (**📝 Wortlich** = Substring-Match Default + **🧠 Semantisch** mit Score-Threshold), **Advanced Search** (aufklappbares Panel, beliebig viele AND/OR-verknuepfte Felder, + Button fuer mehr Zeilen), Type+Pinned-Filter (greifen auch in der Suche), klappbare Type-Kategorien (Default eingeklappt), Add/Edit/Delete mit Category-Autosuggest, **📎 Anhaenge** pro Memory (Bilder/PDFs/...): Upload + Thumbnail-Vorschau + Lightbox + Lösch-Button, 📎N-Badge in der Liste, automatischer Cleanup beim Memory-Delete. ℹ-Info-Modal das erklaert welche Types FEST in den Prompt vs. Cold Memory wandern. **📄 Druckansicht** (Strg+P → PDF). **Datum/Uhrzeit pro Gedanke** („angelegt 03.10.26, 09:14 · geändert … (vor 3 Std)") — `created_at`/`updated_at` lagen immer schon in der DB und wurden nur nie angezeigt. Dazu **Sortierung** (nach Typ gruppiert oder Anlage/Aenderung auf-/absteigend; bei Zeit-Sortierung flach statt gruppiert) und ein **🕒 Zeitraum-Filter** (von/bis, umschaltbar angelegt/geaendert, Schnellwahl Heute / 7 / 30 Tage) der auch fuer Such-Treffer gilt. Konversation-Status mit Destillat-Trigger, **Token/Call-Metrics mit Subscription-Quota-Tracking**, Bootstrap & Migration (3 Wiederherstellungs-Wege), Gehirn-Export/Import (tar.gz)
 - **Skills**: Liste aller Skills mit Logs pro Run, Activate/Deactivate, Export/Import als tar.gz, "von ARIA"-Badge fuer selbst gebaute
 - **Trigger**: passive Aufweck-Quellen. **Timer** (einmalig, ISO-Timestamp oder via `in_seconds` als Server-Berechnung) + **Watcher** (recurring, mit Condition + Throttle). Liste aktiver Trigger + Logs pro Feuer-Event. Modal mit Type-Dropdown, Live-Anzeige aller verfuegbaren Condition-Variablen (`disk_free_gb`, `hour_of_day`, `current_lat/lon`, `last_user_message_ago_sec`, …). **Drei GPS-Funktionen** mit unterschiedlicher Semantik:
   - `near(lat, lon, r)` — SOLANGE im Radius (mit Throttle gegen Spam). Use-Case: „bin ich noch in der Nähe von X?"
@@ -446,22 +521,39 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
   Sicherer Condition-Parser via Python `ast` (Whitelist, kein `eval`). Der System-Prompt enthaelt zusaetzlich einen `## Aktuelle Zeit`-Block (UTC + Europa/Berlin) damit ARIA Timer-Zeitpunkte korrekt setzen kann.
 
   **Auflösung**: Background-Loop tickt alle 8s (vorher 30s — bei 100 km/h durch einen 300m-Radius war eine Vorbeifahrt nur ~22s drin und konnte verpasst werden). Plus event-getrieben: Bridge ruft nach jedem `location_update` von der App sofort einen `/triggers/check-now` im Brain — Watcher sehen die frische Position in Millisekunden statt im Polling-Takt. `near()`-Funktionen ignorieren GPS-Daten älter als 5 Minuten (verhindert Phantom-Fires bei abgeschaltetem Tracking).
+
+  **Projekt-Kontext**: ein Trigger merkt sich das Projekt, in dem er angelegt wurde (`project_id`), und die Antwort kommt beim Feuern **dort** zurueck. Ohne das landete jede Trigger-Antwort im Hauptchat — im Projekt-Thread blieb es still, und es sah aus wie „der Timer hat nicht gefeuert".
+
+  **Zustand ehrlich**: ein One-Shot-Timer wird nach dem Feuern automatisch deaktiviert. `trigger_list` zeigt darum ausdruecklich `SCHON GEFEUERT (Nx, zuletzt <Zeit>)` statt nur „DEAKTIVIERT" — sonst sind „hat sauber gefeuert" und „war nie an" nicht unterscheidbar, und ARIA berichtet guten Glaubens das Falsche.
+- **Integrationen → Jellyfin**: beliebig viele Server (`+`-Button) mit URL + API-Key. ARIA steuert die Wiedergabe ueber die **API** (`jellyfin_search` / `jellyfin_devices` / `jellyfin_play` / `jellyfin_control`) statt sich per `ui_tap` durch die Oberflaeche zu klicken — schneller und zuverlaessiger. Eine eingeschlafene Sitzung erkennt ARIA selbst und baut sie neu auf.
 - **Dateien**: Browser fuer `/shared/uploads/` mit Multi-Select + "Alle markieren" + Bulk-Download (ZIP bei 2+) + Bulk-Delete. Live-Update der Chat-Bubbles beim Delete.
 - **Einstellungen**: Reparatur (Container-Restart fuer Brain/Bridge/Qdrant), Komplett-Reset, Betriebsmodi, Sprachausgabe + Voice-Cloning + F5-TTS-Tuning + Voice Export/Import, **FLUX Bildgenerierung** (Default-Modell + Raw/Switch-Keywords + HF-Token), **OAuth-Apps** (Spotify Default, alle anderen Provider per ARIA on-demand oder "+ Custom"-Button mit auth_url/token_url/scopes) mit client_id+client_secret pro Service + One-Click-Autorisieren + Service-Loeschen, Whisper, Sprachmodell (brainModel), Onboarding-QR, App-Cleanup
 
 ### Was zusaetzlich noch drin steckt
 
+- **Agent-Historie** (Satelliten → Host-Agenten): pro Agent eine aufklappbare Historie der Befehle und Screenshots, gruppiert **pro User-Nachricht** — man sieht, welche Geraete-Aktionen zu welcher Frage gehoerten. Brain schickt dafuer je Host-Aktion ein `agent_history`-Event; die Bridge haelt es und antwortet auf `agent_history_query`.
+- **Auslastungs-Monitor** pro Compute-Box: Klick auf „Auslastung" zeigt **live `nvidia-smi`** (1s-Takt) plus zwei Verlaufs-Graphen (GPU-Last und Token-Verbrauch, 15s-Sampling, Ringpuffer ~2h) und ein Besen-Symbol zum Zuruecksetzen. Die **Historie liegt auf der Box**, nicht im Diagnostic — abgeholt per RVS (`node_stats_*`), kein SSH und kein Docker-Socket noetig.
 - **Disk-Voll Banner** mit copy-baren Cleanup-Befehlen (safe + aggressiv)
 - **Token/Call-Metrics**: pro Claude-Call ein Eintrag in `/data/metrics.jsonl` mit ts + Token-Schaetzung. Gehirn-Tab zeigt 1h/5h/24h/30d-Aggregat plus Progress-Bar gegen Plan-Limit (Pro / Max 5x / Max 20x / Custom). Warn-Schwelle 80%, kritisch 90%.
 - **Voice Cloning**: Audio-Samples hochladen, Whisper transkribiert den Ref-Text automatisch
-- **Voice Export/Import**: einzelne Stimmen als `.tar.gz` zwischen Gameboxen mitnehmen
+- **Voice Export/Import**: einzelne Stimmen als `.tar.gz` zwischen Compute-Nodes mitnehmen
 - **Settings Export/Import**: `voice_config.json` + `highlight_triggers.json` als JSON-Bundle
 - **Claude Login**: Browser-Terminal zum Einloggen in den Proxy
 - **ARIA Live**: read-only Mirror der Claude-Code-Session — alle Tool-Calls + Inputs + Outputs live in einer Monospace-Liste, farbcodiert. **Persistenz**: jeder `agent_stream`-Event wird parallel in `/shared/logs/agent_stream.jsonl` (soft-cap 50 MB) geschrieben, Live-View laedt beim Tab-Oeffnen / Page-Reload die letzten 200 Eintraege — Browser-Standby wirft nichts mehr weg. Plus ⛔ **Not-Aus**-Button der per RVS einen `cancel_request` mit `hard:true` ausloest → aria-bridge ruft den proxy-internen `/cancel-all` Side-Channel → alle Claude-Subprocesses werden sofort gekillt
 - **Debug-API ohne SSH** (Diagnostic-Server, Port 3001):
   - `GET /api/chat-backup?lines=N` — letzte N Zeilen aus `chat_backup.jsonl` (Default 200, max 5000) als geparstes JSON. Hilfreich um nachzuvollziehen was ARIA tatsaechlich gemacht hat.
   - `GET /api/agent-stream?lines=N` — gleiche Mechanik fuer den persistierten Live-Stream (Tool-Calls + Inputs + Outputs).
-- **OAuth-Callback-Pipeline**: Caddy davor terminiert TLS via Let's Encrypt, RVS hat einen HTTP-Listener auf demselben Port wie der WebSocket. Provider (Spotify/Dropbox/Discord/...) redirecten den User an `https://{RVS_HOST}/oauth/callback/{service}` → RVS broadcastet als `oauth_callback`-WS-Message → aria-bridge forwarded an Brain → Brain matched `state`, tauscht `code` gegen Token, persistiert in `/shared/config/oauth_tokens.json`. Token-Refresh laeuft automatisch. ARIA hat vier Brain-Tools: **`oauth_register_provider`** (legt URLs eines neuen Providers wie Dropbox/Discord/Notion/... on-demand in `oauth_apps.json` an — Credentials bleiben Stefans Job), `oauth_authorize`, `oauth_get_token`, `oauth_revoke`
+- **OAuth-Callback-Pipeline**: Caddy davor terminiert TLS via Let's Encrypt, RVS hat einen HTTP-Listener auf demselben Port wie der WebSocket. Provider (Spotify/Dropbox/Discord/...) redirecten den User an `https://{RVS_HOST}/oauth/callback/{service}` → RVS broadcastet als `oauth_callback`-WS-Message → aria-bridge forwarded an Brain → Brain matched `state`, tauscht `code` gegen Token, persistiert in `/shared/config/oauth_tokens.json`. Token-Refresh laeuft automatisch. ARIA hat fuenf Brain-Tools: **`oauth_register_provider`** (legt URLs eines neuen Providers wie Dropbox/Discord/Notion/... on-demand in `oauth_apps.json` an — Credentials bleiben Stefans Job), `oauth_authorize`, `oauth_get_token`, **`oauth_call`**, `oauth_revoke`
+- **LLM-Cluster: Programme fragen ein Modell, der Cluster waehlt die Karte** — die ARIA-Bridge ([`bridge/llm_cluster.py`](bridge/llm_cluster.py)) kennt alle Boxen und Karten. Programme schicken `llm_cluster_request` ueber RVS (ohne Box/Karte), die Bridge waehlt unter allen Karten mit diesem Modell die mit den wenigsten laufenden Anfragen, und faellt eine Box mitten in der Anfrage aus (kein Ping mehr), geht sie einmal an eine andere. `llm_cluster_models` liefert jedes Modell **einmal** samt `ctx` (kleinstes Kontextfenster unter seinen Karten). Fehler kommen als Fehler (`model_unavailable` …), nie als Antwort-Text. ARIA selbst nutzt denselben Router (mit ihrer kurzen 30-s-Frist). Fuer Programme, die nur OpenAI koennen: [`xtts/openai_rvs_wrapper/`](xtts/openai_rvs_wrapper/) — kleiner Container NEBEN dem Programm, fuer das der Cluster dann `http://127.0.0.1:8099/v1` ist; Hilfsseite auf `/` zeigt Status und Modelle; braucht nur eine ausgehende Verbindung zum RVS (getestet mit dem offiziellen OpenAI-SDK). Schnittstelle: [`docs/LLM-SCHNITTSTELLE.md`](docs/LLM-SCHNITTSTELLE.md)
+- **Lokale Modelle: ein Modell pro Karte, Clients waehlen nur aus** — Schnittstelle fuer Drittprogramme: [`docs/LLM-SCHNITTSTELLE.md`](docs/LLM-SCHNITTSTELLE.md). Jede LLM-Karte einer Box (`LLM_GPUS=1,2` in der `.env`, alt `LLM_GPU=1`) haelt genau ein Modell, dauerhaft geladen; welches, legt nur die Diagnostic fest (Modell-Katalog → „Laden" → Ziel-**Karte**, in der Flotte pro Karte „Entladen"). Karten, die nicht fuers LLM vorgesehen sind, erscheinen dort gar nicht. Clients — ARIA, Fremdprogramme ueber RVS, OpenHands ueber den OpenAI-Port — sehen nur die geladenen Modelle aller Boxen und laden **nie** etwas: eine Anfrage fuer ein anderes Modell wird abgelehnt (`model_not_loaded` bzw. HTTP 404), nichts wird verdraengt. Mehrere Clients koennen dasselbe Modell gleichzeitig nutzen (gemessen: zwei parallel in 4,5 s statt 10 s nacheinander). Technik: der llm-adapter schreibt eine llama-swap-Config nur aus den belegten Karten — pro Modell `CUDA_VISIBLE_DEVICES=<Karte>` (mit `CUDA_DEVICE_ORDER=PCI_BUS_ID`, damit die Nummern wie bei nvidia-smi zaehlen), `ttl: 0`, eine Gruppe mit `swap: false` und Preload beim Start; llama-swap laeuft mit `--watch-config` (die frueher aufgerufenen Reload-Endpunkte gab es nicht). Laden oder Entladen startet die anderen Karten der Box kurz neu. Schlaegt das Laden fehl, wird die Karte auf ihr vorheriges Modell zurueckgesetzt. Bestehende Boxen: das bisherige Standardmodell (`LLM_MODEL`) landet beim ersten Start auf der ersten LLM-Karte
+- **Lokale Modelle laden mit Fortschritt** (Modell-Katalog → „Laden", Knopf **⬇ Downloads**): echte Prozentanzeige mit Tempo und Restzeit, danach „laedt in die Karte" und am Ende „✓ in Karte N (Name) geladen" samt belegtem VRAM. llama.cpp zieht das GGUF per `-hf` selbst und meldet nichts; der llm-adapter fragt deshalb vorab bei Hugging Face, welche Dateien mit welcher Groesse und sha256 kommen, und misst genau diese im HF-Cache-Layout (`/models/models--org--repo/blobs/<sha256>.downloadInProgress`, nach Abschluss ohne Endung) — klappt auch bei gesplitteten Modellen und parallelen Downloads; liegt es schon im Cache, geht es direkt ans Laden. Der Warmup wartet jetzt bis zu `LLM_WARMUP_TIMEOUT_S` (1900 s) statt 60 s — vorher meldete ein mehrere GB grosses Modell „Fehler", waehrend llama-swap weiterlud. Ein Auftrag, auf den die Box nicht antwortet, erscheint nach 30 s als Warnung statt still zu verschwinden. Pro LLM-Box laeuft **ein** Modell auf ihrer LLM-Karte (`LLM_GPU`), ein anderes zu laden wechselt dorthin. *Wichtig:* `llm_provision_*` fehlte bis hierhin in der RVS-Allow-List — „Laden" hat seit Stage D nie eine Box erreicht
+- **Sprachmodell**: die Auswahlliste kommt aus **Anthropics eigenem Modell-Katalog** (`downloads.claude.ai/model-catalog/v1/catalog.json`, Surface `cc`) — dieselbe Quelle, aus der sich Claude Code bedient. Oeffentlich, ohne API-Key. Oben die **Tier-Aliase** (opus/sonnet/haiku/fable), die automatisch der neuesten Version folgen; darunter die **exakten Versionen**, aeltere als solche markiert. „↻ Aktualisieren" holt frisch, sonst 6h-Cache mit Datei-Fallback fuer offline. **🔬 Testen** schickt eine echte Mini-Anfrage durch den ganzen Weg und zeigt, welches Modell tatsaechlich geantwortet hat (aus `modelUsage.canonicalModel` der CLI — das Modell selbst zu fragen waere unzuverlaessig). Vier Ergebnisse: Tier aufgeloest (gruen), exakte Version (gruen), **nicht erkannt** (gelb — der Proxy haette still `opus` eingesetzt), ungueltig (rot, mit CLI-Begruendung)
+- **ARIA E-Mail** (Einstellungen → Integrationen): ARIA liest und sendet Mails ueber IMAP/SMTP (je SSL/TLS, STARTTLS oder unverschluesselt, Zertifikatspruefung abschaltbar fuer eigene Server) — Text, HTML, **Anhaenge** und **eingebettete Bilder** (`<img src="cid:…">`), Antworten mit `In-Reply-To`, Ordner anlegen (auch Unterordner) und Mails verschieben. Tools: `email_status`, `email_send`, `email_list`, `email_read`, `email_folders`, `email_folder_create`, `email_move`. Code in [`aria-brain/aria_mail.py`](aria-brain/aria_mail.py). **Whitelist** ist eine harte Grenze im Sendepfad, kein Prompt-Hinweis: alles, was nicht drinsteht, ist gesperrt, leer = ARIA sendet nirgendwohin; geprueft wird jeder Empfaenger (An/Cc/Bcc), ein fremder blockiert die ganze Mail. Eine Schreibweise, damit kein Eintrag mehrdeutig ist: `stefan@hacker-net.de` (genau die), `*@hacker-net.de` (die Domain, NICHT `evilhacker-net.de`, keine Subdomains), `*@*.hacker-net.de` (Subdomains), `*@*` (alles); Kurzformen wie `*hacker-net.de` werden beim Speichern mit Korrekturvorschlag abgelehnt. **Zugangsdaten sieht ARIA nie**: Konfiguration und Passwort liegen im Brain unter `/data` (in ARIAs Container nicht eingehaengt — `/shared` dagegen schon, darum NICHT dort), keine Schnittstelle gibt das Passwort zurueck (nur „gesetzt"), der Brain-Export laesst `email_secret.json` und `email_admin.key` aus. Konfiguration lesen/aendern nur mit Admin-Schluessel (`X-Aria-Admin`, liegt in `/data`), den die Diagnostic anhaengt — Anfragen aus ARIAs Container weist sie ab, sonst koennte eine eingehende Mail ARIA dazu bringen, per curl die Whitelist zu oeffnen. *Grenze:* ARIAs Container hat einen SSH-Schluessel auf die VM; legt sie es gezielt darauf an, kommt sie als root an jede Datei — das hier verhindert, dass Zugangsdaten von selbst irgendwo auftauchen, keinen bewussten Einbruch. Eingehende Mails sind fuer ARIA als **Daten, nicht Anweisungen** markiert. Kopie jeder gesendeten Mail landet in „Gesendet" (fehlt der Ordner, wird er angelegt). **📬 Postfach oeffnen** zeigt ARIAs ganzes Postfach in eigenem Fenster, Unterordner eingerueckt — nur fuer dich zum Reinschauen, markiert nichts als gelesen (sonst wuesste ARIA nicht mehr, was neu ist); Mail-HTML laeuft in einem Rahmen ohne Skripte und ohne Nachladen von aussen (kein Tracking-Pixel), eingebettete Bilder werden mitgeliefert
+- **Modell pro Chat**: jeder Chat (Hauptchat und jedes Projekt) kann sein eigenes Modell haben, ohne die Einstellung fuer alle umzustellen. Reihenfolge: **Einstellung** (`brainModel`) < **pro Chat** (`/shared/config/context_models.json`, gesetzt per 🧠-Auswahl neben „+ Projekt") < **Ausweich** (Sicherheitsfilter, s.u.). Angezeigt wird immer, was der **naechste Turn wirklich nutzt**: in den Kontext-Karten, in der Auswahl (orange „↪ läuft auf …" plus **„↩ zurück zu …"**, wenn gerade ausgewichen wird) und an jeder ARIA-Bubble — dort das Modell, das tatsaechlich geantwortet hat (aus `modelUsage` der CLI, also die aufgeloeste Version statt des Alias). Als Grundeinstellung zaehlt das Modell, mit dem das Brain **laeuft**, nicht der Dateiwert — ein ausstehender Neustart nach Aenderung von `brainModel` faellt so auf. In der **App** dasselbe hinter der Quell-Anzeige (Einstellungen, Default aus): Modell-Chip in der Kopfzeile, Tippen oeffnet die Auswahl fuer diesen Chat, die Bubbles zeigen das Modell statt nur „Claude"
+- **Sicherheitsfilter-Rettung** (🛡 Sicherheitsfilter): Anthropics Filter („*... safeguards flagged this message*", `Details: [cyber]`) trifft gern genau die Themen, um die es hier geht — Ports, Tunnel, Zugangsdaten. Die Meldung kommt **nicht** als HTTP-Fehler: die CLI liefert ein normales Ergebnis mit `is_error:true` und dem Fehlertext im `content`, also genau dort, wo sonst ARIAs Antwort steht. Ungeprueft landete dieser Text als ARIAs Wort im Verlauf — und weil der Verlauf bei jedem Turn mitgeht, kippte danach **jede** weitere Frage im selben Projekt an derselben Stelle. Jetzt zwei Stufen: **(1)** derselbe Turn wird automatisch mit dem **Ausweich-Modell** neu gefragt (einstellbar unter Sprachmodell, Default: anderes Tier — der Filter haengt am Modell, Anthropic raet selbst zu „change your model"); der ausloesende Turn wird vermerkt, damit die naechsten Turns nicht erst wieder gegen die Wand laufen, und der Vermerk verfaellt von selbst, sobald der Turn aus dem Rolling Window gerollt ist. **(2)** Blockt auch das Ausweich-Modell, liegt es am Verlauf: der ausloesende Turn fliegt aus dem Prompt-Fenster (**Quarantaene**) — nicht geloescht, er bleibt in `conversation.jsonl`, steht mit Text im Panel und ist per „↩ Zurueckholen" wieder drin. Der rohe API-Fehlertext wird nie persistiert; ARIA sagt in eigenen Worten, was passiert ist. Das Panel zeigt pro Vorfall Projekt, Modell, Klassifikator-Code und ob die Blockade **noch wirkt** (= Turn liegt noch im Fenster). Zustand in `/data/safeguard.json`, Code in [`aria-brain/safeguard.py`](aria-brain/safeguard.py); gilt auch fuer das Memory-Destillat, das denselben Verlauf nochmal durchschickt. **Altlasten** — Fehlertexte, die vor diesem Fix schon in `conversation.jsonl` stehen und dort weiter vergiften — raeumt [`aria-brain/clean_poisoned_turns.py`](aria-brain/clean_poisoned_turns.py) einmalig weg (Dry-Run per Default, `--apply` schreibt mit Backup; findet jetzt beide Giftsorten und in Projekten genauso wie im Hauptchat)
+- **Datenschutz-Schalter**: die drei Kanaele, ueber die Claude Code zusaetzlich sendet (`DISABLE_ERROR_REPORTING`, `DISABLE_TELEMETRY`, `DISABLE_FEEDBACK_COMMAND`) pruefen und setzen. Geschrieben wird nach `~/.claude/settings.json` unter `env` — die CLI liest das bei jedem Aufruf, **kein Neustart noetig**. Geprueft wird, was wirklich im Prozess ankommt: eine per docker-compose gesetzte Variable gewinnt und wird als gesperrt angezeigt, statt einen wirkungslosen Haken anzubieten. **Nicht** dasselbe wie die Trainings-Einstellung — die steht im Anthropic-Konto (Link daneben)
+- **Warnung bei veralteten Proxy-Patches**: der Proxy kopiert `proxy-patches/` beim **Start**. Wer nach einem `git pull` nur neu startet — oder neu startet, bevor der Pull durch ist — laeuft still mit der alten Fassung. Nichts deutet darauf hin. Die Einstellungen vergleichen jetzt die Zeitstempel und zeigen den fertigen Befehl (`--force-recreate proxy`)
+- **Anhang-Limit** (System & Wartung): Groesse fuer Memory-Anhaenge, Default 64 MB. Liegt in `runtime.json`, das Brain liest es bei jedem Upload neu — greift sofort. Ueber 64 MB warnt die UI, weil die Handy-App darueber nichts mehr herunterlaedt
 
 ---
 
@@ -469,19 +561,28 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 
 ### Features
 
+- **Desktop-Workbench (Kompakt ↔ Cockpit)**: Umschalter oben rechts im Header. **Kompakt** = klassischer Vollbild-Chat (Default). **Cockpit** = Workbench mit **Taskleiste unten** (Chat · Code · Desktop) — ein Daumen-Tap wechselt sofort das Panel, animierter Indikator, Aktivitäts-Punkte (Code blau / Desktop grün). Jedes Panel bildschirmfüllend und Handy-optimiert; Dock blendet bei offener Tastatur aus. Desktop-Umfang, aber auf 5 Zoll bedienbar
+- **Live-Code-Editor** (Code-Projekte): Wird ein Projekt zum Code-Projekt (`set_project_kind('code')`), zeigt eine Editor-Kachel **live, was ARIA schreibt** (Syntax-Highlighting, offline) und du kannst selbst editieren → zurück an ARIA. ARIAs `Write`/`Edit` unter `/shared/projects/<id>/` werden im Proxy abgefangen und als `code_file` gespiegelt; deine Edits kommen als `code_file_edit` pfad-sicher zurück
+- **Live-Desktop per VNC (durch RVS getunnelt)**: ARIA baut/testet VMs mit **QEMU für jede Architektur** (x86/ARM/MIPS/PPC/RISC-V/SPARC, Host-Helper `aria-vm`, KVM für x86). Der QEMU-Desktop erscheint **live in der Desktop-Kachel** — noVNC in der WebView, RFB-Bytes werden als Base64 über RVS gebrückt (Bridge ↔ QEMU `127.0.0.1:5901`). Du bedienst die VM **live mit Maus/Tastatur**, NAT-sicher, kein offener Port am Host
 - Text-Chat mit ARIA
 - **Sprachaufnahme**: Tap-to-Talk (tippen startet, tippen stoppt, Auto-Stop bei Stille via VAD)
 - **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
 - **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
 - **VAD (Voice Activity Detection)**: Adaptive Schwelle (Baseline aus ersten 500ms Mic-Pegel + 6dB Offset). Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme einstellbar (1–30 min, Default 5 min)
-- **Barge-In**: Wenn du waehrend ARIAs Antwort eine neue Sprach-/Text-Nachricht reinschickst, wird sie unterbrochen + bekommt den Hint "das ist eine Korrektur"
+- **Nachricht anstellen statt abbrechen** (Queue pro Projekt): Schickst du eine zweite Nachricht waehrend ARIA noch am aktuellen Task arbeitet, wird sie **angestellt** statt den laufenden abzubrechen — laeuft der Reihe nach, pro Projekt unabhaengig. Wartende zeigen als `⏸`-Bubble (tippen entfernt sie aus der Warteschlange). Explizites Abbrechen laeuft ueber den Stop-Button am „ARIA denkt". Eine neue Sprachnachricht stoppt nur akustisch das TTS (sauberes Mikro), bricht die laufende Arbeit aber nicht mehr ab
+- **Zwischenruf** (📣): schiebt eine Korrektur in den **laufenden** Turn statt sie anzustellen — ohne Abbruch. Erscheint, sobald ARIA im Kontext arbeitet. Mit Text im Feld geht er sofort raus; **ohne Text schaltet er die naechste Aufnahme scharf**, dann geht der Zwischenruf per Sprache. Der laufende Turn wird dabei nicht gecancelt, nur die Wiedergabe gestoppt (sonst redet ARIA ins offene Mikro)
+- **Sprachnachricht zu Anhaengen**: Bild anhaengen und den Auftrag dazu **sprechen** statt tippen. Die Dateien gehen beim Antippen des Mikros sofort hoch (Upload laeuft parallel zum Reden); die Bridge fuehrt Anhang und gesprochenen Satz ueber die `clientMsgId` zu **einem** Turn zusammen und legt beides in **eine** Bubble. Ohne das sah ARIA ein Bild ohne Auftrag und danach einen Satz ohne Bild. Das Mikro ist darum immer sichtbar — auch mit Anhang oder getipptem Text
+- **Teilen-Ziel** (Android-Share): „Teilen → ARIA" aus WhatsApp, Galerie, Browser … → Dialog zeigt *was* geteilt wurde, dann *wohin* (Projekt oder Hauptchat), dann optional ein Text dazu (darf leer bleiben). Die native Seite kopiert die Dateien sofort in den App-Cache, weil die Leseerlaubnis einer `content://`-URI nur fuer diesen Intent gilt und nach der Projektauswahl schon erloschen waere
+- **Rueckfrage-Loop**: Stellt ARIA eine echte, blockierende Rueckfrage, **pausiert** die Queue und deine naechste Eingabe beantwortet sie — bis eine finale Antwort kommt, dann laeuft der naechste Queue-Eintrag (gleiches Muster). Banner „❓ ARIA fragt nach — deine Eingabe beantwortet das". ARIA signalisiert das ueber einen unsichtbaren `[[AWAIT]]`-Marker im Antworttext (das Modell deklariert den Zustand selbst, kein „endet-mit-?"-Raten; Brain strippt ihn und gibt `awaiting_reply` an App + Diagnostic durch)
+- **Pro-Projekt-Textfeld-Entwuerfe**: Der Feldinhalt bleibt beim Projektwechsel erhalten — in Projekt X tippen, zu Y wechseln (leeres Feld), zurueck zu X → dein Entwurf steht wieder da. Persistiert ueber Neustart. Gleiches Verhalten im Diagnostic
 - **Wake-Word waehrend TTS**: Du kannst "Computer" sagen waehrend ARIA noch redet — AcousticEchoCanceler verhindert dass ARIAs eigene Stimme das Wake-Word triggert
 - **Anruf-Pause + Auto-Resume**: TTS verstummt bei klassischem Anruf oder VoIP-Call (WhatsApp/Signal/Discord). Nach dem Auflegen geht ARIA von der **genauen Stelle** weiter wo sie unterbrochen wurde — die App misst die Position vom Wiedergabe-Anfang und nutzt den WAV-Cache der Antwort
 - **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
-- **STT (Speech-to-Text)**: 16kHz mono → Bridge → Gamebox-Whisper (CUDA) → Text im Chat. Fast in Echtzeit.
+- **STT (Speech-to-Text)**: 16kHz mono → STT-Node (Voxtral-3B, CUDA) → Text im Chat. Fast in Echtzeit.
 - **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
 - **TTS-Wiedergabe**: F5-TTS PCM-Streaming direkt in AudioTrack mit konfigurierbarem Pre-Roll-Buffer (1.0–6.0s, Default 3.5s) gegen Gaps bei Render-Pausen
 - **Audio-Pause**: Andere Apps (Spotify, YouTube etc.) pausieren komplett waehrend ARIA spricht und kommen erst wieder nach echtem Wiedergabe-Ende
+- **TTS-Abspiel-Queue**: Zwei fast gleichzeitig fertige Antworten sprechen garantiert **nacheinander** statt sich abzuschneiden — eine neue hoerbare Antwort, die waehrend der Wiedergabe einer anderen ankommt, wird gepuffert und erst nach deren echtem Wiedergabe-Ende (`PcmPlaybackFinished`, nicht nur Stream-Ende) nachgespielt. Harter Stop / Barge-In / Mund-Button verwirft die Queue
 - **Lokale Voice-Wahl**: Pro Geraet eigene Stimme moeglich (in Settings). Diagnostic-Wechsel ueberschreibt alle App-Wahlen.
 - **Voice-Ready Toast**: Beim Wechsel zeigt die App "Stimme X bereit (X.Ys)" sobald der Preload durch ist
 - **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden (aus Cache wenn vorhanden, sonst neu rendern)
@@ -571,7 +672,8 @@ cd android
 ### Release auf Gitea veroeffentlichen
 
 ```bash
-./release.sh 1.2.0
+./release.sh            # Version automatisch +1 (0.2.6.1 → 0.2.6.2, 0.2.6.9 → 0.2.7.0)
+./release.sh 1.2.0      # oder Version selbst setzen
 ```
 
 Das Script macht alles in einem Schritt:
@@ -605,7 +707,7 @@ die VM voll laeuft:
 
 Die App prueft beim Start ob eine neuere Version auf dem RVS liegt.
 Der Update-Flow:
-1. `./release.sh 0.0.3.0` → APK wird auf RVS kopiert (via scp)
+1. `./release.sh` (Version automatisch +1) → APK wird auf RVS kopiert (via scp)
 2. Alternativ: `git pull` auf dem RVS-Server → APK in `rvs/updates/`
 3. App sendet `update_check` mit aktueller Version
 4. RVS vergleicht → sendet `update_available`
@@ -617,7 +719,7 @@ Der Update-Flow:
 App (Mikrofon) → AAC/MP4 Aufnahme → Base64 → RVS → Bridge
 Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-brain
 Bridge: STT-Ergebnis → RVS → App (Placeholder wird durch transkribierten Text ersetzt)
-aria-brain → Antwort → Bridge → F5-TTS (Gaming-PC) → PCM-Stream → RVS → App
+aria-brain → Antwort → Bridge → F5-TTS (Compute-Node) → PCM-Stream → RVS → App
 App: AudioTrack MODE_STREAM (nahtlos), Cache als WAV pro Message
 ```
 
@@ -724,23 +826,39 @@ Wer sich mit dem gleichen Token verbindet, landet im gleichen Room.
 
 ```bash
 cd rvs
-cp .env.example .env       # PUBLIC_URL eintragen (Domain die auf den Server zeigt)
+cp .env.example .env       # Modus waehlen (COMPOSE_PROFILES) + Werte eintragen
 docker compose up -d
 ```
 
+**Zwei Modi** — in der `rvs/.env` per `COMPOSE_PROFILES`:
+
+| Modus | `.env` | Wer macht TLS | Apps/Satelliten verbinden auf |
+|---|---|---|---|
+| **mit Caddy** | `COMPOSE_PROFILES=caddy` + `PUBLIC_URL` | Caddy im Stack (Let's Encrypt) | `PUBLIC_URL:CADDY_HTTPS_PORT` |
+| **ohne Caddy** | `COMPOSE_PROFILES=` (leer) | dein Reverse-Proxy (nginx, Traefik …) | Name + Port deines Proxys (meist 443) |
+
 **Stack:**
-- `caddy` (TLS-Terminator + Let's Encrypt, lauscht auf 80+443)
-- `rvs` (WebSocket Relay + OAuth-Callback HTTP, nur intern auf Port 3000)
+- `rvs` (WebSocket Relay + OAuth-Callback HTTP). Unverschluesselter Port
+  `RVS_HTTP_BIND:RVS_HTTP_PORT` (Default `127.0.0.1:3000`) — fuer den Reverse-Proxy.
+- `caddy` (nur Modus Caddy: TLS + Let's Encrypt auf 80 + `CADDY_HTTPS_PORT`)
 
 Caddy holt automatisch ein Zertifikat fuer `PUBLIC_URL` via HTTP-01-Challenge.
-ACME-State persistent in `./data/caddy/` (gitignored) — kein Rate-Limit-Drama
-bei Container-Restart. WebSocket-Upgrades reicht Caddy transparent durch.
+Dafuer muss **Port 80 von aussen auf diesen Rechner** gehen — sonst schlaegt die
+Erneuerung still fehl und das Zertifikat laeuft nach 90 Tagen ab (Apps und
+Satelliten verbinden dann nicht mehr). ACME-State persistent in `./data/caddy/`
+(gitignored). WebSocket-Upgrades reicht Caddy transparent durch.
+
+> **Bestehende Installation aktualisieren:** Caddy startet nur noch mit
+> `COMPOSE_PROFILES=caddy` in der `rvs/.env`. Wer Caddy weiter nutzt, traegt das
+> dort ein (sonst laeuft nach `git pull` + `up -d` kein TLS mehr).
 
 **Features:**
 - WebSocket Relay (alle Message-Types: chat, audio, file, config, xtts, update, etc.)
 - OAuth-Callback HTTP: `GET /oauth/callback/{service}?code=...` → broadcastet als
   `oauth_callback`-WS-Message + zeigt dem Browser eine "OAuth erfolgreich"-Seite
-- Auto-Update: APK-Verteilung an Apps ueber WebSocket
+- Auto-Update: App fragt per WebSocket nach der Version, laedt die APK per HTTP
+  (`/update/latest.apk`, nur mit gueltigem Raum-Token im Header `X-RVS-Token`,
+  mit Fortschrittsanzeige + Fortsetzen per Range). Alte Apps: Fallback ueber WebSocket
 - Heartbeat + tote Verbindungen aufraeumen
 
 **Auto-Update APK bereitstellen:**
@@ -752,43 +870,143 @@ cp ARIA-v0.0.3.0.apk ~/ARIA-AGENT/rvs/updates/
 
 **Multi-Instanz:** Mehrere ARIA-VMs koennen denselben RVS nutzen — jede mit eigenem Token.
 
-**Ohne Caddy / eigener TLS-Terminator:** Wenn Du schon einen Reverse-Proxy
-(nginx/Traefik) davor hast, kommentier den `caddy`-Service in der
-`rvs/docker-compose.yml` aus und gib `rvs` wieder einen `ports`-Block
-(z.B. `["3000:3000"]`). Dein Reverse-Proxy macht dann TLS und reicht weiter.
+**Ohne Caddy — eigener Reverse-Proxy:** in der `rvs/.env`
+
+```bash
+COMPOSE_PROFILES=
+RVS_HTTP_BIND=0.0.0.0      # Proxy auf anderem Rechner; gleicher Rechner: 127.0.0.1
+RVS_HTTP_PORT=3000
+```
+
+Steht der Proxy auf einem anderen Rechner, den Port per Firewall **nur fuer den
+Proxy** freigeben.
+
+**Strecke Proxy → RVS verschluesseln:** `RVS_HTTP_TLS=true` — der RVS spricht
+dann HTTPS auf `RVS_HTTP_PORT`, mit einem selbstsignierten Zertifikat (beim
+ersten Start in `rvs/data/rvs-tls/` erzeugt; eigenes `rvs.crt`/`rvs.key` darf
+dort liegen). Im Proxy als Ziel `https://<ip>:<port>`, das Zertifikat dabei
+**nicht** pruefen (nginx: Default; Nginx Proxy Manager: Scheme `https`,
+„Websockets Support" an). Nur ohne Caddy — der spricht den RVS per HTTP an.
+
+Umstellen von Caddy:
+`docker compose rm -sf caddy && docker compose up -d`.
+
+> ⚠️ **WebSocket nicht vergessen!** Der RVS ist fast nur WebSocket. Ohne
+> WebSocket-Weiterleitung laedt im Browser zwar eine Seite (404 o.ae.), aber
+> App, Bridge, Satelliten und KI-Boxen bekommen **keine Verbindung** — ohne
+> klare Fehlermeldung. Beim Neueinrichten des Proxys immer pruefen:
+>
+> - **Nginx Proxy Manager:** im Proxy Host den Schalter **„Websockets Support"**
+>   einschalten (bei `RVS_HTTP_TLS=true` zusaetzlich Scheme **`https`**).
+> - **nginx von Hand:** `proxy_http_version 1.1;` plus die beiden Header
+>   `Upgrade` / `Connection "upgrade"` (siehe Beispiel unten) und lange
+>   Timeouts — sonst trennt nginx die Verbindung nach 60 s Stille.
+> - **Test:** `curl -i -H "Connection: Upgrade" -H "Upgrade: websocket"
+>   -H "Sec-WebSocket-Version: 13" -H "Sec-WebSocket-Key: dGVzdHRlc3R0ZXN0dGVzdA=="
+>   "https://<dein-name>/?token=test"` muss mit **`101 Switching Protocols`**
+>   antworten. Kommt 200/400/404, fehlt die WebSocket-Weiterleitung.
+
+nginx-Beispiel (WebSocket braucht HTTP/1.1 + Upgrade-Header und lange Timeouts):
+
+```nginx
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;            # Handys nehmen bevorzugt IPv6 — mit AAAA-Eintrag Pflicht
+    server_name rvs.example.de;
+
+    ssl_certificate     /etc/letsencrypt/live/rvs.example.de/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/rvs.example.de/privkey.pem;
+
+    location / {
+        proxy_pass http://192.168.1.10:3000;     # RVS_HTTP_BIND-IP : RVS_HTTP_PORT (https:// bei RVS_HTTP_TLS=true)
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto https;
+        proxy_read_timeout 3600s;               # WebSocket bleibt lange offen
+        proxy_send_timeout 3600s;
+        proxy_buffering off;
+        client_max_body_size 0;                 # APK-Download, Uploads
+    }
+}
+```
+
+Apps, Satelliten, KI-Boxen, Host-Agenten und die Bridge (`RVS_HOST`/`RVS_PORT`
+in deren `.env`) dann auf den Namen und Port des Proxys umstellen.
 
 ---
 
-## Gamebox-Stack — F5-TTS + Whisper (GPU-Services)
+## Compute-Nodes — STT / TTS / LLM (GPU-Dienste)
 
-Laeuft auf einem separaten Rechner mit NVIDIA GPU (z.B. Gaming-PC mit RTX 3060).
-Verbindet sich ueber RVS mit der ARIA-Infrastruktur — kein VPN noetig, funktioniert
-ueber verschiedene Netze hinweg.
+Die GPU-Dienste laufen auf einem oder mehreren separaten Rechnern mit NVIDIA GPU.
+Jeder **Compute-Node** verbindet sich ueber RVS mit der ARIA-Infrastruktur — kein
+VPN noetig, funktioniert ueber verschiedene Netze hinweg. Frueher war das *eine*
+feste „AI-Box"; jetzt sind es beliebig viele Nodes, jeder per `.env` konfiguriert.
 
-### Architektur
+### Dienste & Profile
+
+Jeder Dienst haengt an einem Compose-Profil. Ein Node startet ueber
+`COMPOSE_PROFILES` (in seiner `.env`) nur die Profile, die er anbieten soll:
+
+| Profil    | Container                    | Rolle |
+|-----------|------------------------------|-------|
+| `voxtral` | aria-voxtral-bridge          | Default-STT (Voxtral-Mini-3B, ~9 GB) |
+| `whisper` | aria-whisper-bridge          | STT-Fallback (faster-whisper CUDA) |
+| `f5tts`   | aria-f5tts-bridge            | TTS (F5-TTS Voice Cloning) |
+| `llm`     | aria-llama-swap + llm-adapter| Lokales LLM (llama-swap, OpenAI-kompat.) |
+| `openhands`| aria-openhands              | OpenHands gegen das lokale LLM (optional) |
+
+#### OpenAI-Endpunkt fuers lokale LLM
+
+Das lokale LLM ist zusaetzlich als **OpenAI-kompatibler Endpunkt** erreichbar —
+damit laesst sich z.B. OpenHands oder jedes andere OpenAI-SDK darauf richten.
+Port und Key kommen aus der `.env` der Box (`LLM_OPENAI_PORT`,
+`LLM_OPENAI_API_KEY`, siehe `xtts/.env.example`).
+
+> **Die `.env` gewinnt immer.** Steht der Wert dort, sind die Felder in der
+> Diagnostic **nur lesend** — sonst traegt man dort etwas ein, es wirkt nach dem
+> naechsten Container-Start nicht, und niemand versteht warum. Ist in der `.env`
+> nichts gesetzt, laesst sich der Key pro Box in der Diagnostic pflegen
+> (`llm_openai_config`).
+
+Der Port ist ein Docker-Port-Mapping und darum **nie** aus der Diagnostic
+aenderbar. Zur Absicherung nach aussen: SSH-Tunnel statt den Port im LAN
+aufzureissen (Details in [`xtts/README.md`](xtts/README.md)).
+
+### Architektur (Aufteilung auf mehrere Nodes)
 
 ```
-Gamebox (Windows, RTX 3060, Docker Desktop + WSL2)
-├── aria-f5tts-bridge       F5-TTS Voice Cloning + RVS-Relay
-│                           Hoert auf xtts_request, streamt audio_pcm
-├── aria-whisper-bridge     faster-whisper auf CUDA (float16)
-│                           Hoert auf stt_request, antwortet mit stt_response
-└── ./voices/               Geteilt zwischen beiden:
-                              {name}.wav  — Referenz-Audio (~6-10s)
-                              {name}.txt  — Referenz-Text (auto via Whisper)
+STT-Box   COMPOSE_PROFILES=voxtral   VOXTRAL_GPU=0
+TTS-Box   COMPOSE_PROFILES=f5tts     F5TTS_GPU=0
+LLM-Box   COMPOSE_PROFILES=llm       LLM_GPU=0
+   -- kleine Karte: Whisper (klein) statt Voxtral, neben F5-TTS --
+Klein-Box COMPOSE_PROFILES=whisper,f5tts   WHISPER_GPU=0 F5TTS_GPU=0
+   ── oder All-in-One ──
+AI-Box   COMPOSE_PROFILES=voxtral,f5tts,llm   VOXTRAL_GPU=1 F5TTS_GPU=0 LLM_GPU=0
 
          ↕ RVS (Rechenzentrum, WebSocket Relay)
 
 ARIA-VM
-└── aria-bridge: STT primaer remote (45s Timeout, dann lokaler CPU-Fallback)
-                 TTS via xtts_request → audio_pcm Stream
+└── aria-bridge: orchestriert TTS/LLM (xtts_request/llm_request),
+                 lauscht passiv auf den STT-Stream App↔STT-Node.
+                 STT-Timeout → lokaler CPU-Whisper-Fallback.
 ```
 
-### Voraussetzungen
+> STT: pro Node **genau einen** — Voxtral-3B (~9 GB, beste Qualitaet) *oder*
+> Whisper (klein, passt neben F5-TTS auf eine GPU mit wenig VRAM). Beide zusammen
+> beantworten dieselbe Anfrage doppelt.
 
-- Docker Desktop mit WSL2 (Windows) oder Docker mit NVIDIA Runtime (Linux)
-- NVIDIA Container Toolkit
-- GPU mit mindestens 6GB VRAM (Whisper-large + F5-TTS gemeinsam)
+Die STT-Node teilt sich das `./voices/`-Volume mit F5-TTS nur, wenn beide auf
+demselben Node laufen (Referenz-Text-Transkription beim Voice-Upload). Auf
+getrennten Nodes transkribiert F5-TTS ueber den STT-Node via RVS.
+
+### Voraussetzungen (pro Node)
+
+- Docker + **NVIDIA Container Toolkit** (registriert die `nvidia`-Runtime — die
+  Compose nutzt `runtime: nvidia` + `NVIDIA_VISIBLE_DEVICES`).
+- Genug VRAM fuer die gewaehlten Profile (Voxtral-3B ~9 GB, F5-TTS ~1 GB, LLM je Modell).
 - **Gleicher RVS_TOKEN wie auf der ARIA-VM!**
 
 ### Setup
@@ -796,13 +1014,17 @@ ARIA-VM
 ```bash
 cd xtts
 cp .env.example .env
-# .env mit RVS-Verbindungsdaten fuellen (gleicher Token wie ARIA-VM!)
+# .env anpassen:
+#   COMPOSE_PROFILES  → welche Dienste dieser Node fahren soll
+#   NODE_NAME         → Name des Rechners (erscheint in Diagnostic + Logs)
+#   *_GPU             → welche Grafikkarte pro Dienst (NVIDIA_VISIBLE_DEVICES)
+#   RVS_*             → gleiche Verbindungsdaten wie die ARIA-VM
 docker compose up -d
-# Erster Start laedt die Modelle (Whisper ~1-3GB je nach Groesse, F5-TTS ~1GB)
+# Erster Start laedt die Modelle der aktiven Profile (Voxtral ~9GB, F5-TTS ~1GB)
 ```
 
-Die Modelle werden in den Volumes `f5tts-models` und `whisper-models` gecacht
-und muessen nur einmal geladen werden.
+Die Modelle liegen im Bind-Mount `./hf-cache/` (bzw. `./models/` fuer LLM-GGUFs)
+und muessen pro Node nur einmal geladen werden.
 
 ### Features
 
@@ -824,7 +1046,7 @@ In der Diagnostic unter Einstellungen → Sprachausgabe:
 - **TTS aktiv**: Global An/Aus
 - **F5-TTS Stimme**: Default oder gecloned (Maia etc.)
 
-> F5-TTS ist die einzige Engine — wenn die Gamebox offline ist, bleibt ARIA stumm.
+> F5-TTS ist die einzige Engine — wenn kein f5tts-Node online ist, bleibt ARIA stumm.
 > Chat-Antworten kommen weiter an (nur kein Audio).
 
 ### Stimme klonen
@@ -870,6 +1092,181 @@ dem Cache wiederverwendet.
 
 ---
 
+## Host-Agenten 💻 — Direktzugriff auf einen Rechner
+
+Ein **Host-Agent** läuft als **Standalone-Binary direkt auf einem Rechner**
+(Linux) und verbindet sich **ausgehend** zum RVS (gleicher Token). Damit steuert
+ARIA diesen Rechner direkt — auch wenn er sonst aus dem Netz **nicht erreichbar**
+ist (hinter NAT/Firewall, kein offener Port). Unterschied zum Satelliten: der
+Satellit ist ein LAN-Gateway (entdeckt/steuert *andere* Geräte); der Host-Agent
+steuert den Rechner, auf dem er *läuft*.
+
+**Fähigkeiten** (ARIA-Tools `host_list` / `host_exec` / `host_read` /
+`host_write` / `host_info` / `host_screenshot`): Shell-Kommandos (optional
+`sudo`), Datei lesen/schreiben, System-Info (CPU/RAM/Disk/Uptime), Screenshot
+(ARIA öffnet ihn mit ihrem Read-Tool und *sieht* den Bildschirm; erscheint zudem
+inline im Chat).
+
+### 1. Binary bauen (portabel, Linux x86_64)
+
+```bash
+cd host-agent
+./build.sh          # braucht Docker; erzeugt dist/aria-host-agent (~15 MB)
+```
+
+Gebaut wird via PyInstaller in einem bullseye-Container (altes glibc) → läuft auf
+möglichst vielen Distributionen. Keine Runtime auf dem Ziel nötig.
+
+### 2. Auf dem Ziel-Rechner installieren
+
+```bash
+# dist/aria-host-agent auf den Rechner kopieren, dann:
+cp .env.example .env      # RVS-Zugang + CONTROL_ENABLED=true eintragen
+chmod +x aria-host-agent && ./aria-host-agent
+```
+
+**Als systemd-Dienst** (Dauerbetrieb) — der Installer kopiert Binary + `.env`
+an ihre Plätze und richtet den Dienst ein:
+
+```bash
+sudo ./install-service.sh /pfad/zur/.env    # .env-Pfad direkt
+sudo ./install-service.sh                   # oder: ncurses-Dateidialog (dialog)
+```
+
+→ Binary nach `/usr/local/bin`, `.env` nach `/etc/aria-host-agent/.env` (0600),
+Unit installiert + `enable --now`. Danach `journalctl -u aria-host-agent -f`.
+
+### TLS / SNI — Agent im selben Netz wie der RVS
+
+Verbindet der Agent direkt auf die **interne RVS-IP** (statt über den externen
+Hostnamen per NAT-Hairpin), scheitert TLS sonst am fehlenden Cert für die IP
+(`tlsv1 alert internal error`). Dann in der `.env`: `RVS_HOST=<interne-ip>` +
+`RVS_SNI=<zert-name>` (z.B. `example.com`). Gilt genauso für Satelliten
+und Compute-Nodes im RZ-Netz (`RVS_SNI` in deren `.env`).
+
+### sudo
+
+Der Agent wählt automatisch: **root** → direkt · `SUDO_PASSWORD` in der `.env`
+→ `sudo -S` · **`SUDO_NOPASSWD=true`** → `sudo -n` (Live-ISO / passwortloses
+sudo, z.B. Linux Mint vom Stick) · sonst klare Fehlermeldung.
+
+### Sicherheit
+
+Reagiert nur auf den eigenen RVS-Raum (Token) und nur bei `CONTROL_ENABLED=true`;
+keine offenen Ports; alle Kommandos werden geloggt. Gibt **vollen** Rechnerzugriff
+— nur auf Maschinen einsetzen, denen du ARIA anvertraust. Details:
+[`host-agent/README.md`](host-agent/README.md).
+
+> Sichtbar in der Diagnostic unter **Satelliten → Host-Agenten 💻**.
+
+### GUI-Steuerung (Desktop)
+
+Auf Linux/Windows/macOS kann der Agent zusaetzlich die **grafische Oberflaeche**
+bedienen (`host_ui_tap` / `host_ui_text` / `host_ui_swipe` / `host_ui_key` /
+`host_app_launch`). Das ist **capability-gated**: der Agent meldet beim
+`host_hello` nur, was er wirklich kann — auf einem Linux-Server ohne X/Wayland
+fehlt die GUI-Faehigkeit einfach in der Liste, und ARIA sieht das. Eingabe-Weg
+je System: `windows` · `macos` · `xdotool` (X11) · `ydotool` (Wayland).
+
+---
+
+## Android-Agent 📱📺 — Handy, Tablet, Fire TV
+
+Dieselbe APK laeuft auf **Handy/Tablet** und auf **Fire TV / Android TV**
+(`host-agent/android/`). Sie ist das Android-Gegenstueck zum Host-Agenten:
+ausgehende Verbindung zum RVS, kein offener Port, erscheint in der Diagnostic
+unter **Satelliten → Host-Agenten 💻**.
+
+**Sehen** — Screenshot (MediaProjection) und Bildschirm-Inhalt als Struktur
+(`ui_dump` via Accessibility-Service, nur lesend). Beides geht auch bei
+gesperrtem Geraet.
+
+**Steuern** — `ui_tap` / `ui_text` / `ui_swipe` / `ui_key` / `app_launch` ueber
+den Accessibility-Service. **Nur bei entsperrtem Geraet** — Android laesst
+Gesten auf dem Sperrbildschirm nicht zu; der Agent sagt das klar, statt stumm
+nichts zu tun. Auf dem Fire TV gibt es keinen Touchscreen, dafuer das D-Pad.
+
+**Ausgeben** (v.a. Fire TV, dort ist ARIA ein echter Endpunkt):
+
+| Weg | Was passiert |
+|-----|--------------|
+| Einblendung | Text ueber dem laufenden Bild (Overlay, braucht „Ueber anderen Apps anzeigen") |
+| Sprache | ARIAs **echte** Stimme — der Agent fordert das Audio per `tts_request` ueber den normalen F5-TTS-Pfad an und spielt das PCM ab |
+| Einstellung | Overlay oder Sprache als Standard, pro Anfrage ueberschreibbar (`mode`) |
+| Bild + Text | `host_notify(image_path=/shared/uploads/...)` blendet ein Bild MIT Text ein — z.B. eine Wetterkarte |
+
+**Wie die Einblendung wieder weggeht.** Eine feste Anzeigedauer ist immer
+geraten: mal zu kurz zum Lesen, mal steht sie laengst im Weg. Darum bedeutet
+`seconds=0`: **bleibt, bis Stefan etwas tut.**
+
+- *Fernbedienung*: der Accessibility-Dienst bekommt `onKeyEvent` und raeumt die
+  Einblendung weg — gibt die Taste aber mit `return false` **weiter an den
+  Film**. Es geht kein Tastendruck verloren, der Player bleibt bedienbar.
+- *Touch*: `FLAG_WATCH_OUTSIDE_TOUCH` meldet eine Beruehrung daneben; die geht
+  dank `FLAG_NOT_TOUCHABLE` gleichzeitig an die App darunter.
+- *Notbremse*: nach 10 Minuten verschwindet sie in jedem Fall.
+
+> Bewusst **nicht** der naheliegende Weg (Overlay faengt Tasten selbst ab):
+> dafuer muessten `FLAG_NOT_FOCUSABLE` und `FLAG_NOT_TOUCHABLE` weg — und dann
+> nimmt die Einblendung dem laufenden Film JEDE Eingabe, solange sie steht.
+>
+> Der Accessibility-Dienst braucht dafuer `canRequestFilterKeyEvents`. Nach
+> einem Update also pruefen, ob er in den Bedienungshilfen noch aktiv ist —
+> Android schaltet Dienste bei geaenderter Konfiguration gern ab.
+
+> Fire TV Sticks haben oft **keine deutsche TTS-Engine**. Darum laeuft die
+> Sprachausgabe bewusst nicht ueber die Geraete-Stimme, sondern ueber ARIAs
+> eigene. Die Geraete-Stimme gibt es nur noch auf ausdrueckliche Anforderung
+> (`engine=device`).
+
+**Audio-Fokus** — bevor ARIA redet, wird der laufende Film leiser (`duck`) oder
+angehalten (`pause`); danach laeuft er weiter. Sonst redet ARIA mitten in
+Netflix hinein und man versteht beides nicht.
+
+**Sprachdialog** — der Agent kann auch *zuhoeren* (`listen` / `listen_stop`) und
+streamt das Mikrofon mit demselben Protokoll wie die App
+(`stt_stream_start` → `stt_audio_chunk` → `stt_stream_end`).
+
+> **Turn-Ownership:** der RVS ist ein Broadcast-Relay ohne Adressierung — jeder
+> Client im Raum bekommt jede Antwort. Ohne Filter wuerden Handy und Fire TV
+> dieselbe Antwort gleichzeitig vorlesen. Jedes Geraet gibt darum nur aus, was
+> aus *seiner* eigenen Frage entstanden ist (`audioRequestId` → `messageId`).
+
+### Bauen + ausrollen
+
+```bash
+cd host-agent/android && ./build.sh      # Docker (Android-SDK + Gradle)
+# -> dist/aria-android-agent.apk
+
+# Release mit allen Agent-Artefakten (Linux/Windows/Android) als Gitea-Assets:
+cd host-agent && ./release_agent.sh        # Version automatisch +1
+```
+
+Der Signaturschluessel liegt fest in `host-agent/android/aria-agent.keystore`
+(gitignored). Ohne ihn bekaeme jeder Build einen neuen Debug-Key, und Android
+verweigert die Installation mit *„Konflikt mit einem bestehenden Paket"* statt
+zu aktualisieren.
+
+### Ausrollen per Satellit (ohne Kabel, ohne Abtippen)
+
+Ein Satellit im selben Netz kann Android-Geraete per **ADB over Network**
+bespielen — besonders fuer den Fire TV, wo QR-Code-Scannen nicht geht:
+
+```
+Diagnostic → Satelliten → Geraet → „Agent ausrollen"
+```
+
+Der Satellit verbindet per ADB (Port 5555, wartet auf die Bestaetigung am
+Geraet — ein Klick genuegt), installiert die APK, erteilt die Berechtigungen per
+`appops`/`pm grant` und **provisioniert die RVS-Zugangsdaten per Intent** — man
+tippt am Fernseher nichts ein. Ein schon vergebener Geraetename wird dabei
+vorgeschlagen; nur wenn es keinen gibt, kommt der automatisch generierte.
+
+> Die Berechtigungen bleiben ueber Neustarts erhalten; die Bildschirm-Aufnahme
+> schaltet sich nach einem Reboot selbst wieder scharf.
+
+---
+
 ## Docker Volumes
 
 | Volume / Bind | Pfad im Container | Zweck |
@@ -896,6 +1293,40 @@ dem Cache wiederverwendet.
 6. **Panic Button**: `docker compose down` → sofort stoppen
 7. **Alles loggen** — Stefan sieht immer was passiert
 
+### Secrets und was bei Anthropic landet
+
+ARIA laeuft ueber Claude Code auf einem Claude-Abo. **Alles, was ARIA sieht —
+auch jedes Tool-Ergebnis — wird uebertragen und gespeichert.** Bei Consumer-
+Plaenen (Free/Pro/Max) haengt es an einer Einstellung im Konto, ob daraus auch
+Trainingsdaten werden; die Aufbewahrung betraegt entsprechend 5 Jahre oder
+30 Tage ([claude.ai/settings/data-privacy-controls](https://claude.ai/settings/data-privacy-controls),
+Details in Anthropics [Data-usage-Doku](https://code.claude.com/docs/en/data-usage)).
+
+Daraus folgen drei Regeln:
+
+1. **Secrets nie in den Chat tippen.** Das ist der Weg, ueber den hier
+   tatsaechlich einmal ein `client_secret` abgeflossen ist — nicht ueber ein
+   Tool, sondern weil es eingetippt und von ARIA zurueckzitiert wurde. Der
+   System-Prompt und die seed_rules weisen ARIA inzwischen an, das abzulehnen
+   und ein Secret nie zu wiederholen.
+2. **Zugangsdaten gehoeren in eine Konfiguration, nicht in Code oder Chat.**
+   OAuth → Diagnostic → OAuth-Apps. Alles andere (Benutzername/Passwort,
+   API-Keys) → **Skill-Konfiguration** (`skill_set_config`), kommt zur Laufzeit
+   als `CFG_<NAME>` an und wird in der Oberflaeche maskiert.
+3. **ARIA bekommt Zugangstokens nicht mehr zu sehen.** `oauth_get_token` sagt
+   nur noch, OB authentifiziert ist. Fuer API-Aufrufe gibt es **`oauth_call`**:
+   das Brain haengt die Authorization selbst an, fuehrt den Request aus und
+   gibt nur die Antwort zurueck — der Token verlaesst den Brain-Prozess nicht.
+   Abgesichert durch eine Host-Sperre: nur https und nur Hosts, die zum
+   Provider gehoeren (Vergleich auf den letzten zwei Labels, **nicht** per
+   `endswith` — sonst waere `boesespotify.com` durchgerutscht).
+
+> Was ARIA NICHT schuetzt: sie laeuft mit Root im Proxy-Container und hat
+> `/shared` gemountet. Sie *kann* `/shared/config/*.json` lesen, wenn sie
+> hinschaut — und was sie liest, ist Tool-Ergebnis. Die Dateirechte (600)
+> helfen dagegen nicht. Behandle jedes dort erreichbare Secret als
+> „sichtbar, sobald ARIA hinschaut".
+
 ---
 
 ## Haeufige Befehle
@@ -937,14 +1368,28 @@ docker exec aria-brain curl localhost:8080/memory/stats
   `Hey Rhasspy` funktionieren sofort, eigene Wake-Words muessen aktuell noch als
   `.onnx`-Datei ins App-Bundle gelegt + zur Liste in `wakeword.ts` hinzugefuegt werden.
   Die Diagnostic-Upload-UI ist Phase 2.
-- **Audio-Format**: App nimmt AAC/MP4 auf, Bridge konvertiert via FFmpeg zu 16kHz PCM.
+- **Audio-Format**: Die App streamt live 16 kHz mono s16le an die STT-Bridge
+  (`stt_stream_start` → `stt_audio_chunk` → `stt_stream_end`). Der alte Weg
+  (AAC/MP4 aufnehmen, Bridge konvertiert per FFmpeg) existiert noch als Fallback.
+- **Sprachaufnahme ist nicht wiederaufsetzbar**: Die Audio-Chunks gehen live
+  raus. Bricht die Verbindung mitten in der Aufnahme ab, fehlt dieses Stueck —
+  es wird nicht gepuffert und nicht nachgeschickt. Gleiches gilt fuer die
+  Sprachausgabe: F5-TTS streamt saetzeweise PCM, ein Abbruch verliert den Rest.
+  Lokal aufnehmen + wiederaufsetzbar hochladen (Queue mit Teil-Uebertragung)
+  waere der naechste Schritt, ist aber noch nicht gebaut.
 - **RVS Zombie-Connections**: WebSocket-Verbindungen sterben gelegentlich ohne Fehlermeldung.
   Bridge hat Ping-Check (5s), Diagnostic nutzt frische Verbindungen pro Request.
-- **Bildanalyse eingeschraenkt**: Bilder werden in `/shared/uploads/` gespeichert. ARIA kann
-  sie per Bash/Read-Tool oeffnen, aber Claude Vision (direkte Bildanalyse) ist ueber den
-  Proxy-Pfad (`claude --print`) noch nicht moeglich. ARIA sieht den Dateipfad, nicht das Bild.
-- **Dateigroesse**: Grosse Dateien (>5MB) koennen WebSocket-Limits ueberschreiten.
-  Bilder werden in der App auf max 1920x1920px @ 80% Qualitaet komprimiert.
+  App-seitig fragt die Aufnahme-Sperre den Socket statt den gemerkten Zustand.
+- **Dateigroesse**: Der RVS und alle Worker fahren `max_size` 1500 MB (≈1 GB
+  binaer plus base64-Overhead); groessere Dateien weist die Bridge aktiv ab,
+  statt die Verbindung reissen zu lassen. Die App holt ueber **25 MB** nichts
+  mehr ungefragt nach und bremst beim ausdruecklichen Antippen bei **64 MB** —
+  base64-in-JSON muss komplett in den Speicher, und ein 150-MB-Video hat das
+  Handy per OOM umgebracht. Bilder werden in der App auf max 1920x1920px @ 80%
+  Qualitaet komprimiert.
+- **Lautstarke Umgebung stoert die STT**: Laute Musik im Raum verschlechtert die
+  Erkennung messbar. Bewusst akzeptiert — Wake-Wort-Bestaetigung und der
+  Silero-Endpoint stehen als Opt-in bereit.
 
 ---
 
@@ -986,7 +1431,7 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] Pre-Roll-Buffer einstellbar in App-Settings
 - [x] Decimal-zu-Worte fuer TTS + generisches Acronym-Buchstabieren
 - [x] voice_preload/voice_ready: visueller Status-Indikator beim Stimmen-Wechsel
-- [x] Whisper STT auf die Gamebox ausgelagert (CUDA float16, fast Echtzeit)
+- [x] Whisper STT auf die AI-Box ausgelagert (CUDA float16, fast Echtzeit)
 - [x] **F5-TTS ersetzt XTTS** — bessere Voice-Cloning-Qualitaet, Whisper-auto-transkribierter Referenz-Text
 - [x] Audio-Pause statt Ducking (TRANSIENT statt MAY_DUCK) + release-Timing fix
 - [x] VAD-Stille-Toleranz einstellbar (1-8s) + adaptive Mikro-Baseline + Max-Aufnahme einstellbar (1-30 min)
@@ -994,6 +1439,9 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] Anruf-Pause + Auto-Resume: TTS verstummt bei Anruf, faehrt nach Auflegen ab der gemerkten Position fort (Date.now()-Tracking + WAV-Cache der Antwort)
 - [x] PcmPlaybackFinished-Event: AudioFocus wird erst released wenn AudioTrack wirklich durch ist — kein Spotify-mid-TTS mehr
 - [x] Edge-Case: neue Frage waehrend Telefonat verwirft pending Auto-Resume, neueste Antwort gewinnt
+- [x] **Pro-Projekt-Nachrichten-Queue** (loest das alte Barge-In-Cancel ab): zweite Nachricht wird **angestellt** statt den laufenden Task abzubrechen; **Rueckfrage-Loop** via unsichtbarem `[[AWAIT]]`-Marker (Queue pausiert, naechste Eingabe beantwortet die Rueckfrage); Stop-Button schaltet zum naechsten; sichtbare `⏸`-Bubbles (loeschbar). Pro Projekt unabhaengig, App + Diagnostic
+- [x] Pro-Projekt-Textfeld-Entwuerfe (Feldinhalt bleibt beim Projektwechsel erhalten, persistiert; App + Diagnostic)
+- [x] **TTS-Abspiel-Queue**: zwei fast gleichzeitig fertige Antworten sprechen garantiert nacheinander statt sich abzuschneiden (Puffern bis `PcmPlaybackFinished` der laufenden)
 - [x] Settings-Sub-Screens: 8 Kategorien statt langer Liste
 - [x] APK ABI-Split arm64-v8a: 35 MB statt 136 MB
 - [x] Sprachnachrichten-Bubble: audioRequestId statt Substring-Match — keine vertauschten Bubbles mehr bei parallelen Aufnahmen
@@ -1004,6 +1452,11 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] Background Audio Service: TTS, Wake-Word-Lauschen + Aufnahme laufen auch bei minimierter App weiter (Foreground-Service mit mediaPlayback|microphone, dynamische Notification)
 - [x] Disk-Voll Banner in Diagnostic mit copy-baren Cleanup-Befehlen
 - [x] Wake-Word on-device via openWakeWord (ONNX Runtime, kein API-Key) + State-Icon
+- [x] **Desktop-Workbench**: Taskleisten-Dock (Chat · Code · Desktop), Ein-Tap-Panelwechsel im Daumenbereich, Aktivitäts-Badges, keyboard-aware; Kompakt↔Cockpit-Umschalter. (Ersetzte den anfänglichen Pinch-Zoom-Kachel-Canvas — auf 5 Zoll zu fummelig)
+- [x] **noVNC-Konsole bedienbar**: Tastatur-Einblendung (tippt in die VM), Strg+Alt+Entf, Fit↔1:1
+- [x] **Live-Code-Editor** für Code-Projekte (WebView, offline, bidirektional) — ARIAs Write/Edit unter `/shared/projects/<id>/` live gespiegelt (`code_file`), eigene Edits zurück (`code_file_edit`)
+- [x] **QEMU für alle Architekturen** (Host-Helper `aria-vm`, `qemu-setup.sh`) + `set_project_kind`-Tool + Seed-Regel
+- [x] **VNC-Live-Desktop durch RVS getunnelt** (Bridge RFB-TCP ↔ RVS, noVNC-WebView mit WebSocket-Shim) — VM live mit Maus/Tastatur bedienbar
 
 ### Phase A — Refactor: OpenClaw raus, eigenes Brain rein
 
@@ -1033,7 +1486,7 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] App: Chat-Suche mit Next/Prev Navigation statt Filter
 - [x] Token/Call-Metrics + Subscription-Quota-Tracking (Pro / Max 5x / Max 20x / Custom)
 - [x] Datei-Manager Multi-Select: Bulk-Download als ZIP + Bulk-Delete (Diagnostic + App)
-- [x] **FLUX.1 Bildgenerierung**: eigener `flux-bridge`-Container auf der Gamebox (analog xtts/whisper) mit Hot-Swap zwischen FLUX.1-dev (Quali) und FLUX.1-schnell (Tempo). Default-Modell + Raw-/Switch-Keywords + HuggingFace-Token in Diagnostic-UI verwaltet, automatischer Pipeline-Reload bei Modell-Wechsel. ARIA bekommt `flux_generate`-Tool, Output landet als `/shared/uploads/aria_generated_<ts>.png` und wird via `[FILE: ...]`-Marker als Anhang-Bubble in App + Diagnostic gerendert. Download-Status (mehrere GB) sichtbar als 🎉-Toast wenn fertig
+- [x] **FLUX.1 Bildgenerierung**: eigener `flux-bridge`-Container auf der AI-Box (analog xtts/whisper) mit Hot-Swap zwischen FLUX.1-dev (Quali) und FLUX.1-schnell (Tempo). Default-Modell + Raw-/Switch-Keywords + HuggingFace-Token in Diagnostic-UI verwaltet, automatischer Pipeline-Reload bei Modell-Wechsel. ARIA bekommt `flux_generate`-Tool, Output landet als `/shared/uploads/aria_generated_<ts>.png` und wird via `[FILE: ...]`-Marker als Anhang-Bubble in App + Diagnostic gerendert. Download-Status (mehrere GB) sichtbar als 🎉-Toast wenn fertig
 - [x] **ARIA Live (Diagnostic) + Not-Aus**: read-only Mirror der Claude-Code-Session ersetzt den SSH-Tab. Tool-Calls + Inputs + Outputs (truncated 4 KB) live, farbcodiert. Roter ⛔ Not-Aus-Button schickt `cancel_request` mit `hard:true` → Bridge ruft den proxy-internen `/cancel-all` Side-Channel (Port 3457) → alle Claude-Subprocesses sofort tot. Plus: Idle-Watchdog im Proxy (20 min Inaktivitaet → Subprocess-Kill) + httpx-Timeout-Split im Brain (connect 10s / read 24h) damit lange Pentests durchlaufen
 - [x] **OAuth2-Pipeline ueber RVS-Callback**: Caddy mit Let's Encrypt vor dem RVS, HTTP-Route `/oauth/callback/{service}` broadcastet als `oauth_callback`-WS-Message, aria-bridge forwarded an Brain, Token landet in `/shared/config/oauth_tokens.json` (mode 0600). ARIAs `oauth_register_provider`-Tool legt neue Provider on-demand an (URLs/scopes, nicht Credentials). Diagnostic + App haben beide Provider-Verwaltung inklusive Custom-Provider-Anlage
 - [x] **Skill-Mgmt-Tools fuer ARIA**: `skill_update` (Code/README/pip_packages mit venv-Rebuild) + `skill_delete` — verhindert Skill-Friedhof mit `-v2`/`-fixed`-Suffixen. Plus App-seitiger SkillBrowser (Run + Live-Output + Logs der letzten 20 Runs) in Settings → 🛠️ Skills
@@ -1046,6 +1499,52 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] **Bridge-Hang-Schutz + Voice-Speed persistent**: 3-Schichten-Watchdog (TCP-Keepalive + Asyncio-Watchdog + File-Based Liveness mit Self-Kill), TLS-Fallback klebt nicht mehr beim Reconnect. `xttsSpeed` jetzt im voice_config.json persistiert — greift auch bei Diagnostic-Chats und nach Bridge-Restart
 - [x] **Bubble-Aktionen in der App**: Long-Press oder ⎘-Icon auf einer Chat-Bubble → Aktions-Menu mit "📋 Ganzen Text teilen" plus pro extrahierte URL/E-Mail/Telefonnummer eine eigene Teilen-Option (System-Share-Sheet → Zwischenablage / Apps / Browser)
 
+### Phase C — ARIA greift auf echte Geraete durch (09–10/2026)
+
+- [x] **Host-Agenten** (Linux/Windows/macOS): Standalone-Binary, ausgehend zum RVS, steuert den Rechner auf dem es laeuft. Windows-Build per Docker+Wine samt `setup.exe` (NSIS + nssm) das einen Dienst installiert und seine `.env` aus ProgramData liest. Plus **GUI-Steuerung** capability-gated (`windows`/`macos`/`xdotool`/`ydotool`) — ein Server ohne X meldet die Faehigkeit einfach nicht
+- [x] **Android-Agent** (eine APK fuer Handy + Fire TV): sehen (Screenshot via MediaProjection, `ui_dump` via Accessibility), steuern (tap/text/swipe/key/app_launch, nur entsperrt), ausgeben (Overlay ueber dem laufenden Bild + ARIAs **echte** Stimme per `tts_request`, weil Fire TV Sticks oft keine deutsche TTS-Engine haben), Audio-Fokus (Film wird leiser/angehalten), Sprachdialog mit demselben STT-Protokoll wie die App. Fester Signaturschluessel, damit Builds als Update statt als Paket-Konflikt ankommen
+- [x] **Ausrollen per Satellit** (ADB over Network): APK installieren, Berechtigungen per `appops`/`pm grant` erteilen und die **RVS-Zugangsdaten per Intent provisionieren** — am Fire TV tippt man nichts ein, QR-Scannen geht dort nicht. Geraetename am PC vergeben, vorhandener Name wird vorgeschlagen
+- [x] **Agent-Historie** in der Diagnostic: Befehle + Screenshots pro Agent, gruppiert pro User-Nachricht, aufklappbar
+- [x] **Jellyfin-Integration**: mehrere Server mit API-Key, ARIA steuert die Wiedergabe ueber die API statt sich durch die Oberflaeche zu klicken; eingeschlafene Sitzungen baut sie selbst neu auf
+- [x] **Auslastungs-Monitor** pro Compute-Box: live `nvidia-smi` + Verlaufs-Graphen (GPU + Tokens) ueber RVS, Historie liegt auf der Box
+- [x] **OpenAI-Endpunkt fuers lokale LLM** (+ optionales `openhands`-Profil); `.env` gewinnt immer, Diagnostic-Felder dann nur lesend
+- [x] **Teilen-Ziel in der App** + **Sprachnachricht zu Anhaengen** + **Zwischenruf per Sprache**
+- [x] **Trigger mit Projekt-Kontext**: die Antwort kommt dort zurueck, wo der Timer gestellt wurde (vorher immer Hauptchat), und `trigger_list` unterscheidet „schon gefeuert" von „deaktiviert"
+- [x] **Modell-Liste von Anthropic** statt handgepflegt — und feste Versionen greifen wirklich. Vorher schmolz `extractModel` jeden unbekannten Namen still auf `opus` ein: eine bewusst gewaehlte Version wurde ohne Meldung durch eine andere ersetzt. Dazu ein **Test-Knopf**, der zeigt, welches Modell tatsaechlich geantwortet hat — moeglich wurde das erst, nachdem `normalizeModelName` aufhoerte, den echten Namen zu ueberschreiben
+- [x] **Datenschutz**: die drei Claude-Code-Sendekanaele in der Diagnostic pruef- und abschaltbar (ohne Neustart), **`oauth_call`** statt Token-Herausgabe, Secrets-Regeln in Prompt und seed_rules, Warnung bei veralteten Proxy-Patches
+- [x] **Anhang-Limit einstellbar** (Default 20 → 64 MB, greift sofort) und **Zeitstempel/Sortierung/Zeitraum** bei den Gedanken
+- [x] **Flugwetter-Skill** mit pc_met-Anbindung, Seitenwind gegen Pistenrichtung und Herkunftsangabe pro Zahl; Ausgabe als Einblendung + Sprache auf einem Agenten
+- [x] **Einblendung geht per Tastendruck weg** statt nach geratener Zeit — ueber `onKeyEvent` des Accessibility-Dienstes, der die Taste an den Film weiterreicht
+
+#### Jagd auf verlorene Sprachnachrichten (die lange Kette)
+
+Ein hartnaeckiges „die erste Sprachnachricht kommt nicht durch" waren am Ende
+**fuenf unabhaengige Ursachen** — hier dokumentiert, weil jede einzelne fuer
+sich plausibel aussah:
+
+- [x] **200-MB-Broadcast** — der RVS ist ein Broadcast-Relay: ein per
+  `file_request` nachgeladenes 150-MB-Video ging als ~200 MB base64 an **alle**
+  Clients. Die STT/TTS-Worker starben daran mit Code 1009 und nahmen die
+  laufende Aufnahme mit; die App starb am OOM und wurde von Android neu
+  gestartet → Auto-Re-Download → von vorn (Schleife alle ~70s). Fix dreifach:
+  Worker-`max_size` an den RVS angeglichen, **Datei-Antworten gehen nur noch an
+  den Fragenden** (requestId-Korrelation im RVS), und die App holt ueber 25 MB
+  nichts mehr ungefragt
+- [x] **`spawn E2BIG`** im Proxy — der System-Prompt lief als Kommandozeilen-
+  Argument gegen `ARG_MAX` (131072). Jetzt `--system-prompt-file`
+- [x] **RVS-Allow-List** verwarf fuenf Nachrichtentypen still (`stt_lease*`,
+  `chat_ack`, `stt_transcribe_*`) — jede Aufnahme startete verspaetet, erste
+  Silben weg
+- [x] **Whisper-Kaltstart** — Session wurde angelegt, bevor das Modell geladen
+  war; Audio lief ins Leere
+- [x] **Zombie-Verbindung** in der App — zeigte „getrennt", empfing aber weiter;
+  die Aufnahme-Sperre fragt jetzt den Socket statt den gemerkten Zustand
+- [x] **Lange Sprachnachrichten brachen mitten im Satz ab** — der Endpointer
+  zaehlte seine **eigene** Rechenzeit als Stille: der 200ms-Tick wartete auf die
+  Zwischen-Transkription, und die lief jedes Mal ueber den kompletten Buffer
+  (bei zwei Minuten mehrere Sekunden). Jetzt laeuft sie nebenher und sieht nur
+  die letzten 30s; der finale Text kommt unveraendert aus dem ganzen Buffer
+
 ### Phase 2 — ARIA wird produktiv
 
 - [ ] Erste Skills bauen lassen (yt-dlp, pdf-extract, etc. — durch normale Anfragen)
@@ -1060,4 +1559,4 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
 - [ ] Custom-`.onnx`-Upload fuer Wake-Word ueber Diagnostic (ohne App-Rebuild)
-- [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)
+- [x] Bildanalyse / Vision — ARIA sieht App-Uploads & Screenshots via Read-Tool (`/shared/uploads/` ist im Proxy-Container gemountet). „Direkt ohne Dateipfad" waere reine Politur (ein Read weniger) und ist bewusst NICHT geplant.

android/App.tsx

@@ -6,13 +6,17 @@
  */
 
 import React, { useEffect } from 'react';
-import { AppState, AppStateStatus, PermissionsAndroid, Platform, StatusBar, StyleSheet } from 'react-native';
+import { AppState, AppStateStatus, PermissionsAndroid, Platform, StatusBar, StyleSheet, View } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { GestureHandlerRootView } from 'react-native-gesture-handler';
 import { NavigationContainer, DefaultTheme } from '@react-navigation/native';
-import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
+import { BottomTabBar, createBottomTabNavigator } from '@react-navigation/bottom-tabs';
 
-import ChatScreen from './src/screens/ChatScreen';
+import WorkspaceScreen from './src/workspace/WorkspaceScreen';
 import SettingsScreen from './src/screens/SettingsScreen';
+import ViewModeToggle from './src/components/ViewModeToggle';
+import SecurityLock from './src/components/SecurityLock';
+import UpdateProgress from './src/components/UpdateProgress';
 import rvs from './src/services/rvs';
 import { initLogger, installGlobalCrashReporter } from './src/services/logger';
 import { acquireBackgroundAudio } from './src/services/backgroundAudio';
@@ -132,10 +136,19 @@ const App: React.FC = () => {
   }, []);
 
   return (
-    <>
+    <GestureHandlerRootView style={styles.root}>
       <StatusBar barStyle="light-content" backgroundColor="#0D0D1A" />
       <NavigationContainer theme={DarkTheme}>
         <Tab.Navigator
+          tabBar={(props) => (
+            // Tab-Leiste + Schloss-Symbol rechts neben dem Zahnrad
+            <View style={styles.tabBarRow}>
+              <View style={styles.tabBarTabs}>
+                <BottomTabBar {...props} />
+              </View>
+              <SecurityLock onOpenSettings={() => props.navigation.navigate('Einstellungen')} />
+            </View>
+          )}
           screenOptions={({ route }) => ({
             headerStyle: styles.header,
             headerTitleStyle: styles.headerTitle,
@@ -165,10 +178,11 @@ const App: React.FC = () => {
         >
           <Tab.Screen
             name="Chat"
-            component={ChatScreen}
+            component={WorkspaceScreen}
             options={{
               title: 'ARIA Chat',
               headerTitle: 'ARIA Cockpit',
+              headerRight: () => <ViewModeToggle />,
             }}
           />
           <Tab.Screen
@@ -180,13 +194,17 @@ const App: React.FC = () => {
           />
         </Tab.Navigator>
       </NavigationContainer>
-    </>
+      <UpdateProgress />
+    </GestureHandlerRootView>
   );
 };
 
 // --- Styles ---
 
 const styles = StyleSheet.create({
+  root: {
+    flex: 1,
+  },
   header: {
     backgroundColor: '#12122A',
     elevation: 0,
@@ -199,10 +217,18 @@ const styles = StyleSheet.create({
     fontSize: 18,
     fontWeight: '700',
   },
-  tabBar: {
+  tabBarRow: {
+    flexDirection: 'row',
     backgroundColor: '#12122A',
     borderTopColor: '#1E1E2E',
     borderTopWidth: 1,
+  },
+  tabBarTabs: {
+    flex: 1,
+  },
+  tabBar: {
+    backgroundColor: '#12122A',
+    borderTopWidth: 0,
     height: 60,
     paddingBottom: 6,
     paddingTop: 4,

android/android/app/build.gradle

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

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

@@ -49,6 +49,28 @@
             <action android:name="android.intent.action.MAIN" />
             <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>
+
+        <!-- Teilen-Ziel: ARIA erscheint im Teilen-Menue anderer Apps (WhatsApp,
+             Galerie, Browser ...). EINE Datei bzw. reiner Text. -->
+        <intent-filter>
+            <action android:name="android.intent.action.SEND" />
+            <category android:name="android.intent.category.DEFAULT" />
+            <data android:mimeType="text/*" />
+            <data android:mimeType="image/*" />
+            <data android:mimeType="video/*" />
+            <data android:mimeType="audio/*" />
+            <data android:mimeType="application/*" />
+        </intent-filter>
+
+        <!-- Mehrere Dateien auf einmal. -->
+        <intent-filter>
+            <action android:name="android.intent.action.SEND_MULTIPLE" />
+            <category android:name="android.intent.category.DEFAULT" />
+            <data android:mimeType="image/*" />
+            <data android:mimeType="video/*" />
+            <data android:mimeType="audio/*" />
+            <data android:mimeType="application/*" />
+        </intent-filter>
       </activity>
 
       <provider

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

@@ -1,5 +1,6 @@
 package com.ariacockpit
 
+import android.content.Intent
 import com.facebook.react.ReactActivity
 import com.facebook.react.ReactActivityDelegate
 import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
@@ -19,4 +20,26 @@ class MainActivity : ReactActivity() {
    */
   override fun createReactActivityDelegate(): ReactActivityDelegate =
       DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled)
+
+  /**
+   * Teilen in die LAUFENDE App (launchMode=singleTask liefert das hier ab).
+   * setIntent() ist wichtig, damit getSharedData() denselben Inhalt sieht, und
+   * das Event weckt die JS-Seite sofort — ohne es wuerde der geteilte Inhalt
+   * erst beim naechsten Kaltstart auftauchen.
+   */
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+    // Best effort: je nach RN-Architektur ist der Kontext anders erreichbar.
+    // Scheitert es, greift der zuverlaessige Zweitweg — die JS-Seite fragt beim
+    // Zurueckkehren in den Vordergrund ohnehin nochmal via getSharedData() nach
+    // (setIntent() oben sorgt dafuer, dass sie denselben Inhalt sieht).
+    try {
+      val ctx = (application as? com.facebook.react.ReactApplication)
+          ?.reactNativeHost?.reactInstanceManager?.currentReactContext
+      ShareIntentModule.notifyNewIntent(
+          ctx as? com.facebook.react.bridge.ReactApplicationContext, intent)
+    } catch (_: Throwable) {
+    }
+  }
 }

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

@@ -25,6 +25,8 @@ class MainApplication : Application(), ReactApplication {
               add(OpenWakeWordPackage())
               add(PhoneCallPackage())
               add(BackgroundAudioPackage())
+              add(ShareIntentPackage())
+              add(TlsTrustPackage())
             }
 
         override fun getJSMainModuleName(): String = "index"
@@ -41,6 +43,8 @@ class MainApplication : Application(), ReactApplication {
   override fun onCreate() {
     super.onCreate()
     SoLoader.init(this, false)
+    // Vor der ersten Verbindung: Zertifikatspruefung (abgelaufen erlaubt?)
+    TlsTrust.install(this)
     if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
       // If you opted-in for the New Architecture, we load the native entry point for this app.
       load()

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

@@ -59,7 +59,12 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
         // Trigger eingestuft werden kann. Folge: App pausiert beim Oeffnen die Musik,
         // weil der False-Positive die AudioFocus-Switch-Logik anwirft (Stefan-Bug 06/2026).
         // Loesung: in dieser Phase keine Detections an JS weiterleiten.
-        private const val STARTUP_SUPPRESSION_MS = 1500L
+        private const val STARTUP_SUPPRESSION_MS = 600L
+        // PCM-Ringpuffer fuer die Wake-Wort-Bestaetigung: letzte 2s roh (16kHz
+        // mono s16). Bei einer Erkennung wird der Vor-Trigger-Schnipsel an JS
+        // gereicht und dort von Voxtral verifiziert (gegen Musik-Fehltrigger).
+        private const val PCM_RING_SAMPLES = 32000        // 2.0s @ 16kHz
+        private const val PRE_TRIGGER_SAMPLES = 24000     // 1.5s Schnipsel an JS
     }
 
     private val env: OrtEnvironment = OrtEnvironment.getEnvironment()
@@ -106,6 +111,13 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
     private val embBuffer: ArrayDeque<FloatArray> = ArrayDeque(32)  // Ringpuffer letzter Embeddings
     private var consecutiveAboveThreshold: Int = 0
     private var lastDetectionMs: Long = 0L
+    // Roh-PCM-Ringpuffer (letzte ~2s) fuer die Wake-Wort-Bestaetigung. Bei einer
+    // Erkennung wird der Vor-Trigger-Schnipsel base64-kodiert an JS gereicht und
+    // dort von Voxtral verifiziert ("war das wirklich 'Computer' oder Musik?").
+    private val pcmRing = ShortArray(PCM_RING_SAMPLES)
+    private var pcmRingPos = 0
+    private var pcmRingFilled = false
+    private val pcmRingLock = Any()
     // Zeitpunkt des letzten startRecording — fuer STARTUP_SUPPRESSION_MS-Fenster
     private var recordingStartedMs: Long = 0L
 
@@ -430,6 +442,36 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
         embBuffer.clear()
         consecutiveAboveThreshold = 0
         lastDetectionMs = 0L
+        // PCM-Ring frisch: sonst koennte Alt-Audio aus dem vorigen Arm-Zyklus
+        // in den Bestaetigungs-Schnipsel bluten.
+        synchronized(pcmRingLock) { pcmRingPos = 0; pcmRingFilled = false }
+    }
+
+    /** Letzte ~1.5s Roh-PCM aus dem Ringpuffer als Base64 (s16le, 16kHz mono),
+     *  fuer die Voxtral-Wake-Bestaetigung. null wenn noch zu wenig Audio da ist
+     *  oder das Kodieren scheitert (dann macht JS fail-open weiter wie bisher). */
+    private fun snapshotPreTrigger(): String? {
+        val out: ByteArray
+        synchronized(pcmRingLock) {
+            val available = if (pcmRingFilled) PCM_RING_SAMPLES else pcmRingPos
+            val n = if (available < PRE_TRIGGER_SAMPLES) available else PRE_TRIGGER_SAMPLES
+            if (n <= 0) return null
+            out = ByteArray(n * 2)
+            var idx = (pcmRingPos - n + PCM_RING_SAMPLES) % PCM_RING_SAMPLES
+            for (i in 0 until n) {
+                val s = pcmRing[idx].toInt()
+                out[i * 2] = (s and 0xFF).toByte()
+                out[i * 2 + 1] = ((s shr 8) and 0xFF).toByte()
+                idx += 1
+                if (idx >= PCM_RING_SAMPLES) idx = 0
+            }
+        }
+        return try {
+            android.util.Base64.encodeToString(out, android.util.Base64.NO_WRAP)
+        } catch (e: Exception) {
+            Log.w(TAG, "snapshotPreTrigger base64 fehlgeschlagen: ${e.message}")
+            null
+        }
     }
 
     private fun emitDetected() {
@@ -438,8 +480,10 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
             Log.i(TAG, "Wake-Word emit unterdrueckt (sinceStart=${sinceStart}ms < ${STARTUP_SUPPRESSION_MS}ms — Mikro-Spin-up-Spike)")
             return
         }
+        val preTriggerB64 = snapshotPreTrigger()
         val params = com.facebook.react.bridge.Arguments.createMap().apply {
             putString("model", modelName)
+            if (preTriggerB64 != null) putString("preTriggerPcm", preTriggerB64)
         }
         try {
             reactApplicationContext
@@ -466,6 +510,14 @@ class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBa
                 read += n
             }
             if (!running.get()) break
+            // Chunk in den PCM-Ringpuffer schreiben (fuer Wake-Wort-Bestaetigung).
+            synchronized(pcmRingLock) {
+                for (i in 0 until CHUNK_SAMPLES) {
+                    pcmRing[pcmRingPos] = buf[i]
+                    pcmRingPos += 1
+                    if (pcmRingPos >= PCM_RING_SAMPLES) { pcmRingPos = 0; pcmRingFilled = true }
+                }
+            }
             try {
                 processChunk(buf)
             } catch (e: Exception) {

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

@@ -0,0 +1,154 @@
+package com.ariacockpit
+
+import android.content.Intent
+import android.net.Uri
+import android.provider.OpenableColumns
+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.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.io.File
+
+/**
+ * Teilen-Ziel: nimmt Inhalte entgegen, die aus anderen Apps (WhatsApp, Galerie,
+ * Browser ...) per "Teilen → ARIA" geschickt werden.
+ *
+ * Die geteilten Dateien kommen als content://-URI, auf die nur DIESE App und nur
+ * JETZT zugreifen darf. Deshalb kopieren wir sie sofort in den App-Cache und
+ * geben einen echten Dateipfad zurueck — den kann die JS-Seite wie eine normal
+ * ausgewaehlte Datei weiterverarbeiten (RNFS.readFile → Base64 → Upload).
+ *
+ * Ablauf:
+ *   App geschlossen → Intent liegt beim Start an    → getSharedData()
+ *   App laeuft       → onNewIntent (launchMode=singleTask) → Event 'ShareReceived'
+ */
+class ShareIntentModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "ShareIntent"
+
+    companion object {
+        private const val EVENT = "ShareReceived"
+
+        /** Vom MainActivity.onNewIntent gerufen, wenn die App schon laeuft. */
+        @JvmStatic
+        fun notifyNewIntent(ctx: ReactApplicationContext?, intent: Intent?) {
+            if (ctx == null || intent == null || !isShare(intent)) return
+            try {
+                val data = extract(ctx, intent)
+                ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit(EVENT, data)
+            } catch (_: Throwable) {
+            }
+        }
+
+        private fun isShare(i: Intent): Boolean =
+            i.action == Intent.ACTION_SEND || i.action == Intent.ACTION_SEND_MULTIPLE
+
+        /** Baut {text, items:[{path,name,type,size}]} aus dem Intent. */
+        private fun extract(ctx: ReactApplicationContext, intent: Intent): WritableMap {
+            val out = Arguments.createMap()
+            out.putString("text", intent.getStringExtra(Intent.EXTRA_TEXT) ?: "")
+
+            val uris = mutableListOf<Uri>()
+            if (intent.action == Intent.ACTION_SEND) {
+                @Suppress("DEPRECATION")
+                (intent.getParcelableExtra<Uri>(Intent.EXTRA_STREAM))?.let { uris.add(it) }
+            } else {
+                @Suppress("DEPRECATION")
+                intent.getParcelableArrayListExtra<Uri>(Intent.EXTRA_STREAM)
+                    ?.forEach { uris.add(it) }
+            }
+
+            val items: WritableArray = Arguments.createArray()
+            for (uri in uris) {
+                copyToCache(ctx, uri)?.let { items.pushMap(it) }
+            }
+            out.putArray("items", items)
+            return out
+        }
+
+        /**
+         * Kopiert den geteilten Inhalt in den Cache. Noetig, weil die Leseerlaubnis
+         * fuer die content://-URI nur fuer diesen Intent gilt — spaeter (nach der
+         * Projektauswahl) waere sie womoeglich schon erloschen.
+         */
+        private fun copyToCache(ctx: ReactApplicationContext, uri: Uri): WritableMap? {
+            return try {
+                val cr = ctx.contentResolver
+                var name = "geteilt"
+                var size = 0L
+                cr.query(uri, null, null, null, null)?.use { c ->
+                    val ni = c.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+                    val si = c.getColumnIndex(OpenableColumns.SIZE)
+                    if (c.moveToFirst()) {
+                        if (ni >= 0) c.getString(ni)?.let { name = it }
+                        if (si >= 0) size = c.getLong(si)
+                    }
+                }
+                val type = cr.getType(uri) ?: "application/octet-stream"
+                val dir = File(ctx.cacheDir, "shared").apply { mkdirs() }
+                // Eindeutiger Name, damit zwei gleichnamige Bilder sich nicht ueberschreiben.
+                val safe = name.replace(Regex("[^A-Za-z0-9._-]"), "_").take(80)
+                val dst = File(dir, "${System.currentTimeMillis()}_$safe")
+                cr.openInputStream(uri)?.use { input ->
+                    dst.outputStream().use { output -> input.copyTo(output) }
+                } ?: return null
+
+                Arguments.createMap().apply {
+                    putString("path", dst.absolutePath)
+                    putString("name", name)
+                    putString("type", type)
+                    putDouble("size", (if (size > 0) size else dst.length()).toDouble())
+                }
+            } catch (_: Throwable) {
+                null
+            }
+        }
+    }
+
+    /**
+     * Holt den Inhalt, mit dem die App GESTARTET wurde (App war zu).
+     * Gibt {text, items:[]} zurueck — items leer, wenn nichts geteilt wurde.
+     */
+    @ReactMethod
+    fun getSharedData(promise: Promise) {
+        try {
+            val activity = currentActivity
+            val intent = activity?.intent
+            if (intent == null || !isShare(intent)) {
+                promise.resolve(Arguments.createMap().apply {
+                    putString("text", "")
+                    putArray("items", Arguments.createArray())
+                })
+                return
+            }
+            val data = extract(reactContext, intent)
+            // Verbraucht markieren, damit ein Rotieren/Zurueckkehren den Dialog
+            // nicht erneut oeffnet.
+            activity.intent = Intent(Intent.ACTION_MAIN)
+            promise.resolve(data)
+        } catch (e: Throwable) {
+            promise.reject("SHARE_READ_FAILED", e.message, e)
+        }
+    }
+
+    /** Aufgeraeumte Kopien loeschen (nach erfolgreichem Senden). */
+    @ReactMethod
+    fun clearCache(promise: Promise) {
+        try {
+            File(reactContext.cacheDir, "shared").listFiles()?.forEach { it.delete() }
+            promise.resolve(true)
+        } catch (e: Throwable) {
+            promise.resolve(false)
+        }
+    }
+
+    // Fuer NativeEventEmitter (RN verlangt diese beiden Methoden).
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+}

android/android/app/src/main/java/com/ariacockpit/ShareIntentPackage.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 ShareIntentPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(ShareIntentModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

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

@@ -0,0 +1,185 @@
+package com.ariacockpit
+
+import android.content.Context
+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.network.NetworkingModule
+import com.facebook.react.modules.websocket.WebSocketModule
+import java.net.Socket
+import java.security.KeyStore
+import java.security.cert.CertPathValidator
+import java.security.cert.CertificateException
+import java.security.cert.CertificateExpiredException
+import java.security.cert.CertificateFactory
+import java.security.cert.PKIXParameters
+import java.security.cert.X509Certificate
+import java.util.Date
+import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLEngine
+import javax.net.ssl.TrustManagerFactory
+import javax.net.ssl.X509ExtendedTrustManager
+import javax.net.ssl.X509TrustManager
+
+/**
+ * Zertifikatspruefung fuer RVS-Verbindung (WebSocket) und fetch.
+ *
+ * Normal pruefen wir wie Android selbst. Mit dem Schalter "Abgelaufenes
+ * Zertifikat akzeptieren" wird GENAU EIN Fehler toleriert: das Ablaufdatum.
+ * Kette und Aussteller werden dann zum Zeitpunkt kurz vor dem Ablauf geprueft
+ * (war das Zertifikat damals gueltig, ist es echt), der Hostname prueft OkHttp
+ * ohnehin separat. Ein fremdes oder selbstgebautes Zertifikat kommt also auch
+ * mit Schalter nicht durch — sonst koennte sich jeder dazwischenhaengen.
+ *
+ * Nebenbei merkt sich das Modul, wie die letzte Pruefung ausging, damit die
+ * App das Schloss-Symbol richtig zeigen kann.
+ */
+object TlsTrust {
+    private const val PREFS = "aria_tls"
+    private const val KEY_ALLOW_EXPIRED = "allow_expired"
+
+    // ok | expired_accepted | expired | invalid | unknown
+    @Volatile var lastStatus: String = "unknown"
+    @Volatile var lastDetail: String = ""
+    @Volatile var lastNotAfter: Long = 0
+    @Volatile var lastSubject: String = ""
+    @Volatile var allowExpired: Boolean = false
+        private set
+
+    private var appContext: Context? = null
+
+    fun install(context: Context) {
+        appContext = context.applicationContext
+        allowExpired = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+            .getBoolean(KEY_ALLOW_EXPIRED, false)
+        try {
+            val tm = ExpiryTolerantTrustManager(defaultTrustManager())
+            val ssl = SSLContext.getInstance("TLS").apply { init(null, arrayOf(tm), null) }
+            val factory = ssl.socketFactory
+            WebSocketModule.setCustomClientBuilder { b -> b.sslSocketFactory(factory, tm) }
+            NetworkingModule.setCustomClientBuilder { b -> b.sslSocketFactory(factory, tm) }
+        } catch (e: Exception) {
+            // Lieber normale Pruefung als gar keine Verbindung
+            android.util.Log.w("TlsTrust", "Eigene Zertifikatspruefung nicht aktiv: ${e.message}")
+        }
+    }
+
+    fun saveAllowExpired(value: Boolean) {
+        allowExpired = value
+        appContext?.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+            ?.edit()?.putBoolean(KEY_ALLOW_EXPIRED, value)?.apply()
+    }
+
+    private fun defaultTrustManager(): X509TrustManager {
+        val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+        tmf.init(null as KeyStore?)
+        return tmf.trustManagers.filterIsInstance<X509TrustManager>().first()
+    }
+
+    private fun remember(status: String, chain: Array<X509Certificate>?, detail: String = "") {
+        lastStatus = status
+        lastDetail = detail
+        val leaf = chain?.firstOrNull()
+        lastNotAfter = leaf?.notAfter?.time ?: 0
+        lastSubject = leaf?.subjectX500Principal?.name ?: ""
+    }
+
+    private fun isExpired(chain: Array<X509Certificate>): Boolean =
+        chain.any { c ->
+            try { c.checkValidity(); false } catch (_: CertificateExpiredException) { true } catch (_: Exception) { false }
+        }
+
+    /** Kette gegen die System-Zertifizierungsstellen pruefen — zum Zeitpunkt
+     *  kurz vor dem fruehesten Ablauf in der Kette. */
+    private fun chainValidBeforeExpiry(chain: Array<X509Certificate>) {
+        val ks = KeyStore.getInstance("AndroidCAStore").apply { load(null) }
+        val params = PKIXParameters(ks).apply {
+            isRevocationEnabled = false
+            date = Date(chain.minOf { it.notAfter.time } - 60_000)
+        }
+        // Mitgeschickte Wurzel (selbstsigniert) gehoert nicht in den Pfad — aber NIE
+        // das Server-Zertifikat selbst: ein leerer Pfad gilt als gueltig, ein
+        // selbstgebautes Zertifikat kaeme sonst durch.
+        if (chain.isEmpty()) throw CertificateException("Leere Zertifikatskette")
+        val path = listOf(chain[0]) + chain.drop(1).filter { it.subjectX500Principal != it.issuerX500Principal }
+        val certPath = CertificateFactory.getInstance("X.509").generateCertPath(path)
+        CertPathValidator.getInstance("PKIX").validate(certPath, params)
+    }
+
+    private class ExpiryTolerantTrustManager(private val inner: X509TrustManager) : X509ExtendedTrustManager() {
+        private val ext = inner as? X509ExtendedTrustManager
+
+        private fun check(chain: Array<X509Certificate>, run: () -> Unit) {
+            try {
+                run()
+                remember("ok", chain)
+            } catch (e: CertificateException) {
+                if (!isExpired(chain)) {
+                    remember("invalid", chain, e.message ?: "")
+                    throw e
+                }
+                if (!allowExpired) {
+                    remember("expired", chain, e.message ?: "")
+                    throw e
+                }
+                try {
+                    chainValidBeforeExpiry(chain)
+                } catch (inner: Exception) {
+                    // Abgelaufen UND sonst nicht in Ordnung → nicht akzeptieren
+                    remember("invalid", chain, inner.message ?: "")
+                    throw e
+                }
+                remember("expired_accepted", chain)
+            }
+        }
+
+        override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) =
+            check(chain) { inner.checkServerTrusted(chain, authType) }
+
+        override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String, socket: Socket?) =
+            check(chain) {
+                if (ext != null) ext.checkServerTrusted(chain, authType, socket)
+                else inner.checkServerTrusted(chain, authType)
+            }
+
+        override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String, engine: SSLEngine?) =
+            check(chain) {
+                if (ext != null) ext.checkServerTrusted(chain, authType, engine)
+                else inner.checkServerTrusted(chain, authType)
+            }
+
+        override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) =
+            inner.checkClientTrusted(chain, authType)
+
+        override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String, socket: Socket?) =
+            if (ext != null) ext.checkClientTrusted(chain, authType, socket) else inner.checkClientTrusted(chain, authType)
+
+        override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String, engine: SSLEngine?) =
+            if (ext != null) ext.checkClientTrusted(chain, authType, engine) else inner.checkClientTrusted(chain, authType)
+
+        override fun getAcceptedIssuers(): Array<X509Certificate> = inner.acceptedIssuers
+    }
+}
+
+class TlsTrustModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "TlsTrust"
+
+    @ReactMethod
+    fun setAllowExpired(value: Boolean, promise: Promise) {
+        TlsTrust.saveAllowExpired(value)
+        promise.resolve(value)
+    }
+
+    @ReactMethod
+    fun getStatus(promise: Promise) {
+        val m = Arguments.createMap()
+        m.putString("status", TlsTrust.lastStatus)
+        m.putString("detail", TlsTrust.lastDetail)
+        m.putDouble("notAfter", TlsTrust.lastNotAfter.toDouble())
+        m.putString("subject", TlsTrust.lastSubject)
+        m.putBoolean("allowExpired", TlsTrust.allowExpired)
+        promise.resolve(m)
+    }
+}

android/android/app/src/main/java/com/ariacockpit/TlsTrustPackage.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 TlsTrustPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(TlsTrustModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

android/babel.config.js

@@ -1,3 +1,6 @@
 module.exports = {
   presets: ['module:metro-react-native-babel-preset'],
+  // react-native-reanimated/plugin MUSS das LETZTE Plugin sein (Worklet-Transform).
+  // Nach dem Hinzufuegen einmalig Metro-Cache leeren: `npm start --reset-cache`.
+  plugins: ['react-native-reanimated/plugin'],
 };

android/index.js

@@ -1,3 +1,6 @@
+// react-native-gesture-handler MUSS als allererstes importiert werden
+// (vor allem anderen), sonst crasht die Gesten-Erkennung auf Android.
+import 'react-native-gesture-handler';
 import { AppRegistry } from 'react-native';
 import App from './App';
 import { name as appName } from './app.json';

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.2.1.3",
+  "version": "0.2.6.2",
   "private": true,
   "scripts": {
     "android": "react-native run-android",
@@ -20,12 +20,15 @@
     "react-native-camera-kit": "^13.0.0",
     "react-native-document-picker": "^9.1.1",
     "react-native-fs": "^2.20.0",
+    "react-native-gesture-handler": "2.14.1",
     "react-native-image-picker": "^7.1.0",
     "react-native-permissions": "^4.1.4",
+    "react-native-reanimated": "3.6.2",
     "react-native-safe-area-context": "^4.8.2",
     "react-native-screens": "3.27.0",
     "react-native-sound": "^0.11.2",
-    "react-native-svg": "^14.1.0"
+    "react-native-svg": "^14.1.0",
+    "react-native-webview": "13.6.4"
   },
   "devDependencies": {
     "@react-native/eslint-config": "^0.73.2",

android/src/components/FileUpload.tsx

@@ -34,13 +34,10 @@ interface FileUploadProps {
   onCancel: () => void;
 }
 
-// Unterstuetzte Dateitypen
-const SUPPORTED_TYPES = [
-  DocumentPicker.types.images,
-  DocumentPicker.types.pdf,
-  DocumentPicker.types.docx,
-  DocumentPicker.types.plainText,
-];
+// Alle Dateitypen zulassen — Stefan will ueber die Bueroklammer jede Datei
+// hochladen koennen, nicht nur Bilder/Dokumente. Die Komponente verarbeitet
+// beliebige Typen ohnehin (Base64 + application/octet-stream als Fallback).
+const SUPPORTED_TYPES = [DocumentPicker.types.allFiles];
 
 // --- Komponente ---
 
@@ -112,7 +109,7 @@ const FileUpload: React.FC<FileUploadProps> = ({ onFileSelected, onCancel }) =>
         <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>
+          <Text style={styles.pickHint}>Alle Dateitypen</Text>
         </TouchableOpacity>
       ) : (
         // Vorschau und Senden

android/src/components/ProjectsBrowser.tsx

@@ -28,6 +28,7 @@ import {
 
 import brainApi, { Project } from '../services/brainApi';
 import rvs from '../services/rvs';
+import projectFocus from '../services/projectFocus';
 
 interface Props {
   /** Optional — wenn als Modal genutzt, sonst inline */
@@ -75,6 +76,7 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
   const [editing, setEditing] = useState<Project | null>(null);
   const [editName, setEditName] = useState('');
   const [editDesc, setEditDesc] = useState('');
+  const [editKind, setEditKind] = useState<'code' | 'chat'>('chat');
   // Versteckte Projekte standardmaessig ausblenden; Toggle blendet sie
   // temporaer (gedimmt) ein — zum Ansehen/Auswaehlen oder Wieder-Sichtbarmachen.
   const [showHidden, setShowHidden] = useState(false);
@@ -148,18 +150,25 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
     setEditing(p);
     setEditName(p.name);
     setEditDesc(p.description || '');
+    setEditKind(p.kind === 'code' ? 'code' : 'chat');
   }, []);
 
   const saveEdit = useCallback(() => {
     if (!editing) return;
-    const patch: Partial<Pick<Project, 'name' | 'description'>> = {};
+    const patch: Partial<Pick<Project, 'name' | 'description' | 'kind'>> = {};
     if (editName.trim() && editName.trim() !== editing.name) patch.name = editName.trim();
     if (editDesc.trim() !== (editing.description || '')) patch.description = editDesc.trim();
+    const curKind = editing.kind === 'code' ? 'code' : 'chat';
+    if (editKind !== curKind) patch.kind = editKind;
     if (Object.keys(patch).length === 0) { setEditing(null); return; }
     brainApi.updateProject(editing.id, patch)
-      .then(() => { setEditing(null); load(); })
+      .then(() => {
+        // Kind sofort in den Workspace spiegeln (Editor/Desktop-Panels).
+        if (patch.kind) projectFocus.setKind(editing.id, patch.kind);
+        setEditing(null); load();
+      })
       .catch(e => Alert.alert('Fehler', String(e?.message || e)));
-  }, [editing, editName, editDesc, load]);
+  }, [editing, editName, editDesc, editKind, load]);
 
   const endProject = useCallback((p: Project) => {
     Alert.alert(`"${p.name}" beenden?`,
@@ -216,6 +225,9 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
               <View style={{ width: 8, height: 8, borderRadius: 4, backgroundColor: dot.color }} />
             )}
             <Text style={[s.rowName, isActive && { color: '#34C759' }]}>{item.name}</Text>
+            {item.has_files && (
+              <Text style={{ fontSize: 12 }} accessibilityLabel="hat Dateien">📄{item.file_count ? ` ${item.file_count}` : ''}</Text>
+            )}
             {hidden && <Text style={s.hiddenBadge}>versteckt</Text>}
             {item.status === 'ended' && <Text style={s.statusBadge}>beendet</Text>}
             {isActive && <Text style={s.activeBadge}>✓ FOCUS</Text>}
@@ -375,6 +387,21 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
               style={[s.input, { height: 70 }]}
               multiline
             />
+            <TouchableOpacity
+              onPress={() => setEditKind(k => (k === 'code' ? 'chat' : 'code'))}
+              style={{ flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', paddingVertical: 8 }}
+            >
+              <Text style={{ color: '#E0E0F0', fontSize: 14 }}>💻 Code-Projekt{'\n'}
+                <Text style={{ color: '#8888AA', fontSize: 11 }}>zeigt Editor + Desktop im Cockpit</Text>
+              </Text>
+              <View style={{
+                width: 46, height: 26, borderRadius: 13, padding: 3,
+                backgroundColor: editKind === 'code' ? '#0096FF' : '#2A2A3E',
+                alignItems: editKind === 'code' ? 'flex-end' : 'flex-start',
+              }}>
+                <View style={{ width: 20, height: 20, borderRadius: 10, backgroundColor: '#FFFFFF' }} />
+              </View>
+            </TouchableOpacity>
             <View style={{ flexDirection: 'row', gap: 8, marginTop: 12 }}>
               <TouchableOpacity onPress={() => setEditing(null)} style={[s.modalBtn, { backgroundColor: '#2A2A3E' }]}>
                 <Text style={s.modalBtnText}>Abbrechen</Text>

android/src/components/QRScanner.tsx

@@ -121,13 +121,20 @@ const QRScanner: React.FC<QRScannerProps> = ({ visible, onScan, onClose }) => {
       <View style={styles.container}>
         {hasPermission ? (
           <>
+            {/* react-native-camera-kit v13: die .d.ts markiert viele OPTIONALE
+                CameraScreen-Props faelschlich als required (defaultProps fuellen
+                sie zur Laufzeit) und kennt colorForScannerFrame nicht — der war
+                ein No-Op und ist raus. scanBarcode/onReadCode ist die korrekte
+                v13-Barcode-API. Props als any spreaden, um die kaputten Lib-Typen
+                zu umgehen, ohne echten Code zu veraendern. */}
             <CameraScreen
-              scanBarcode={true}
-              onReadCode={handleBarcodeScan}
-              showFrame={true}
-              frameColor="#0096FF"
-              laserColor="#0096FF"
-              colorForScannerFrame="#0096FF"
+              {...({
+                scanBarcode: true,
+                onReadCode: handleBarcodeScan,
+                showFrame: true,
+                frameColor: '#0096FF',
+                laserColor: '#0096FF',
+              } as any)}
             />
 
             {/* Overlay oben */}

android/src/components/SecurityLock.tsx

@@ -0,0 +1,150 @@
+/**
+ * Schloss-Symbol in der Tab-Leiste (neben dem Zahnrad): zeigt, ob die
+ * Verbindung zu ARIA verschluesselt ist.
+ *
+ *   🔒        verschluesselt, alles in Ordnung
+ *   🔒 + !    Problem mit dem Zertifikat (abgelaufen / abgelehnt)
+ *   🔒 durchgestrichen   keine Verschluesselung (Fallback oder so eingestellt)
+ *
+ * Antippen erklaert in einfachen Worten, was das Symbol bedeutet.
+ * Einmal pro App-Start gibt's ausserdem einen Hinweis, wenn das Zertifikat
+ * abgelaufen ist — damit es nicht unbemerkt bleibt.
+ */
+
+import React, { useEffect, useRef, useState } from 'react';
+import { Alert, Modal, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import rvs, { SecurityState } from '../services/rvs';
+
+interface Props {
+  onOpenSettings: () => void;
+}
+
+const fmtDate = (ms: number) =>
+  ms ? new Date(ms).toLocaleString('de-DE', { day: '2-digit', month: '2-digit', year: 'numeric',
+                                              hour: '2-digit', minute: '2-digit' }) : 'unbekannt';
+
+const SecurityLock: React.FC<Props> = ({ onOpenSettings }) => {
+  const [sec, setSec] = useState<SecurityState>(rvs.getSecurity());
+  const [open, setOpen] = useState(false);
+  const alerted = useRef<Set<string>>(new Set());
+
+  useEffect(() => rvs.onSecurityChange(setSec), []);
+
+  // Einmaliger Hinweis pro App-Start
+  useEffect(() => {
+    if (sec.kind === 'expired' && !alerted.current.has('expired')) {
+      alerted.current.add('expired');
+      Alert.alert('Zertifikat abgelaufen',
+        `Die Verbindung zu ARIA ist weiterhin verschlüsselt, aber das Sicherheits-Zertifikat `
+        + `des Servers ist seit ${fmtDate(sec.notAfter)} abgelaufen. Bitte dem Admin Bescheid geben.`);
+    } else if (sec.kind === 'cert_error' && sec.certStatus === 'expired' && !alerted.current.has('cert_error')) {
+      alerted.current.add('cert_error');
+      Alert.alert('Keine Verbindung — Zertifikat abgelaufen',
+        `Das Sicherheits-Zertifikat des Servers ist seit ${fmtDate(sec.notAfter)} abgelaufen, `
+        + `deshalb verbindet sich die App nicht.\n\nIn den Einstellungen unter „Verbindung“ kann man `
+        + `abgelaufene Zertifikate vorübergehend erlauben.`,
+        [{ text: 'OK' }, { text: 'Einstellungen', onPress: onOpenSettings }]);
+    }
+  }, [sec, onOpenSettings]);
+
+  const warn = sec.kind === 'expired' || sec.kind === 'cert_error';
+  const crossed = sec.kind === 'fallback' || sec.kind === 'plain';
+  if (sec.kind === 'unknown') return <View style={styles.slot} />;
+
+  let title = '';
+  let text = '';
+  if (sec.kind === 'secure') {
+    title = 'Verbindung verschlüsselt';
+    text = 'Alles in Ordnung. Die Verbindung zu ARIA ist verschlüsselt und das Zertifikat des Servers ist gültig.';
+  } else if (sec.kind === 'expired') {
+    title = 'Zertifikat abgelaufen';
+    text = `Die Verbindung ist verschlüsselt, aber das Zertifikat des Servers ist seit ${fmtDate(sec.notAfter)} `
+      + 'abgelaufen. Die App akzeptiert es, weil das in den Einstellungen so erlaubt ist. '
+      + 'Geprüft wird trotzdem, dass es wirklich das Zertifikat dieses Servers ist.\n\n'
+      + 'Das Zertifikat sollte erneuert werden.';
+  } else if (sec.kind === 'cert_error') {
+    title = 'Keine Verbindung — Zertifikat-Problem';
+    text = sec.certStatus === 'expired'
+      ? `Das Zertifikat des Servers ist seit ${fmtDate(sec.notAfter)} abgelaufen. Deshalb verbindet sich die App nicht.\n\n`
+        + 'In den Einstellungen unter „Verbindung“ kann man abgelaufene Zertifikate vorübergehend erlauben.'
+      : 'Das Zertifikat des Servers ist ungültig oder gehört nicht zu diesem Server. Zur Sicherheit verbindet sich '
+        + 'die App nicht.' + (sec.reason ? `\n\nGrund: ${sec.reason}` : '');
+  } else if (sec.kind === 'fallback') {
+    title = 'Nicht verschlüsselt (Notlösung)';
+    text = 'Die verschlüsselte Verbindung hat nicht geklappt. Die App ist deshalb ersatzweise UNVERSCHLÜSSELT '
+      + 'verbunden (TLS-Fallback).'
+      + (sec.certStatus === 'expired' ? `\n\nGrund: Das Zertifikat ist seit ${fmtDate(sec.notAfter)} abgelaufen.`
+        : sec.certStatus === 'invalid' ? '\n\nGrund: Das Zertifikat des Servers ist ungültig.'
+        : '\n\nGrund: Die verschlüsselte Verbindung kam nicht zustande.');
+  } else if (sec.kind === 'plain') {
+    title = 'Nicht verschlüsselt';
+    text = 'Für diese Verbindung ist keine Verschlüsselung eingestellt. Das ist nur im eigenen Heimnetz in Ordnung.';
+  }
+
+  return (
+    <>
+      <TouchableOpacity style={styles.slot} onPress={() => setOpen(true)} accessibilityLabel={title}>
+        <View>
+          <Text style={[styles.lock, crossed && styles.lockDim]}>{'🔒'}</Text>
+          {crossed && <View style={styles.strike} />}
+          {warn && <Text style={styles.bang}>!</Text>}
+        </View>
+      </TouchableOpacity>
+
+      <Modal visible={open} transparent animationType="fade" onRequestClose={() => setOpen(false)}>
+        <TouchableOpacity style={styles.overlay} activeOpacity={1} onPress={() => setOpen(false)}>
+          <View style={styles.box}>
+            <Text style={styles.title}>{title}</Text>
+            <Text style={styles.text}>{text}</Text>
+
+            <View style={styles.legend}>
+              <Text style={styles.legendRow}>{'🔒'}  verschlüsselt, alles in Ordnung</Text>
+              <Text style={styles.legendRow}>{'🔒'}<Text style={styles.legendBang}>!</Text>  Problem mit dem Zertifikat</Text>
+              <Text style={styles.legendRow}>{'🔒'}<Text style={styles.legendStrike}>/</Text>  nicht verschlüsselt</Text>
+            </View>
+
+            <View style={styles.buttons}>
+              {(sec.kind === 'cert_error' || sec.kind === 'expired' || sec.kind === 'fallback') && (
+                <TouchableOpacity style={styles.btn} onPress={() => { setOpen(false); onOpenSettings(); }}>
+                  <Text style={styles.btnText}>Einstellungen</Text>
+                </TouchableOpacity>
+              )}
+              <TouchableOpacity style={[styles.btn, styles.btnPrimary]} onPress={() => setOpen(false)}>
+                <Text style={styles.btnText}>OK</Text>
+              </TouchableOpacity>
+            </View>
+          </View>
+        </TouchableOpacity>
+      </Modal>
+    </>
+  );
+};
+
+const styles = StyleSheet.create({
+  slot: { width: 52, alignItems: 'center', justifyContent: 'center' },
+  lock: { fontSize: 20 },
+  lockDim: { opacity: 0.7 },
+  strike: {
+    position: 'absolute', left: -3, right: -3, top: '50%', height: 2.5,
+    backgroundColor: '#FF3B30', transform: [{ rotate: '-45deg' }],
+  },
+  bang: {
+    position: 'absolute', right: -8, top: -6, minWidth: 15, height: 15, borderRadius: 8,
+    backgroundColor: '#FF9F0A', color: '#000', fontSize: 11, fontWeight: '900',
+    textAlign: 'center', lineHeight: 15, overflow: 'hidden',
+  },
+  overlay: { flex: 1, backgroundColor: 'rgba(0,0,0,0.6)', justifyContent: 'center', padding: 24 },
+  box: { backgroundColor: '#1A1A2E', borderRadius: 14, padding: 20 },
+  title: { color: '#FFFFFF', fontSize: 17, fontWeight: '700', marginBottom: 10 },
+  text: { color: '#C8C8D8', fontSize: 14, lineHeight: 20 },
+  legend: { marginTop: 16, paddingTop: 12, borderTopWidth: 1, borderTopColor: '#2A2A3E' },
+  legendRow: { color: '#9090A8', fontSize: 13, marginVertical: 2 },
+  legendBang: { color: '#FF9F0A', fontWeight: '900' },
+  legendStrike: { color: '#FF3B30', fontWeight: '900' },
+  buttons: { flexDirection: 'row', justifyContent: 'flex-end', marginTop: 16, gap: 10 },
+  btn: { paddingVertical: 9, paddingHorizontal: 16, borderRadius: 8, backgroundColor: '#2A2A3E' },
+  btnPrimary: { backgroundColor: '#0096FF' },
+  btnText: { color: '#FFFFFF', fontWeight: '600' },
+});
+
+export default SecurityLock;

android/src/components/ShareModal.tsx

@@ -0,0 +1,183 @@
+/**
+ * Teilen-Dialog — was aus anderen Apps per "Teilen → ARIA" hereinkommt.
+ *
+ * Ablauf wie gewuenscht: erst sehen WAS geteilt wurde, dann WOHIN (Projekt
+ * oder Hauptchat), dann optional ein Text dazu. Ohne Text geht genauso.
+ */
+import React, { useCallback, useEffect, useState } from 'react';
+import {
+  ActivityIndicator, FlatList, Image, Modal, StyleSheet, Text,
+  TextInput, TouchableOpacity, View,
+} from 'react-native';
+import brainApi, { Project } from '../services/brainApi';
+
+export interface SharedItem {
+  path: string;
+  name: string;
+  type: string;
+  size: number;
+}
+
+interface Props {
+  visible: boolean;
+  items: SharedItem[];
+  /** Text, den die sendende App mitgegeben hat (z.B. geteilter Link). */
+  initialText?: string;
+  onCancel: () => void;
+  /** projectId: '' = Hauptchat. text: optional, darf leer sein. */
+  onSend: (projectId: string, text: string) => void;
+}
+
+const fmtSize = (n: number) =>
+  n > 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)} MB`
+    : n > 1024 ? `${Math.round(n / 1024)} KB` : `${n} B`;
+
+const ShareModal: React.FC<Props> = ({ visible, items, initialText, onCancel, onSend }) => {
+  const [projects, setProjects] = useState<Project[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [pid, setPid] = useState<string | null>(null);     // null = noch nichts gewaehlt
+  const [text, setText] = useState('');
+  const [sending, setSending] = useState(false);
+
+  useEffect(() => {
+    if (!visible) return;
+    setPid(null);
+    setText(initialText || '');
+    setSending(false);
+    setLoading(true);
+    brainApi.listProjects(false)
+      .then(ps => setProjects(ps || []))
+      .catch(() => setProjects([]))
+      .finally(() => setLoading(false));
+  }, [visible, initialText]);
+
+  const send = useCallback(() => {
+    if (pid === null || sending) return;
+    setSending(true);
+    onSend(pid, text.trim());
+  }, [pid, text, sending, onSend]);
+
+  const preview = items.find(i => i.type?.startsWith('image/'));
+
+  return (
+    <Modal visible={visible} animationType="slide" transparent onRequestClose={onCancel}>
+      <View style={s.backdrop}>
+        <View style={s.box}>
+          <Text style={s.title}>Mit ARIA teilen</Text>
+
+          {/* Was wird geteilt */}
+          <View style={s.itemsBox}>
+            {preview ? (
+              <Image source={{ uri: 'file://' + preview.path }} style={s.thumb} resizeMode="cover" />
+            ) : null}
+            <View style={{ flex: 1 }}>
+              {items.length === 0 ? (
+                <Text style={s.dim}>Nur Text</Text>
+              ) : items.slice(0, 3).map((it, i) => (
+                <Text key={i} style={s.itemLine} numberOfLines={1}>
+                  {it.name} <Text style={s.dim}>({fmtSize(it.size)})</Text>
+                </Text>
+              ))}
+              {items.length > 3 ? (
+                <Text style={s.dim}>+ {items.length - 3} weitere</Text>
+              ) : null}
+            </View>
+          </View>
+
+          {/* Wohin */}
+          <Text style={s.label}>Wohin soll das?</Text>
+          {loading ? (
+            <ActivityIndicator color="#FFD60A" style={{ marginVertical: 12 }} />
+          ) : (
+            <FlatList
+              style={s.list}
+              data={[{ id: '', name: 'Hauptchat', description: '' } as Project, ...projects]}
+              keyExtractor={p => p.id || '__main__'}
+              keyboardShouldPersistTaps="handled"
+              renderItem={({ item }) => {
+                const sel = pid === item.id;
+                return (
+                  <TouchableOpacity
+                    style={[s.row, sel && s.rowSel]}
+                    onPress={() => setPid(item.id)}>
+                    <Text style={[s.rowText, sel && s.rowTextSel]} numberOfLines={1}>
+                      {item.id ? '📁 ' : '💬 '}{item.name}
+                    </Text>
+                    {sel ? <Text style={s.check}>✓</Text> : null}
+                  </TouchableOpacity>
+                );
+              }}
+            />
+          )}
+
+          {/* Optionaler Text */}
+          <Text style={s.label}>Text dazu <Text style={s.dim}>(optional)</Text></Text>
+          <TextInput
+            style={s.input}
+            value={text}
+            onChangeText={setText}
+            placeholder="z.B. „Schau dir das mal an“ — kann auch leer bleiben"
+            placeholderTextColor="#666680"
+            multiline
+          />
+
+          <View style={s.actions}>
+            <TouchableOpacity style={s.btnGhost} onPress={onCancel} disabled={sending}>
+              <Text style={s.btnGhostText}>Abbrechen</Text>
+            </TouchableOpacity>
+            <TouchableOpacity
+              style={[s.btn, (pid === null || sending) && s.btnDisabled]}
+              onPress={send}
+              disabled={pid === null || sending}>
+              <Text style={s.btnText}>
+                {sending ? 'Senden …' : pid === null ? 'Ziel wählen' : 'Senden'}
+              </Text>
+            </TouchableOpacity>
+          </View>
+        </View>
+      </View>
+    </Modal>
+  );
+};
+
+const s = StyleSheet.create({
+  backdrop: { flex: 1, backgroundColor: 'rgba(0,0,0,0.75)', justifyContent: 'flex-end' },
+  box: {
+    backgroundColor: '#0D0D1A', borderTopLeftRadius: 16, borderTopRightRadius: 16,
+    padding: 18, maxHeight: '88%',
+  },
+  title: { color: '#E0E0F0', fontSize: 19, fontWeight: '700', marginBottom: 12 },
+  itemsBox: {
+    flexDirection: 'row', gap: 10, alignItems: 'center',
+    backgroundColor: '#12121E', borderRadius: 10, padding: 10, marginBottom: 14,
+  },
+  thumb: { width: 56, height: 56, borderRadius: 8, backgroundColor: '#1E1E2E' },
+  itemLine: { color: '#E0E0F0', fontSize: 13 },
+  dim: { color: '#8888AA', fontSize: 12 },
+  label: { color: '#8888AA', fontSize: 12, marginBottom: 6 },
+  list: { maxHeight: 190, marginBottom: 14 },
+  row: {
+    flexDirection: 'row', alignItems: 'center', paddingVertical: 10,
+    paddingHorizontal: 12, borderRadius: 8, marginBottom: 4, backgroundColor: '#12121E',
+  },
+  rowSel: { backgroundColor: '#1E2A1E', borderWidth: 1, borderColor: '#3FFF9F' },
+  rowText: { color: '#E0E0F0', fontSize: 14, flex: 1 },
+  rowTextSel: { color: '#3FFF9F', fontWeight: '600' },
+  check: { color: '#3FFF9F', fontSize: 16 },
+  input: {
+    backgroundColor: '#12121E', borderRadius: 8, color: '#E0E0F0',
+    paddingHorizontal: 12, paddingVertical: 10, minHeight: 56,
+    textAlignVertical: 'top', marginBottom: 16, fontSize: 14,
+  },
+  actions: { flexDirection: 'row', gap: 10, justifyContent: 'flex-end' },
+  btnGhost: { paddingVertical: 11, paddingHorizontal: 18 },
+  btnGhostText: { color: '#8888AA', fontSize: 15 },
+  btn: {
+    backgroundColor: '#FFD60A', borderRadius: 8,
+    paddingVertical: 11, paddingHorizontal: 24,
+  },
+  btnDisabled: { backgroundColor: '#3A3A2A' },
+  btnText: { color: '#0D0D1A', fontSize: 15, fontWeight: '700' },
+});
+
+export default ShareModal;

android/src/components/UpdateProgress.tsx

@@ -0,0 +1,57 @@
+/**
+ * Fortschrittsanzeige beim App-Update: Balken mit Prozent und MB, Knopf
+ * zum Abbrechen. Erscheint nur, waehrend ein Update laedt/installiert.
+ */
+
+import React, { useEffect, useState } from 'react';
+import { Modal, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import updateService, { UpdateProgress as Progress } from '../services/updater';
+
+const UpdateProgress: React.FC = () => {
+  const [p, setP] = useState<Progress | null>(null);
+
+  useEffect(() => updateService.onProgress(setP), []);
+
+  if (!p || !p.active) return null;
+  const known = p.fraction >= 0;
+  const pct = known ? Math.round(p.fraction * 100) : 0;
+
+  return (
+    <Modal visible transparent animationType="fade" onRequestClose={() => {}}>
+      <View style={styles.overlay}>
+        <View style={styles.box}>
+          <Text style={styles.title}>Update auf Version {p.version}</Text>
+          <Text style={styles.status}>{p.status}</Text>
+          <View style={styles.track}>
+            <View style={[styles.bar, { width: known ? `${pct}%` : '100%' }, !known && styles.barUnknown]} />
+          </View>
+          <Text style={styles.numbers}>
+            {known ? `${pct} %  ·  ` : ''}
+            {p.receivedMB > 0 ? `${p.receivedMB.toFixed(1)} von ${p.totalMB.toFixed(1)} MB` : `${p.totalMB.toFixed(1)} MB`}
+          </Text>
+          {p.status !== 'Installiere …' && (
+            <TouchableOpacity style={styles.btn} onPress={() => updateService.cancelDownload()}>
+              <Text style={styles.btnText}>Abbrechen</Text>
+            </TouchableOpacity>
+          )}
+        </View>
+      </View>
+    </Modal>
+  );
+};
+
+const styles = StyleSheet.create({
+  overlay: { flex: 1, backgroundColor: 'rgba(0,0,0,0.6)', justifyContent: 'center', padding: 24 },
+  box: { backgroundColor: '#1A1A2E', borderRadius: 14, padding: 20 },
+  title: { color: '#FFFFFF', fontSize: 17, fontWeight: '700' },
+  status: { color: '#C8C8D8', fontSize: 14, marginTop: 6 },
+  track: { height: 10, borderRadius: 5, backgroundColor: '#2A2A3E', marginTop: 14, overflow: 'hidden' },
+  bar: { height: 10, borderRadius: 5, backgroundColor: '#0096FF' },
+  barUnknown: { opacity: 0.35 },
+  numbers: { color: '#9090A8', fontSize: 13, marginTop: 8 },
+  btn: { alignSelf: 'flex-end', marginTop: 14, paddingVertical: 8, paddingHorizontal: 16,
+         borderRadius: 8, backgroundColor: '#2A2A3E' },
+  btnText: { color: '#FFFFFF', fontWeight: '600' },
+});
+
+export default UpdateProgress;

android/src/components/ViewModeToggle.tsx

@@ -0,0 +1,47 @@
+/**
+ * ViewModeToggle — kleiner Header-Button zum Umschalten zwischen Kompakt-
+ * Ansicht (klassischer Chat) und Cockpit (Kachel-Desktop).
+ *
+ * Sitzt rechts im Navigations-Header ("ARIA Cockpit"), kollidiert also mit
+ * nichts in der Chat-Ansicht. Zeigt das Ziel des naechsten Taps.
+ */
+
+import React, { useEffect, useState } from 'react';
+import { StyleSheet, Text, TouchableOpacity } from 'react-native';
+import viewMode, { ViewModeValue } from '../services/viewMode';
+
+const ViewModeToggle: React.FC = () => {
+  const [mode, setMode] = useState<ViewModeValue>(viewMode.get());
+  useEffect(() => viewMode.subscribe(setMode), []);
+
+  const isCockpit = mode === 'cockpit';
+  return (
+    <TouchableOpacity
+      onPress={() => viewMode.toggle()}
+      style={[styles.pill, isCockpit && styles.pillActive]}
+      hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+      activeOpacity={0.75}
+    >
+      <Text style={[styles.text, isCockpit && styles.textActive]}>
+        {isCockpit ? '⧉ Cockpit' : '⧉ Kompakt'}
+      </Text>
+    </TouchableOpacity>
+  );
+};
+
+const styles = StyleSheet.create({
+  pill: {
+    marginRight: 12,
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderRadius: 16,
+    borderWidth: 1,
+    borderColor: '#1E1E2E',
+    backgroundColor: '#12122A',
+  },
+  pillActive: { borderColor: '#0096FF', backgroundColor: '#0A1F33' },
+  text: { color: '#9090B0', fontSize: 13, fontWeight: '700' },
+  textActive: { color: '#0096FF' },
+});
+
+export default ViewModeToggle;

android/src/components/VoiceButton.tsx

@@ -35,6 +35,8 @@ interface VoiceButtonProps {
   onTapStart: () => Promise<boolean>;
   /** User hat nochmal getippt — ChatScreen soll stopStreamingRecording rufen. */
   onTapStop: () => Promise<void>;
+  /** Muelleimer waehrend der Aufnahme — verwerfen, NICHTS an ARIA senden. */
+  onTapCancel?: () => Promise<void>;
   /** Button deaktivieren */
   disabled?: boolean;
   /** Wake-Word-Modus aktiv (zeigt gruenen Indikator-Dot) */
@@ -46,6 +48,7 @@ interface VoiceButtonProps {
 const VoiceButton: React.FC<VoiceButtonProps> = ({
   onTapStart,
   onTapStop,
+  onTapCancel,
   disabled = false,
   wakeWordActive = false,
 }) => {
@@ -136,6 +139,16 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     }
   }, [disabled, onTapStart, onTapStop]);
 
+  const handleCancel = useCallback(async () => {
+    if (!onTapCancel || tapBusy.current) return;
+    tapBusy.current = true;
+    try {
+      if (audioService.getRecordingState() === 'recording') await onTapCancel();
+    } finally {
+      tapBusy.current = false;
+    }
+  }, [onTapCancel]);
+
   const formatDuration = (ms: number): string => {
     const seconds = Math.floor(ms / 1000);
     const tenths = Math.floor((ms % 1000) / 100);
@@ -154,6 +167,16 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
       {wakeWordActive && !isRecording && (
         <View style={styles.wakeWordDot} />
       )}
+      {isRecording && onTapCancel && (
+        <TouchableOpacity
+          onPress={handleCancel}
+          accessibilityLabel="Aufnahme verwerfen"
+          hitSlop={{ top: 8, bottom: 8, left: 8, right: 8 }}
+          style={styles.cancelButton}
+        >
+          <Text style={styles.cancelIcon}>🗑</Text>
+        </TouchableOpacity>
+      )}
       <Animated.View
         style={[
           styles.buttonOuter,
@@ -197,6 +220,22 @@ const styles = StyleSheet.create({
     backgroundColor: '#34C759',
     zIndex: 10,
   },
+  // Muelleimer links neben dem Aufnahmeknopf — nur waehrend der Aufnahme
+  cancelButton: {
+    position: 'absolute',
+    left: -46,
+    top: 14,
+    width: 36,
+    height: 36,
+    borderRadius: 18,
+    backgroundColor: 'rgba(60, 60, 70, 0.9)',
+    alignItems: 'center',
+    justifyContent: 'center',
+    zIndex: 10,
+  },
+  cancelIcon: {
+    fontSize: 18,
+  },
   buttonOuter: {
     width: 64,
     height: 64,

android/src/screens/SettingsScreen.tsx

@@ -63,14 +63,16 @@ import {
   VAD_SILENCE_MIN_SEC,
   VAD_SILENCE_MAX_SEC,
   VAD_SILENCE_STORAGE_KEY,
-  CONV_WINDOW_DEFAULT_SEC,
-  CONV_WINDOW_MIN_SEC,
-  CONV_WINDOW_MAX_SEC,
-  CONV_WINDOW_STORAGE_KEY,
+  STT_ENDPOINT_DEFAULT_MS,
+  STT_ENDPOINT_MIN_MS,
+  STT_ENDPOINT_MAX_MS,
+  STT_ENDPOINT_STORAGE_KEY,
   MAX_RECORDING_DEFAULT_SEC,
   MAX_RECORDING_MIN_SEC,
   MAX_RECORDING_MAX_SEC,
   MAX_RECORDING_STORAGE_KEY,
+  loadBargeInEnabled,
+  saveBargeInEnabled,
   VAD_SILENCE_DB_DEFAULT,
   VAD_SILENCE_DB_MIN,
   VAD_SILENCE_DB_MAX,
@@ -110,9 +112,10 @@ import wakeWordService, {
   WAKE_THRESHOLD_MAX,
   loadWakeThreshold,
   saveWakeThreshold,
-  PASSIVE_LISTEN_DEFAULT_MS,
-  loadPassiveListenMs,
-  savePassiveListenMs,
+  loadBgWakeEnabled,
+  saveBgWakeEnabled,
+  loadWakeConfirmEnabled,
+  saveWakeConfirmEnabled,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
@@ -175,6 +178,14 @@ const SettingsScreen: React.FC = () => {
   const winDims = useWindowDimensions();
   const [connectionState, setConnectionState] = useState<ConnectionState>('disconnected');
   const [manualToken, setManualToken] = useState('');
+  // Abgelaufenes Server-Zertifikat trotzdem akzeptieren (Kette + Hostname werden weiter geprueft)
+  const [allowExpiredCert, setAllowExpiredCert] = useState(false);
+  useEffect(() => { rvs.getAllowExpiredCert().then(setAllowExpiredCert); }, []);
+  const handleAllowExpiredCert = useCallback(async (value: boolean) => {
+    setAllowExpiredCert(value);
+    await rvs.setAllowExpiredCert(value);
+    rvs.connect(true);   // gleich mit der neuen Regel neu verbinden
+  }, []);
   const [manualHost, setManualHost] = useState('');
   const [manualPort, setManualPort] = useState('8765');
   const [currentMode, setCurrentMode] = useState('normal');
@@ -195,8 +206,12 @@ const SettingsScreen: React.FC = () => {
   const [ttsEnabled, setTtsEnabled] = useState(true);
   const [ttsPrerollSec, setTtsPrerollSec] = useState<number>(TTS_PREROLL_DEFAULT_SEC);
   const [vadSilenceSec, setVadSilenceSec] = useState<number>(VAD_SILENCE_DEFAULT_SEC);
-  const [convWindowSec, setConvWindowSec] = useState<number>(CONV_WINDOW_DEFAULT_SEC);
+  // Aktive Streaming-Pausen-Toleranz (STT_ENDPOINT) — der "Stille-Toleranz"-Regler
+  // steuert jetzt DIESEN Wert (der alte vadSilenceSec war der tote Legacy-dB-Pfad).
+  const [sttEndpointSec, setSttEndpointSec] = useState<number>(STT_ENDPOINT_DEFAULT_MS / 1000);
   const [maxRecordingSec, setMaxRecordingSec] = useState<number>(MAX_RECORDING_DEFAULT_SEC);
+  // Barge-in: ARIA waehrend ihrer Antwort unterbrechen duerfen. Default aus (Halb-Duplex).
+  const [bargeIn, setBargeIn] = useState<boolean>(false);
   // null = automatisch (adaptive Baseline), sonst manueller dB-Override
   const [vadSilenceDb, setVadSilenceDb] = useState<number | null>(null);
   const [showVadInfo, setShowVadInfo] = useState(false);
@@ -209,7 +224,10 @@ const SettingsScreen: React.FC = () => {
   const [wakeStatus, setWakeStatus] = useState<string>('');
   const [wakeReadySound, setWakeReadySound] = useState<boolean>(true);
   const [wakeThreshold, setWakeThreshold] = useState<number>(WAKE_THRESHOLD_DEFAULT);
-  const [passiveSec, setPassiveSec] = useState<number>(Math.round(PASSIVE_LISTEN_DEFAULT_MS / 1000));
+  // Hintergrund-Wake: auch bei gesperrtem Bildschirm auf das Wake-Wort hoeren. Default aus.
+  const [bgWake, setBgWake] = useState<boolean>(false);
+  // Wake-Wort per Voxtral bestaetigen (gegen Musik-Fehltrigger). Default aus.
+  const [wakeConfirm, setWakeConfirm] = useState<boolean>(false);
   const [editingPath, setEditingPath] = useState(false);
   const [xttsVoice, setXttsVoice] = useState('');
   const [loadingVoice, setLoadingVoice] = useState<string | null>(null);
@@ -298,11 +316,11 @@ const SettingsScreen: React.FC = () => {
         }
       }
     });
-    AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY).then(saved => {
+    AsyncStorage.getItem(STT_ENDPOINT_STORAGE_KEY).then(saved => {
       if (saved != null) {
-        const n = parseFloat(saved);
-        if (isFinite(n) && n >= CONV_WINDOW_MIN_SEC && n <= CONV_WINDOW_MAX_SEC) {
-          setConvWindowSec(n);
+        const n = parseInt(saved, 10);
+        if (isFinite(n) && n >= STT_ENDPOINT_MIN_MS && n <= STT_ENDPOINT_MAX_MS) {
+          setSttEndpointSec(n / 1000);
         }
       }
     });
@@ -314,6 +332,7 @@ const SettingsScreen: React.FC = () => {
         }
       }
     });
+    loadBargeInEnabled().then(setBargeIn).catch(() => {});
     AsyncStorage.getItem(VAD_SILENCE_DB_OVERRIDE_KEY).then(saved => {
       if (saved != null && saved !== '') {
         const n = parseFloat(saved);
@@ -333,7 +352,8 @@ const SettingsScreen: React.FC = () => {
     });
     isWakeReadySoundEnabled().then(setWakeReadySound);
     loadWakeThreshold().then(setWakeThreshold).catch(() => {});
-    loadPassiveListenMs().then(ms => setPassiveSec(Math.round(ms / 1000))).catch(() => {});
+    loadBgWakeEnabled().then(setBgWake).catch(() => {});
+    loadWakeConfirmEnabled().then(setWakeConfirm).catch(() => {});
     updateService.getApkCacheSize().then(setApkCacheInfo).catch(() => {});
     audioService.getTtsCacheSize().then(setTtsCacheInfo).catch(() => {});
     AsyncStorage.getItem('aria_xtts_voice').then(saved => {
@@ -1438,6 +1458,24 @@ const SettingsScreen: React.FC = () => {
         <TouchableOpacity style={styles.connectButton} onPress={connectManually}>
           <Text style={styles.connectButtonText}>Verbinden</Text>
         </TouchableOpacity>
+
+        <View style={[styles.toggleRow, {marginTop: 16, borderTopWidth: 1, borderTopColor: '#1E1E2E', paddingTop: 12}]}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Abgelaufenes Zertifikat akzeptieren</Text>
+            <Text style={styles.toggleHint}>
+              Notlösung, wenn das Zertifikat des Servers abgelaufen ist. Die Verbindung bleibt
+              verschlüsselt, und es wird weiter geprüft, dass es wirklich das Zertifikat dieses
+              Servers ist — nur das Ablaufdatum wird ignoriert. Wieder ausschalten, sobald das
+              Zertifikat erneuert ist.
+            </Text>
+          </View>
+          <Switch
+            value={allowExpiredCert}
+            onValueChange={handleAllowExpiredCert}
+            trackColor={{ false: '#2A2A3E', true: '#FF9F0A' }}
+            thumbColor={allowExpiredCert ? '#FFFFFF' : '#666680'}
+          />
+        </View>
       </View>
 
       {/* === Verbindungslog === */}
@@ -1651,72 +1689,56 @@ const SettingsScreen: React.FC = () => {
       {currentSection === 'voice_input' && (<>
       <Text style={styles.sectionTitle}>Spracheingabe</Text>
       <View style={styles.card}>
-        <Text style={styles.toggleLabel}>Stille-Toleranz</Text>
+        <View style={styles.toggleRow}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Barge-in (unterbrechen)</Text>
+            <Text style={styles.toggleHint}>
+              AUS (empfohlen): ARIA spricht ihre Antwort ZU ENDE, dann geht das
+              Mikro auf — sauber, kein Selbst-Echo, du hoerst sie ganz. AN: du
+              kannst sie waehrend des Sprechens per Wake-Wort unterbrechen.
+            </Text>
+          </View>
+          <Switch
+            value={bargeIn}
+            onValueChange={(v) => { setBargeIn(v); saveBargeInEnabled(v).catch(() => {}); }}
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={bargeIn ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+
+        <Text style={[styles.toggleLabel, {marginTop: 20}]}>Stille-Toleranz</Text>
         <Text style={styles.toggleHint}>
           Wie lange du eine Sprechpause machen darfst, bevor die Aufnahme
           automatisch beendet und gesendet wird. Hoeher = mehr Zeit zum
-          Nachdenken; niedriger = schnelleres Senden.
-          Default: {VAD_SILENCE_DEFAULT_SEC.toFixed(1)}s.
+          Nachdenken (z.B. im Auto); niedriger = schnelleres Senden.
+          Default: {(STT_ENDPOINT_DEFAULT_MS / 1000).toFixed(1)}s.
         </Text>
         <View style={styles.prerollRow}>
           <TouchableOpacity
             style={styles.prerollButton}
             onPress={() => {
-              const next = Math.max(VAD_SILENCE_MIN_SEC, Math.round((vadSilenceSec - 0.5) * 10) / 10);
-              setVadSilenceSec(next);
-              AsyncStorage.setItem(VAD_SILENCE_STORAGE_KEY, String(next));
+              const next = Math.max(STT_ENDPOINT_MIN_MS / 1000, Math.round((sttEndpointSec - 0.5) * 10) / 10);
+              setSttEndpointSec(next);
+              AsyncStorage.setItem(STT_ENDPOINT_STORAGE_KEY, String(Math.round(next * 1000)));
             }}
-            disabled={vadSilenceSec <= VAD_SILENCE_MIN_SEC}
+            disabled={sttEndpointSec <= STT_ENDPOINT_MIN_MS / 1000}
           >
             <Text style={styles.prerollButtonText}>−0.5</Text>
           </TouchableOpacity>
-          <Text style={styles.prerollValue}>{vadSilenceSec.toFixed(1)} s</Text>
+          <Text style={styles.prerollValue}>{sttEndpointSec.toFixed(1)} s</Text>
           <TouchableOpacity
             style={styles.prerollButton}
             onPress={() => {
-              const next = Math.min(VAD_SILENCE_MAX_SEC, Math.round((vadSilenceSec + 0.5) * 10) / 10);
-              setVadSilenceSec(next);
-              AsyncStorage.setItem(VAD_SILENCE_STORAGE_KEY, String(next));
+              const next = Math.min(STT_ENDPOINT_MAX_MS / 1000, Math.round((sttEndpointSec + 0.5) * 10) / 10);
+              setSttEndpointSec(next);
+              AsyncStorage.setItem(STT_ENDPOINT_STORAGE_KEY, String(Math.round(next * 1000)));
             }}
-            disabled={vadSilenceSec >= VAD_SILENCE_MAX_SEC}
+            disabled={sttEndpointSec >= STT_ENDPOINT_MAX_MS / 1000}
           >
             <Text style={styles.prerollButtonText}>+0.5</Text>
           </TouchableOpacity>
         </View>
 
-        <Text style={[styles.toggleLabel, {marginTop: 24}]}>Konversations-Fenster</Text>
-        <Text style={styles.toggleHint}>
-          Im Gespraechsmodus (Ohr-Button): nach ARIA's Antwort hast du so lange
-          Zeit, weiter zu sprechen, bevor die Konversation automatisch beendet wird.
-          Sprichst du nichts → Mikrofon zu.
-          Default: {CONV_WINDOW_DEFAULT_SEC.toFixed(1)}s.
-        </Text>
-        <View style={styles.prerollRow}>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.max(CONV_WINDOW_MIN_SEC, Math.round((convWindowSec - 1) * 10) / 10);
-              setConvWindowSec(next);
-              AsyncStorage.setItem(CONV_WINDOW_STORAGE_KEY, String(next));
-            }}
-            disabled={convWindowSec <= CONV_WINDOW_MIN_SEC}
-          >
-            <Text style={styles.prerollButtonText}>−1</Text>
-          </TouchableOpacity>
-          <Text style={styles.prerollValue}>{convWindowSec.toFixed(0)} s</Text>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.min(CONV_WINDOW_MAX_SEC, Math.round((convWindowSec + 1) * 10) / 10);
-              setConvWindowSec(next);
-              AsyncStorage.setItem(CONV_WINDOW_STORAGE_KEY, String(next));
-            }}
-            disabled={convWindowSec >= CONV_WINDOW_MAX_SEC}
-          >
-            <Text style={styles.prerollButtonText}>+1</Text>
-          </TouchableOpacity>
-        </View>
-
         <Text style={[styles.toggleLabel, {marginTop: 24}]}>Maximale Aufnahmedauer</Text>
         <Text style={styles.toggleHint}>
           Notbremse: nach so vielen Minuten wird die Aufnahme automatisch beendet,
@@ -1749,56 +1771,10 @@ const SettingsScreen: React.FC = () => {
           </TouchableOpacity>
         </View>
 
-        <View style={{flexDirection: 'row', alignItems: 'center', marginTop: 24, gap: 8}}>
-          <Text style={styles.toggleLabel}>Stille-Pegel (dB)</Text>
-          <TouchableOpacity onPress={() => setShowVadInfo(true)} style={styles.infoBtn}>
-            <Text style={styles.infoBtnText}>i</Text>
-          </TouchableOpacity>
-        </View>
-        <Text style={styles.toggleHint}>
-          Welcher Mikro-Pegel als "Stille" gilt. Standard: automatisch (Baseline aus
-          den ersten 500ms). Manuell setzen wenn Auto nicht zuverlaessig greift.
-        </Text>
-        <View style={styles.prerollRow}>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = vadSilenceDb == null
-                ? VAD_SILENCE_DB_DEFAULT - 1
-                : Math.max(VAD_SILENCE_DB_MIN, vadSilenceDb - 1);
-              setVadSilenceDb(next);
-              AsyncStorage.setItem(VAD_SILENCE_DB_OVERRIDE_KEY, String(next));
-            }}
-          >
-            <Text style={styles.prerollButtonText}>−1</Text>
-          </TouchableOpacity>
-          <Text style={styles.prerollValue}>
-            {vadSilenceDb == null ? 'auto' : `${vadSilenceDb} dB`}
-          </Text>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = vadSilenceDb == null
-                ? VAD_SILENCE_DB_DEFAULT + 1
-                : Math.min(VAD_SILENCE_DB_MAX, vadSilenceDb + 1);
-              setVadSilenceDb(next);
-              AsyncStorage.setItem(VAD_SILENCE_DB_OVERRIDE_KEY, String(next));
-            }}
-          >
-            <Text style={styles.prerollButtonText}>+1</Text>
-          </TouchableOpacity>
-        </View>
-        {vadSilenceDb != null && (
-          <TouchableOpacity
-            onPress={() => {
-              setVadSilenceDb(null);
-              AsyncStorage.removeItem(VAD_SILENCE_DB_OVERRIDE_KEY);
-            }}
-            style={{alignSelf: 'center', marginTop: 8, paddingVertical: 6, paddingHorizontal: 12}}
-          >
-            <Text style={{color: '#0096FF', fontSize: 13}}>↻ Auf automatisch zuruecksetzen</Text>
-          </TouchableOpacity>
-        )}
+        {/* "Stille-Pegel (dB)"-Regler entfernt: der aktive Streaming-STT nutzt
+            einen adaptiven Rausch-Boden (automatisch), ein manueller dB-Wert war
+            wirkungslos. Rauschen-als-Wort verhindert das STT-Modell selbst
+            (no_speech_prob-Filter), nicht die dB-Schwelle. */}
       </View>
 
       <Modal
@@ -1954,38 +1930,58 @@ const SettingsScreen: React.FC = () => {
           />
         </View>
 
-        <Text style={[styles.toggleLabel, {marginTop: 20}]}>Weiterreden-Fenster (Gespraech)</Text>
-        <Text style={styles.toggleHint}>
-          Nach einer gesprochenen ARIA-Antwort kannst du so lange einfach
-          weiterreden — ohne Wake-Word — bevor zurueck aufs Wake-Word geschaltet
-          wird. Reine Steuerbefehle (z.B. „nächster Titel") beenden sofort.
-          Default: {Math.round(PASSIVE_LISTEN_DEFAULT_MS / 1000)}s.
-        </Text>
-        <View style={styles.prerollRow}>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.max(10, passiveSec - 5);
-              setPassiveSec(next);
-              savePassiveListenMs(next * 1000);
+        <View style={[styles.toggleRow, {marginTop: 20, borderTopWidth: 1, borderTopColor: '#1E1E2E', paddingTop: 16}]}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Auch bei gesperrtem Bildschirm zuhören</Text>
+            <Text style={styles.toggleHint}>
+              AUS (empfohlen): das Wake-Wort greift nur, wenn die App offen ist —
+              im Hintergrund sind die meisten „Trigger" Fehlalarme (TV, Husten).
+              AN: ARIA hört auch bei gesperrtem Bildschirm / im Hintergrund auf
+              „{KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS] || wakeKeyword}" — mehr Fehlauslöser möglich.
+            </Text>
+          </View>
+          <Switch
+            value={bgWake}
+            onValueChange={(val) => {
+              setBgWake(val);
+              saveBgWakeEnabled(val).catch(() => {});
+              wakeWordService.setBgWakeEnabled(val);
             }}
-            disabled={passiveSec <= 10}
-          >
-            <Text style={styles.prerollButtonText}>−5</Text>
-          </TouchableOpacity>
-          <Text style={styles.prerollValue}>{passiveSec} s</Text>
-          <TouchableOpacity
-            style={styles.prerollButton}
-            onPress={() => {
-              const next = Math.min(60, passiveSec + 5);
-              setPassiveSec(next);
-              savePassiveListenMs(next * 1000);
-            }}
-            disabled={passiveSec >= 60}
-          >
-            <Text style={styles.prerollButtonText}>+5</Text>
-          </TouchableOpacity>
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={bgWake ? '#FFFFFF' : '#666680'}
+          />
         </View>
+
+        <View style={[styles.toggleRow, {marginTop: 20, borderTopWidth: 1, borderTopColor: '#1E1E2E', paddingTop: 16}]}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Wake-Wort per Voxtral bestätigen</Text>
+            <Text style={styles.toggleHint}>
+              Gegen Musik-Fehltrigger: nach „{KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS] || wakeKeyword}"
+              prüft Voxtral kurz nach, ob's wirklich das Wake-Wort war (oder nur
+              Musik/TV) — erst dann Gong + Mikro. Kostet ~0,5–1 s Extra vor dem
+              Gong. Empfohlen zusammen mit Hintergrund-Zuhören.
+            </Text>
+          </View>
+          <Switch
+            value={wakeConfirm}
+            onValueChange={(val) => {
+              setWakeConfirm(val);
+              saveWakeConfirmEnabled(val).catch(() => {});
+              wakeWordService.setWakeConfirmEnabled(val);
+            }}
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={wakeConfirm ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+
+        <Text style={[styles.toggleLabel, {marginTop: 20}]}>Weiterreden nach der Antwort</Text>
+        <Text style={styles.toggleHint}>
+          Nach einer gesprochenen ARIA-Antwort geht das Mikro auf — du kannst ohne
+          Wake-Word weiterreden. Fängst du nicht innerhalb der „Stille-Toleranz"
+          (Sektion Spracheingabe) an, geht's zurück aufs Wake-Word. Reine
+          Steuerbefehle beenden sofort. Ein separates Zeitfenster gibt es nicht
+          mehr — es zählt überall derselbe Stille-Wert.
+        </Text>
       </View>
       </>)}
 
@@ -2543,8 +2539,7 @@ const SettingsScreen: React.FC = () => {
           style={[styles.connectButton, {marginTop: 12}]}
           onPress={() => {
             const updateService = require('../services/updater').default;
-            updateService.checkForUpdate();
-            Alert.alert('Update-Check', 'Pruefe auf neue Version...');
+            updateService.checkForUpdateManual();
           }}
         >
           <Text style={styles.connectButtonText}>Auf Updates pr{'\u00FC'}fen</Text>

android/src/services/ariaView.ts

@@ -0,0 +1,104 @@
+/**
+ * ariaView — Empfaenger der von ARIA komponierten RAEUMLICHEN Ansichten (M1).
+ *
+ * Fluss: ARIA ruft im Brain `present_view` → Brain-Event `aria_view` → Bridge →
+ * RVS `aria_view` → hier gepuffert → WorkspaceCanvas rendert Orb + Karten, die
+ * auf der Flaeche materialisieren.
+ *
+ * Der Service haelt pro Projekt die AKTUELLE View-Spec, damit eine spaet
+ * gemountete Canvas-Kachel sofort den Ist-Stand bekommt. Muster wie
+ * services/codeFile.ts (Singleton, rvs.onMessage).
+ *
+ * Die Karten-Typen sind bewusst offen (string), damit spaetere Renderer (vnc,
+ * chart, file …) ohne Service-Aenderung dazukommen. Der jeweilige Client-Renderer
+ * entscheidet, was er mit einem unbekannten Typ macht (i.d.R. ignorieren).
+ */
+
+import rvs, { RVSMessage } from './rvs';
+
+export type OrbState = 'idle' | 'listening' | 'thinking' | 'speaking' | 'working';
+
+export interface ViewMarker {
+  lat: number;
+  lon: number;
+  label?: string;
+}
+
+export interface ViewCard {
+  type: 'text' | 'image' | 'map' | 'code' | 'list' | string;
+  title?: string;
+  md?: string;        // text/list
+  src?: string;       // image
+  markers?: ViewMarker[]; // map
+  path?: string;      // code
+  lang?: string;      // code
+  // Zukuenftige Kartenfelder ohne Service-Aenderung:
+  [k: string]: any;
+}
+
+export interface ViewSpec {
+  cards: ViewCard[];
+  orb?: OrbState;
+  title?: string;
+}
+
+export interface AriaView {
+  projectId: string;
+  view: ViewSpec;
+  clientMsgId?: string;
+  ts: number;
+}
+
+type ViewSub = (v: AriaView) => void;
+
+class AriaViewService {
+  private views = new Map<string, AriaView>();
+  private subs: ViewSub[] = [];
+
+  constructor() {
+    rvs.onMessage((m) => this.onMessage(m));
+  }
+
+  private onMessage(m: RVSMessage): void {
+    if (m.type !== 'aria_view') return;
+    const p = (m.payload || {}) as any;
+    const raw = (p.view || {}) as any;
+    const cards: ViewCard[] = Array.isArray(raw.cards) ? raw.cards : [];
+    if (cards.length === 0) return; // leere Ansicht ignorieren
+    const view: ViewSpec = {
+      cards,
+      orb: raw.orb || 'speaking',
+      title: raw.title || '',
+    };
+    const projectId: string = p.projectId || '';
+    const entry: AriaView = {
+      projectId,
+      view,
+      clientMsgId: p.clientMsgId || '',
+      ts: Date.now(),
+    };
+    this.views.set(projectId, entry);
+    this.subs.forEach((cb) => {
+      try { cb(entry); } catch {}
+    });
+  }
+
+  /** Aktuelle Ansicht eines Projekts (leer = Hauptchat). */
+  getView(projectId: string): AriaView | undefined {
+    return this.views.get(projectId || '');
+  }
+
+  /** Registriert einen Listener fuer neue Ansichten. */
+  subscribe(cb: ViewSub): () => void {
+    this.subs.push(cb);
+    return () => { this.subs = this.subs.filter((s) => s !== cb); };
+  }
+
+  /** Ansicht eines Projekts verwerfen (z.B. wenn der User sie wegwischt). */
+  clear(projectId: string): void {
+    this.views.delete(projectId || '');
+  }
+}
+
+const ariaView = new AriaViewService();
+export default ariaView;

android/src/services/audio.ts

@@ -143,23 +143,100 @@ export const VAD_SILENCE_MIN_SEC = 1.0;
 export const VAD_SILENCE_MAX_SEC = 8.0;
 export const VAD_SILENCE_STORAGE_KEY = 'aria_vad_silence_sec';
 
-// Konversations-Fenster (in Sekunden) — nach ARIA's Antwort hat der User so
-// lange Zeit, im Gespraechsmodus weiter zu sprechen, ohne dass die Konversation
-// beendet wird. Sprichst du im Fenster nichts → Konversation aus.
-export const CONV_WINDOW_DEFAULT_SEC = 8.0;
-export const CONV_WINDOW_MIN_SEC = 3.0;
-export const CONV_WINDOW_MAX_SEC = 20.0;
-export const CONV_WINDOW_STORAGE_KEY = 'aria_conv_window_sec';
-
 // STT-Endpoint (ms Stille bis "fertig gesprochen"). Zu kurz = schneidet mitten
-// im Satz ab, besonders im Auto wo man mit Pausen spricht (Reproduktion: die
-// 11.8s-Frage wurde bei "…ohne dass ein" gekappt). 1500 war zu aggressiv;
-// 2400 default, im Auto ggf. hoeher. Konfigurierbar in den Settings.
+// im Satz ab, besonders im Auto oder wenn man zum Nachdenken pausiert. 1500 war
+// zu aggressiv; 2400 default, bis 8s hoch stellbar (Denkpausen). In den Settings
+// unter "Stille-Toleranz" konfigurierbar.
 export const STT_ENDPOINT_DEFAULT_MS = 2400;
 export const STT_ENDPOINT_MIN_MS = 1000;
-export const STT_ENDPOINT_MAX_MS = 4000;
+export const STT_ENDPOINT_MAX_MS = 8000;   // bis 8s: genug Zeit zum Ueberlegen
 export const STT_ENDPOINT_STORAGE_KEY = 'aria_stt_endpoint_ms';
 
+// Barge-in-Modus: darf man ARIA waehrend ihrer TTS-Antwort unterbrechen (reden)?
+// Default AUS = sauberes Halb-Duplex (ARIA spricht aus, DANN oeffnet das Mikro —
+// kein Selbst-Echo, kein Mischmasch). AN = waehrend TTS auf Wake-Wort lauschen.
+export const BARGE_IN_STORAGE_KEY = 'aria_barge_in_enabled';
+
+export async function loadBargeInEnabled(): Promise<boolean> {
+  try {
+    return (await AsyncStorage.getItem(BARGE_IN_STORAGE_KEY)) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+export async function saveBargeInEnabled(enabled: boolean): Promise<void> {
+  try {
+    await AsyncStorage.setItem(BARGE_IN_STORAGE_KEY, String(enabled));
+  } catch {}
+}
+
+/** One-Shot-Transkription eines PCM-Schnipsels (base64, s16le 16kHz mono) via
+ *  Voxtral — fuer die Wake-Wort-Bestaetigung. Schickt stt_transcribe_blob und
+ *  wartet auf stt_transcribe_result (matching requestId) mit Timeout.
+ *  Rueckgabe: Text (evtl. '') bei Antwort, oder null bei Timeout/Fehler →
+ *  Aufrufer macht dann fail-open (Wake normal durchlassen). */
+export async function transcribeBlob(pcmBase64: string, timeoutMs = 2500): Promise<string | null> {
+  if (!pcmBase64) return null;
+  const requestId = `wakeverify_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+  return new Promise<string | null>((resolve) => {
+    let done = false;
+    let unsub: (() => void) | null = null;
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    function finish(val: string | null) {
+      if (done) return;
+      done = true;
+      try { unsub && unsub(); } catch {}
+      clearTimeout(timer);
+      resolve(val);
+    }
+    try {
+      unsub = rvs.onMessage((msg: any) => {
+        if (msg?.type !== 'stt_transcribe_result') return;
+        const p = (msg as any).payload || {};
+        if (String(p.requestId || '') !== requestId) return;
+        finish(typeof p.text === 'string' ? p.text : '');
+      });
+      rvs.send('stt_transcribe_blob' as any, { requestId, pcm: pcmBase64, language: 'de' });
+    } catch {
+      finish(null);
+    }
+  });
+}
+
+/** Fragt die Bridge vor dem Aufnahme-Stream, welche STT-Instanz adressiert
+ *  werden soll (Redundanz ueber mehrere STT-Nodes/Apps). Schickt
+ *  stt_lease_request, wartet kurz auf stt_lease (matching requestId).
+ *  Rueckgabe: instanceId (z.B. "voxtral@box-a") oder '' bei Timeout/keine
+ *  Instanz — dann streamt die App wie bisher an ALLE (Broadcast, Single-Node
+ *  unveraendert). Bewusst kurzer Timeout, damit die Aufnahme nie haengt. */
+export async function requestSttLease(timeoutMs = 250): Promise<string> {
+  const requestId = `sttlease_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+  return new Promise<string>((resolve) => {
+    let done = false;
+    let unsub: (() => void) | null = null;
+    const timer = setTimeout(() => finish(''), timeoutMs);
+    function finish(val: string) {
+      if (done) return;
+      done = true;
+      try { unsub && unsub(); } catch {}
+      clearTimeout(timer);
+      resolve(val);
+    }
+    try {
+      unsub = rvs.onMessage((msg: any) => {
+        if (msg?.type !== 'stt_lease') return;
+        const p = (msg as any).payload || {};
+        if (String(p.requestId || '') !== requestId) return;
+        finish(typeof p.instanceId === 'string' ? p.instanceId : '');
+      });
+      rvs.send('stt_lease_request' as any, { requestId });
+    } catch {
+      finish('');
+    }
+  });
+}
+
 export async function loadSttEndpointMs(): Promise<number> {
   try {
     const raw = await AsyncStorage.getItem(STT_ENDPOINT_STORAGE_KEY);
@@ -189,18 +266,6 @@ export async function loadTtsSpeed(): Promise<number> {
   return TTS_SPEED_DEFAULT;
 }
 
-export async function loadConvWindowMs(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(CONV_WINDOW_STORAGE_KEY);
-    if (raw != null) {
-      const n = parseFloat(raw);
-      if (isFinite(n) && n >= CONV_WINDOW_MIN_SEC && n <= CONV_WINDOW_MAX_SEC) {
-        return Math.round(n * 1000);
-      }
-    }
-  } catch {}
-  return Math.round(CONV_WINDOW_DEFAULT_SEC * 1000);
-}
 
 async function loadVadSilenceMs(): Promise<number> {
   try {
@@ -284,6 +349,13 @@ class AudioService {
   private pcmSampleRate: number = 24000;
   private pcmChannels: number = 1;
   private pcmBuffer: string[] = []; // base64-chunks zum spaeteren WAV-Build
+  // ── TTS-Abspiel-Queue: zwei back-to-back-Antworten sollen sich NICHT
+  // gegenseitig abschneiden. Eine neue hoerbare Antwort, die reinkommt waehrend
+  // eine andere noch HOERBAR spielt, wird gepuffert und nach PcmPlaybackFinished
+  // nachgespielt (statt via start()→stopInternal() die laufende zu cutten). ──
+  private pcmAudiblePlaying: boolean = false;  // eine hoerbare Antwort spielt (bis PcmPlaybackFinished)
+  private pcmPlayingMsgId: string = '';         // deren messageId
+  private pcmPendingStreams: Array<{ messageId: string; sampleRate: number; channels: number; chunks: string[]; final: boolean }> = [];
   private pcmBytesCollected: number = 0;
   private readonly PCM_MAX_CACHE_BYTES = 30 * 1024 * 1024; // 30MB
 
@@ -344,6 +416,9 @@ class AudioService {
   // lich Chunks einer alten Session in eine neue mischen.
   private streamRequestId: string = '';
   private streamAudioRequestId: string = '';
+  // Adressierte STT-Instanz fuer diesen Stream (Redundanz-Routing). '' =
+  // Broadcast an alle STT-Nodes (Single-Node / kein Lease = wie bisher).
+  private streamTargetInstance: string = '';
   // Latch: ist endpointListeners fuer den aktuellen Session-Cycle schon gefeuert
   // worden? Wird auf false gesetzt beim startStreamingRecording, auf true beim
   // ersten Endpoint (egal ob via RVS oder Fallback). Verhindert Doppel-Fires.
@@ -374,6 +449,16 @@ class AudioService {
         const emitter = new NativeEventEmitter(NativeModules.PcmStreamPlayer as any);
         emitter.addListener('PcmPlaybackFinished', () => {
           console.log('[Audio] PcmPlaybackFinished — AudioTrack drained');
+          this.pcmAudiblePlaying = false;
+          this.pcmPlayingMsgId = '';
+          // TTS-Abspiel-Queue: steht eine naechste Antwort bereit? Dann NICHT
+          // "fertig" melden (kein Wake-Word-Re-Arm / Conversation-Ende) — ARIA
+          // spricht gleich weiter. Die naechste gepufferte Antwort direkt spielen.
+          if (this.pcmPendingStreams.length > 0) {
+            this._promoteNextPendingStream().catch(err =>
+              console.warn('[Audio] promote next pending stream err:', err));
+            return;
+          }
           this._releaseFocusDeferred();
           // Erst HIER playbackFinished-Listener feuern — nicht schon beim
           // Empfang des letzten PCM-Chunks (siehe handlePcmChunk). AudioTrack
@@ -1056,7 +1141,14 @@ class AudioService {
      *  Leer = Hauptchat. Ohne Prefix / Sticky landet die STT-Nachricht damit
      *  automatisch in dem Kontext den Stefan gerade sieht. */
     projectId?: string;
-  }): Promise<{ requestId: string; ok: boolean }> {
+    /** clientMsgId wartender Anhaenge: diese Aufnahme ist ihre Beschreibung.
+     *  Die Bridge fuehrt Anhang + gesprochenen Satz darueber zu EINEM Turn
+     *  zusammen, statt das Bild ohne Auftrag und den Satz ohne Bild zu sehen. */
+    clientMsgId?: string;
+    /** Zwischenruf: der Text geht in den LAUFENDEN Turn, nicht als neue
+     *  Anfrage in die Warteschlange (Sprach-Gegenstueck zum 📣-Knopf). */
+    interject?: boolean;
+  }): Promise<{ requestId: string; ok: boolean; error?: string }> {
     if (this.recordingState !== 'idle') {
       console.warn('[Audio] startStreamingRecording: bereits aktiv (state=%s)', this.recordingState);
       return { requestId: '', ok: false };
@@ -1070,13 +1162,42 @@ class AudioService {
       console.warn('[Audio] Keine Mikrofon-Berechtigung');
       return { requestId: '', ok: false };
     }
+    // Ohne Verbindung gar nicht erst aufnehmen: rvs.send() verwirft still, wenn
+    // der Socket nicht offen ist (kein Puffer, kein Retry). Genau deshalb fiel
+    // nach App-Resume/Reconnect die ERSTE Aufnahme komplett unter den Tisch —
+    // start, Chunks und end waren weg, die Bubble verschwand, und erst der
+    // zweite Versuch klappte (da war der Reconnect durch). Nachtraeglich
+    // gepuffertes Audio waere sinnlos: die STT-Sitzung laeuft in Echtzeit.
+    // WICHTIG: den SOCKET fragen, nicht den gemerkten Zustand. Der kann
+    // faelschlich 'disconnected' sein, obwohl die Verbindung laeuft (Zombie) —
+    // dann wuerde hier jede Aufnahme abgelehnt, bevor sie beginnt, und der
+    // Nutzer kann gar nicht mehr sprechen.
+    if (!rvs.isSocketOpen()) {
+      console.warn('[Audio] startStreamingRecording: Socket nicht offen (state=%s)',
+                   rvs.getState());
+      return { requestId: '', ok: false, error: 'not-connected' };
+    }
 
     // Laufende Wiedergabe stoppen (damit ARIA sich nicht selbst hoert)
     this.stopPlayback();
 
     const requestId = `sttstr_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
     this.streamRequestId = requestId;
+    // Zustand SOFORT setzen (nicht erst nach den awaits weiter unten): sonst ist
+    // isStreamingRecording() bereits true, recordingState aber noch 'idle' —
+    // ein Abbruch in diesem Fenster liess den Start danach weiterlaufen und der
+    // Recorder blieb haengen, sodass die NAECHSTE Aufnahme abgelehnt wurde.
+    this.setState('recording');
     this.streamAudioRequestId = opts.audioRequestId || '';
+    // Redundanz-Routing: freie STT-Instanz leasen BEVOR Chunks fliessen, damit
+    // start + alle Chunks + end dieselbe Instanz adressieren. Kurzer Timeout →
+    // '' (Broadcast) falls keine Instanz/keine Antwort. Nie blockierend genug
+    // um die Aufnahme spuerbar zu verzoegern.
+    try {
+      this.streamTargetInstance = await requestSttLease();
+    } catch {
+      this.streamTargetInstance = '';
+    }
     this.streamGotPartial = false;
     this.streamEndpointFired = false;
     this.recordingStartTime = Date.now();
@@ -1097,6 +1218,7 @@ class AudioService {
             requestId: sessionId,
             pcm: String(e?.pcm || ''),
             seq: Number(e?.seq || 0),
+            targetInstance: this.streamTargetInstance,
           });
         });
         this.streamPcmErrorSub = emitter.addListener('PcmStreamError', (e: any) => {
@@ -1107,6 +1229,33 @@ class AudioService {
         console.warn('[Audio] PcmStreamChunk-Subscription fehlgeschlagen:', err);
       }
 
+      // Abbruch waehrend der awaits oben? Dann hier aussteigen, statt eine
+      // Sitzung zu starten, die niemand mehr erwartet.
+      if (this.streamRequestId !== requestId) {
+        console.warn('[Audio] Start abgebrochen (Session gewechselt) — breche ab');
+        return { requestId: '', ok: false, error: 'superseded' };
+      }
+
+      // stt_stream_start MUSS vor dem Recorder raus: sonst treffen die ersten
+      // Chunks (200ms-Takt) auf eine Bridge, die die Sitzung noch nicht kennt,
+      // und werden verworfen — der Wortanfang fehlt, bei kurzen Kommandos bleibt
+      // gar nichts uebrig.
+      rvs.send('stt_stream_start' as any, {
+        requestId,
+        audioRequestId: opts.audioRequestId || '',
+        voice: opts.voice || '',
+        speed: typeof opts.speed === 'number' ? opts.speed : 1.0,
+        interrupted: !!opts.interrupted,
+        location: opts.location || null,
+        endpointMs: typeof opts.endpointMs === 'number' ? opts.endpointMs : STT_ENDPOINT_DEFAULT_MS,
+        hardCapMs: typeof opts.hardCapMs === 'number' ? opts.hardCapMs : 60000,
+        sampleRate: 16000,
+        projectId: opts.projectId || '',
+        targetInstance: this.streamTargetInstance,
+        ...(opts.clientMsgId ? { clientMsgId: opts.clientMsgId } : {}),
+        ...(opts.interject ? { interject: true } : {}),
+      });
+
       const started = await PcmStreamRecorder.start();
       if (!started) {
         throw new Error('PcmStreamRecorder.start returned false');
@@ -1118,34 +1267,29 @@ class AudioService {
       this._cancelDeferredFocusRelease();
       AudioFocus?.requestExclusive().catch(() => {});
 
-      this.setState('recording');
-
-      // stt_stream_start — der Whisper-Bridge mitteilen dass jetzt Chunks kommen.
-      rvs.send('stt_stream_start' as any, {
-        requestId,
-        audioRequestId: opts.audioRequestId || '',
-        voice: opts.voice || '',
-        speed: typeof opts.speed === 'number' ? opts.speed : 1.0,
-        interrupted: !!opts.interrupted,
-        location: opts.location || null,
-        endpointMs: typeof opts.endpointMs === 'number' ? opts.endpointMs : 1500,
-        hardCapMs: typeof opts.hardCapMs === 'number' ? opts.hardCapMs : 60000,
-        sampleRate: 16000,
-        projectId: opts.projectId || '',
-      });
 
       // No-Speech-Watchdog — ersetzt den alten VAD-noSpeechTimer.
       // Wenn nach Konversationsfenster kein einziger stt_partial gekommen ist,
       // hat der User vermutlich nix gesagt → Session beenden.
+      // WICHTIG: Der Aufrufer uebergibt hier die Sprechpausen-Toleranz
+      // (sttEndpointMs, Default 2400ms). Die misst aber ab dem ENDE des
+      // Sprechens — dieser Watchdog laeuft ab dem START der Aufnahme. Bis das
+      // erste Zwischenergebnis zurueck sein KANN, vergehen realistisch 1,3-2,2s
+      // (Mindest-Puffer 600ms + Transkriptions-Takt 700ms + Netzweg hin/zurueck).
+      // Ohne Zuschlag reisst schon ein kurzes Ueberlegen nach dem Gong die
+      // Grenze: die Aufnahme wurde abgebrochen und die Bubble verschwand — erst
+      // der zweite Versuch klappte, weil man da sofort losredet.
+      const NO_SPEECH_GRACE_MS = 2500;
       const noSpeechMs = Number(opts.noSpeechTimeoutMs || 0);
       if (noSpeechMs > 0) {
+        const effectiveMs = noSpeechMs + NO_SPEECH_GRACE_MS;
         this.streamNoSpeechTimer = setTimeout(() => {
           if (this.streamRequestId === requestId && !this.streamGotPartial) {
             console.log('[Audio] Stream %s: no-speech nach %dms → cancel',
-                        requestId.slice(0, 12), noSpeechMs);
+                        requestId.slice(0, 12), effectiveMs);
             this.cancelStreamingRecording('no-speech').catch(() => {});
           }
-        }, noSpeechMs);
+        }, effectiveMs);
       }
 
       // Hard-Cap als zweite Sicherheitsleine (App-seitig zusaetzlich zur Bridge).
@@ -1181,7 +1325,7 @@ class AudioService {
     if (!reqId) return;
     const audioReqId = this.streamAudioRequestId;
     try {
-      rvs.send('stt_stream_end' as any, { requestId: reqId, reason });
+      rvs.send('stt_stream_end' as any, { requestId: reqId, reason, targetInstance: this.streamTargetInstance });
     } catch (e) {
       console.warn('[Audio] stt_stream_end senden fehlgeschlagen:', e);
     }
@@ -1216,7 +1360,7 @@ class AudioService {
     if (!reqId) return;
     const audioReqId = this.streamAudioRequestId;
     try {
-      rvs.send('stt_stream_end' as any, { requestId: reqId, reason: `cancel:${reason}` });
+      rvs.send('stt_stream_end' as any, { requestId: reqId, reason: `cancel:${reason}`, targetInstance: this.streamTargetInstance });
     } catch {}
     this._cleanupStreamLocal(`cancel:${reason}`);
     // Listener feuern damit ChatScreen reagieren kann (endConversation etc.)
@@ -1401,6 +1545,23 @@ class AudioService {
     const base64 = payload.base64 || '';
     const isFinal = !!payload.final;
 
+    // ── TTS-Abspiel-Queue ──
+    // Kommt eine NEUE hoerbare Antwort rein, waehrend eine andere noch hoerbar
+    // spielt? Dann NICHT starten (start()→stopInternal() wuerde die laufende
+    // abschneiden) — puffern und nach deren PcmPlaybackFinished nachspielen.
+    if (!silent && this.pcmAudiblePlaying && messageId && messageId !== this.pcmPlayingMsgId) {
+      let entry = this.pcmPendingStreams.find(e => e.messageId === messageId);
+      if (!entry) {
+        entry = { messageId, sampleRate, channels, chunks: [], final: false };
+        this.pcmPendingStreams.push(entry);
+        console.log('[Audio] TTS-Queue: Antwort %s wird gepuffert (spielt gerade %s)',
+                    messageId, this.pcmPlayingMsgId);
+      }
+      if (base64) entry.chunks.push(base64);
+      if (isFinal) entry.final = true;
+      return '';  // Live-Player nicht anfassen
+    }
+
     // Neuer Stream? (messageId Wechsel oder nicht aktiv)
     if (!this.pcmStreamActive || this.pcmMessageId !== messageId) {
       if (this.pcmStreamActive && !silent) {
@@ -1448,6 +1609,8 @@ class AudioService {
         this._cancelDeferredFocusRelease();
         AudioFocus?.requestDuck().catch(() => {});
         this._firePlaybackStarted();
+        this.pcmAudiblePlaying = true;
+        this.pcmPlayingMsgId = messageId;
       }
     }
 
@@ -1490,6 +1653,73 @@ class AudioService {
     return '';
   }
 
+  /** Naechste gepufferte TTS-Antwort abspielen (TTS-Abspiel-Queue). Wird nach
+   *  PcmPlaybackFinished der vorherigen aufgerufen — so sprechen zwei
+   *  back-to-back-Antworten NACHEINANDER statt sich abzuschneiden. */
+  private async _promoteNextPendingStream(): Promise<void> {
+    const entry = this.pcmPendingStreams.shift();
+    if (!entry) return;
+    // Inzwischen global gemutet / im Anruf / vom User gestoppt? Dann NICHT
+    // hoerbar abspielen — nur cachen und die naechste promoten.
+    const mutedNow = this._muted || this._pausedForCall ||
+                     (!!this._stoppedMessageId && this._stoppedMessageId === entry.messageId);
+    console.log('[Audio] TTS-Queue: spiele gepufferte Antwort %s (%d chunks, final=%s, muted=%s)',
+                entry.messageId, entry.chunks.length, entry.final, mutedNow);
+    // SOFORT als "spielt" markieren (vor jedem await) — sonst koennte ein
+    // gleichzeitig eintreffender Chunk einer DRITTEN Antwort in der await-Luecke
+    // einen konkurrierenden Stream starten statt zu puffern.
+    this.pcmPlayingMsgId = entry.messageId;
+    this.pcmAudiblePlaying = !mutedNow;
+    // Cache-State fuer den WAV-Build (Mund-Button-Replay) setzen.
+    this.pcmMessageId = entry.messageId;
+    this.pcmSampleRate = entry.sampleRate;
+    this.pcmChannels = entry.channels;
+    this.pcmBuffer = entry.chunks.slice();
+    this.pcmBytesCollected = entry.chunks.reduce((n, c) => n + Math.floor(c.length * 0.75), 0);
+    this.pcmStreamActive = true;
+    if (!mutedNow && PcmStreamPlayer) {
+      try {
+        const prerollSec = await loadPrerollSec();
+        await PcmStreamPlayer.start(entry.sampleRate, entry.channels, prerollSec);
+        this._cancelDeferredFocusRelease();
+        AudioFocus?.requestDuck().catch(() => {});
+        this._firePlaybackStarted();
+        this.pcmAudiblePlaying = true;
+        this.pcmPlayingMsgId = entry.messageId;
+        for (const c of entry.chunks) {
+          try { await PcmStreamPlayer.writeChunk(c); } catch (err) { console.warn('[Audio] promote writeChunk', err); }
+        }
+        if (entry.final) { try { await PcmStreamPlayer.end(); } catch {} }
+      } catch (err) {
+        console.error('[Audio] TTS-Queue promote start fehlgeschlagen:', err);
+        this.pcmAudiblePlaying = false;
+        this.pcmPlayingMsgId = '';
+      }
+    }
+    // War die Antwort schon komplett (final) da: WAV cachen + State wie im
+    // Normalpfad zuruecksetzen. Bei NICHT-final laeuft der Rest live ueber
+    // _handlePcmChunkImpl (messageId == pcmPlayingMsgId → Normalpfad).
+    if (entry.final) {
+      this.pcmStreamActive = false;
+      if (this.pcmBuffer.length > 0) {
+        const audioPath = await this._savePcmBufferAsWav(entry.messageId).catch(() => '');
+        if (audioPath) {
+          this.pcmCachedListeners.forEach(cb => {
+            try { cb(entry.messageId, audioPath); } catch (e) { console.warn('[Audio] pcmCached cb err:', e); }
+          });
+        }
+      }
+      this.pcmBuffer = [];
+      this.pcmBytesCollected = 0;
+      this.pcmMessageId = '';
+      // Nicht hoerbar abgespielt (gemutet)? Dann feuert PcmPlaybackFinished nicht
+      // → die naechste gepufferte Antwort selbst nachziehen (Kette).
+      if (!this.pcmAudiblePlaying) {
+        await this._promoteNextPendingStream();
+      }
+    }
+  }
+
   /** Gesammelte PCM-Chunks als WAV speichern. Gibt file:// Pfad zurueck. */
   private async _savePcmBufferAsWav(messageId: string): Promise<string> {
     try {
@@ -1578,6 +1808,19 @@ class AudioService {
   // Callback wenn alle Audio-Teile abgespielt sind
   private playbackFinishedListeners: (() => void)[] = [];
   private playbackStartedListeners: (() => void)[] = [];
+  // Feuert wenn eine aus der TTS-Queue NACHgespielte Antwort ihren WAV-Cache
+  // geschrieben hat — der Normalpfad meldet den Pfad ueber den handlePcmChunk-
+  // Rueckgabewert, gepufferte (zweite) Antworten koennen das aber nicht (ihre
+  // Chunks returnen '' waehrend sie warten). Damit setzt die App auch fuer die
+  // nachgespielte Antwort m.audioPath (Mund-Button-Replay).
+  private pcmCachedListeners: Array<(messageId: string, audioPath: string) => void> = [];
+
+  onPcmCached(callback: (messageId: string, audioPath: string) => void): () => void {
+    this.pcmCachedListeners.push(callback);
+    return () => {
+      this.pcmCachedListeners = this.pcmCachedListeners.filter(cb => cb !== callback);
+    };
+  }
 
   onPlaybackFinished(callback: () => void): () => void {
     this.playbackFinishedListeners.push(callback);
@@ -1759,6 +2002,10 @@ class AudioService {
     }
     // AudioTrack IMMER hart stoppen (idempotent) — auch im Drain-Fall.
     PcmStreamPlayer?.stop().catch(() => {});
+    // Wartende TTS-Antworten verwerfen (Mund-Button = still sein).
+    this.pcmPendingStreams = [];
+    this.pcmAudiblePlaying = false;
+    this.pcmPlayingMsgId = '';
     stopBackgroundAudio().catch(() => {});
     this._cancelDeferredFocusRelease();
     AudioFocus?.release().catch(() => {});
@@ -1770,7 +2017,8 @@ class AudioService {
     // Kick-Cycle anstossen — Re-Renders triggern setMuted oft mehrfach hinter-
     // einander, und jeder weitere Kick lässt Spotify nochmal kurz pausieren.
     const hasAnything = !!(this.currentSound || this.resumeSound || this.preloadedSound
-                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying);
+                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying
+                           || this.pcmPendingStreams.length);
     if (!hasAnything) return;
     console.log('[Audio] stopPlayback: currentSound=%s queue=%d pcm=%s',
                 this.currentSound ? 'aktiv' : 'null', this.audioQueue.length, this.pcmStreamActive);
@@ -1804,6 +2052,11 @@ class AudioService {
     this.pcmBuffer = [];
     this.pcmBytesCollected = 0;
     this.pcmMessageId = '';
+    // TTS-Abspiel-Queue verwerfen — harter Stop/Abbruch/Barge-In soll auch
+    // wartende Antworten fallenlassen (sonst sprechen sie nach dem Stop weiter).
+    this.pcmPendingStreams = [];
+    this.pcmAudiblePlaying = false;
+    this.pcmPlayingMsgId = '';
     // Audio-Focus sofort freigeben — User hat explizit abgebrochen.
     // Unser Focus war TRANSIENT, Spotify resumed darum automatisch beim
     // Abandon. Den frueheren kickReleaseMedia haben wir entfernt: er

android/src/services/brainApi.ts

@@ -162,6 +162,15 @@ export interface Project {
   updated_at: number;
   last_activity_at: number;
   turn_count: number;
+  // Workspace: 'code' blendet Editor-/VNC-Kacheln ein. ARIA setzt das selbst
+  // via set_project_kind; fehlt/undefined = 'chat' (nur Chat-Kachel).
+  kind?: 'code' | 'chat';
+  // Optionale absolute noVNC-URL (falls der Desktop direkt erreichbar ist,
+  // sonst laeuft der VNC-Stream als RFB-Bytes durch RVS).
+  desktop_url?: string;
+  // Automatisch: hat das Projekt Dateien in /shared/projects/<id>/? → Datei-Symbol.
+  has_files?: boolean;
+  file_count?: number;
 }
 
 export interface ProjectStatus {
@@ -170,6 +179,19 @@ export interface ProjectStatus {
   projects: Project[];
 }
 
+/** QEMU-VM eines Projekts (Registry + Live-Status). */
+export interface ProjectVm {
+  name: string;
+  arch: string;
+  iso?: string;
+  vnc_display: number;
+  mem: number;
+  running?: boolean;
+  vnc_port?: number;
+  boot_cmd?: string;
+  created_at?: number;
+}
+
 /** Queue-Status pro Kontext — was gerade arbeitet, was wartet.
  *  Key "__main__" = Hauptchat, sonst project_id. */
 export interface QueueContextStatus {
@@ -238,6 +260,43 @@ export interface Trigger {
 
 // ── Memory CRUD ──────────────────────────────────────────────────────
 
+// ── Modell pro Chat ──────────────────────────────────────────────────
+// reason: 'einstellung' (brainModel) | 'pro-chat' (fuer diesen Chat gewaehlt)
+//       | 'ausweich' (Sicherheitsfilter hat das gewaehlte Modell blockiert)
+export interface ContextModelRow {
+  context_id: string;
+  name: string;
+  override: string;    // '' = folgt der Einstellung
+  selected: string;    // gewaehlt (Einstellung oder pro Chat)
+  effective: string;   // was der naechste Turn tatsaechlich nutzt
+  reason: 'einstellung' | 'pro-chat' | 'ausweich' | string;
+  blocked: string[];
+}
+
+export interface ContextModelChoice {
+  id: string;
+  name: string;
+  section: 'tier' | 'main' | 'overflow' | string;
+}
+
+export interface ContextModels {
+  default: string;
+  rows: ContextModelRow[];
+  choices: ContextModelChoice[];
+  names: Record<string, string>;
+}
+
+/** "claude-sonnet-5-5" → "Sonnet 5.5". Katalog-Namen (names) haben Vorrang;
+ *  Datums-Suffixe ("-20251001") gehoeren nicht zur Version. Gleiche Logik wie
+ *  prettyModel() in der Diagnostic. */
+export function prettyModel(id: string, names?: Record<string, string>): string {
+  if (!id) return '';
+  if (names && names[id]) return names[id];
+  const m = /^claude-([a-z]+)-(\d+)(?:-(\d{1,2}))?(?:-|$)/.exec(id);
+  if (m) return m[1][0].toUpperCase() + m[1].slice(1) + ' ' + m[2] + (m[3] ? '.' + m[3] : '');
+  return id.charAt(0).toUpperCase() + id.slice(1);
+}
+
 export const brainApi = {
   /** Einzelne Memory holen (mit allen Feldern inkl. Anhaenge) */
   getMemory(id: string): Promise<Memory> {
@@ -594,14 +653,58 @@ export const brainApi = {
     });
   },
 
-  /** Projekt-Metadaten patchen (name / description / hidden). */
-  updateProject(projectId: string, patch: Partial<Pick<Project, 'name' | 'description' | 'hidden'>>): Promise<Project> {
+  /** Projekt-Metadaten patchen (name / description / hidden / kind). */
+  updateProject(projectId: string, patch: Partial<Pick<Project, 'name' | 'description' | 'hidden' | 'kind'>>): Promise<Project> {
     return _send(`/projects/${encodeURIComponent(projectId)}`, {
       method: 'PATCH',
       body: patch,
     });
   },
 
+  /** Projekt manuell als Code-Projekt / normalen Chat markieren. */
+  setProjectKind(projectId: string, kind: 'code' | 'chat'): Promise<Project> {
+    return _send(`/projects/${encodeURIComponent(projectId)}`, {
+      method: 'PATCH',
+      body: { kind },
+    });
+  },
+
+  /** Vorhandene Code-Dateien eines Projekts auflisten (/shared/projects/<id>/). */
+  listProjectFiles(projectId: string): Promise<{ projectId: string; files: { path: string; size: number }[] }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/files`);
+  },
+
+  /** Inhalt einer Projekt-Datei laden (Text). */
+  readProjectFile(projectId: string, path: string): Promise<{ projectId: string; path: string; content: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/file?path=${encodeURIComponent(path)}`);
+  },
+
+  /** Binaere Projekt-Datei (z.B. Bild) als Base64 + MIME laden. */
+  readProjectFileBinary(projectId: string, path: string): Promise<{ path: string; mime: string; base64: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/file?binary=1&path=${encodeURIComponent(path)}`, { timeoutMs: 30000 });
+  },
+
+  // ── QEMU-VMs pro Projekt ─────────────────────────────────────────
+  listProjectVms(projectId: string): Promise<{ projectId: string; vms: ProjectVm[] }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms`, { timeoutMs: 20000 });
+  },
+  addProjectVm(projectId: string, body: { name: string; arch?: string; iso?: string; vnc_display?: number; mem?: number; create_disk?: boolean; size?: string }): Promise<ProjectVm> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms`, { method: 'POST', body, timeoutMs: 30000 });
+  },
+  removeProjectVm(projectId: string, name: string, purge = false): Promise<{ ok: boolean }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}?purge=${purge ? 'true' : 'false'}`, { method: 'DELETE' });
+  },
+  bootProjectVm(projectId: string, name: string): Promise<{ ok: boolean; vnc_port: number; output: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}/boot`, { method: 'POST', timeoutMs: 45000 });
+  },
+  stopProjectVm(projectId: string, name: string): Promise<{ ok: boolean; output: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}/stop`, { method: 'POST', timeoutMs: 30000 });
+  },
+  /** Screenshot der laufenden VM (Base64-PNG) — VM-Bildschirm ohne Live-VNC. */
+  screenshotProjectVm(projectId: string, name: string): Promise<{ ok: boolean; filename: string; base64: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}/screenshot`, { method: 'POST', timeoutMs: 30000 });
+  },
+
   /** Projekt verstecken / wieder sichtbar machen (bleibt voll nutzbar). */
   setProjectHidden(projectId: string, hidden: boolean): Promise<Project> {
     return _send(`/projects/${encodeURIComponent(projectId)}`, {
@@ -616,6 +719,25 @@ export const brainApi = {
   getProjectQueueStatus(): Promise<ProjectQueueStatus> {
     return _send('/projects/queue-status');
   },
+
+  /** Modelle aller Chats: gewaehlt, effektiv, Grund + Auswahl-Liste. */
+  getContextModels(): Promise<ContextModels> {
+    return _send('/context-model/list');
+  },
+  /** Modell fuer einen Chat setzen ('' als Modell = wieder die Einstellung). */
+  setContextModel(contextId: string, model: string): Promise<ContextModels> {
+    return _send('/context-model/set', {
+      method: 'POST',
+      body: { context_id: contextId || '', model: model || '' },
+    });
+  },
+  /** Ausweich-Modell beenden: zurueck aufs gewaehlte Modell dieses Chats. */
+  contextModelBack(contextId: string): Promise<ContextModels> {
+    return _send('/context-model/back-to-selected', {
+      method: 'POST',
+      body: { context_id: contextId || '' },
+    });
+  },
 };
 
 export default brainApi;

android/src/services/desktop.ts

@@ -0,0 +1,102 @@
+/**
+ * desktop — Desktop-/VNC-Anbindung fuer Code-Projekte.
+ *
+ * Zwei Aufgaben:
+ *  1. Verfuegbarkeit: `check_desktop` triggert die Bridge, `desktop_status`
+ *     meldet zurueck ob eine QEMU-VNC laeuft (und ggf. eine direkte URL).
+ *  2. VNC-Tunnel: der noVNC-Client in der App-WebView spricht kein eigenes
+ *     WebSocket, sondern schickt RFB-Bytes als `vnc_input` (Base64) ueber RVS;
+ *     die Bridge oeffnet die TCP-Verbindung zu QEMU (host:5901) und streamt die
+ *     Antwort als `vnc_data` zurueck. Base64-in-JSON wie audio_pcm.
+ *
+ * Eine Session = ein Desktop; wir nutzen die Projekt-ID als Session-Key (leer =
+ * 'main'). Muster wie services/rvs.ts (Singleton mit Listener-Listen).
+ */
+
+import rvs, { RVSMessage } from './rvs';
+
+export interface DesktopStatus {
+  available: boolean;
+  session: string;
+  /** optionale direkte noVNC-URL (falls Host direkt erreichbar) */
+  url?: string;
+  message?: string;
+}
+
+type StatusSub = (s: DesktopStatus) => void;
+type VncDataSub = (b64: string) => void;
+
+const DEFAULT_VNC_PORT = 5901;
+const sessionOf = (projectId: string) => projectId || 'main';
+
+class DesktopService {
+  private status: DesktopStatus = { available: false, session: '' };
+  private statusSubs: StatusSub[] = [];
+  private vncDataSubs: VncDataSub[] = [];
+  private currentSession = '';
+
+  constructor() {
+    rvs.onMessage((m) => this.onMessage(m));
+  }
+
+  private onMessage(m: RVSMessage): void {
+    const p = (m.payload || {}) as any;
+    if (m.type === 'desktop_status') {
+      this.status = {
+        available: !!p.available,
+        session: p.session || '',
+        url: typeof p.url === 'string' ? p.url : undefined,
+        message: p.message,
+      };
+      const s = this.status;
+      this.statusSubs.forEach((cb) => cb(s));
+    } else if (m.type === 'vnc_data') {
+      if (this.currentSession && p.session && p.session !== this.currentSession) return;
+      const b64 = typeof p.b64 === 'string' ? p.b64 : '';
+      if (b64) this.vncDataSubs.forEach((cb) => cb(b64));
+    }
+  }
+
+  getStatus(): DesktopStatus {
+    return this.status;
+  }
+
+  subscribeStatus(cb: StatusSub): () => void {
+    this.statusSubs.push(cb);
+    cb(this.status);
+    return () => { this.statusSubs = this.statusSubs.filter((s) => s !== cb); };
+  }
+
+  /** Bridge fragen, ob fuer dieses Projekt ein QEMU-Desktop laeuft. */
+  requestCheck(projectId: string, port: number = DEFAULT_VNC_PORT): void {
+    rvs.send('check_desktop', { projectId: projectId || '', session: sessionOf(projectId), port });
+  }
+
+  /** VNC-Tunnel oeffnen — Bridge verbindet TCP zu QEMU. */
+  openVnc(projectId: string, port: number = DEFAULT_VNC_PORT): string {
+    const session = sessionOf(projectId);
+    this.currentSession = session;
+    rvs.send('vnc_open', { session, port });
+    return session;
+  }
+
+  closeVnc(): void {
+    if (this.currentSession) rvs.send('vnc_close', { session: this.currentSession });
+    this.currentSession = '';
+  }
+
+  /** RFB-Bytes (Base64) aus der noVNC-WebView an die Bridge weiterreichen. */
+  sendInput(b64: string): void {
+    if (!this.currentSession) return;
+    rvs.send('vnc_input', { session: this.currentSession, b64 });
+  }
+
+  /** Listener fuer eingehende RFB-Bytes (Base64) — die noVNC-WebView. */
+  onVncData(cb: VncDataSub): () => void {
+    this.vncDataSubs.push(cb);
+    return () => { this.vncDataSubs = this.vncDataSubs.filter((s) => s !== cb); };
+  }
+}
+
+const desktop = new DesktopService();
+export default desktop;

android/src/services/gpsTracking.ts

@@ -145,6 +145,17 @@ class GpsTrackingService {
     // liefert im Hintergrund keine Updates (nur Heartbeat sendet alte Werte).
     const bgEnabled = await isBackgroundGpsEnabled();
     if (bgEnabled) {
+      // Ohne ACCESS_BACKGROUND_LOCATION liefert watchPosition im Hintergrund
+      // NICHTS (Android 10+) → der Foreground-Service allein bringt nichts, und
+      // genau der Fall "Ankunft waehrend der Fahrt, Screen aus" faellt durch.
+      // Deshalb erst die Permission sicherstellen (oeffnet ggf. die Android-
+      // Settings fuer "Immer erlauben"), DANN den Location-Foreground-Service
+      // hochziehen — der haelt den Prozess wach, sodass watchPosition + der
+      // 60s-Heartbeat auch unter Doze weiterlaufen.
+      const bgOk = await ensureBackgroundLocationPermission();
+      if (!bgOk) {
+        console.warn('[gps-track] Background-Permission fehlt — Tracking nur im Vordergrund zuverlaessig');
+      }
       try { await acquireBackgroundAudio('location'); } catch {}
     }
     try {

android/src/services/logger.ts

@@ -7,7 +7,7 @@
  */
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { Platform, DeviceEventEmitter } from 'react-native';
+import { Platform, DeviceEventEmitter, AppState } from 'react-native';
 import rvs from './rvs';
 
 // Lokales Event damit die SettingsScreen Live Logs / Events Tabs
@@ -38,6 +38,30 @@ const noop = () => {};
 let _verbose = true;
 let _debugLogsToBridge = false;
 
+// ─── Crash-Kontext ohne adb ─────────────────────────────────────────
+// Ein RUN_MARKER bleibt gesetzt, solange die App AKTIV laeuft; bei sauberem
+// Wechsel in den Hintergrund wird er geloescht. Ist er beim naechsten Start
+// noch da, ist der vorige Lauf unsauber gestorben (nativer Crash/OOM — der
+// schreibt KEINEN JS-Fehler, taucht also sonst nirgends auf). Wir melden das
+// dann via RVS mit dem letzten Breadcrumb (was die App zuletzt tat).
+const RUN_MARKER_KEY = 'aria_run_marker';
+const BREADCRUMB_KEY = 'aria_last_breadcrumb';
+let _breadcrumb: { ts: number; scope: string; message: string } = { ts: 0, scope: '', message: '' };
+let _breadcrumbDirty = false;
+
+/** Letzte App-Aktivitaet merken — Crash-Kontext fuer den naechsten Boot.
+ *
+ *  Die Crash-Meldung selbst darf den Brotkrumen NICHT ueberschreiben: sonst
+ *  merkt sich der zweite Absturz nur noch "letzte Aktivitaet: Crash-Meldung",
+ *  der dritte "letzte Aktivitaet: Crash-Meldung ueber Crash-Meldung" — und bei
+ *  einer Absturzschleife ist nach dem ersten Durchlauf jede Spur weg. Genau
+ *  das ist passiert; die eigentliche Ursache stand nur in der ERSTEN Meldung. */
+export function noteBreadcrumb(scope: string, message: string): void {
+  if (scope === 'app.crash-detected') return;
+  _breadcrumb = { ts: Date.now(), scope: scope || '', message: String(message || '').slice(0, 120) };
+  _breadcrumbDirty = true;
+}
+
 function applyState(): void {
   console.log = _verbose ? originalLog : noop;
 }
@@ -53,6 +77,45 @@ export async function initLogger(): Promise<void> {
     _debugLogsToBridge = d === 'true'; // default: false
   } catch {}
   applyState();
+  await _initCrashDetection();
+}
+
+// Native-Crash-Erkennung (ohne adb) — siehe RUN_MARKER-Kommentar oben.
+async function _initCrashDetection(): Promise<void> {
+  try {
+    const marker = await AsyncStorage.getItem(RUN_MARKER_KEY);
+    if (marker) {
+      let bc: any = {};
+      try { bc = JSON.parse((await AsyncStorage.getItem(BREADCRUMB_KEY)) || '{}'); } catch {}
+      const gap = bc && bc.ts ? Math.round((Date.now() - bc.ts) / 1000) : -1;
+      // Verzoegert melden — RVS ist beim Boot oft noch nicht verbunden.
+      setTimeout(() => {
+        reportAppError({
+          scope: 'app.crash-detected',
+          level: 'warn',
+          message: `Voriger Lauf ohne sauberes Shutdown beendet (nativer Crash/OOM?). `
+            + `Letzte Aktivitaet: [${(bc && bc.scope) || '?'}] ${(bc && bc.message) || '?'}`
+            + (gap >= 0 ? ` (vor ~${gap}s)` : ''),
+        });
+      }, 6000);
+    }
+    await AsyncStorage.setItem(RUN_MARKER_KEY, String(Date.now()));
+  } catch {}
+  // Breadcrumb throttled persistieren (alle 5s, nur wenn geaendert).
+  setInterval(() => {
+    if (_breadcrumbDirty) {
+      _breadcrumbDirty = false;
+      AsyncStorage.setItem(BREADCRUMB_KEY, JSON.stringify(_breadcrumb)).catch(() => {});
+    }
+  }, 5000);
+  // Sauberer Hintergrund-Wechsel → Marker weg (kein Crash). Rueckkehr → wieder
+  // scharf. So melden nur echte Aktiv-Crashes, kein normales Backgrounden.
+  try {
+    AppState.addEventListener('change', (s) => {
+      if (s === 'background') AsyncStorage.removeItem(RUN_MARKER_KEY).catch(() => {});
+      else if (s === 'active') AsyncStorage.setItem(RUN_MARKER_KEY, String(Date.now())).catch(() => {});
+    });
+  } catch {}
 }
 
 export function isVerboseLogging(): boolean {
@@ -94,6 +157,7 @@ let _reportingInstalled = false;
 /** Schickt einen App-Fehler via RVS an die Bridge. */
 export function reportAppError(ev: AppErrorEvent): void {
   const ts = Date.now();
+  noteBreadcrumb(ev.scope, ev.message);
   try {
     rvs.send('app_log' as any, {
       ts,
@@ -128,6 +192,9 @@ export function reportAppError(ev: AppErrorEvent): void {
  *  Default aus damit Mama-Modus keine Disk-Schreiblast hat. Error-Reports
  *  (reportAppError) gehen weiterhin IMMER durch. */
 export function reportAppDebug(scope: string, message: string): void {
+  // Breadcrumb IMMER aktualisieren (auch wenn Debug-Logs-an-Bridge aus ist) —
+  // fuer den Crash-Kontext beim naechsten Boot.
+  noteBreadcrumb(scope, message);
   if (!_debugLogsToBridge) return;
   const ts = Date.now();
   const trimmed = String(message).slice(0, 2000);

android/src/services/projectFocus.ts

@@ -0,0 +1,105 @@
+/**
+ * projectFocus — leichter Publish/Subscribe-Spiegel des aktuell fokussierten
+ * Projekt-Kontexts.
+ *
+ * ChatScreen bleibt die Quelle der Wahrheit fuer sein eigenes Rendering und
+ * publiziert hier bei jedem Focus-/Namens-/Kind-Wechsel EINWEG hinein. Der
+ * Workspace-Canvas liest/abonniert das Singleton, um zu wissen welches Projekt
+ * gerade aktiv ist und ob es ein Code-Projekt ist — ohne dass ChatScreen den
+ * Workspace kennen oder umgebaut werden muss.
+ *
+ * Muster wie services/rvs.ts (Singleton mit Listener-Liste + Unsubscribe).
+ */
+
+export type ProjectKind = 'code' | 'chat';
+
+export interface FocusSnapshot {
+  /** '' = Hauptchat, sonst Projekt-ID */
+  focusedProjectId: string;
+  projectNameById: Record<string, string>;
+  projectKindById: Record<string, ProjectKind>;
+}
+
+type Sub = (snap: FocusSnapshot) => void;
+
+class ProjectFocus {
+  private snap: FocusSnapshot = {
+    focusedProjectId: '',
+    projectNameById: {},
+    projectKindById: {},
+  };
+  private subs: Sub[] = [];
+
+  // --- Getter (synchron, fuer Nicht-Reaktive Leser) ---
+
+  get(): FocusSnapshot {
+    return this.snap;
+  }
+
+  getFocusedProjectId(): string {
+    return this.snap.focusedProjectId;
+  }
+
+  getProjectName(id: string): string {
+    return this.snap.projectNameById[id] || id;
+  }
+
+  /** Default 'chat' — ein Projekt ist erst 'code' wenn es explizit so
+   *  markiert wurde (set_project_kind) oder ein Code-/Desktop-Signal kam. */
+  getProjectKind(id: string): ProjectKind {
+    return this.snap.projectKindById[id] || 'chat';
+  }
+
+  // --- Publisher (von ChatScreen aufgerufen) ---
+
+  setFocus(id: string): void {
+    if (this.snap.focusedProjectId === id) return;
+    this.snap = { ...this.snap, focusedProjectId: id };
+    this.emit();
+  }
+
+  setNames(map: Record<string, string>): void {
+    // Flacher Merge — behaelt bereits bekannte Namen, ueberschreibt neue.
+    this.snap = {
+      ...this.snap,
+      projectNameById: { ...this.snap.projectNameById, ...map },
+    };
+    this.emit();
+  }
+
+  setKind(id: string, kind: ProjectKind): void {
+    if (this.snap.projectKindById[id] === kind) return;
+    this.snap = {
+      ...this.snap,
+      projectKindById: { ...this.snap.projectKindById, [id]: kind },
+    };
+    this.emit();
+  }
+
+  setKinds(map: Record<string, ProjectKind>): void {
+    this.snap = {
+      ...this.snap,
+      projectKindById: { ...this.snap.projectKindById, ...map },
+    };
+    this.emit();
+  }
+
+  // --- Abo ---
+
+  /** Registriert einen Listener und liefert sofort den aktuellen Snapshot. */
+  subscribe(cb: Sub): () => void {
+    this.subs.push(cb);
+    cb(this.snap);
+    return () => {
+      this.subs = this.subs.filter(s => s !== cb);
+    };
+  }
+
+  private emit(): void {
+    const s = this.snap;
+    this.subs.forEach(cb => cb(s));
+  }
+}
+
+const projectFocus = new ProjectFocus();
+export default projectFocus;

android/src/services/rvs.ts

@@ -7,6 +7,9 @@
  */
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { NativeModules, Platform } from 'react-native';
+
+const TlsTrust: any = NativeModules.TlsTrust;
 
 // --- Typen ---
 
@@ -27,6 +30,29 @@ export interface ConnectionConfig {
   useTLS: boolean;
 }
 
+/**
+ * Wie sicher ist die Verbindung? Fuer das Schloss-Symbol in der Tab-Leiste.
+ *   secure    — verschluesselt, Zertifikat in Ordnung
+ *   expired   — verschluesselt, aber das Zertifikat ist abgelaufen (per Schalter erlaubt)
+ *   cert_error— keine Verbindung, weil das Zertifikat abgelehnt wurde
+ *   fallback  — verbunden OHNE Verschluesselung, weil TLS fehlschlug
+ *   plain     — verbunden ohne Verschluesselung, so konfiguriert
+ *   unknown   — (noch) nichts Genaues
+ */
+export type SecurityKind = 'secure' | 'expired' | 'cert_error' | 'fallback' | 'plain' | 'unknown';
+
+export interface SecurityState {
+  kind: SecurityKind;
+  /** Pruefergebnis der App: ok | expired_accepted | expired | invalid | unknown */
+  certStatus: string;
+  /** Ablaufdatum des Server-Zertifikats (ms), 0 = unbekannt */
+  notAfter: number;
+  /** Bei fallback/cert_error: warum TLS nicht ging */
+  reason: string;
+}
+
+type SecurityCallback = (state: SecurityState) => void;
+
 type MessageCallback = (message: RVSMessage) => void;
 type StateCallback = (state: ConnectionState) => void;
 
@@ -64,6 +90,10 @@ class RVSConnection {
   private logListeners: LogCallback[] = [];
   private connectionLog: ConnectionLogEntry[] = [];
   private usingTLSFallback: boolean = false;
+  private securityListeners: SecurityCallback[] = [];
+  private security: SecurityState = { kind: 'unknown', certStatus: 'unknown', notAfter: 0, reason: '' };
+  /** Letzter Zertifikats-Fehler beim wss://-Versuch (bleibt bis wss:// wieder klappt) */
+  private certFailure: { status: string; notAfter: number; detail: string } | null = null;
 
   // --- Konfiguration ---
 
@@ -104,11 +134,7 @@ class RVSConnection {
     // Verbindungen + doppelte Events.
     if (this.ws) {
       this.log('info', 'Bestehende WS-Verbindung wird geschlossen vor Neu-Connect');
-      try {
-        this.ws.onclose = null;  // verhindert dass scheduleReconnect doppelt feuert
-        this.ws.onerror = null;
-        this.ws.close();
-      } catch (_) {}
+      this.detachSocket(this.ws);
       this.ws = null;
     }
 
@@ -134,6 +160,15 @@ class RVSConnection {
     this.setState('disconnected');
   }
 
+  /**
+   * Ist die Verbindung WIRKLICH offen? Fragt den Socket selbst, nicht den
+   * gemerkten Zustand — der kann (z.B. nach einem Zombie) falsch sein. Wer
+   * davon abhaengig macht, ob ueberhaupt gesendet wird, muss das Echte wissen.
+   */
+  isSocketOpen(): boolean {
+    return !!this.ws && this.ws.readyState === WebSocket.OPEN;
+  }
+
   /** Nachricht an den RVS senden */
   send(type: MessageType, payload: Record<string, unknown>): void {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
@@ -211,11 +246,18 @@ class RVSConnection {
         const tlsInfo = this.usingTLSFallback ? ' (TLS-Fallback: ws://)' : '';
         this.log('info', `Verbunden${tlsInfo}`);
         this.setState('connected');
+        this.updateSecurityOnOpen(useTLS);
+        this.sendClientHello();
         this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
         this.startHeartbeat();
       };
 
+      const socket = this.ws;   // genau DIESE Verbindung (nicht 'this.ws' spaeter)
       this.ws.onmessage = (event: WebSocketMessageEvent) => {
+        // Nur die AKTUELLE Verbindung darf Nachrichten einspeisen. Sonst
+        // koennte eine alte, laengst aufgegebene Verbindung weiter Daten
+        // liefern und vortaeuschen, es sei alles in Ordnung.
+        if (socket !== this.ws) return;
         try {
           const message: RVSMessage = JSON.parse(event.data as string);
           this.notifyMessageListeners(message);
@@ -229,6 +271,10 @@ class RVSConnection {
         this.clearTimers();
         this.ws = null;
         this.setState('disconnected');
+        this.setSecurity(this.certFailure
+          ? { kind: 'cert_error', certStatus: this.certFailure.status, notAfter: this.certFailure.notAfter,
+              reason: this.certFailure.detail }
+          : { kind: 'unknown', certStatus: 'unknown', notAfter: 0, reason: '' });
 
         // Sticky-Fallback-Reset: beim naechsten Reconnect wieder primary
         // (wss://) versuchen statt fuer immer auf ws:// zu kleben. War
@@ -248,6 +294,7 @@ class RVSConnection {
       this.ws.onerror = (error) => {
         const errorMsg = (error as any)?.message || 'Unbekannter Fehler';
         this.log('error', `WebSocket-Fehler: ${errorMsg}`);
+        if (useTLS) this.checkCertFailure(errorMsg);
 
         // TLS-Fallback: Wenn wss:// fehlschlaegt, auf ws:// wechseln
         if (this.config?.useTLS && !this.usingTLSFallback) {
@@ -258,8 +305,7 @@ class RVSConnection {
           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.detachSocket(this.ws);   // inkl. onmessage — sonst bleibt ein Zombie, der weiter empfaengt
           }
           this.ws = null;
           this.shouldReconnect = true;
@@ -278,6 +324,95 @@ class RVSConnection {
     }
   }
 
+  /** Beim RVS vorstellen — Diagnostic zeigt so, welches Handy im Raum ist. */
+  private sendClientHello(): void {
+    try {
+      const c: any = (Platform as any).constants || {};
+      const device = [c.Manufacturer, c.Model].filter(Boolean).join(' ') || Platform.OS;
+      let version = '';
+      try { version = require('../../package.json').version || ''; } catch (_) {}
+      this.send('client_hello', { kind: 'App', name: device,
+        detail: `Android ${c.Release || Platform.Version}`, version });
+    } catch (_) {}
+  }
+
+  // --- Verbindungs-Sicherheit (Schloss-Symbol) ---
+
+  getSecurity(): SecurityState {
+    return this.security;
+  }
+
+  onSecurityChange(callback: SecurityCallback): () => void {
+    this.securityListeners.push(callback);
+    return () => {
+      this.securityListeners = this.securityListeners.filter(cb => cb !== callback);
+    };
+  }
+
+  private setSecurity(next: SecurityState): void {
+    const cur = this.security;
+    if (cur.kind === next.kind && cur.certStatus === next.certStatus
+        && cur.notAfter === next.notAfter && cur.reason === next.reason) return;
+    this.security = next;
+    this.securityListeners.forEach(cb => cb(next));
+  }
+
+  private async nativeCertStatus(): Promise<{ status: string; notAfter: number; detail: string }> {
+    try {
+      const r = await TlsTrust?.getStatus();
+      return { status: r?.status || 'unknown', notAfter: Number(r?.notAfter) || 0, detail: r?.detail || '' };
+    } catch (_) {
+      return { status: 'unknown', notAfter: 0, detail: '' };
+    }
+  }
+
+  private async updateSecurityOnOpen(viaTLS: boolean): Promise<void> {
+    if (viaTLS) {
+      this.certFailure = null;
+      const c = await this.nativeCertStatus();
+      if (c.status === 'expired_accepted') {
+        this.log('warn', `Zertifikat abgelaufen (${new Date(c.notAfter).toLocaleDateString()}) — per Einstellung akzeptiert`);
+      }
+      this.setSecurity({ kind: c.status === 'expired_accepted' ? 'expired' : 'secure',
+                         certStatus: c.status, notAfter: c.notAfter, reason: '' });
+    } else if (this.config?.useTLS) {
+      // wss:// ging nicht, ws:// schon → unverschluesselt per Fallback
+      this.setSecurity({ kind: 'fallback', certStatus: this.certFailure?.status || 'unknown',
+                         notAfter: this.certFailure?.notAfter || 0, reason: this.certFailure?.detail || '' });
+    } else {
+      this.setSecurity({ kind: 'plain', certStatus: 'unknown', notAfter: 0, reason: '' });
+    }
+  }
+
+  /** Lag der wss://-Fehler am Zertifikat? Dann merken (fuer Schloss + Hinweis). */
+  private async checkCertFailure(errorMsg: string): Promise<void> {
+    if (!/cert|trust anchor|chain validation|handshake|ssl/i.test(errorMsg)) return;
+    const c = await this.nativeCertStatus();
+    if (c.status !== 'expired' && c.status !== 'invalid') return;
+    this.certFailure = { status: c.status, notAfter: c.notAfter, detail: c.detail || errorMsg };
+    this.log('error', c.status === 'expired'
+      ? `Server-Zertifikat abgelaufen seit ${new Date(c.notAfter).toLocaleString()}`
+      : 'Server-Zertifikat ungueltig');
+    if (this.state !== 'connected') {
+      this.setSecurity({ kind: 'cert_error', certStatus: c.status, notAfter: c.notAfter,
+                         reason: this.certFailure.detail });
+    } else if (this.security.kind === 'fallback') {
+      // ws://-Fallback war schneller verbunden als diese Pruefung — Grund nachtragen
+      this.setSecurity({ ...this.security, certStatus: c.status, notAfter: c.notAfter,
+                         reason: this.certFailure.detail });
+    }
+  }
+
+  /** Schalter "Abgelaufenes Zertifikat akzeptieren" */
+  async getAllowExpiredCert(): Promise<boolean> {
+    try { return !!(await TlsTrust?.getStatus())?.allowExpired; } catch (_) { return false; }
+  }
+
+  async setAllowExpiredCert(value: boolean): Promise<void> {
+    try { await TlsTrust?.setAllowExpired(value); } catch (_) {}
+    this.log('info', `Abgelaufene Zertifikate ${value ? 'werden akzeptiert' : 'werden abgelehnt'}`);
+  }
+
   /** Reconnect mit exponentiellem Backoff planen */
   private scheduleReconnect(): void {
     this.log('info', `Reconnect in ${this.reconnectDelay / 1000}s...`);
@@ -302,6 +437,25 @@ class RVSConnection {
     }, HEARTBEAT_INTERVAL_MS);
   }
 
+  /**
+   * Klemmt eine Verbindung VOLLSTAENDIG ab, bevor sie verworfen wird.
+   *
+   * Wichtig: frueher wurden nur onclose/onerror entfernt — onmessage blieb
+   * haengen. Eine aufgegebene (Zombie-)Verbindung lieferte dadurch weiter
+   * Nachrichten an die App, waehrend gesendet wurde ueber die neue/tote.
+   * Symptom: die App zeigt "getrennt", ARIAs Sprachausgabe kommt aber trotzdem
+   * an — und nichts, was man schreibt oder spricht, erreicht den Server.
+   */
+  private detachSocket(ws: WebSocket): void {
+    try {
+      ws.onopen = null;
+      ws.onmessage = null;   // <- das fehlte
+      ws.onclose = null;     // verhindert doppelten Reconnect
+      ws.onerror = null;
+      ws.close();
+    } catch (_) {}
+  }
+
   private clearTimers(): void {
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);

android/src/services/shareIntent.ts

@@ -0,0 +1,77 @@
+/**
+ * Teilen-Ziel — Bruecke zum nativen ShareIntent-Modul.
+ *
+ * Zwei Faelle:
+ *   App war ZU   → der Inhalt liegt beim Start am Intent → getShared()
+ *   App LAEUFT   → onNewIntent feuert das Event 'ShareReceived' → onShare()
+ *
+ * Die Dateien hat die native Seite schon in den App-Cache kopiert und liefert
+ * echte Pfade; content://-URIs waeren nach dem Dialog womoeglich nicht mehr
+ * lesbar (die Leseerlaubnis gilt nur fuer den Intent).
+ */
+import { NativeEventEmitter, NativeModules } from 'react-native';
+import RNFS from 'react-native-fs';
+import type { FileData } from '../components/FileUpload';
+import type { SharedItem } from '../components/ShareModal';
+
+const { ShareIntent } = NativeModules;
+
+export interface SharedPayload {
+  text: string;
+  items: SharedItem[];
+}
+
+const EMPTY: SharedPayload = { text: '', items: [] };
+
+/** Inhalt, mit dem die App gestartet wurde (leer, wenn normal geoeffnet). */
+export async function getShared(): Promise<SharedPayload> {
+  if (!ShareIntent?.getSharedData) return EMPTY;
+  try {
+    const r = await ShareIntent.getSharedData();
+    return { text: r?.text || '', items: Array.isArray(r?.items) ? r.items : [] };
+  } catch (e) {
+    console.warn('[Share] getSharedData fehlgeschlagen:', e);
+    return EMPTY;
+  }
+}
+
+/** Abonniert Shares in die bereits laufende App. Gibt Unsubscribe zurueck. */
+export function onShare(cb: (p: SharedPayload) => void): () => void {
+  if (!ShareIntent) return () => {};
+  const emitter = new NativeEventEmitter(ShareIntent);
+  const sub = emitter.addListener('ShareReceived', (r: any) => {
+    cb({ text: r?.text || '', items: Array.isArray(r?.items) ? r.items : [] });
+  });
+  return () => { try { sub.remove(); } catch (_) {} };
+}
+
+/** Zwischenkopien loeschen (nach erfolgreichem Senden). */
+export async function clearShareCache(): Promise<void> {
+  try { await ShareIntent?.clearCache?.(); } catch (_) {}
+}
+
+/**
+ * Macht aus geteilten Dateien das Format, das der bestehende Upload-Weg
+ * erwartet (Base64) — so laeuft Teilen durch exakt dieselbe Strecke wie die
+ * Bueroklammer, inklusive Anhang-Darstellung im Chat.
+ */
+export async function toFileData(items: SharedItem[]): Promise<FileData[]> {
+  const out: FileData[] = [];
+  for (const it of items) {
+    try {
+      const base64 = await RNFS.readFile(it.path, 'base64');
+      out.push({
+        name: it.name || 'geteilt',
+        type: it.type || 'application/octet-stream',
+        size: it.size || 0,
+        base64,
+        uri: 'file://' + it.path,
+      });
+    } catch (e) {
+      console.warn('[Share] Datei nicht lesbar (%s): %s', it.name, e);
+    }
+  }
+  return out;
+}
+
+export default { getShared, onShare, clearShareCache, toFileData };

android/src/services/updater.ts

@@ -17,6 +17,26 @@ const APP_VERSION = packageJson.version || '0.0.0.0';
 
 type UpdateCallback = (info: UpdateInfo) => void;
 
+/** Fortschritt fuer die Anzeige (UpdateProgress-Komponente) */
+export interface UpdateProgress {
+  active: boolean;
+  version: string;
+  /** 0..1, -1 = unbekannt */
+  fraction: number;
+  receivedMB: number;
+  totalMB: number;
+  /** z.B. "Lade herunter …", "Neuer Versuch (2/3) …", "Installiere …" */
+  status: string;
+}
+
+type ProgressCallback = (p: UpdateProgress) => void;
+
+const HTTP_ATTEMPTS = 3;
+// Abbruch nur, wenn der Download HAENGT (so lange kommt kein Byte) — nicht
+// nach einer festen Gesamtzeit wie frueher (60 s fuer 65 MB war zu knapp).
+const READ_STALL_MS = 30_000;
+const WS_TIMEOUT_MS = 5 * 60_000;
+
 export interface UpdateInfo {
   version: string;
   downloadUrl: string;
@@ -27,6 +47,13 @@ class UpdateService {
   private listeners: UpdateCallback[] = [];
   private checking = false;
   private downloading = false;
+  private progressListeners: ProgressCallback[] = [];
+  private progress: UpdateProgress = { active: false, version: '', fraction: -1, receivedMB: 0, totalMB: 0, status: '' };
+  private jobId: number | null = null;
+  /** Laeuft gerade eine Pruefung per Knopf? Dann geht die Antwort NUR dorthin
+   *  (sonst zeigt der ChatScreen-Listener denselben Dialog ein zweites Mal). */
+  private manualWaiter: ((r: { type: 'available'; info: UpdateInfo } | { type: 'none'; latest: string }) => void) | null = null;
+  private cancelled = false;
 
   constructor() {
     // Beim Start alte APK-Reste aus dem Cache wegraeumen — wenn diese App
@@ -42,10 +69,19 @@ class UpdateService {
           downloadUrl: (msg.payload.downloadUrl as string) || '',
           size: (msg.payload.size as number) || 0,
         };
+        if (this.manualWaiter) {
+          const w = this.manualWaiter; this.manualWaiter = null;
+          if (info.version && this.isNewer(info.version)) w({ type: 'available', info });
+          else w({ type: 'none', latest: info.version });
+          return;
+        }
         if (info.version && this.isNewer(info.version)) {
           console.log(`[Update] Neue Version verfuegbar: ${info.version} (aktuell: ${APP_VERSION})`);
           this.listeners.forEach(cb => cb(info));
         }
+      } else if ((msg.type as string) === 'update_none' && this.manualWaiter) {
+        const w = this.manualWaiter; this.manualWaiter = null;
+        w({ type: 'none', latest: String(msg.payload.latest || '') });
       }
     });
   }
@@ -126,6 +162,64 @@ class UpdateService {
     setTimeout(() => { this.checking = false; }, 10000);
   }
 
+  /**
+   * Pruefung per Knopf (Einstellungen → Ueber): sagt IMMER etwas —
+   * neue Version (Update-Dialog), "keine neue Version" mit der Version auf dem
+   * Server, oder warum der Update-Server nicht erreichbar ist (mit Details).
+   */
+  async checkForUpdateManual(): Promise<void> {
+    const cfg = rvs.getConfig();
+    const where = cfg ? `${cfg.useTLS ? 'wss' : 'ws'}://${cfg.host}:${cfg.port}` : '(nicht eingerichtet)';
+    if (!cfg) {
+      Alert.alert('Update-Server nicht erreichbar', 'Es ist noch kein Server eingerichtet (Einstellungen → Verbindung).');
+      return;
+    }
+    if (!rvs.isSocketOpen()) {
+      const lastErr = [...rvs.getConnectionLog()].reverse().find(e => e.level === 'error');
+      Alert.alert('Update-Server nicht erreichbar',
+        `Keine Verbindung zu ${where}.\n\nZustand: ${rvs.getState()}`
+        + (lastErr ? `\nLetzter Fehler (${new Date(lastErr.timestamp).toLocaleTimeString()}):\n${lastErr.message}` : ''));
+      return;
+    }
+
+    const result = await new Promise<{ type: 'available'; info: UpdateInfo } | { type: 'none'; latest: string } | { type: 'timeout' }>(resolve => {
+      const t = setTimeout(() => { this.manualWaiter = null; resolve({ type: 'timeout' }); }, 10_000);
+      this.manualWaiter = (r) => { clearTimeout(t); resolve(r); };
+      rvs.send('update_check' as any, { version: APP_VERSION });
+    });
+
+    if (result.type === 'available') {
+      this.promptUpdate(result.info);
+      return;
+    }
+    if (result.type === 'timeout') {
+      Alert.alert('Update-Server antwortet nicht',
+        `Verbunden mit ${where}, aber nach 10 s keine Antwort auf die Update-Anfrage.\n\n`
+        + 'Moeglicherweise laeuft auf dem Server eine alte RVS-Version.');
+      return;
+    }
+
+    // Keine neue Version — zusaetzlich pruefen, ob der Download-Weg funktioniert
+    let dl = '';
+    try {
+      const ctrl = new AbortController();
+      const t = setTimeout(() => ctrl.abort(), 10_000);
+      const r = await fetch(`${cfg.useTLS ? 'https' : 'http'}://${cfg.host}:${cfg.port}/update/latest.apk`,
+        { method: 'HEAD', headers: { 'X-RVS-Token': cfg.token }, signal: ctrl.signal });
+      clearTimeout(t);
+      dl = r.ok ? 'Download-Weg: erreichbar ✓'
+        : r.status === 404 && result.latest ? 'Download-Weg: vom Server noch nicht unterstuetzt (alter RVS)'
+        : r.status === 404 ? 'Download-Weg: erreichbar, aber auf dem Server liegt keine APK'
+        : `Download-Weg: Fehler HTTP ${r.status}`;
+    } catch (e: any) {
+      dl = `Download-Weg: nicht erreichbar (${e?.name === 'AbortError' ? 'Zeitueberschreitung' : (e?.message || e)})`;
+    }
+    Alert.alert('Keine neue Version',
+      `Installiert: ${APP_VERSION}\n`
+      + `Neueste auf dem Server: ${result.latest || '(keine APK hinterlegt)'}\n\n`
+      + `Update-Server: ${where} ✓\n${dl}`);
+  }
+
   /** Callback registrieren */
   onUpdateAvailable(callback: UpdateCallback): () => void {
     this.listeners.push(callback);
@@ -150,46 +244,125 @@ class UpdateService {
     );
   }
 
-  /** APK ueber WebSocket herunterladen und installieren */
+  onProgress(callback: ProgressCallback): () => void {
+    this.progressListeners.push(callback);
+    callback(this.progress);
+    return () => {
+      this.progressListeners = this.progressListeners.filter(cb => cb !== callback);
+    };
+  }
+
+  private setProgress(p: Partial<UpdateProgress>): void {
+    this.progress = { ...this.progress, ...p };
+    this.progressListeners.forEach(cb => cb(this.progress));
+  }
+
+  /** Laufenden Download abbrechen (Knopf in der Fortschrittsanzeige) */
+  cancelDownload(): void {
+    this.cancelled = true;
+    if (this.jobId !== null) {
+      try { RNFS.stopDownload(this.jobId); } catch (_) {}
+    }
+  }
+
+  /**
+   * APK per HTTP vom RVS laden (/update/latest.apk, Token im Header).
+   * Gibt false zurueck, wenn der RVS den Weg noch nicht kennt (alter RVS) —
+   * dann nimmt downloadAndInstall den alten WebSocket-Weg.
+   */
+  private async downloadViaHttp(info: UpdateInfo, destPath: string): Promise<boolean> {
+    const cfg = rvs.getConfig();
+    if (!cfg) return false;
+    const url = `${cfg.useTLS ? 'https' : 'http'}://${cfg.host}:${cfg.port}/update/latest.apk`;
+    let lastErr = '';
+    for (let attempt = 1; attempt <= HTTP_ATTEMPTS; attempt++) {
+      if (this.cancelled) throw new Error('Abgebrochen');
+      this.setProgress({ status: attempt === 1 ? 'Lade herunter …' : `Neuer Versuch (${attempt}/${HTTP_ATTEMPTS}) …`,
+                         fraction: -1, receivedMB: 0 });
+      let expected = 0;
+      try {
+        const job = RNFS.downloadFile({
+          fromUrl: url,
+          toFile: destPath,
+          headers: { 'X-RVS-Token': cfg.token },
+          connectionTimeout: 15_000,
+          readTimeout: READ_STALL_MS,
+          progressInterval: 300,
+          begin: (r) => { expected = r.contentLength > 0 ? r.contentLength : 0; },
+          progress: (r) => {
+            const total = r.contentLength > 0 ? r.contentLength : info.size;
+            this.setProgress({
+              fraction: total > 0 ? Math.min(1, r.bytesWritten / total) : -1,
+              receivedMB: r.bytesWritten / 1048576,
+              totalMB: total / 1048576,
+            });
+          },
+        });
+        this.jobId = job.jobId;
+        const res = await job.promise;
+        this.jobId = null;
+        if (res.statusCode === 403 || res.statusCode === 404) {
+          // Alter RVS ohne HTTP-Download (404) bzw. Token unbekannt (403)
+          console.warn(`[Update] HTTP-Download nicht verfuegbar (${res.statusCode}) — nehme WebSocket`);
+          return false;
+        }
+        if (res.statusCode !== 200) throw new Error(`HTTP ${res.statusCode}`);
+        const st = await RNFS.stat(destPath);
+        if (expected && Number(st.size) !== expected) {
+          throw new Error(`Datei unvollstaendig (${st.size} von ${expected} Bytes)`);
+        }
+        return true;
+      } catch (err: any) {
+        this.jobId = null;
+        if (this.cancelled) throw new Error('Abgebrochen');
+        lastErr = err?.message || String(err);
+        console.warn(`[Update] HTTP-Download Versuch ${attempt} fehlgeschlagen: ${lastErr}`);
+        await new Promise<void>(r => setTimeout(r, 2000 * attempt));
+      }
+    }
+    throw new Error(`Download fehlgeschlagen: ${lastErr}`);
+  }
+
+  /** Alter Weg: APK als ein grosser Block ueber die WebSocket-Verbindung */
+  private async downloadViaWebSocket(info: UpdateInfo, destPath: string): Promise<void> {
+    this.setProgress({ status: 'Lade herunter (ohne Fortschritt) …', fraction: -1 });
+    rvs.send('update_download' as any, {});
+    const base64 = await new Promise<string>((resolve, reject) => {
+      const timeout = setTimeout(() => { unsub(); reject(new Error('Download-Timeout (5 min)')); }, WS_TIMEOUT_MS);
+      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(msg.payload.base64 as string);
+        }
+      });
+    });
+    if (this.cancelled) throw new Error('Abgebrochen');
+    await RNFS.writeFile(destPath, base64, 'base64');
+  }
+
+  /** APK herunterladen (HTTP mit Fortschritt, sonst WebSocket) und installieren */
   async downloadAndInstall(info: UpdateInfo): Promise<void> {
     if (this.downloading) return;
     this.downloading = true;
+    this.cancelled = false;
+    this.setProgress({ active: true, version: info.version, fraction: -1, receivedMB: 0,
+                       totalMB: info.size / 1048576, status: 'Starte …' });
 
+    const fileName = `ARIA-v${info.version}.apk`;
+    const destPath = `${RNFS.CachesDirectoryPath}/${fileName}`;
     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
+      console.log(`[Update] Lade APK v${info.version} …`);
+      // Vor dem Download alte APKs im Cache wegraeumen
       await this.cleanupOldApks();
 
-      // Base64 als APK-Datei speichern
-      const destPath = `${RNFS.CachesDirectoryPath}/${apkData.fileName}`;
-      await RNFS.writeFile(destPath, apkData.base64, 'base64');
+      const viaHttp = await this.downloadViaHttp(info, destPath);
+      if (!viaHttp) await this.downloadViaWebSocket(info, destPath);
+
       const fileSize = await RNFS.stat(destPath);
-      console.log(`[Update] APK gespeichert: ${destPath} (${(Number(fileSize.size) / 1024 / 1024).toFixed(1)}MB)`);
+      console.log(`[Update] APK gespeichert: ${destPath} (${(Number(fileSize.size) / 1024 / 1024).toFixed(1)}MB, ${viaHttp ? 'HTTP' : 'WebSocket'})`);
+      this.setProgress({ fraction: 1, status: 'Installiere …' });
 
       // APK installieren via natives ApkInstaller Module (FileProvider + Intent)
       if (Platform.OS === 'android') {
@@ -199,15 +372,17 @@ class UpdateService {
         } catch (installErr: any) {
           Alert.alert(
             'APK heruntergeladen',
-            `Version ${info.version} gespeichert.\n\nBitte manuell installieren:\nDateimanager → ${apkData.fileName} antippen.\n\n(${installErr.message})`,
+            `Version ${info.version} gespeichert.\n\nBitte manuell installieren:\nDateimanager → ${fileName} antippen.\n\n(${installErr.message})`,
           );
         }
       }
     } catch (err: any) {
       console.error(`[Update] Fehler: ${err.message}`);
-      Alert.alert('Update fehlgeschlagen', err.message);
+      try { await RNFS.unlink(destPath); } catch (_) {}
+      if (!this.cancelled) Alert.alert('Update fehlgeschlagen', err.message);
     } finally {
       this.downloading = false;
+      this.setProgress({ active: false });
     }
   }
 

android/src/services/viewMode.ts

@@ -0,0 +1,57 @@
+/**
+ * viewMode — App-Ansicht: 'compact' (klassischer Vollbild-Chat wie vor 0.2.2.0)
+ * oder 'cockpit' (zoombarer Kachel-Desktop).
+ *
+ * Default 'compact' → fuer normale Nutzung aendert sich nichts (Mama-tauglich).
+ * Umschaltbar ueber den Header-Button; persistiert in AsyncStorage. Muster wie
+ * services/rvs.ts (Singleton mit Listener-Liste).
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export type ViewModeValue = 'compact' | 'cockpit';
+
+const KEY = 'aria_view_mode';
+type Sub = (mode: ViewModeValue) => void;
+
+class ViewMode {
+  private mode: ViewModeValue = 'compact';
+  private subs: Sub[] = [];
+  private loaded = false;
+
+  constructor() {
+    AsyncStorage.getItem(KEY).then((v) => {
+      if (v === 'cockpit' || v === 'compact') this.mode = v;
+      this.loaded = true;
+      this.emit();
+    }).catch(() => { this.loaded = true; });
+  }
+
+  get(): ViewModeValue { return this.mode; }
+  isLoaded(): boolean { return this.loaded; }
+
+  set(mode: ViewModeValue): void {
+    if (this.mode === mode) return;
+    this.mode = mode;
+    AsyncStorage.setItem(KEY, mode).catch(() => {});
+    this.emit();
+  }
+
+  toggle(): void {
+    this.set(this.mode === 'compact' ? 'cockpit' : 'compact');
+  }
+
+  subscribe(cb: Sub): () => void {
+    this.subs.push(cb);
+    cb(this.mode);
+    return () => { this.subs = this.subs.filter((s) => s !== cb); };
+  }
+
+  private emit(): void {
+    const m = this.mode;
+    this.subs.forEach((cb) => cb(m));
+  }
+}
+
+const viewMode = new ViewMode();
+export default viewMode;

android/src/services/wakeword.ts

@@ -30,34 +30,22 @@ type PassiveListenCallback = () => void;
 
 export type WakeWordState = 'off' | 'armed' | 'conversing' | 'listening';
 
-/** Default-Dauer fuer den Passive-Listen-Modus nach einer Konversation —
- *  in dem Fenster braucht's kein Wake-Word, Speaker-ID-Filter haelt
- *  fremde Stimmen raus (TV, Familie). 30s default; konfigurierbar. */
-export const PASSIVE_LISTEN_DEFAULT_MS = 30_000;
-export const PASSIVE_LISTEN_STORAGE_KEY = 'aria_passive_listen_ms';
-
-export async function loadPassiveListenMs(): Promise<number> {
-  try {
-    const raw = await AsyncStorage.getItem(PASSIVE_LISTEN_STORAGE_KEY);
-    if (raw) {
-      const n = parseInt(raw, 10);
-      if (isFinite(n) && n >= 0 && n <= 120_000) return n;
-    }
-  } catch {}
-  return PASSIVE_LISTEN_DEFAULT_MS;
-}
-
-export async function savePassiveListenMs(ms: number): Promise<void> {
-  await AsyncStorage.setItem(PASSIVE_LISTEN_STORAGE_KEY, String(ms));
-}
+/** Reine HANG-Notbremse fuer den Passive-Listen-Modus. Das echte Ende regelt IMMER
+ *  die passive Aufnahme selbst: Stille-Toleranz (User pausiert), No-Speech (User
+ *  sagt gar nichts) oder Hard-Cap (max. Aufnahmedauer, ~5min) → ChatScreen ruft
+ *  dann exitPassiveListening. Dieser Timer darf aktives Reden NIE abschneiden —
+ *  deshalb LÄNGER als der Hard-Cap (nur falls ein Endpoint-Event mal verloren geht
+ *  und der State sonst ewig 'listening' bliebe). Das alte 30s-Fenster, das lange
+ *  Antworten mitten im Satz kappte, ist damit raus. */
+const PASSIVE_BACKSTOP_MS = 10 * 60_000;
 
 export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';
 
 // Wake-Word-Empfindlichkeit (openWakeWord-Threshold). Hoeher = strenger =
-// weniger Fehlauslösung (z.B. durch Musik/Radio ueber die Auto-Lautsprecher,
-// die das Mikro mithoert — der App-Echo-Canceler kann nur ARIAs eigenes TTS
-// rausrechnen, NICHT Spotify). Default 0.6 (war 0.5). 0..1.
-export const WAKE_THRESHOLD_DEFAULT = 0.6;
+// weniger Fehlauslösung, aber man muss deutlicher/lauter sprechen (fuehlt sich
+// "traege" an). Fehlausloeser werden ueber Speaker-ID (E3) ohnehin verworfen,
+// deshalb darf der Default empfindlicher sein. 0.45 (war 0.6/0.5). 0..1.
+export const WAKE_THRESHOLD_DEFAULT = 0.45;
 export const WAKE_THRESHOLD_MIN = 0.3;
 export const WAKE_THRESHOLD_MAX = 0.9;
 export const WAKE_THRESHOLD_STORAGE_KEY = 'aria_wake_threshold';
@@ -77,6 +65,49 @@ export async function saveWakeThreshold(v: number): Promise<void> {
   await AsyncStorage.setItem(WAKE_THRESHOLD_STORAGE_KEY, String(v));
 }
 
+// Hintergrund-Wake: darf das Wake-Wort auch triggern, wenn die App im
+// Hintergrund / der Bildschirm gesperrt ist? Default AUS — im Hintergrund
+// sind die meisten „Trigger" Fehlalarme (TV, Husten, AudioFocus-Spikes).
+// AN = auch bei gesperrtem Bildschirm zuhoeren. Die native Erkennung laeuft
+// ohnehin durch (Foreground-Service + Wake-Locks) — dieser Schalter oeffnet
+// nur das JS-Gate in onWakeDetected.
+export const BG_WAKE_STORAGE_KEY = 'aria_bg_wake_enabled';
+
+export async function loadBgWakeEnabled(): Promise<boolean> {
+  try {
+    return (await AsyncStorage.getItem(BG_WAKE_STORAGE_KEY)) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+export async function saveBgWakeEnabled(enabled: boolean): Promise<void> {
+  try {
+    await AsyncStorage.setItem(BG_WAKE_STORAGE_KEY, String(enabled));
+  } catch {}
+}
+
+// Wake-Wort-Bestaetigung: nach einem openWakeWord-Trigger den Vor-Trigger-Audio
+// von Voxtral gegenpruefen lassen ("war das wirklich 'Computer' oder Musik?").
+// Killt Musik-Fehltrigger (z.B. Pet Shop Boys), kostet ~0.5-1s Extra-Latenz pro
+// Wake. Default AUS (opt-in), fail-open. Braucht das native preTriggerPcm im
+// Event (neueres APK) — ohne das macht die App normal weiter.
+export const WAKE_CONFIRM_STORAGE_KEY = 'aria_wake_confirm_enabled';
+
+export async function loadWakeConfirmEnabled(): Promise<boolean> {
+  try {
+    return (await AsyncStorage.getItem(WAKE_CONFIRM_STORAGE_KEY)) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+export async function saveWakeConfirmEnabled(enabled: boolean): Promise<void> {
+  try {
+    await AsyncStorage.setItem(WAKE_CONFIRM_STORAGE_KEY, String(enabled));
+  } catch {}
+}
+
 /** 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
@@ -103,7 +134,9 @@ export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
 // Detection-Tuning. Threshold ist ueber die Settings konfigurierbar
 // (loadWakeThreshold) — der Wert hier ist nur der Fallback.
 const DEFAULT_THRESHOLD = WAKE_THRESHOLD_DEFAULT;
-const DEFAULT_PATIENCE = 2;
+// patience=1 statt 2: nur EIN Frame ueber Threshold noetig → deutlich schneller.
+// Speaker-ID filtert Fehlausloeser, also ist das vertretbar.
+const DEFAULT_PATIENCE = 1;
 const DEFAULT_DEBOUNCE_MS = 1500;
 
 interface OpenWakeWordModule {
@@ -143,6 +176,13 @@ class WakeWordService {
    *  Hintergrund-Detections sind quasi immer false-positives (TV, Husten,
    *  AudioFocus-Switch beim Wechsel zu Musik etc.). */
   private inBackground: boolean = false;
+  /** Wenn true: Wake-Wort triggert auch im Hintergrund / bei gesperrtem
+   *  Bildschirm. Default false. Wird beim Arm aus AsyncStorage geladen und
+   *  bei Aenderung in den Einstellungen via setBgWakeEnabled() aktualisiert. */
+  private bgWakeEnabled: boolean = false;
+  /** Wake-Wort per Voxtral bestaetigen (gegen Musik-Fehltrigger)? Default false.
+   *  Wird beim Arm geladen + per setWakeConfirmEnabled aus den Einstellungen. */
+  private wakeConfirmEnabled: boolean = false;
   /** Re-Entry-Guard fuer onWakeDetected: native kann mehrere
    *  WakeWordDetected-Events emitten BEVOR OpenWakeWord.stop() in JS
    *  resolved (Bridge-Queue + Doze-Backlog). Mit dem Flag wird das zweite
@@ -150,8 +190,9 @@ class WakeWordService {
    *  Ausnahme: bargeListening → Barge-In ist ein legitimer neuer Trigger
    *  waehrend ARIA noch redet, NICHT vom Guard blockieren. */
   private detectionInProgress: boolean = false;
-  /** Passive-Listen-Timer: feuert nach PASSIVE_LISTEN_MS ohne Stefan-Speech,
-   *  beendet den listening-State und geht zurueck zu armed. */
+  /** Passive-Listen-Backstop-Timer: Notbremse (PASSIVE_BACKSTOP_MS). Normal endet
+   *  das Fenster ueber die Stille-Toleranz der Aufnahme; feuert dieser Timer
+   *  trotzdem, zurueck zu armed. */
   private passiveListenTimer: ReturnType<typeof setTimeout> | null = null;
   /** Callbacks fuer den Eintritt in Passive-Listen — ChatScreen startet
    *  hier eine streaming-Aufnahme OHNE User-Bubble (passiv lauschen). */
@@ -223,15 +264,20 @@ class WakeWordService {
     this.initInProgress = (async () => {
       try {
         const threshold = await loadWakeThreshold();
-        console.log('[WakeWord] init mit threshold=%s', threshold);
+        this.bgWakeEnabled = await loadBgWakeEnabled();
+        this.wakeConfirmEnabled = await loadWakeConfirmEnabled();
+        console.log('[WakeWord] init mit threshold=%s, bgWake=%s, confirm=%s',
+                    threshold, this.bgWakeEnabled, this.wakeConfirmEnabled);
         await OpenWakeWord.init(this.keyword, threshold, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
         // Subscribe nur einmal
         if (!this.eventSub) {
           const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
-          this.eventSub = emitter.addListener('WakeWordDetected', () => {
+          this.eventSub = emitter.addListener('WakeWordDetected', (payload: any) => {
             console.log('[WakeWord] Native Detection-Event empfangen');
-            this.onWakeDetected().catch(err =>
-              console.warn('[WakeWord] onWakeDetected crashed:', err));
+            // payload.preTriggerPcm (base64 s16le 16kHz) fuer die Bestaetigung —
+            // nur in neueren APKs vorhanden; ohne = fail-open (kein Verify).
+            this.onWakeDetected(payload && payload.preTriggerPcm ? String(payload.preTriggerPcm) : null)
+              .catch(err => console.warn('[WakeWord] onWakeDetected crashed:', err));
           });
         }
         this.nativeReady = true;
@@ -310,7 +356,7 @@ class WakeWordService {
   /** 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 {
+  setResumeCooldown(ms: number = 500): void {
     this.cooldownUntilMs = Date.now() + ms;
     console.log('[WakeWord] Cooldown aktiv fuer %dms', ms);
   }
@@ -320,23 +366,45 @@ class WakeWordService {
    *  was als „Wake-Word" reinkommt ist Husten/TV/AudioFocus-Switch. */
   setBackground(): void {
     this.inBackground = true;
-    console.log('[WakeWord] App im Hintergrund — Detections gesperrt');
+    console.log('[WakeWord] App im Hintergrund — Detections %s',
+                this.bgWakeEnabled ? 'AKTIV (Hintergrund-Wake an)' : 'gesperrt');
   }
 
-  /** App im Vordergrund: Detections wieder freigeben, plus 3s Cooldown
-   *  als Schutz gegen den AudioFocus-/AudioTrack-Spike der direkt nach
-   *  dem Resume kommt. Ersetzt das alte setResumeCooldown(3000)-Pattern. */
+  /** Hintergrund-Wake ein/aus schalten (aus den Einstellungen). */
+  setBgWakeEnabled(enabled: boolean): void {
+    this.bgWakeEnabled = enabled;
+    console.log('[WakeWord] Hintergrund-Wake = %s', enabled);
+  }
+
+  /** Wake-Wort-Bestaetigung (Voxtral) ein/aus (aus den Einstellungen). */
+  setWakeConfirmEnabled(enabled: boolean): void {
+    this.wakeConfirmEnabled = enabled;
+    console.log('[WakeWord] Wake-Bestaetigung = %s', enabled);
+  }
+
+  /** Ist Hintergrund-Wake an? Steuert u.a. ob der Konversationsmodus auch im
+   *  Hintergrund weiterlaeuft (sonst: im Hintergrund direkt zurueck aufs Wake-Word). */
+  isBgWakeEnabled(): boolean {
+    return this.bgWakeEnabled;
+  }
+
+  /** App im Vordergrund: Detections wieder freigeben, plus kurzer Cooldown
+   *  als Schutz gegen den AudioFocus-/AudioTrack-Spike direkt nach dem Resume.
+   *  1s statt 3s — 3s hat sich "traege" angefuehlt (Trigger direkt nach dem
+   *  App-Oeffnen wurden verschluckt). */
   setForeground(): void {
     this.inBackground = false;
-    this.cooldownUntilMs = Date.now() + 3000;
-    console.log('[WakeWord] App im Vordergrund — Cooldown 3s aktiv');
+    this.cooldownUntilMs = Date.now() + 1000;
+    console.log('[WakeWord] App im Vordergrund — Cooldown 1s aktiv');
   }
 
-  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
-  private async onWakeDetected(): Promise<void> {
-    if (this.inBackground) {
-      console.log('[WakeWord] Trigger ignoriert (App im Hintergrund)');
-      import('./logger').then(m => m.reportAppDebug('wake.detect', 'ignored: app in background')).catch(()=>{});
+  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten.
+   *  preTriggerPcm: base64 s16le 16kHz Vor-Trigger-Audio fuer die Bestaetigung
+   *  (null = nicht verfuegbar → keine Bestaetigung, normal weiter). */
+  private async onWakeDetected(preTriggerPcm: string | null = null): Promise<void> {
+    if (this.inBackground && !this.bgWakeEnabled) {
+      console.log('[WakeWord] Trigger ignoriert (App im Hintergrund, Hintergrund-Wake aus)');
+      import('./logger').then(m => m.reportAppDebug('wake.detect', 'ignored: app in background (bg-wake off)')).catch(()=>{});
       return;
     }
     // Re-Entry-Guard: blocken wenn ein Detection-Zyklus schon laeuft.
@@ -379,6 +447,22 @@ class WakeWordService {
       // Kein erneutes setState — wir bleiben in 'conversing'.
       return;
     }
+    // Wake-Wort-Bestaetigung (gegen Musik-Fehltrigger): den Vor-Trigger-Schnipsel
+    // von Voxtral gegenpruefen. Bestaetigt → weiter (Gong + Mikro). Verworfen
+    // (Musik/Rauschen, kein "Computer") → kein Dialog, kein Gong, re-arm. Fail-
+    // open: ohne PCM / bei Timeout/Fehler laeuft es normal durch.
+    if (this.wakeConfirmEnabled && preTriggerPcm) {
+      const confirmed = await this.confirmWake(preTriggerPcm);
+      if (!confirmed) {
+        this.detectionInProgress = false;
+        if (this.nativeReady && OpenWakeWord) {
+          try { await OpenWakeWord.start(); } catch (e) {
+            console.warn('[WakeWord] re-arm nach verworfener Bestaetigung failed:', e);
+          }
+        }
+        return;
+      }
+    }
     this.setState('conversing');
     // Direkt feuern — KEIN setTimeout. Im Hintergrund (Display aus) parkt
     // Android den JS-Thread; ein setTimeout(200ms) kann dann Minuten lang
@@ -392,6 +476,34 @@ class WakeWordService {
     });
   }
 
+  /** Voxtral-Bestaetigung des Vor-Trigger-Schnipsels. true = Wake-Wort erkannt
+   *  (oder fail-open bei Timeout/Fehler), false = Musik/Rauschen → verwerfen. */
+  private async confirmWake(pcm: string): Promise<boolean> {
+    try {
+      const audio = await import('./audio');
+      const text = await audio.transcribeBlob(pcm);
+      if (text === null) {
+        console.log('[WakeWord] Bestaetigung: Timeout/Fehler → fail-open (durchlassen)');
+        return true;
+      }
+      const norm = text.toLowerCase();
+      // Distinktive Wake-Wort-Bestandteile (>= 4 Zeichen; 'hey' o.ae. rausfiltern,
+      // taucht sonst in Song-Texten auf und wuerde faelschlich bestaetigen).
+      const kwWords = this.keyword.toLowerCase().replace(/_/g, ' ')
+        .split(/\s+/).filter(w => w.length >= 4);
+      if (kwWords.length === 0) return true;  // zu kurzes Keyword → nicht pruefbar
+      const ok = kwWords.some(w => norm.includes(w));
+      console.log('[WakeWord] Bestaetigung: text=%o kw=%o → %s',
+                  text, kwWords, ok ? 'BESTAETIGT' : 'verworfen (Musik-FP?)');
+      import('./logger').then(m => m.reportAppDebug('wake.confirm',
+        `text="${text.slice(0, 40)}" kw=${kwWords.join('|')} → ${ok ? 'ok' : 'reject'}`)).catch(() => {});
+      return ok;
+    } catch (e) {
+      console.warn('[WakeWord] confirmWake err → fail-open:', e);
+      return true;
+    }
+  }
+
   /** 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.
@@ -486,13 +598,12 @@ class WakeWordService {
     import('./logger').then(m => m.reportAppDebug('wake.end',
       `endConversation called, wasBarge=${wasBarge}, nativeReady=${this.nativeReady}`)).catch(()=>{});
 
-    // Passive-Listen aktiv? Dann nicht direkt zu armed — passive lauschen
-    // fuer N Sekunden, dann erst Wake-Word wieder aktivieren. Speaker-ID
-    // (Phase 3) filtert fremde Stimmen weg, der User kann ohne erneute
-    // Anrede weitersprechen.
-    const passiveMs = await loadPassiveListenMs();
-    if (!skipPassive && passiveMs > 0 && this.nativeReady) {
-      this.enterPassiveListening(passiveMs);
+    // Kein skipPassive? Dann EIN Stille-Fenster zum Weiterreden (kein Wake-Word
+    // noetig). Das echte Ende regelt die Stille-Toleranz der passiven Aufnahme;
+    // der Backstop-Timer ist nur die Notbremse. Der User kann ohne erneute
+    // Anrede weitersprechen; sagt er nichts → zurueck aufs Wake-Word.
+    if (!skipPassive && this.nativeReady) {
+      this.enterPassiveListening(PASSIVE_BACKSTOP_MS);
       return;
     }
 
@@ -534,10 +645,10 @@ class WakeWordService {
     this.cancelPassiveListenTimer();
     this.setState('listening');
     const seconds = Math.round(durationMs / 1000);
-    console.log('[WakeWord] Passive-Listen aktiv (%ds) — Speaker-ID gefiltert', seconds);
+    console.log('[WakeWord] Passive-Listen aktiv (Backstop %ds) — Speaker-ID gefiltert', seconds);
     import('./logger').then(m => m.reportAppDebug('wake.passive',
-      `entered listening for ${seconds}s, cb-count=${this.passiveListenCallbacks.length}`)).catch(()=>{});
-    ToastAndroid.show(`🎧 ${seconds}s lauscht — sprich einfach weiter`, ToastAndroid.SHORT);
+      `entered listening (backstop ${seconds}s), cb-count=${this.passiveListenCallbacks.length}`)).catch(()=>{});
+    ToastAndroid.show('🎧 sprich einfach weiter', ToastAndroid.SHORT);
     this.passiveListenTimer = setTimeout(() => {
       this.passiveListenTimer = null;
       this.exitPassiveListening('timeout').catch(() => {});

android/src/workspace/AriaViewCanvas.tsx

@@ -0,0 +1,175 @@
+/**
+ * AriaViewCanvas — die pannbare Flaeche, auf der ARIAs komponierte Ansicht
+ * (aria_view) MATERIALISIERT: Orb oben, darunter die Karten. Erscheint als
+ * Overlay ueber dem Chat, sobald ARIA present_view aufruft ("sag was → Orb denkt
+ * → Karte fliegt rein"). Der erste, greifbare Vorgeschmack aufs generative
+ * Cockpit (M1).
+ *
+ * Bedienung (NoMachine-Prinzip): 2-Finger halten + schieben bewegt die Welt,
+ * Pinch zoomt. Ein-Finger-Touch geht an die Karten durch (Scrollen). Die Welt
+ * traegt gerenderte/gestreamte Inhalte — interaktive native Panels rasten
+ * spaeter bei Scale 1 ein (Chat bleibt separat darunter).
+ *
+ * Geraete-agnostisch gehalten: liest nur die ViewSpec, damit ein spaeterer Web-/
+ * AR-Renderer dieselbe Spec konsumieren kann.
+ */
+
+import React from 'react';
+import { StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import Animated, {
+  FadeInDown,
+  useAnimatedStyle,
+  useSharedValue,
+  withTiming,
+} from 'react-native-reanimated';
+import { Gesture, GestureDetector } from 'react-native-gesture-handler';
+import { ViewSpec } from '../services/ariaView';
+import Orb from './Orb';
+import CardView from './CardView';
+
+const MIN_SCALE = 0.5;
+const MAX_SCALE = 3;
+
+interface Props {
+  view: ViewSpec;
+  onClose: () => void;
+}
+
+const AriaViewCanvas: React.FC<Props> = ({ view, onClose }) => {
+  const tx = useSharedValue(0);
+  const ty = useSharedValue(0);
+  const scale = useSharedValue(1);
+  const savedTx = useSharedValue(0);
+  const savedTy = useSharedValue(0);
+  const savedScale = useSharedValue(1);
+
+  const pan = Gesture.Pan()
+    .minPointers(2)
+    .maxPointers(2)
+    .onUpdate((e) => {
+      tx.value = savedTx.value + e.translationX;
+      ty.value = savedTy.value + e.translationY;
+    })
+    .onEnd(() => {
+      savedTx.value = tx.value;
+      savedTy.value = ty.value;
+    });
+
+  const pinch = Gesture.Pinch()
+    .onUpdate((e) => {
+      const next = savedScale.value * e.scale;
+      scale.value = Math.max(MIN_SCALE, Math.min(MAX_SCALE, next));
+    })
+    .onEnd(() => {
+      savedScale.value = scale.value;
+    });
+
+  const composed = Gesture.Simultaneous(pan, pinch);
+
+  const worldStyle = useAnimatedStyle(() => ({
+    transform: [
+      { translateX: tx.value },
+      { translateY: ty.value },
+      { scale: scale.value },
+    ],
+  }));
+
+  const resetCamera = () => {
+    tx.value = withTiming(0);
+    ty.value = withTiming(0);
+    scale.value = withTiming(1);
+    savedTx.value = 0;
+    savedTy.value = 0;
+    savedScale.value = 1;
+  };
+
+  const cards = Array.isArray(view.cards) ? view.cards : [];
+
+  return (
+    <View style={styles.overlay}>
+      <GestureDetector gesture={composed}>
+        <Animated.View style={[styles.world, worldStyle]}>
+          <View style={styles.orbWrap}>
+            <Orb state={view.orb} size={110} />
+          </View>
+          {!!view.title && <Text style={styles.worldTitle}>{view.title}</Text>}
+          <View style={styles.cards}>
+            {cards.map((c, i) => (
+              <Animated.View
+                key={i}
+                entering={FadeInDown.duration(420).delay(120 + i * 90)}
+              >
+                <CardView card={c} />
+              </Animated.View>
+            ))}
+          </View>
+        </Animated.View>
+      </GestureDetector>
+
+      {/* Steuerung — ausserhalb des Transforms, immer bei Scale 1 bedienbar */}
+      <View style={styles.topBar} pointerEvents="box-none">
+        <TouchableOpacity style={styles.iconBtn} onPress={resetCamera}>
+          <Text style={styles.icon}>⤢</Text>
+        </TouchableOpacity>
+        <TouchableOpacity style={styles.iconBtn} onPress={onClose}>
+          <Text style={styles.icon}>✕</Text>
+        </TouchableOpacity>
+      </View>
+      <View style={styles.hintWrap} pointerEvents="none">
+        <Text style={styles.hint}>2 Finger: schieben · Pinch: zoomen</Text>
+      </View>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  overlay: {
+    ...StyleSheet.absoluteFillObject,
+    backgroundColor: 'rgba(6,6,16,0.94)',
+    zIndex: 50,
+  },
+  world: {
+    ...StyleSheet.absoluteFillObject,
+    alignItems: 'center',
+    paddingTop: 48,
+    paddingHorizontal: 18,
+  },
+  orbWrap: { marginTop: 8, marginBottom: 6 },
+  worldTitle: {
+    color: '#C9C9FF',
+    fontSize: 18,
+    fontWeight: '700',
+    marginBottom: 4,
+    textAlign: 'center',
+  },
+  cards: { width: '100%', maxWidth: 560 },
+  topBar: {
+    position: 'absolute',
+    top: 10,
+    right: 12,
+    flexDirection: 'row',
+  },
+  iconBtn: {
+    width: 40,
+    height: 40,
+    borderRadius: 20,
+    marginLeft: 10,
+    alignItems: 'center',
+    justifyContent: 'center',
+    backgroundColor: 'rgba(30,30,60,0.9)',
+    borderWidth: 1,
+    borderColor: 'rgba(123,92,255,0.4)',
+  },
+  icon: { color: '#C9C9FF', fontSize: 18 },
+  hintWrap: {
+    position: 'absolute',
+    bottom: 14,
+    alignSelf: 'center',
+  },
+  hint: {
+    color: '#6A6A90',
+    fontSize: 12,
+  },
+});
+
+export default AriaViewCanvas;

android/src/workspace/CardView.tsx

@@ -0,0 +1,114 @@
+/**
+ * CardView — rendert EINE Karte einer aria_view-Spec (M1). Schaltet nach
+ * card.type auf den passenden Renderer. Unbekannte Typen werden als Text-
+ * Fallback gezeigt (nie crashen).
+ *
+ * Bewusst dependency-leicht (v1): Markdown wird als Klartext dargestellt, Map
+ * als Marker-Liste (kein Karten-Lib), Code als Monospace-Block. Spaeter koennen
+ * einzelne Renderer aufgebohrt werden, ohne die Spec/den Fluss zu aendern.
+ */
+
+import React from 'react';
+import { Image, ScrollView, StyleSheet, Text, View } from 'react-native';
+import { ViewCard, ViewMarker } from '../services/ariaView';
+
+const ImageBody: React.FC<{ src?: string }> = ({ src }) => {
+  const isUrl = !!src && /^https?:\/\//i.test(src);
+  if (isUrl) {
+    return <Image source={{ uri: src }} style={styles.image} resizeMode="contain" />;
+  }
+  return <Text style={styles.muted}>🖼️ {src || '(kein Bild)'}</Text>;
+};
+
+const ListBody: React.FC<{ md?: string }> = ({ md }) => {
+  const lines = (md || '')
+    .split('\n')
+    .map((l) => l.replace(/^\s*[-*•]\s?/, '').trim())
+    .filter(Boolean);
+  if (lines.length === 0) return <Text style={styles.muted}>(leer)</Text>;
+  return (
+    <View>
+      {lines.map((l, i) => (
+        <View key={i} style={styles.listRow}>
+          <Text style={styles.bullet}>•</Text>
+          <Text style={styles.text}>{l}</Text>
+        </View>
+      ))}
+    </View>
+  );
+};
+
+const MapBody: React.FC<{ markers?: ViewMarker[] }> = ({ markers }) => {
+  const ms = Array.isArray(markers) ? markers : [];
+  return (
+    <View style={styles.map}>
+      <Text style={styles.mapHint}>🗺️ Karte ({ms.length} Orte)</Text>
+      {ms.map((m, i) => (
+        <Text key={i} style={styles.text}>
+          📍 {m.label || `${m.lat?.toFixed?.(4)}, ${m.lon?.toFixed?.(4)}`}
+        </Text>
+      ))}
+    </View>
+  );
+};
+
+const CodeBody: React.FC<{ md?: string; path?: string; lang?: string }> = ({ md, path, lang }) => (
+  <View>
+    {(path || lang) && (
+      <Text style={styles.codeCaption}>
+        {path || ''}{lang ? `  · ${lang}` : ''}
+      </Text>
+    )}
+    <ScrollView horizontal style={styles.codeScroll}>
+      <Text style={styles.code}>{md || ''}</Text>
+    </ScrollView>
+  </View>
+);
+
+const CardView: React.FC<{ card: ViewCard }> = ({ card }) => {
+  return (
+    <View style={styles.card}>
+      {!!card.title && <Text style={styles.cardTitle}>{card.title}</Text>}
+      {card.type === 'image' ? (
+        <ImageBody src={card.src} />
+      ) : card.type === 'list' ? (
+        <ListBody md={card.md} />
+      ) : card.type === 'map' ? (
+        <MapBody markers={card.markers} />
+      ) : card.type === 'code' ? (
+        <CodeBody md={card.md} path={card.path} lang={card.lang} />
+      ) : (
+        <Text style={styles.text}>{card.md || ''}</Text>
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  card: {
+    backgroundColor: 'rgba(18,18,42,0.92)',
+    borderColor: 'rgba(123,92,255,0.35)',
+    borderWidth: 1,
+    borderRadius: 14,
+    padding: 14,
+    marginVertical: 8,
+    shadowColor: '#7B5CFF',
+    shadowOpacity: 0.25,
+    shadowRadius: 12,
+    shadowOffset: { width: 0, height: 2 },
+    elevation: 6,
+  },
+  cardTitle: { color: '#C9C9FF', fontSize: 15, fontWeight: '700', marginBottom: 8 },
+  text: { color: '#E6E6F0', fontSize: 14, lineHeight: 20, flexShrink: 1 },
+  muted: { color: '#8A8AB0', fontSize: 13, fontStyle: 'italic' },
+  image: { width: '100%', height: 200, borderRadius: 8, backgroundColor: '#0D0D1A' },
+  listRow: { flexDirection: 'row', alignItems: 'flex-start', marginVertical: 2 },
+  bullet: { color: '#7B5CFF', marginRight: 8, fontSize: 14, lineHeight: 20 },
+  map: { backgroundColor: '#0D0D1A', borderRadius: 8, padding: 10 },
+  mapHint: { color: '#00B4D8', fontSize: 13, fontWeight: '600', marginBottom: 6 },
+  codeCaption: { color: '#8A8AB0', fontSize: 12, marginBottom: 6 },
+  codeScroll: { backgroundColor: '#0A0A14', borderRadius: 8, padding: 10 },
+  code: { color: '#B9F5C9', fontFamily: 'monospace', fontSize: 12.5, lineHeight: 18 },
+});
+
+export default React.memo(CardView);

android/src/workspace/Orb.tsx

@@ -0,0 +1,106 @@
+/**
+ * Orb — ARIAs Praesenz-Avatar (M1). Zeigt ihren Zustand (idle/listening/
+ * thinking/speaking/working) als pulsierender Leucht-Kern und ist das
+ * verbindende Element ueber alle Oberflaechen (App/Web/spaeter Brille).
+ *
+ * Reine Optik, keine Logik — der Zustand kommt von aussen (aria_view.orb bzw.
+ * spaeter direkt von Audio/Wake-Word-Signalen). Dependency-leicht: nur
+ * reanimated (schon installiert), kein SVG/Gradient noetig.
+ */
+
+import React, { useEffect } from 'react';
+import { StyleSheet, View } from 'react-native';
+import Animated, {
+  Easing,
+  cancelAnimation,
+  useAnimatedStyle,
+  useSharedValue,
+  withRepeat,
+  withTiming,
+} from 'react-native-reanimated';
+import { OrbState } from '../services/ariaView';
+
+const COLORS: Record<OrbState, string> = {
+  idle: '#3A6EA5',
+  listening: '#00B4D8',
+  thinking: '#7B5CFF',
+  speaking: '#34C759',
+  working: '#FF9500',
+};
+
+interface Props {
+  state?: OrbState;
+  size?: number;
+}
+
+const Orb: React.FC<Props> = ({ state = 'idle', size = 120 }) => {
+  const pulse = useSharedValue(1);
+
+  useEffect(() => {
+    const fast = state === 'thinking' || state === 'working';
+    cancelAnimation(pulse);
+    pulse.value = 1;
+    pulse.value = withRepeat(
+      withTiming(fast ? 1.14 : 1.07, {
+        duration: fast ? 620 : 1500,
+        easing: Easing.inOut(Easing.ease),
+      }),
+      -1,
+      true,
+    );
+    return () => cancelAnimation(pulse);
+  }, [state, pulse]);
+
+  const animStyle = useAnimatedStyle(() => ({ transform: [{ scale: pulse.value }] }));
+  const color = COLORS[state] || COLORS.idle;
+
+  return (
+    <View style={[styles.wrap, { width: size, height: size }]}>
+      <Animated.View
+        style={[
+          styles.glow,
+          { width: size, height: size, borderRadius: size / 2, backgroundColor: color },
+          animStyle,
+        ]}
+      />
+      <Animated.View
+        style={[
+          styles.ring,
+          {
+            width: size * 0.72,
+            height: size * 0.72,
+            borderRadius: size * 0.36,
+            borderColor: color,
+          },
+          animStyle,
+        ]}
+      />
+      <View
+        style={[
+          styles.core,
+          {
+            width: size * 0.44,
+            height: size * 0.44,
+            borderRadius: size * 0.22,
+            backgroundColor: color,
+            shadowColor: color,
+          },
+        ]}
+      />
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  wrap: { alignItems: 'center', justifyContent: 'center' },
+  glow: { position: 'absolute', opacity: 0.22 },
+  ring: { position: 'absolute', borderWidth: 2, opacity: 0.55 },
+  core: {
+    shadowOpacity: 0.9,
+    shadowRadius: 16,
+    shadowOffset: { width: 0, height: 0 },
+    elevation: 12,
+  },
+});
+
+export default React.memo(Orb);

android/src/workspace/WorkspaceDeck.tsx

@@ -0,0 +1,92 @@
+/**
+ * WorkspaceDeck — die Workbench: Vollbild-Panels + Taskleisten-Dock unten.
+ *
+ * Statt einer Zoom-Landkarte: jedes Panel ist bildschirmfuellend und Handy-
+ * optimiert, das Dock wechselt per Daumen-Tap sofort. Alle Panels sind IMMER
+ * gemountet (nur das aktive ist via display sichtbar) → kein Remount, Chat
+ * behaelt RVS/Audio/Queue, WebViews behalten ihren Zustand.
+ *
+ * Bei offener Tastatur blendet das Dock aus (mehr Platz zum Tippen).
+ */
+
+import React, { useEffect, useState } from 'react';
+import { Keyboard, StyleSheet, View } from 'react-native';
+import { TileId } from './layout';
+import { useWorkspaceLayout } from './useWorkspaceLayout';
+import WorkspaceDock from './WorkspaceDock';
+import ChatTile from './tiles/ChatTile';
+import FilesTile from './tiles/FilesTile';
+import CodeEditorTile from './tiles/CodeEditorTile';
+import DesktopTile from './tiles/DesktopTile';
+
+interface Props {
+  projectId: string;
+  panels: TileId[];
+  badges?: Partial<Record<TileId, string>>;
+}
+
+const WorkspaceDeck: React.FC<Props> = ({ projectId, panels, badges }) => {
+  const [active, setActive] = useState<TileId>('chat');
+  const [kbVisible, setKbVisible] = useState(false);
+  const { loaded, getFocus, saveFocus } = useWorkspaceLayout(projectId);
+
+  // Aktives Panel pro Projekt wiederherstellen.
+  useEffect(() => {
+    if (!loaded) return;
+    const stored = getFocus();
+    if (stored && panels.includes(stored)) setActive(stored);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [projectId, loaded]);
+
+  // Falls das aktive Panel wegfaellt → erstes nehmen.
+  useEffect(() => {
+    if (!panels.includes(active)) setActive(panels[0] || 'chat');
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [panels.join(',')]);
+
+  useEffect(() => {
+    if (loaded) saveFocus(active);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [active, loaded]);
+
+  useEffect(() => {
+    const s1 = Keyboard.addListener('keyboardDidShow', () => setKbVisible(true));
+    const s2 = Keyboard.addListener('keyboardDidHide', () => setKbVisible(false));
+    return () => { s1.remove(); s2.remove(); };
+  }, []);
+
+  const render = (id: TileId) => {
+    switch (id) {
+      case 'chat': return <ChatTile />;
+      case 'files': return <FilesTile projectId={projectId} focused={active === 'files'} />;
+      case 'editor': return <CodeEditorTile projectId={projectId} />;
+      case 'vnc': return <DesktopTile projectId={projectId} focused={active === 'vnc'} />;
+      default: return null;
+    }
+  };
+
+  return (
+    <View style={styles.root}>
+      <View style={styles.stack}>
+        {panels.map((id) => (
+          <View
+            key={id}
+            style={[StyleSheet.absoluteFill, { display: active === id ? 'flex' : 'none' }]}
+          >
+            {render(id)}
+          </View>
+        ))}
+      </View>
+      {!kbVisible && (
+        <WorkspaceDock panels={panels} active={active} badges={badges} onSelect={setActive} />
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  root: { flex: 1, backgroundColor: '#0D0D1A' },
+  stack: { flex: 1, position: 'relative' },
+});
+
+export default WorkspaceDeck;

android/src/workspace/WorkspaceDock.tsx

@@ -0,0 +1,108 @@
+/**
+ * WorkspaceDock — die Taskleiste unten (Daumenzone). Ein Tap wechselt sofort
+ * das Panel; ein animierter Indikator gleitet unter das aktive Icon. Kleine
+ * Aktivitaets-Punkte (Badges) zeigen z.B. „Desktop verbunden" / „Code da".
+ *
+ * Das ist der Kern des Workbench-Gefuehls: Desktop-Umfang, aber Handy-schnell
+ * per Daumen erreichbar — statt einer Zoom-Landkarte.
+ */
+
+import React, { useState } from 'react';
+import { LayoutChangeEvent, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import Animated, { useAnimatedStyle, withTiming } from 'react-native-reanimated';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { TileId, TILE_META } from './layout';
+
+interface Props {
+  panels: TileId[];
+  active: TileId;
+  badges?: Partial<Record<TileId, string>>; // TileId → Punkt-Farbe (undefined = kein Punkt)
+  onSelect: (id: TileId) => void;
+}
+
+const WorkspaceDock: React.FC<Props> = ({ panels, active, badges, onSelect }) => {
+  const insets = useSafeAreaInsets();
+  const [rowW, setRowW] = useState(0);
+  const n = Math.max(1, panels.length);
+  const idx = Math.max(0, panels.indexOf(active));
+  const slot = rowW / n;
+
+  const onLayout = (e: LayoutChangeEvent) => setRowW(e.nativeEvent.layout.width);
+
+  const indicatorStyle = useAnimatedStyle(() => ({
+    width: slot,
+    transform: [{ translateX: withTiming(slot * idx, { duration: 200 }) }],
+  }));
+
+  return (
+    <View style={[styles.dock, { paddingBottom: Math.max(insets.bottom, 6) }]}>
+      <View style={styles.row} onLayout={onLayout}>
+        {rowW > 0 && <Animated.View style={[styles.indicator, indicatorStyle]} pointerEvents="none" />}
+        {panels.map((id) => {
+          const meta = TILE_META[id];
+          const isActive = id === active;
+          const badge = badges?.[id];
+          return (
+            <TouchableOpacity
+              key={id}
+              style={styles.item}
+              onPress={() => onSelect(id)}
+              activeOpacity={0.7}
+            >
+              <View>
+                <Text style={[styles.icon, isActive && styles.iconActive]}>{meta.icon}</Text>
+                {!!badge && <View style={[styles.badge, { backgroundColor: badge }]} />}
+              </View>
+              <Text style={[styles.label, isActive && styles.labelActive]} numberOfLines={1}>
+                {meta.title}
+              </Text>
+            </TouchableOpacity>
+          );
+        })}
+      </View>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  dock: {
+    backgroundColor: '#0B0B18',
+    borderTopWidth: 1,
+    borderTopColor: '#1E1E2E',
+  },
+  row: {
+    flexDirection: 'row',
+    height: 58,
+    position: 'relative',
+  },
+  indicator: {
+    position: 'absolute',
+    top: 0,
+    height: 3,
+    backgroundColor: '#0096FF',
+    borderBottomLeftRadius: 3,
+    borderBottomRightRadius: 3,
+  },
+  item: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: 2,
+  },
+  icon: { fontSize: 22, opacity: 0.55 },
+  iconActive: { opacity: 1 },
+  label: { color: '#6A6A85', fontSize: 10, fontWeight: '600' },
+  labelActive: { color: '#0096FF' },
+  badge: {
+    position: 'absolute',
+    top: -2,
+    right: -6,
+    width: 8,
+    height: 8,
+    borderRadius: 4,
+    borderWidth: 1,
+    borderColor: '#0B0B18',
+  },
+});
+
+export default WorkspaceDock;

android/src/workspace/WorkspaceScreen.tsx

@@ -0,0 +1,102 @@
+/**
+ * WorkspaceScreen — Screen-Wrapper fuer die Workbench.
+ *
+ * Kompakt-Modus → klassischer Vollbild-Chat (wie vor dem Umbau).
+ * Cockpit-Modus  → Workbench mit Taskleisten-Dock: Chat · Code · Desktop.
+ *
+ * Aktivitaets-Badges am Dock: Editor blau, wenn schon Code-Dateien da sind;
+ * Desktop gruen NUR, wenn im aktiven Projekt eine VM laeuft.
+ */
+
+import React, { useEffect, useMemo, useState } from 'react';
+import { View } from 'react-native';
+import projectFocus, { FocusSnapshot } from '../services/projectFocus';
+import codeFile from '../services/codeFile';
+import brainApi from '../services/brainApi';
+import viewMode, { ViewModeValue } from '../services/viewMode';
+import ChatScreen from '../screens/ChatScreen';
+import { TileId } from './layout';
+import WorkspaceDeck from './WorkspaceDeck';
+import ariaView, { AriaView } from '../services/ariaView';
+import AriaViewCanvas from './AriaViewCanvas';
+
+const COCKPIT_PANELS: TileId[] = ['chat', 'files', 'editor', 'vnc'];
+
+const WorkspaceScreen: React.FC = () => {
+  const [mode, setMode] = useState<ViewModeValue>(viewMode.get());
+  const [focus, setFocus] = useState<FocusSnapshot>(projectFocus.get());
+  const [hasCode, setHasCode] = useState(false);
+  const [hasDesktop, setHasDesktop] = useState(false);
+  const [view, setView] = useState<AriaView | undefined>(undefined);
+
+  useEffect(() => viewMode.subscribe(setMode), []);
+  useEffect(() => projectFocus.subscribe(setFocus), []);
+
+  const pid = focus.focusedProjectId;
+
+  // aria_view: ARIAs komponierte Ansicht fuers fokussierte Projekt spiegeln.
+  useEffect(() => {
+    setView(ariaView.getView(pid));
+    return ariaView.subscribe((v) => {
+      if ((v.projectId || '') === (pid || '')) setView(v);
+    });
+  }, [pid]);
+
+  // Code-Signal: hat der Spiegel schon Dateien fuer dieses Projekt?
+  useEffect(() => {
+    setHasCode(codeFile.getFiles(pid).length > 0);
+    return codeFile.subscribe((u) => {
+      if ((u.projectId || '') === (pid || '')) setHasCode(true);
+    });
+  }, [pid]);
+
+  // Desktop-Signal: gruener Punkt NUR, wenn im AKTIVEN Projekt wirklich eine VM
+  // laeuft (nicht generell irgendwo). Quelle ist die projektbezogene VM-Liste;
+  // leichtes Nachfassen, damit Start/Stop sich zeitnah zeigt.
+  useEffect(() => {
+    if (!pid) { setHasDesktop(false); return; }
+    let alive = true;
+    const check = () => {
+      brainApi.listProjectVms(pid)
+        .then(r => { if (alive) setHasDesktop((r.vms || []).some(v => v.running)); })
+        .catch(() => { if (alive) setHasDesktop(false); });
+    };
+    check();
+    const t = setInterval(check, 6000);
+    return () => { alive = false; clearInterval(t); };
+  }, [pid]);
+
+  const badges = useMemo(() => ({
+    editor: hasCode ? '#0096FF' : undefined,
+    vnc: hasDesktop ? '#34C759' : undefined,
+  } as Partial<Record<TileId, string>>), [hasCode, hasDesktop]);
+
+  // Kompakt-Ansicht: klassischer Vollbild-Chat; Cockpit: Workbench mit Dock.
+  const content =
+    mode === 'compact' ? (
+      <ChatScreen />
+    ) : (
+      <WorkspaceDeck projectId={pid} panels={COCKPIT_PANELS} badges={badges} />
+    );
+
+  // Generative Flaeche als Overlay, sobald ARIA fuer dieses Projekt eine Ansicht
+  // komponiert hat (present_view → aria_view). Chat/Cockpit bleiben darunter.
+  const showView = !!view && (view.projectId || '') === (pid || '');
+
+  return (
+    <View style={{ flex: 1 }}>
+      {content}
+      {showView && view && (
+        <AriaViewCanvas
+          view={view.view}
+          onClose={() => {
+            ariaView.clear(pid);
+            setView(undefined);
+          }}
+        />
+      )}
+    </View>
+  );
+};
+
+export default WorkspaceScreen;

android/src/workspace/assets/editorHtml.ts

@@ -0,0 +1,167 @@
+/**
+ * editorHtml — selbstenthaltener Live-Code-Editor fuer die WebView (offline,
+ * kein CDN/Bundler). Eine transparente <textarea> ueber einer <pre>-Highlight-
+ * Ebene: man sieht Syntax-Highlighting UND kann tippen. Bewusst leichtgewichtig
+ * (Regex-Highlighter fuer C-artige/JS/Python/Shell), damit es ohne Build-Schritt
+ * inline passt.
+ *
+ * Bridge-Protokoll:
+ *   RN -> WebView  window.ariaBridge.onMessage(jsonString):
+ *     {cmd:'setContent', content, language, version}
+ *     {cmd:'applyPatch', from, to, insert, version}
+ *     {cmd:'setLanguage', language}
+ *     {cmd:'setReadOnly', value}
+ *   WebView -> RN  window.ReactNativeWebView.postMessage(jsonString):
+ *     {event:'ready'}
+ *     {event:'onEditFromUser', from, to, insert, fullText, version}
+ */
+
+export const EDITOR_HTML = `<!doctype html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  html, body { height: 100%; background: #0D0D1A; }
+  #wrap { position: relative; height: 100%; width: 100%; }
+  #hl, #ed {
+    position: absolute; top: 0; left: 0; width: 100%; height: 100%;
+    margin: 0; border: 0; padding: 10px 12px;
+    font-family: 'Courier New', monospace; font-size: 13px; line-height: 1.45;
+    white-space: pre; word-wrap: normal; overflow: auto; tab-size: 2;
+  }
+  #hl { color: #C8C8E0; z-index: 1; pointer-events: none; }
+  #ed {
+    z-index: 2; color: transparent; background: transparent; caret-color: #0096FF;
+    resize: none; outline: none;
+    -webkit-text-fill-color: transparent;
+  }
+  #ed::selection { background: rgba(0,150,255,0.3); }
+  .tok-cmt { color: #6A7A6A; font-style: italic; }
+  .tok-str { color: #C6A972; }
+  .tok-num { color: #B58BE0; }
+  .tok-kw  { color: #4F9CE8; font-weight: bold; }
+</style></head><body>
+<div id="wrap">
+  <pre id="hl"></pre>
+  <textarea id="ed" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"></textarea>
+</div>
+<script>
+(function(){
+  var ed = document.getElementById('ed');
+  var hl = document.getElementById('hl');
+  var lang = 'text';
+  var version = 0;
+  var lastValue = '';
+  var applyingProgrammatic = false;
+
+  var KW = {
+    common: ['if','else','for','while','do','return','break','continue','switch','case','default','function','var','let','const','class','new','this','import','from','export','try','catch','finally','throw','typeof','instanceof','void','delete','in','of','yield','async','await','def','elif','end','then','fi','esac','local','echo','extends','implements','interface','public','private','protected','static','struct','enum','include','define','null','true','false','undefined','None','True','False','print','with','as','pass','lambda','not','and','or','is']
+  };
+
+  function esc(s){ return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
+
+  function highlight(code){
+    // Token-Scan: Kommentare, Strings, Zahlen, Keywords. Bewusst simpel.
+    var out = '';
+    var i = 0, n = code.length;
+    var kwRe = /[A-Za-z_][A-Za-z0-9_]*/;
+    while(i < n){
+      var c = code[i];
+      var two = code.substr(i,2);
+      // Zeilenkommentar // oder #
+      if(two === '//' || (c === '#')){
+        var j = code.indexOf('\\n', i); if(j<0) j=n;
+        out += '<span class="tok-cmt">'+esc(code.slice(i,j))+'</span>'; i=j; continue;
+      }
+      // Blockkommentar
+      if(two === '/*'){
+        var k = code.indexOf('*/', i+2); k = (k<0)? n : k+2;
+        out += '<span class="tok-cmt">'+esc(code.slice(i,k))+'</span>'; i=k; continue;
+      }
+      // Strings
+      if(c === '"' || c === "'" || c === '\`'){
+        var q=c, m=i+1;
+        while(m<n){ if(code[m]==='\\\\'){m+=2;continue;} if(code[m]===q){m++;break;} m++; }
+        out += '<span class="tok-str">'+esc(code.slice(i,m))+'</span>'; i=m; continue;
+      }
+      // Zahl
+      if(c>='0' && c<='9'){
+        var p=i+1; while(p<n && /[0-9a-fA-F.xX_]/.test(code[p])) p++;
+        out += '<span class="tok-num">'+esc(code.slice(i,p))+'</span>'; i=p; continue;
+      }
+      // Wort / Keyword
+      if(/[A-Za-z_]/.test(c)){
+        var rest = code.slice(i);
+        var mm = rest.match(kwRe);
+        var w = mm[0];
+        if(KW.common.indexOf(w) >= 0){ out += '<span class="tok-kw">'+esc(w)+'</span>'; }
+        else { out += esc(w); }
+        i += w.length; continue;
+      }
+      out += esc(c); i++;
+    }
+    return out;
+  }
+
+  function render(){
+    hl.innerHTML = highlight(ed.value) + '\\n';
+    hl.scrollTop = ed.scrollTop; hl.scrollLeft = ed.scrollLeft;
+  }
+
+  function post(obj){ if(window.ReactNativeWebView) window.ReactNativeWebView.postMessage(JSON.stringify(obj)); }
+
+  // Minimalen Diff (gemeinsamer Prefix/Suffix) zwischen alt und neu.
+  function diff(a, b){
+    var s = 0; var maxS = Math.min(a.length, b.length);
+    while(s < maxS && a[s] === b[s]) s++;
+    var e = 0;
+    while(e < (maxS - s) && a[a.length-1-e] === b[b.length-1-e]) e++;
+    return { from: s, to: a.length - e, insert: b.slice(s, b.length - e) };
+  }
+
+  var editTimer = null;
+  ed.addEventListener('input', function(){
+    render();
+    if(applyingProgrammatic) return;
+    if(editTimer) clearTimeout(editTimer);
+    editTimer = setTimeout(function(){
+      var nv = ed.value;
+      var d = diff(lastValue, nv);
+      lastValue = nv; version++;
+      post({ event:'onEditFromUser', from:d.from, to:d.to, insert:d.insert, fullText:nv, version:version });
+    }, 160);
+  });
+  ed.addEventListener('scroll', function(){ hl.scrollTop=ed.scrollTop; hl.scrollLeft=ed.scrollLeft; });
+
+  window.ariaBridge = {
+    onMessage: function(json){
+      var m; try { m = JSON.parse(json); } catch(e){ return; }
+      if(m.cmd === 'setContent'){
+        applyingProgrammatic = true;
+        ed.value = m.content || '';
+        lastValue = ed.value;
+        if(typeof m.version === 'number') version = m.version;
+        if(m.language) lang = m.language;
+        render();
+        applyingProgrammatic = false;
+      } else if(m.cmd === 'applyPatch'){
+        applyingProgrammatic = true;
+        var v = ed.value;
+        var from = Math.max(0, Math.min(m.from, v.length));
+        var to = Math.max(from, Math.min(m.to, v.length));
+        ed.value = v.slice(0, from) + (m.insert||'') + v.slice(to);
+        lastValue = ed.value;
+        if(typeof m.version === 'number') version = m.version;
+        render();
+        applyingProgrammatic = false;
+      } else if(m.cmd === 'setLanguage'){
+        lang = m.language || 'text'; render();
+      } else if(m.cmd === 'setReadOnly'){
+        ed.readOnly = !!m.value;
+      }
+    }
+  };
+
+  render();
+  post({ event:'ready' });
+})();
+</script></body></html>`;

android/src/workspace/assets/novncHtml.ts

@@ -0,0 +1,134 @@
+/**
+ * novncHtml — noVNC-Client fuer die WebView, dessen WebSocket durch den
+ * RVS-Tunnel gebrueckt wird.
+ *
+ * Trick: window.WebSocket wird VOR dem Laden von noVNC durch einen Shim
+ * ersetzt. noVNC (RFB) glaubt, ein echtes WebSocket zu benutzen; tatsaechlich
+ * gehen die RFB-Bytes als Base64 per postMessage an RN → RVS → Bridge → QEMU
+ * (und zurueck). Da RFB "server-speaks-first" ist, ist die Reihenfolge robust.
+ *
+ * noVNC wird vom CDN geladen (das Telefon hat Internet, da es ohnehin am RVS
+ * haengt). Voll-offline-Bundling waere ein spaeterer Schritt.
+ *
+ * Protokoll:
+ *   RN -> WebView  window.ariaVnc.onData(b64)   RFB-Bytes vom Server
+ *   WebView -> RN  {event:'ready'}              RFB initialisiert → Tunnel oeffnen
+ *                  {event:'vnc_send', b64}      RFB-Bytes an den Server
+ *                  {event:'vnc_close'}          RFB hat geschlossen
+ *                  {event:'vnc_state', state}   connected|disconnected
+ */
+
+export const NOVNC_HTML = `<!doctype html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+<style>
+  * { margin:0; padding:0; }
+  html, body { height:100%; background:#000; overflow:hidden; }
+  #screen { width:100%; height:100%; }
+  #msg { position:absolute; top:8px; left:0; right:0; text-align:center;
+         color:#9090B0; font-family:sans-serif; font-size:12px; pointer-events:none; }
+</style></head><body>
+<div id="screen"></div>
+<div id="msg">Verbinde mit Desktop …</div>
+<script>
+(function(){
+  function post(o){ if(window.ReactNativeWebView) window.ReactNativeWebView.postMessage(JSON.stringify(o)); }
+  function b64FromBytes(bytes){
+    var CHUNK=0x8000, parts=[];
+    for(var i=0;i<bytes.length;i+=CHUNK){ parts.push(String.fromCharCode.apply(null, bytes.subarray(i,i+CHUNK))); }
+    return btoa(parts.join(''));
+  }
+  function bytesFromB64(b64){
+    var s=atob(b64), a=new Uint8Array(s.length);
+    for(var i=0;i<s.length;i++) a[i]=s.charCodeAt(i);
+    return a;
+  }
+
+  // --- WebSocket-Shim ---
+  function BridgeSocket(url, protocols){
+    this.url=url; this.protocol=''; this.readyState=0; this.binaryType='arraybuffer';
+    this.onopen=null; this.onclose=null; this.onerror=null; this.onmessage=null;
+    var self=this; window.__vncSocket=self;
+    setTimeout(function(){ self.readyState=1; if(self.onopen) self.onopen({type:'open'}); }, 0);
+  }
+  BridgeSocket.CONNECTING=0; BridgeSocket.OPEN=1; BridgeSocket.CLOSING=2; BridgeSocket.CLOSED=3;
+  BridgeSocket.prototype.send=function(data){
+    var bytes;
+    if(data instanceof ArrayBuffer) bytes=new Uint8Array(data);
+    else if(ArrayBuffer.isView(data)) bytes=new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    else bytes=new Uint8Array(0);
+    post({event:'vnc_send', b64:b64FromBytes(bytes)});
+  };
+  BridgeSocket.prototype.close=function(){
+    if(this.readyState===3) return;
+    this.readyState=3; if(this.onclose) this.onclose({type:'close'}); post({event:'vnc_close'});
+  };
+  BridgeSocket.prototype.addEventListener=function(t,fn){ this['on'+t]=fn; };
+  BridgeSocket.prototype.removeEventListener=function(t){ this['on'+t]=null; };
+  window.WebSocket = BridgeSocket;
+
+  // Eingehende Server-Bytes → in den Shim einspeisen.
+  window.ariaVnc = {
+    onData:function(b64){
+      var sock=window.__vncSocket;
+      if(!sock || !sock.onmessage) return;
+      sock.onmessage({ type:'message', data: bytesFromB64(b64).buffer });
+    }
+  };
+
+  var msg=document.getElementById('msg');
+
+  // Tastatur laeuft NICHT mehr ueber ein verstecktes WebView-Feld (Android
+  // oeffnet die Software-Tastatur dafuer unzuverlaessig). Stattdessen haelt die
+  // App ein echtes RN-<TextInput> und ruft window.ariaVncKey.* per
+  // injectJavaScript auf → wird unten (nach RFB-Init) definiert.
+  //   cp<0x100  → Keysym == Codepoint (Latin-1)
+  //   sonst     → X11-Unicode-Keysym 0x01000000+cp
+  function cpToKeysym(cp){ return cp < 0x100 ? cp : 0x01000000 + cp; }
+
+  import('https://cdn.jsdelivr.net/npm/@novnc/novnc@1.4.0/core/rfb.js').then(function(mod){
+    var RFB = mod.default;
+    var rfb = new RFB(document.getElementById('screen'), 'ws://aria-vnc/', {});
+    var fit=true;
+    rfb.scaleViewport = true;
+    rfb.clipViewport = false;
+    rfb.addEventListener('connect', function(){ msg.style.display='none'; post({event:'vnc_state', state:'connected'}); });
+    rfb.addEventListener('disconnect', function(e){
+      msg.style.display='block'; msg.textContent='Desktop getrennt';
+      post({event:'vnc_state', state:'disconnected'});
+    });
+    window.__rfb = rfb;
+
+    // Down+Up einer Taste an die VM schicken.
+    function tap(keysym, code){ try{ rfb.sendKey(keysym, code||null, true); rfb.sendKey(keysym, code||null, false); }catch(_){} }
+
+    // Empfaenger-API: die App (RN-<TextInput> + Sondertasten-Leiste) ruft das
+    // per injectJavaScript.
+    //   char(cp)        druckbares Zeichen (Codepoint)
+    //   keysym(ks)      Sondertaste als fertiges X11-Keysym (Enter/Esc/F1/…)
+    //   combo(mods,ks)  Modifier(-Keysyms) halten → Taste → wieder loslassen
+    //                   (Strg+C, Strg+Alt+Entf, …). mods = Array von Keysyms.
+    window.ariaVncKey = {
+      char:   function(cp){ tap(cpToKeysym(cp)); },
+      keysym: function(ks){ tap(ks); },
+      combo:  function(mods, ks){
+        try{
+          for(var i=0;i<mods.length;i++) rfb.sendKey(mods[i], null, true);
+          rfb.sendKey(ks, null, true); rfb.sendKey(ks, null, false);
+          for(var j=mods.length-1;j>=0;j--) rfb.sendKey(mods[j], null, false);
+        }catch(_){}
+      }
+    };
+
+    // Steuerungs-API fuer die App (per injectJavaScript).
+    window.ariaVncCtl = {
+      cad: function(){ try{ rfb.sendCtrlAltDel(); }catch(_){} },
+      toggleFit: function(){ fit=!fit; rfb.scaleViewport=fit; rfb.clipViewport=!fit; post({event:'vnc_fit', fit:fit}); }
+    };
+
+    post({event:'ready'});
+  }).catch(function(err){
+    msg.textContent='noVNC konnte nicht geladen werden (Internet?)';
+    post({event:'vnc_state', state:'error', error:String(err)});
+  });
+})();
+</script></body></html>`;

android/src/workspace/layout.ts

@@ -0,0 +1,15 @@
+/**
+ * layout — Panel-Definitionen der Workbench (Metadaten fuer das Dock).
+ */
+
+export type TileId = 'chat' | 'files' | 'editor' | 'vnc' | 'preview';
+
+export interface TileDef { id: TileId; title: string; icon: string }
+
+export const TILE_META: Record<TileId, TileDef> = {
+  chat: { id: 'chat', title: 'Chat', icon: '💬' },
+  files: { id: 'files', title: 'Dateien', icon: '📁' },
+  editor: { id: 'editor', title: 'Code', icon: '📝' },
+  vnc: { id: 'vnc', title: 'Desktop', icon: '🖥️' },
+  preview: { id: 'preview', title: 'Vorschau', icon: '🖼️' },
+};

android/src/workspace/tiles/ChatTile.tsx

@@ -0,0 +1,15 @@
+/**
+ * ChatTile — hostet die bestehende ChatScreen unveraendert als Workspace-Kachel.
+ *
+ * ChatScreen bleibt genau EINE Instanz (der Workspace-Tab ersetzt den alten
+ * Chat-Tab) und wird nie beim Fokuswechsel remountet — sie liegt in der
+ * Identity-Content-Ebene und wird nur per display ein-/ausgeblendet. So
+ * behaelt sie RVS-Abos, Audio, Queue-State und Keyboard-Verhalten wie bisher.
+ */
+
+import React from 'react';
+import ChatScreen from '../../screens/ChatScreen';
+
+const ChatTile: React.FC = () => <ChatScreen />;
+
+export default React.memo(ChatTile);

android/src/workspace/tiles/CodeEditorTile.tsx

@@ -0,0 +1,168 @@
+/**
+ * CodeEditorTile — Live-Code-Editor (WebView, editorHtml.ts).
+ *
+ * Zeigt die Dateien eines Code-Projekts aus /shared/projects/<id>/:
+ *  - beim Oeffnen werden die BEREITS vorhandenen Dateien vom Brain geladen
+ *    (listProjectFiles/readProjectFile) — sonst waere der Editor leer, obwohl
+ *    ARIA schon Dateien geschrieben hat.
+ *  - live schreibt ARIA weiter → code_file-Stream aktualisiert die offene Datei.
+ * Stefan kann selbst editieren → code_file_edit zurueck an die Bridge.
+ */
+
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import { WebView, WebViewMessageEvent } from 'react-native-webview';
+import codeFile from '../../services/codeFile';
+import brainApi from '../../services/brainApi';
+import { EDITOR_HTML } from '../assets/editorHtml';
+
+interface Props {
+  projectId: string;
+}
+
+function guessLang(path: string): string {
+  const ext = (path.split('.').pop() || '').toLowerCase();
+  const map: Record<string, string> = {
+    js: 'javascript', ts: 'typescript', tsx: 'typescript', py: 'python',
+    c: 'c', h: 'c', cpp: 'cpp', asm: 'asm', s: 'asm', sh: 'shell', bash: 'shell',
+    html: 'html', css: 'css', json: 'json', yaml: 'yaml', yml: 'yaml', md: 'markdown',
+    go: 'go', rs: 'rust', java: 'java', kt: 'kotlin', txt: 'text',
+  };
+  return map[ext] || 'text';
+}
+
+const CodeEditorTile: React.FC<Props> = ({ projectId }) => {
+  const webRef = useRef<WebView>(null);
+  // Pfade aus dem Brain (vorhandene Dateien) — mit Live-Dateien gemergt.
+  const [serverPaths, setServerPaths] = useState<string[]>([]);
+  const [currentPath, setCurrentPath] = useState<string | null>(null);
+  const [loadErr, setLoadErr] = useState<string>('');
+
+  const readyRef = useRef(false);
+  const currentPathRef = useRef<string | null>(currentPath);
+  currentPathRef.current = currentPath;
+
+  // Vereinigte, sortierte Dateiliste (Live-Spiegel + Server-Dateien).
+  const files = useMemo(() => {
+    const set = new Set<string>(serverPaths);
+    for (const f of codeFile.getFiles(projectId)) set.add(f.path);
+    return Array.from(set).sort((a, b) => a.localeCompare(b));
+  }, [serverPaths, projectId]);
+
+  const sendToWeb = useCallback((payload: Record<string, unknown>) => {
+    const js = `window.ariaBridge && window.ariaBridge.onMessage(${JSON.stringify(JSON.stringify(payload))}); true;`;
+    webRef.current?.injectJavaScript(js);
+  }, []);
+
+  const loadFileIntoEditor = useCallback(async (path: string | null) => {
+    if (!path) { sendToWeb({ cmd: 'setContent', content: '', language: 'text', version: 0 }); return; }
+    // Live-Version bevorzugen (falls ARIA gerade schreibt), sonst vom Brain holen.
+    const live = codeFile.getFile(projectId, path);
+    if (live) {
+      sendToWeb({ cmd: 'setContent', content: live.content, language: live.language, version: live.version });
+      return;
+    }
+    try {
+      const res = await brainApi.readProjectFile(projectId, path);
+      sendToWeb({ cmd: 'setContent', content: res.content ?? '', language: guessLang(path), version: 0 });
+    } catch (e: any) {
+      sendToWeb({ cmd: 'setContent', content: `// Konnte ${path} nicht laden: ${e?.message || e}`, language: 'text', version: 0 });
+    }
+  }, [projectId, sendToWeb]);
+
+  // Projektwechsel: vorhandene Dateien vom Brain laden.
+  useEffect(() => {
+    let cancelled = false;
+    setLoadErr('');
+    brainApi.listProjectFiles(projectId)
+      .then(res => {
+        if (cancelled) return;
+        const paths = (res.files || []).map(f => f.path);
+        setServerPaths(paths);
+        setCurrentPath(prev => (prev && paths.includes(prev)) ? prev : (paths[0] ?? codeFile.getFiles(projectId)[0]?.path ?? null));
+      })
+      .catch(e => { if (!cancelled) setLoadErr(String(e?.message || e)); });
+    return () => { cancelled = true; };
+  }, [projectId]);
+
+  // Live-Updates aus dem Spiegel.
+  useEffect(() => {
+    return codeFile.subscribe((u) => {
+      if ((u.projectId || '') !== (projectId || '')) return;
+      setServerPaths(prev => prev.includes(u.path) ? prev : [...prev, u.path]);
+      if (!currentPathRef.current) { setCurrentPath(u.path); return; }
+      if (u.path !== currentPathRef.current || !readyRef.current) return;
+      if (u.patch) {
+        sendToWeb({ cmd: 'applyPatch', from: u.patch.from, to: u.patch.to, insert: u.patch.insert, version: u.version });
+      } else {
+        sendToWeb({ cmd: 'setContent', content: u.content ?? '', language: u.language, version: u.version });
+      }
+    });
+  }, [projectId, sendToWeb]);
+
+  // Datei-Auswahl gewechselt → laden (falls WebView bereit).
+  useEffect(() => {
+    if (readyRef.current) loadFileIntoEditor(currentPath);
+  }, [currentPath, loadFileIntoEditor]);
+
+  const onMessage = useCallback((e: WebViewMessageEvent) => {
+    let m: any;
+    try { m = JSON.parse(e.nativeEvent.data); } catch { return; }
+    if (m.event === 'ready') {
+      readyRef.current = true;
+      loadFileIntoEditor(currentPathRef.current);
+    } else if (m.event === 'onEditFromUser') {
+      const path = currentPathRef.current;
+      if (!path) return;
+      codeFile.sendEdit(projectId, path, { from: m.from, to: m.to, insert: m.insert }, m.fullText, m.version);
+    }
+  }, [projectId, loadFileIntoEditor]);
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.tabsRow}>
+        {files.length === 0 ? (
+          <Text style={styles.noFiles}>{loadErr ? `Fehler: ${loadErr}` : 'Noch keine Datei in diesem Projekt'}</Text>
+        ) : (
+          <ScrollView horizontal showsHorizontalScrollIndicator={false} contentContainerStyle={styles.tabs}>
+            {files.map((path) => {
+              const active = path === currentPath;
+              const name = path.split('/').pop() || path;
+              return (
+                <TouchableOpacity key={path} onPress={() => setCurrentPath(path)} style={[styles.tab, active && styles.tabActive]}>
+                  <Text style={[styles.tabText, active && styles.tabTextActive]} numberOfLines={1}>{name}</Text>
+                </TouchableOpacity>
+              );
+            })}
+          </ScrollView>
+        )}
+      </View>
+      <WebView
+        ref={webRef}
+        style={styles.web}
+        originWhitelist={['*']}
+        source={{ html: EDITOR_HTML, baseUrl: '' }}
+        onMessage={onMessage}
+        javaScriptEnabled
+        domStorageEnabled
+        keyboardDisplayRequiresUserAction={false}
+        androidLayerType="hardware"
+        setBuiltInZoomControls={false}
+      />
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#0D0D1A' },
+  tabsRow: { height: 40, backgroundColor: '#12122A', borderBottomColor: '#1E1E2E', borderBottomWidth: 1, justifyContent: 'center' },
+  tabs: { alignItems: 'center', paddingHorizontal: 6 },
+  noFiles: { color: '#9090B0', fontSize: 13, paddingHorizontal: 12 },
+  tab: { paddingHorizontal: 12, paddingVertical: 6, marginHorizontal: 3, borderRadius: 12, backgroundColor: '#0D0D1A', maxWidth: 180 },
+  tabActive: { backgroundColor: '#0096FF' },
+  tabText: { color: '#9090B0', fontSize: 12, fontWeight: '600' },
+  tabTextActive: { color: '#FFFFFF' },
+  web: { flex: 1, backgroundColor: '#0D0D1A' },
+});
+
+export default CodeEditorTile;

android/src/workspace/tiles/DesktopTile.tsx

@@ -0,0 +1,192 @@
+/**
+ * DesktopTile — das Desktop-Panel eines Code-Projekts.
+ *
+ * Zeigt die (pro Projekt gefuehrte) QEMU-VM-Liste: leer, bis ARIA per
+ * vm_register eine VM eintraegt. Pro VM: Start / Stop / Verbinden. „Verbinden"
+ * oeffnet die noVNC-Ansicht (VncTile) fuer den VNC-Port dieser VM.
+ */
+
+import React, { useCallback, useEffect, useState } from 'react';
+import { ActivityIndicator, Image, Modal, ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import brainApi, { ProjectVm } from '../../services/brainApi';
+import VncTile from './VncTile';
+
+interface Props {
+  projectId: string;
+  focused: boolean;
+}
+
+const DesktopTile: React.FC<Props> = ({ projectId, focused }) => {
+  const [vms, setVms] = useState<ProjectVm[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [err, setErr] = useState('');
+  const [busy, setBusy] = useState('');           // VM-Name, der gerade bootet/stoppt
+  const [connected, setConnected] = useState<ProjectVm | null>(null);
+  const [shotBusy, setShotBusy] = useState('');
+  const [shot, setShot] = useState<{ name: string; b64: string } | null>(null);
+
+  const load = useCallback(() => {
+    if (!projectId) { setVms([]); setErr(''); setLoading(false); return; }
+    setLoading(true); setErr('');
+    brainApi.listProjectVms(projectId)
+      .then(r => setVms(r.vms || []))
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setLoading(false));
+  }, [projectId]);
+
+  useEffect(() => {
+    if (focused && !connected) load();
+  }, [focused, projectId, connected, load]);
+
+  const boot = useCallback((vm: ProjectVm) => {
+    setBusy(vm.name);
+    brainApi.bootProjectVm(projectId, vm.name)
+      .then(() => load())
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setBusy(''));
+  }, [projectId, load]);
+
+  const stop = useCallback((vm: ProjectVm) => {
+    setBusy(vm.name);
+    brainApi.stopProjectVm(projectId, vm.name)
+      .then(() => load())
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setBusy(''));
+  }, [projectId, load]);
+
+  const screenshot = useCallback((vm: ProjectVm) => {
+    setShotBusy(vm.name); setErr('');
+    brainApi.screenshotProjectVm(projectId, vm.name)
+      .then(r => setShot({ name: vm.name, b64: r.base64 }))
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setShotBusy(''));
+  }, [projectId]);
+
+  if (!focused) {
+    return (
+      <View style={styles.placeholder}>
+        <Text style={styles.icon}>🖥️</Text>
+        <Text style={styles.text}>Desktop</Text>
+        <Text style={styles.sub}>Panel öffnen für VM-Liste</Text>
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.bar}>
+        <Text style={styles.barTitle}>Virtuelle Maschinen</Text>
+        <TouchableOpacity onPress={load} style={styles.barBtn}><Text style={styles.barBtnText}>↻</Text></TouchableOpacity>
+      </View>
+      <ScrollView contentContainerStyle={{ padding: 12 }}>
+        {loading && vms.length === 0 ? (
+          <ActivityIndicator color="#0096FF" style={{ marginTop: 20 }} />
+        ) : err ? (
+          <Text style={styles.err}>{err}</Text>
+        ) : !projectId ? (
+          <Text style={styles.empty}>Kein aktives Projekt — wechsle in ein Projekt für dessen VMs.</Text>
+        ) : vms.length === 0 ? (
+          <Text style={styles.empty}>
+            Noch keine VM in diesem Projekt.{'\n'}
+            Sag ARIA z.B. „bau eine QEMU-VM zum Testen" — sie registriert sie hier,
+            dann kannst du sie starten und verbinden.
+          </Text>
+        ) : (
+          vms.map(vm => {
+            const isBusy = busy === vm.name;
+            return (
+              <View key={vm.name} style={styles.vmRow}>
+                <View style={{ flex: 1 }}>
+                  <Text style={styles.vmName}>
+                    <Text style={{ color: vm.running ? '#34C759' : '#555570' }}>●</Text> {vm.name}
+                    <Text style={styles.vmMeta}>  {vm.arch} · {vm.running ? 'läuft' : 'gestoppt'}</Text>
+                  </Text>
+                  <Text style={styles.vmCmd} numberOfLines={2}>{vm.boot_cmd || `aria-vm boot ${vm.name} --vnc-display ${vm.vnc_display}`}</Text>
+                </View>
+                <View style={styles.vmBtns}>
+                  {isBusy ? (
+                    <ActivityIndicator color="#0096FF" />
+                  ) : vm.running ? (
+                    <>
+                      <TouchableOpacity onPress={() => screenshot(vm)} style={[styles.vmBtn, { borderColor: '#8888AA' }]} disabled={shotBusy === vm.name}>
+                        {shotBusy === vm.name
+                          ? <ActivityIndicator color="#8888AA" size="small" />
+                          : <Text style={[styles.vmBtnText, { color: '#C8C8E0' }]}>📷</Text>}
+                      </TouchableOpacity>
+                      <TouchableOpacity onPress={() => setConnected(vm)} style={[styles.vmBtn, { borderColor: '#0096FF' }]}>
+                        <Text style={[styles.vmBtnText, { color: '#0096FF' }]}>Verbinden</Text>
+                      </TouchableOpacity>
+                      <TouchableOpacity onPress={() => stop(vm)} style={[styles.vmBtn, { borderColor: '#E55C5C' }]}>
+                        <Text style={[styles.vmBtnText, { color: '#E55C5C' }]}>Stop</Text>
+                      </TouchableOpacity>
+                    </>
+                  ) : (
+                    <TouchableOpacity onPress={() => boot(vm)} style={[styles.vmBtn, { borderColor: '#34C759' }]}>
+                      <Text style={[styles.vmBtnText, { color: '#34C759' }]}>Start</Text>
+                    </TouchableOpacity>
+                  )}
+                </View>
+              </View>
+            );
+          })
+        )}
+      </ScrollView>
+
+      <Modal visible={!!shot} transparent animationType="fade" onRequestClose={() => setShot(null)}>
+        <TouchableOpacity style={styles.shotOverlay} activeOpacity={1} onPress={() => setShot(null)}>
+          <Text style={styles.shotTitle}>{shot?.name} — Screenshot</Text>
+          {shot && (
+            <Image
+              source={{ uri: `data:image/png;base64,${shot.b64}` }}
+              style={styles.shotImg}
+              resizeMode="contain"
+            />
+          )}
+          <Text style={styles.shotHint}>Tippen zum Schließen</Text>
+        </TouchableOpacity>
+      </Modal>
+
+      {/* Vollbild-VNC — randlos ueber das ganze Display (Header + Dock weg). */}
+      {connected && (
+        <Modal visible animationType="slide" onRequestClose={() => setConnected(null)} supportedOrientations={['portrait', 'landscape']}>
+          <View style={styles.fs}>
+            <VncTile projectId={projectId} focused port={connected.vnc_port || (5900 + (connected.vnc_display || 1))} />
+            <TouchableOpacity style={styles.fsBack} onPress={() => setConnected(null)} activeOpacity={0.8}>
+              <Text style={styles.fsBackText}>‹ VMs</Text>
+            </TouchableOpacity>
+          </View>
+        </Modal>
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#0D0D1A' },
+  placeholder: { flex: 1, backgroundColor: '#000', alignItems: 'center', justifyContent: 'center' },
+  icon: { fontSize: 64, marginBottom: 16 },
+  text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
+  sub: { color: '#9090B0', fontSize: 14, marginTop: 8 },
+  bar: { height: 40, flexDirection: 'row', alignItems: 'center', paddingHorizontal: 12, backgroundColor: '#12122A', borderBottomColor: '#1E1E2E', borderBottomWidth: 1 },
+  barTitle: { color: '#E0E0F0', fontSize: 14, fontWeight: '700', flex: 1 },
+  barBtn: { paddingHorizontal: 10, paddingVertical: 4 },
+  barBtnText: { color: '#0096FF', fontSize: 14, fontWeight: '700' },
+  empty: { color: '#8888AA', fontSize: 13, lineHeight: 20, textAlign: 'center', marginTop: 24 },
+  err: { color: '#FF6E6E', fontSize: 13, marginTop: 16 },
+  vmRow: { flexDirection: 'row', alignItems: 'center', backgroundColor: '#12122A', borderRadius: 10, padding: 12, marginBottom: 8 },
+  vmName: { color: '#E0E0F0', fontSize: 15, fontWeight: '700' },
+  vmMeta: { color: '#8888AA', fontSize: 12, fontWeight: '400' },
+  vmCmd: { color: '#6A9BD0', fontSize: 11, fontFamily: 'monospace', marginTop: 4 },
+  vmBtns: { flexDirection: 'row', gap: 6, alignItems: 'center' },
+  vmBtn: { borderWidth: 1, borderRadius: 8, paddingHorizontal: 10, paddingVertical: 6, minWidth: 34, alignItems: 'center' },
+  vmBtnText: { fontSize: 12, fontWeight: '700' },
+  fs: { flex: 1, backgroundColor: '#000000' },
+  fsBack: { position: 'absolute', top: 34, left: 10, backgroundColor: 'rgba(18,18,42,0.9)', borderColor: '#2A2A3E', borderWidth: 1, borderRadius: 10, paddingHorizontal: 12, paddingVertical: 7 },
+  fsBackText: { color: '#0096FF', fontSize: 14, fontWeight: '700' },
+  shotOverlay: { flex: 1, backgroundColor: 'rgba(0,0,0,0.92)', alignItems: 'center', justifyContent: 'center', padding: 12 },
+  shotTitle: { color: '#E0E0F0', fontSize: 14, fontWeight: '700', marginBottom: 10 },
+  shotImg: { width: '100%', height: '78%', backgroundColor: '#000' },
+  shotHint: { color: '#8888AA', fontSize: 12, marginTop: 12 },
+});
+
+export default DesktopTile;

android/src/workspace/tiles/FilesTile.tsx

@@ -0,0 +1,149 @@
+/**
+ * FilesTile — Datei-Browser eines Projekts (/shared/projects/<id>/).
+ *
+ * Listet ALLE Dateien (nicht nur Code): erzeugte Bilder, Logs, Assets … — die
+ * gleichen, die in der Projektliste als 📄 gezaehlt werden. Tippen auf ein Bild
+ * zeigt es; tippen auf eine Textdatei zeigt eine Vorschau.
+ */
+
+import React, { useCallback, useEffect, useState } from 'react';
+import { ActivityIndicator, Image, Modal, ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import brainApi from '../../services/brainApi';
+
+interface Props {
+  projectId: string;
+  focused: boolean;
+}
+
+interface FileEntry { path: string; size: number }
+
+const IMG_EXT = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp'];
+
+function ext(path: string): string { return (path.split('.').pop() || '').toLowerCase(); }
+function isImage(path: string): boolean { return IMG_EXT.includes(ext(path)); }
+function iconFor(path: string): string {
+  const e = ext(path);
+  if (isImage(path)) return '🖼️';
+  if (['md', 'txt', 'readme'].includes(e)) return '📄';
+  if (['asm', 's', 'c', 'h', 'cpp', 'py', 'js', 'ts', 'sh', 'go', 'rs'].includes(e)) return '📝';
+  if (['zip', 'tar', 'gz', 'img', 'iso', 'qcow2'].includes(e)) return '📦';
+  return '📄';
+}
+function humanSize(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+const FilesTile: React.FC<Props> = ({ projectId, focused }) => {
+  const [files, setFiles] = useState<FileEntry[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [err, setErr] = useState('');
+  const [preview, setPreview] = useState<{ path: string; kind: 'image' | 'text'; data: string } | null>(null);
+  const [previewBusy, setPreviewBusy] = useState('');
+
+  const load = useCallback(() => {
+    if (!projectId) { setFiles([]); setErr(''); setLoading(false); return; }
+    setLoading(true); setErr('');
+    brainApi.listProjectFiles(projectId)
+      .then(r => setFiles((r.files || []).slice().sort((a, b) => a.path.localeCompare(b.path))))
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setLoading(false));
+  }, [projectId]);
+
+  useEffect(() => { if (focused) load(); }, [focused, projectId, load]);
+
+  const open = useCallback((f: FileEntry) => {
+    setPreviewBusy(f.path); setErr('');
+    if (isImage(f.path)) {
+      brainApi.readProjectFileBinary(projectId, f.path)
+        .then(r => setPreview({ path: f.path, kind: 'image', data: `data:${r.mime};base64,${r.base64}` }))
+        .catch(e => setErr(String(e?.message || e)))
+        .finally(() => setPreviewBusy(''));
+    } else {
+      brainApi.readProjectFile(projectId, f.path)
+        .then(r => setPreview({ path: f.path, kind: 'text', data: r.content ?? '' }))
+        .catch(e => setErr(String(e?.message || e)))
+        .finally(() => setPreviewBusy(''));
+    }
+  }, [projectId]);
+
+  if (!focused) {
+    return (
+      <View style={styles.placeholder}>
+        <Text style={styles.icon}>📁</Text>
+        <Text style={styles.text}>Dateien</Text>
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.bar}>
+        <Text style={styles.barTitle}>Dateien{files.length ? ` (${files.length})` : ''}</Text>
+        <TouchableOpacity onPress={load} style={styles.barBtn}><Text style={styles.barBtnText}>↻</Text></TouchableOpacity>
+      </View>
+      <ScrollView contentContainerStyle={{ padding: 8 }}>
+        {loading && files.length === 0 ? (
+          <ActivityIndicator color="#0096FF" style={{ marginTop: 20 }} />
+        ) : err ? (
+          <Text style={styles.err}>{err}</Text>
+        ) : files.length === 0 ? (
+          <Text style={styles.empty}>{!projectId ? 'Kein aktives Projekt — wechsle in ein Projekt für dessen Dateien.' : 'Noch keine Dateien in diesem Projekt.'}</Text>
+        ) : (
+          files.map(f => (
+            <TouchableOpacity key={f.path} onPress={() => open(f)} style={styles.row} disabled={previewBusy === f.path}>
+              <Text style={styles.rowIcon}>{iconFor(f.path)}</Text>
+              <Text style={styles.rowName} numberOfLines={1}>{f.path}</Text>
+              {previewBusy === f.path
+                ? <ActivityIndicator color="#8888AA" size="small" />
+                : <Text style={styles.rowSize}>{humanSize(f.size)}</Text>}
+            </TouchableOpacity>
+          ))
+        )}
+      </ScrollView>
+
+      <Modal visible={!!preview} transparent animationType="fade" onRequestClose={() => setPreview(null)}>
+        <View style={styles.pvOverlay}>
+          <View style={styles.pvBar}>
+            <Text style={styles.pvTitle} numberOfLines={1}>{preview?.path}</Text>
+            <TouchableOpacity onPress={() => setPreview(null)}><Text style={styles.pvClose}>✕</Text></TouchableOpacity>
+          </View>
+          {preview?.kind === 'image' ? (
+            <Image source={{ uri: preview.data }} style={styles.pvImg} resizeMode="contain" />
+          ) : (
+            <ScrollView style={styles.pvTextWrap} horizontal>
+              <ScrollView><Text style={styles.pvText}>{preview?.data}</Text></ScrollView>
+            </ScrollView>
+          )}
+        </View>
+      </Modal>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#0D0D1A' },
+  placeholder: { flex: 1, backgroundColor: '#0D0D1A', alignItems: 'center', justifyContent: 'center' },
+  icon: { fontSize: 56, marginBottom: 10 },
+  text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
+  bar: { height: 40, flexDirection: 'row', alignItems: 'center', paddingHorizontal: 12, backgroundColor: '#12122A', borderBottomColor: '#1E1E2E', borderBottomWidth: 1 },
+  barTitle: { color: '#E0E0F0', fontSize: 14, fontWeight: '700', flex: 1 },
+  barBtn: { paddingHorizontal: 10, paddingVertical: 4 },
+  barBtnText: { color: '#0096FF', fontSize: 14, fontWeight: '700' },
+  empty: { color: '#8888AA', fontSize: 13, textAlign: 'center', marginTop: 24 },
+  err: { color: '#FF6E6E', fontSize: 13, marginTop: 16, paddingHorizontal: 8 },
+  row: { flexDirection: 'row', alignItems: 'center', paddingVertical: 10, paddingHorizontal: 8, borderBottomColor: '#161628', borderBottomWidth: 1, gap: 10 },
+  rowIcon: { fontSize: 18 },
+  rowName: { color: '#E0E0F0', fontSize: 13, flex: 1 },
+  rowSize: { color: '#555570', fontSize: 11 },
+  pvOverlay: { flex: 1, backgroundColor: 'rgba(0,0,0,0.94)' },
+  pvBar: { flexDirection: 'row', alignItems: 'center', padding: 12, gap: 10 },
+  pvTitle: { color: '#E0E0F0', fontSize: 13, fontWeight: '700', flex: 1 },
+  pvClose: { color: '#E0E0F0', fontSize: 20, paddingHorizontal: 6 },
+  pvImg: { flex: 1, width: '100%' },
+  pvTextWrap: { flex: 1, padding: 12 },
+  pvText: { color: '#C8C8E0', fontSize: 12, fontFamily: 'monospace' },
+});
+
+export default FilesTile;

android/src/workspace/tiles/VncTile.tsx

@@ -0,0 +1,298 @@
+/**
+ * VncTile — Live-Desktop der QEMU-VM (noVNC in einer WebView, RFB durch RVS).
+ *
+ * Nur aktiv, wenn das Desktop-Panel offen ist (focused): dann WebView mounten,
+ * bei 'ready' den RVS-VNC-Tunnel oeffnen. Zwei Bedien-Leisten machen die VM auf
+ * dem Handy voll bedienbar:
+ *  - ctlBar (oben rechts): Fn-Leiste ein/aus, Software-Tastatur, Fit ↔ 1:1.
+ *  - keyBar (oben, Fn):     echte Steuertasten, die keine Software-Tastatur
+ *    liefert — Esc, Tab, Pfeile, Pos1/Ende/Bild, Einfg/Entf, Enter, F1–F12 und
+ *    Sticky-Modifier Strg/Alt/Shift (fuer Strg+C, Strg+Alt+Entf, …).
+ */
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { Keyboard, NativeSyntheticEvent, ScrollView, StyleSheet, Text, TextInput, TextInputChangeEventData, TextInputKeyPressEventData, TouchableOpacity, View } from 'react-native';
+import { WebView, WebViewMessageEvent } from 'react-native-webview';
+import desktop from '../../services/desktop';
+import { NOVNC_HTML } from '../assets/novncHtml';
+
+interface Props {
+  projectId: string;
+  focused: boolean;
+  port?: number; // VNC-Port der zu verbindenden VM (Default 5901 = Display :1)
+}
+
+// X11-Keysyms fuer Sondertasten, die kein druckbares Zeichen liefern.
+const KEYSYM = { Backspace: 0xff08, Enter: 0xff0d, Tab: 0xff09 };
+const MOD = { ctrl: 0xffe3, alt: 0xffe9, shift: 0xffe1 };
+const cpToKeysym = (cp: number) => (cp < 0x100 ? cp : 0x01000000 + cp);
+
+// Sondertasten fuer die Fn-Leiste (Label → Keysym).
+const NAV_KEYS: { label: string; ks: number }[] = [
+  { label: 'Esc', ks: 0xff1b }, { label: 'Tab', ks: 0xff09 },
+  { label: '←', ks: 0xff51 }, { label: '↑', ks: 0xff52 }, { label: '↓', ks: 0xff54 }, { label: '→', ks: 0xff53 },
+  { label: 'Pos1', ks: 0xff50 }, { label: 'Ende', ks: 0xff57 },
+  { label: 'Bild↑', ks: 0xff55 }, { label: 'Bild↓', ks: 0xff56 },
+  { label: 'Einfg', ks: 0xff63 }, { label: 'Entf', ks: 0xffff }, { label: '⏎', ks: 0xff0d },
+];
+const F_KEYS: { label: string; ks: number }[] = Array.from({ length: 12 }, (_, i) => ({ label: 'F' + (i + 1), ks: 0xffbe + i }));
+
+const VncTile: React.FC<Props> = ({ projectId, focused, port = 5901 }) => {
+  const webRef = useRef<WebView>(null);
+  const kbdRef = useRef<TextInput>(null);
+  const bufRef = useRef('');                        // Spiegel des TextInput-Textes
+  const [status, setStatus] = useState<'idle' | 'connecting' | 'connected' | 'disconnected'>('idle');
+  const [kbdOn, setKbdOn] = useState(false);
+  const [keyBar, setKeyBar] = useState(false);      // Fn-Leiste sichtbar?
+  const [mods, setMods] = useState({ ctrl: false, alt: false, shift: false });
+  const modRef = useRef({ ctrl: false, alt: false, shift: false }); // Spiegel fuer Closures
+  const unsubDataRef = useRef<null | (() => void)>(null);
+
+  const teardown = useCallback(() => {
+    if (unsubDataRef.current) { unsubDataRef.current(); unsubDataRef.current = null; }
+    desktop.closeVnc();
+  }, []);
+
+  useEffect(() => {
+    if (!focused) { teardown(); setStatus('idle'); }
+    return () => teardown();
+  }, [focused, teardown]);
+
+  // Button-Zustand an die ECHTE Tastatur-Sichtbarkeit koppeln: Androids
+  // Zurueck-Taste blendet die Tastatur aus, ohne den TextInput zu blurren —
+  // ueber keyboardDidHide setzen wir das ⌨-Symbol trotzdem zurueck.
+  useEffect(() => {
+    if (!focused) return;
+    const show = Keyboard.addListener('keyboardDidShow', () => setKbdOn(true));
+    const hide = Keyboard.addListener('keyboardDidHide', () => setKbdOn(false));
+    return () => { show.remove(); hide.remove(); };
+  }, [focused]);
+
+  const ctl = useCallback((fn: string) => {
+    webRef.current?.injectJavaScript(`window.ariaVncCtl && window.ariaVncCtl.${fn}(); true;`);
+  }, []);
+
+  const sendKeysym = useCallback((ks: number) => {
+    webRef.current?.injectJavaScript(`window.ariaVncKey && window.ariaVncKey.keysym(${ks}); true;`);
+  }, []);
+  const sendCombo = useCallback((modKeysyms: number[], ks: number) => {
+    webRef.current?.injectJavaScript(`window.ariaVncKey && window.ariaVncKey.combo(${JSON.stringify(modKeysyms)}, ${ks}); true;`);
+  }, []);
+
+  // Aktive Sticky-Modifier als Keysym-Liste; nach dem Anwenden one-shot zuruecksetzen.
+  const activeMods = useCallback(() => {
+    const m = modRef.current; const a: number[] = [];
+    if (m.ctrl) a.push(MOD.ctrl); if (m.alt) a.push(MOD.alt); if (m.shift) a.push(MOD.shift);
+    return a;
+  }, []);
+  const clearMods = useCallback(() => {
+    if (modRef.current.ctrl || modRef.current.alt || modRef.current.shift) {
+      modRef.current = { ctrl: false, alt: false, shift: false };
+      setMods(modRef.current);
+    }
+  }, []);
+  const toggleMod = useCallback((k: 'ctrl' | 'alt' | 'shift') => {
+    modRef.current = { ...modRef.current, [k]: !modRef.current[k] };
+    setMods(modRef.current);
+  }, []);
+
+  // Eine Taste (fertiges Keysym) senden — mit ggf. aktiven Modifiern.
+  const pressKey = useCallback((ks: number) => {
+    const m = activeMods();
+    if (m.length) { sendCombo(m, ks); clearMods(); } else sendKeysym(ks);
+  }, [activeMods, sendCombo, clearMods, sendKeysym]);
+
+  // Ein druckbares Zeichen senden — mit ggf. aktiven Modifiern (Strg+C etc.).
+  const pressChar = useCallback((cp: number) => {
+    const m = activeMods();
+    if (m.length) { sendCombo(m, cpToKeysym(cp)); clearMods(); }
+    else webRef.current?.injectJavaScript(`window.ariaVncKey && window.ariaVncKey.char(${cp}); true;`);
+  }, [activeMods, sendCombo, clearMods]);
+
+  // Tastatur ein-/ausblenden. Oeffnen: blur→focus erzwingt das Aufklappen auch
+  // dann, wenn der TextInput noch fokussiert ist (Tastatur per Zurueck-Taste
+  // versteckt). Schliessen: Keyboard.dismiss(); den Button-Zustand setzt der
+  // keyboardDidShow/Hide-Listener — nicht hier —, damit er nie „haengen" bleibt.
+  const toggleKbd = useCallback(() => {
+    if (kbdOn) { Keyboard.dismiss(); }
+    else { kbdRef.current?.blur(); setTimeout(() => kbdRef.current?.focus(), 30); }
+  }, [kbdOn]);
+
+  // Druckbare Zeichen: Prefix-Diff des (wachsenden) Feldes → nur neu Getipptes an
+  // die VM. Loeschungen kommen ueber onKeyPress(Backspace), daher hier nur Inserts.
+  const onKbdChange = useCallback((e: NativeSyntheticEvent<TextInputChangeEventData>) => {
+    const text = e.nativeEvent.text || '';
+    const prev = bufRef.current;
+    let i = 0;
+    const min = Math.min(prev.length, text.length);
+    while (i < min && prev.charCodeAt(i) === text.charCodeAt(i)) i++;
+    for (const ch of text.slice(i)) { const cp = ch.codePointAt(0); if (cp) pressChar(cp); }
+    bufRef.current = text;
+    if (text.length > 200) { bufRef.current = ''; kbdRef.current?.setNativeProps({ text: '' }); }
+  }, [pressChar]);
+
+  // Sondertasten der Software-Tastatur: Backspace feuert auf Android zuverlaessig
+  // als keyPress; die Return-Taste (Haken) kommt als onSubmitEditing (s.u.).
+  const onKbdKeyPress = useCallback((e: NativeSyntheticEvent<TextInputKeyPressEventData>) => {
+    const k = e.nativeEvent.key;
+    if (k === 'Backspace') pressKey(KEYSYM.Backspace);
+    else if (k === 'Enter') pressKey(KEYSYM.Enter);
+  }, [pressKey]);
+
+  const onMessage = useCallback((e: WebViewMessageEvent) => {
+    let m: any;
+    try { m = JSON.parse(e.nativeEvent.data); } catch { return; }
+    if (m.event === 'ready') {
+      setStatus('connecting');
+      unsubDataRef.current = desktop.onVncData((b64) => {
+        const js = `window.ariaVnc && window.ariaVnc.onData(${JSON.stringify(b64)}); true;`;
+        webRef.current?.injectJavaScript(js);
+      });
+      desktop.openVnc(projectId, port);
+    } else if (m.event === 'vnc_send') {
+      desktop.sendInput(m.b64);
+    } else if (m.event === 'vnc_close') {
+      desktop.closeVnc();
+    } else if (m.event === 'vnc_state') {
+      if (m.state === 'connected') setStatus('connected');
+      else if (m.state === 'disconnected') setStatus('disconnected');
+    }
+  }, [projectId, port]);
+
+  if (!focused) {
+    return (
+      <View style={styles.placeholder}>
+        <Text style={styles.icon}>🖥️</Text>
+        <Text style={styles.text}>Desktop</Text>
+        <Text style={styles.sub}>Panel öffnen zum Verbinden</Text>
+      </View>
+    );
+  }
+
+  const connected = status === 'connected';
+  return (
+    <View style={styles.container}>
+      <WebView
+        ref={webRef}
+        style={styles.web}
+        originWhitelist={['*']}
+        source={{ html: NOVNC_HTML, baseUrl: 'https://aria-vnc.local/' }}
+        onMessage={onMessage}
+        javaScriptEnabled
+        domStorageEnabled
+        mixedContentMode="always"
+        androidLayerType="hardware"
+        keyboardDisplayRequiresUserAction={false}
+      />
+
+      {/* Verstecktes Eingabefeld: fokussiert → Android-Tastatur tippt in die VM.
+          keyboardType=visible-password schaltet Autokorrektur/Vorschlaege ab und
+          liefert saubere Einzelzeichen. Offscreen, aber fokussierbar. */}
+      <TextInput
+        ref={kbdRef}
+        style={styles.hiddenInput}
+        onChange={onKbdChange}
+        onKeyPress={onKbdKeyPress}
+        onSubmitEditing={() => pressKey(KEYSYM.Enter)}
+        keyboardType="visible-password"
+        returnKeyType="send"
+        autoCapitalize="none"
+        autoCorrect={false}
+        spellCheck={false}
+        blurOnSubmit={false}
+        caretHidden
+        contextMenuHidden
+        multiline={false}
+      />
+
+      {/* Steuerungs-Leiste — nur wenn verbunden */}
+      {connected && (
+        <View style={styles.ctlBar}>
+          <TouchableOpacity style={[styles.ctlBtn, keyBar && styles.ctlBtnOn]} onPress={() => setKeyBar(v => !v)} activeOpacity={0.7}>
+            <Text style={styles.ctlText}>Fn</Text>
+          </TouchableOpacity>
+          <TouchableOpacity style={[styles.ctlBtn, kbdOn && styles.ctlBtnOn]} onPress={toggleKbd} activeOpacity={0.7}>
+            <Text style={styles.ctlText}>⌨</Text>
+          </TouchableOpacity>
+          <TouchableOpacity style={styles.ctlBtn} onPress={() => ctl('toggleFit')} activeOpacity={0.7}>
+            <Text style={styles.ctlText}>⤢</Text>
+          </TouchableOpacity>
+        </View>
+      )}
+
+      {/* Fn-Leiste — echte Steuertasten (oben, ueber der Software-Tastatur). */}
+      {connected && keyBar && (
+        <View style={styles.keyBar} pointerEvents="box-none">
+          <ScrollView horizontal showsHorizontalScrollIndicator={false} keyboardShouldPersistTaps="always" contentContainerStyle={styles.keyRow}>
+            <TouchableOpacity style={[styles.key, mods.ctrl && styles.keyOn]} onPress={() => toggleMod('ctrl')} activeOpacity={0.7}><Text style={styles.keyText}>Strg</Text></TouchableOpacity>
+            <TouchableOpacity style={[styles.key, mods.alt && styles.keyOn]} onPress={() => toggleMod('alt')} activeOpacity={0.7}><Text style={styles.keyText}>Alt</Text></TouchableOpacity>
+            <TouchableOpacity style={[styles.key, mods.shift && styles.keyOn]} onPress={() => toggleMod('shift')} activeOpacity={0.7}><Text style={styles.keyText}>Shift</Text></TouchableOpacity>
+            {NAV_KEYS.map(k => (
+              <TouchableOpacity key={k.label} style={styles.key} onPress={() => pressKey(k.ks)} activeOpacity={0.7}><Text style={styles.keyText}>{k.label}</Text></TouchableOpacity>
+            ))}
+          </ScrollView>
+          <ScrollView horizontal showsHorizontalScrollIndicator={false} keyboardShouldPersistTaps="always" contentContainerStyle={styles.keyRow}>
+            {F_KEYS.map(k => (
+              <TouchableOpacity key={k.label} style={styles.key} onPress={() => pressKey(k.ks)} activeOpacity={0.7}><Text style={styles.keyText}>{k.label}</Text></TouchableOpacity>
+            ))}
+            <TouchableOpacity style={styles.key} onPress={() => ctl('cad')} activeOpacity={0.7}><Text style={styles.keyTextSm}>Strg+Alt+Entf</Text></TouchableOpacity>
+          </ScrollView>
+        </View>
+      )}
+
+      {!connected && (
+        <View style={styles.overlay} pointerEvents="none">
+          <Text style={styles.overlayText}>
+            {status === 'connecting' ? 'Verbinde …' : status === 'disconnected' ? 'Getrennt' : ''}
+          </Text>
+        </View>
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#000000' },
+  web: { flex: 1, backgroundColor: '#000000' },
+  placeholder: { flex: 1, backgroundColor: '#000000', alignItems: 'center', justifyContent: 'center' },
+  icon: { fontSize: 64, marginBottom: 16 },
+  text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
+  sub: { color: '#9090B0', fontSize: 14, marginTop: 8 },
+  ctlBar: {
+    position: 'absolute',
+    top: 34,
+    right: 8,
+    flexDirection: 'row',
+    gap: 6,
+  },
+  ctlBtn: {
+    backgroundColor: 'rgba(18,18,42,0.9)',
+    borderColor: '#2A2A3E',
+    borderWidth: 1,
+    borderRadius: 10,
+    paddingHorizontal: 10,
+    paddingVertical: 7,
+    minWidth: 38,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  ctlBtnOn: { backgroundColor: 'rgba(0,150,255,0.85)', borderColor: '#0096FF' },
+  ctlText: { color: '#E0E0F0', fontSize: 16, fontWeight: '700' },
+  ctlTextSmall: { color: '#E0E0F0', fontSize: 11, fontWeight: '700' },
+  // Fokussierbar (nicht display:none), aber aus dem Sichtfeld geschoben.
+  hiddenInput: { position: 'absolute', width: 1, height: 1, top: -100, left: -100, opacity: 0, padding: 0 },
+  keyBar: { position: 'absolute', top: 74, left: 0, right: 0, gap: 5 },
+  keyRow: { paddingHorizontal: 6, gap: 5, alignItems: 'center' },
+  key: {
+    backgroundColor: 'rgba(18,18,42,0.92)', borderColor: '#2A2A3E', borderWidth: 1,
+    borderRadius: 8, paddingHorizontal: 9, paddingVertical: 7, minWidth: 34,
+    alignItems: 'center', justifyContent: 'center',
+  },
+  keyOn: { backgroundColor: 'rgba(0,150,255,0.85)', borderColor: '#0096FF' },
+  keyText: { color: '#E0E0F0', fontSize: 13, fontWeight: '700' },
+  keyTextSm: { color: '#E0E0F0', fontSize: 10, fontWeight: '700' },
+  overlay: { position: 'absolute', top: 12, left: 0, right: 0, alignItems: 'center' },
+  overlayText: { color: '#9090B0', fontSize: 12, backgroundColor: 'rgba(0,0,0,0.6)', paddingHorizontal: 10, paddingVertical: 4, borderRadius: 10, overflow: 'hidden' },
+});
+
+export default VncTile;

android/src/workspace/useWorkspaceLayout.ts

@@ -0,0 +1,40 @@
+/**
+ * useWorkspaceLayout — merkt sich pro Projekt die zuletzt fokussierte Kachel,
+ * damit man beim Zurueckkehren in ein Code-Projekt wieder dort landet (Editor/
+ * Desktop) statt immer im Chat. Persistiert nach AsyncStorage (Muster wie
+ * aria_project_drafts).
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { TileId } from './layout';
+
+const KEY = 'aria_workspace_layout';
+
+interface Entry { focus: TileId | null }
+type LayoutMap = Record<string, Entry>;
+
+const keyOf = (projectId: string) => projectId || '__main__';
+
+export function useWorkspaceLayout(projectId: string) {
+  const mapRef = useRef<LayoutMap>({});
+  const [loaded, setLoaded] = useState(false);
+
+  useEffect(() => {
+    AsyncStorage.getItem(KEY).then((v) => {
+      if (v) { try { mapRef.current = JSON.parse(v) || {}; } catch { /* ignore */ } }
+      setLoaded(true);
+    }).catch(() => setLoaded(true));
+  }, []);
+
+  const getFocus = useCallback((): TileId | null | undefined => {
+    return mapRef.current[keyOf(projectId)]?.focus;
+  }, [projectId]);
+
+  const saveFocus = useCallback((focus: TileId | null) => {
+    mapRef.current = { ...mapRef.current, [keyOf(projectId)]: { focus } };
+    AsyncStorage.setItem(KEY, JSON.stringify(mapRef.current)).catch(() => {});
+  }, [projectId]);
+
+  return { loaded, getFocus, saveFocus };
+}

aria-brain/aria_mail.py

@@ -0,0 +1,950 @@
+"""ARIAs E-Mail: senden (SMTP) und lesen (IMAP).
+
+Drei Grundsaetze, aus denen sich der Rest ergibt:
+
+1. Die Zugangsdaten sieht ARIA nie.
+   ARIAs Claude-Container (proxy) hat /shared eingehaengt — alles unter
+   /shared/config kann sie lesen. Deshalb liegen Konfiguration und Passwort im
+   Brain unter /data, das dort NICHT eingehaengt ist. Keine Schnittstelle gibt
+   das Passwort je zurueck (nur `password_set: true`), kein Tool-Ergebnis
+   enthaelt es, der Brain-Export laesst die Geheimnis-Datei aus.
+
+2. Die Whitelist ist eine harte Grenze, kein Prompt-Hinweis.
+   Geprueft wird hier im Sendepfad, fuer JEDEN Empfaenger (To, Cc, Bcc). Leere
+   Liste = ARIA kann nirgendwohin senden. Aendern darf die Liste nur, wer den
+   Admin-Schluessel hat (/data/email_admin.key) — den liest die Diagnostic,
+   ARIAs Container nicht. Wichtig, weil eingehende Mails Text enthalten, den
+   ARIA liest: eine Mail mit "schick das an X" darf nicht reichen.
+
+3. Eingehende Mails sind Daten, keine Anweisungen.
+   Tool-Ergebnisse mit Mail-Inhalt sind entsprechend markiert.
+
+Grenze, die man kennen sollte: ARIAs Container hat einen SSH-Schluessel auf die
+VM. Legt sie es gezielt darauf an, kommt sie als root an jede Datei. Dieses
+Modul sorgt dafuer, dass die Zugangsdaten nirgends von selbst auftauchen — es
+ist kein Schutz gegen einen bewussten Einbruch.
+"""
+
+from __future__ import annotations
+
+import hmac
+import html as html_mod
+import imaplib
+import json
+import logging
+import mimetypes
+import os
+import re
+import secrets
+import smtplib
+import ssl
+import threading
+import time
+from email import policy
+from email.message import EmailMessage
+from email.parser import BytesParser
+from email.utils import formataddr, formatdate, getaddresses, make_msgid, parseaddr
+from pathlib import Path
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+DATA_DIR = Path(os.environ.get("ARIA_MAIL_DATA_DIR", "/data"))
+CONFIG_FILE = DATA_DIR / "email.json"            # Server, Ports, Whitelist, Benutzername
+SECRET_FILE = DATA_DIR / "email_secret.json"     # nur Passwoerter — vom Export ausgenommen
+ADMIN_KEY_FILE = DATA_DIR / "email_admin.key"    # Schreibrecht auf die Konfiguration
+
+# Wohin ARIA Anhaenge ablegt bzw. woher sie welche nehmen darf. Alles andere
+# (vor allem /data, wo die Passwoerter liegen) ist tabu — auch ueber Symlinks.
+UPLOAD_ROOT = Path(os.environ.get("ARIA_MAIL_UPLOAD_ROOT", "/shared/uploads"))
+ATTACH_ROOTS = [Path(p) for p in os.environ.get(
+    "ARIA_MAIL_ATTACH_ROOTS", "/shared/uploads:/shared/projects").split(":") if p]
+
+MAX_SEND_BYTES = 25 * 1024 * 1024     # gaengiges Limit der meisten Mailserver
+MAX_BODY_CHARS = 20000                # so viel Mailtext bekommt ARIA pro Mail
+NET_TIMEOUT = 30
+
+ENCRYPTIONS = ("ssl", "starttls", "none")
+
+DEFAULTS = {
+    "from_name": "ARIA",
+    "from_address": "",
+    "username": "",
+    "imap_host": "", "imap_port": 993, "imap_encryption": "ssl",
+    "smtp_host": "", "smtp_port": 465, "smtp_encryption": "ssl",
+    # Abweichender SMTP-Login (selten, z.B. Relay). Leer = wie IMAP.
+    "smtp_username": "",
+    "verify_tls": True,
+    "save_sent": True,     # Kopie jeder gesendeten Mail in "Gesendet" ablegen
+    "whitelist": [],
+}
+
+_lock = threading.Lock()
+
+
+class MailError(Exception):
+    """Fehler, dessen Text ARIA/Stefan sehen duerfen (kein Geheimnis darin)."""
+
+
+# ── Speicher ────────────────────────────────────────────────────────
+
+def _read_json(path: Path) -> dict:
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+            if isinstance(data, dict):
+                return data
+    except Exception as exc:
+        logger.warning("[mail] %s nicht lesbar: %s", path.name, exc)
+    return {}
+
+
+def _write_private(path: Path, data: dict) -> None:
+    """Atomar und mit 0600 — die Datei existiert nie mit offeneren Rechten."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    os.replace(tmp, path)
+
+
+def load_config() -> dict:
+    cfg = dict(DEFAULTS)
+    cfg.update({k: v for k, v in _read_json(CONFIG_FILE).items() if k in DEFAULTS})
+    cfg["whitelist"] = [str(p).strip() for p in (cfg.get("whitelist") or []) if str(p).strip()]
+    return cfg
+
+
+def _secrets() -> dict:
+    return _read_json(SECRET_FILE)
+
+
+def public_config() -> dict:
+    """Konfiguration fuer die Diagnostic. Passwoerter NUR als Ja/Nein."""
+    cfg = load_config()
+    sec = _secrets()
+    cfg["password_set"] = bool(sec.get("password"))
+    cfg["smtp_password_set"] = bool(sec.get("smtp_password"))
+    return cfg
+
+
+def save_config(patch: dict) -> dict:
+    """Konfiguration aendern. Passwort-Felder:
+       password / smtp_password  — nicht leer = neu setzen, leer/fehlt = unveraendert
+       clear_password / clear_smtp_password — True = loeschen
+    """
+    with _lock:
+        cfg = load_config()
+        for key in DEFAULTS:
+            if key not in patch:
+                continue
+            val = patch[key]
+            if key in ("imap_port", "smtp_port"):
+                try:
+                    val = int(val)
+                except (TypeError, ValueError):
+                    raise MailError(f"{key}: keine Zahl")
+                if not 1 <= val <= 65535:
+                    raise MailError(f"{key}: {val} ist kein gueltiger Port")
+            elif key in ("imap_encryption", "smtp_encryption"):
+                val = str(val or "").lower()
+                if val not in ENCRYPTIONS:
+                    raise MailError(f"{key}: erlaubt sind {', '.join(ENCRYPTIONS)}")
+            elif key in ("verify_tls", "save_sent"):
+                val = bool(val)
+            elif key == "whitelist":
+                if isinstance(val, str):
+                    val = re.split(r"[\s,;]+", val)
+                val = [str(p).strip() for p in (val or []) if str(p).strip()]
+                for p in val:
+                    _check_pattern(p)
+            else:
+                val = _no_newlines(str(val or "").strip())
+            cfg[key] = val
+        _write_private(CONFIG_FILE, cfg)
+
+        sec = _secrets()
+        changed = False
+        for field in ("password", "smtp_password"):
+            if patch.get("clear_" + field):
+                changed |= sec.pop(field, None) is not None
+            elif patch.get(field):
+                sec[field] = str(patch[field])
+                changed = True
+        if changed:
+            _write_private(SECRET_FILE, sec)
+    # Bewusst ohne Werte geloggt.
+    logger.info("[mail] Konfiguration gespeichert (Whitelist: %d Eintraege)", len(cfg["whitelist"]))
+    return public_config()
+
+
+def admin_key() -> str:
+    """Schreibschluessel fuer die Konfiguration. Wird beim ersten Zugriff
+    erzeugt. Die Diagnostic liest ihn aus ./aria-data/brain/data — ARIAs
+    Container hat diesen Pfad nicht."""
+    with _lock:
+        try:
+            if ADMIN_KEY_FILE.exists():
+                k = ADMIN_KEY_FILE.read_text(encoding="utf-8").strip()
+                if k:
+                    return k
+        except Exception:
+            pass
+        k = secrets.token_urlsafe(32)
+        ADMIN_KEY_FILE.parent.mkdir(parents=True, exist_ok=True)
+        fd = os.open(str(ADMIN_KEY_FILE), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w") as f:
+            f.write(k)
+        return k
+
+
+def check_admin(provided: Optional[str]) -> bool:
+    if not provided:
+        return False
+    return hmac.compare_digest(provided.strip(), admin_key())
+
+
+def status() -> dict:
+    """Was ARIA ueber ihr Postfach wissen darf — ohne Zugangsdaten."""
+    cfg = load_config()
+    sec = _secrets()
+    can_login = bool(cfg["username"] and sec.get("password"))
+    return {
+        "configured_imap": bool(cfg["imap_host"] and can_login),
+        "configured_smtp": bool(cfg["smtp_host"] and (can_login or (
+            cfg["smtp_username"] and sec.get("smtp_password")))),
+        "from_address": cfg["from_address"],
+        "from_name": cfg["from_name"],
+        "whitelist": list(cfg["whitelist"]),
+    }
+
+
+# ── Whitelist ───────────────────────────────────────────────────────
+
+_ADDR_RE = re.compile(r"^[^@\s<>()\[\],;:\"]+@([a-z0-9-]+(\.[a-z0-9-]+)+)$", re.IGNORECASE)
+_DOMAIN_RE = re.compile(r"^[a-z0-9-]+(\.[a-z0-9-]+)+$", re.IGNORECASE)
+
+
+def _pattern(p: str) -> tuple:
+    """Muster zerlegen → (art, wert). Wirft bei ungueltigen Mustern.
+
+    Genau EINE Schreibweise: name@domain, Platzhalter nur als ganzes Teil.
+      stefan@hacker-net.de   → ('adresse',   'stefan@hacker-net.de')
+      *@hacker-net.de        → ('domain',    'hacker-net.de')
+      *@*.hacker-net.de      → ('subdomain', 'hacker-net.de')
+      *@*                    → ('alles',     '')
+
+    Kurzformen wie '*hacker-net.de' oder 'hacker-net.de' werden abgelehnt:
+    '*hacker-net.de' liest sich, als passte es auch auf 'evilhacker-net.de'.
+    In einer Sicherheitsliste soll niemand raten muessen, was ein Eintrag tut.
+    """
+    q = (p or "").strip().lower()
+    if q == "*@*":
+        return "alles", ""
+    if q.count("@") != 1:
+        hint = q.lstrip("*@.")
+        raise MailError(f"Whitelist: '{p}' — Schreibweise ist name@domain"
+                        + (f", fuer alle Adressen der Domain: *@{hint}" if _DOMAIN_RE.match(hint) else ""))
+    local, dom = q.split("@")
+    if local == "*":
+        if dom.startswith("*."):
+            if _DOMAIN_RE.match(dom[2:]):
+                return "subdomain", dom[2:]
+        elif _DOMAIN_RE.match(dom):
+            return "domain", dom
+        raise MailError(f"Whitelist: '{p}' — Domain ungueltig ('*' nur als *@domain oder *@*.domain)")
+    if "*" in q or not _ADDR_RE.match(q):
+        raise MailError(f"Whitelist: '{p}' ist keine gueltige Adresse")
+    return "adresse", q
+
+
+def _check_pattern(p: str) -> None:
+    """Ungueltige Muster schon beim Speichern abweisen — ein Tippfehler soll
+    nicht still 'nichts erlaubt' oder gar 'zu viel erlaubt' bedeuten."""
+    _pattern(p)
+
+
+def address_allowed(address: str, whitelist: Iterable[str]) -> bool:
+    """Darf an diese Adresse gesendet werden? Muster siehe _pattern().
+
+    Verglichen wird die Domain als Ganzes, nie ein Textende: '*@hacker-net.de'
+    trifft weder 'evilhacker-net.de' noch 'mail.hacker-net.de'.
+    """
+    addr = (address or "").strip().lower()
+    m = _ADDR_RE.match(addr)
+    if not m:
+        return False
+    domain = m.group(1)
+    for raw in whitelist or ():
+        try:
+            kind, val = _pattern(str(raw))
+        except MailError:
+            continue   # kaputtes Muster erlaubt nichts
+        if kind == "alles":
+            return True
+        if kind == "adresse" and addr == val:
+            return True
+        if kind == "domain" and domain == val:
+            return True
+        # Mit Punkt davor: "mail.hacker-net.de" endet auf ".hacker-net.de",
+        # "evilhacker-net.de" nicht.
+        if kind == "subdomain" and domain.endswith("." + val):
+            return True
+    return False
+
+
+def _parse_recipients(values) -> list:
+    """Liste aus Strings/Listen → reine Adressen. Namen ("Max <m@x.de>") sind
+    erlaubt, zaehlen aber nur ueber die Adresse."""
+    if not values:
+        return []
+    if isinstance(values, str):
+        values = [values]
+    out = []
+    for name, addr in getaddresses([str(v) for v in values]):
+        addr = addr.strip()
+        if addr:
+            out.append((name.strip(), addr))
+    return out
+
+
+def check_recipients(to, cc=None, bcc=None) -> tuple:
+    """(erlaubt, abgelehnt) ueber ALLE Empfaenger. Ein einziger abgelehnter
+    blockiert die ganze Mail — teilweises Senden waere schlimmer als keins."""
+    wl = load_config()["whitelist"]
+    allowed, rejected = [], []
+    for name, addr in _parse_recipients(to) + _parse_recipients(cc) + _parse_recipients(bcc):
+        (allowed if address_allowed(addr, wl) else rejected).append(addr)
+    return allowed, rejected
+
+
+# ── Pfade ───────────────────────────────────────────────────────────
+
+def _safe_attach_path(p: str) -> Path:
+    """Nur Dateien unter den erlaubten Wurzeln. realpath zuerst: ein Symlink in
+    /shared/uploads, der auf /data/email_secret.json zeigt, wuerde sonst im
+    Brain-Container aufgeloest — und das Passwort als Anhang verschickt."""
+    if not p:
+        raise MailError("Leerer Dateipfad")
+    real = Path(os.path.realpath(p))
+    for root in ATTACH_ROOTS:
+        root_real = Path(os.path.realpath(str(root)))
+        if real == root_real or root_real in real.parents:
+            if not real.is_file():
+                raise MailError(f"{p}: keine Datei")
+            return real
+    raise MailError(f"{p}: nur Dateien unter {', '.join(str(r) for r in ATTACH_ROOTS)} erlaubt")
+
+
+def _no_newlines(s: str) -> str:
+    """Kopfzeilen ohne Zeilenumbruch — sonst liessen sich Header einschmuggeln."""
+    return re.sub(r"[\r\n]+", " ", s or "")
+
+
+def _html_to_text(html: str) -> str:
+    t = re.sub(r"(?is)<(script|style|head)[^>]*>.*?</\1>", "", html or "")
+    t = re.sub(r"(?i)<br\s*/?>", "\n", t)
+    t = re.sub(r"(?i)</(p|div|tr|h[1-6]|li)>", "\n", t)
+    t = re.sub(r"(?s)<[^>]+>", "", t)
+    t = html_mod.unescape(t)
+    t = re.sub(r"[ \t]+", " ", t)
+    return re.sub(r"\n\s*\n+", "\n\n", t).strip()
+
+
+# ── Nachricht bauen ─────────────────────────────────────────────────
+
+def build_message(cfg: dict, to, subject: str, text: str = "", html: str = "",
+                  cc=None, attachments: Optional[list] = None,
+                  inline_images: Optional[list] = None,
+                  in_reply_to: str = "", references: str = "") -> EmailMessage:
+    """Baut die MIME-Struktur:
+
+      multipart/mixed                 (nur wenn Anhaenge)
+        multipart/alternative
+          text/plain                  (immer — aus HTML erzeugt, wenn keiner da)
+          multipart/related           (nur wenn eingebettete Bilder)
+            text/html
+            image/*  Content-ID <cid>
+        application/... Anhaenge
+
+    Bcc steht absichtlich NICHT im Header — er geht nur in die Umschlag-
+    Empfaenger beim Senden.
+    """
+    if not (text or html):
+        raise MailError("Leere Mail: text oder html angeben")
+    if inline_images and not html:
+        raise MailError("Eingebettete Bilder brauchen html (<img src=\"cid:...\">)")
+
+    msg = EmailMessage(policy=policy.SMTP)
+    msg["From"] = formataddr((_no_newlines(cfg["from_name"]), cfg["from_address"]))
+    msg["To"] = ", ".join(formataddr(r) for r in _parse_recipients(to))
+    if cc:
+        msg["Cc"] = ", ".join(formataddr(r) for r in _parse_recipients(cc))
+    msg["Subject"] = _no_newlines(subject or "")
+    msg["Date"] = formatdate(localtime=True)
+    domain = (cfg["from_address"].split("@", 1)[1] if "@" in cfg["from_address"] else None)
+    msg["Message-ID"] = make_msgid(domain=domain)
+    if in_reply_to:
+        msg["In-Reply-To"] = _no_newlines(in_reply_to)
+        msg["References"] = _no_newlines((references + " " + in_reply_to).strip())
+
+    msg.set_content(text or _html_to_text(html))
+    if html:
+        msg.add_alternative(html, subtype="html")
+        if inline_images:
+            html_part = msg.get_payload()[-1]
+            for img in inline_images:
+                path = _safe_attach_path(img.get("path", ""))
+                cid = (img.get("cid") or path.name).strip("<>")
+                ctype = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+                maintype, subtype = ctype.split("/", 1)
+                if maintype != "image":
+                    raise MailError(f"{path.name}: eingebettet werden nur Bilder")
+                html_part.add_related(path.read_bytes(), maintype=maintype, subtype=subtype,
+                                      cid=f"<{cid}>", filename=path.name,
+                                      disposition="inline")
+    for p in attachments or []:
+        path = _safe_attach_path(p)
+        ctype = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+        maintype, subtype = ctype.split("/", 1)
+        msg.add_attachment(path.read_bytes(), maintype=maintype, subtype=subtype,
+                           filename=path.name)
+    return msg
+
+
+# ── Verbindungen ────────────────────────────────────────────────────
+
+def _tls_context(cfg: dict) -> ssl.SSLContext:
+    ctx = ssl.create_default_context()
+    if not cfg.get("verify_tls", True):
+        # Fuer eigene Server mit selbstsigniertem Zertifikat. Bewusste Wahl in
+        # der Diagnostic — verschluesselt bleibt es trotzdem.
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+    return ctx
+
+
+def _login_error(proto: str, exc: Exception) -> MailError:
+    # Fehlertexte der Server enthalten nie das Passwort — trotzdem nur den
+    # Typ + gekuerzte Meldung weitergeben.
+    return MailError(f"{proto}: {type(exc).__name__}: {str(exc)[:200]}")
+
+
+def _smtp_open(cfg: dict):
+    sec = _secrets()
+    user = cfg["smtp_username"] or cfg["username"]
+    pw = sec.get("smtp_password") if cfg["smtp_username"] else sec.get("password")
+    if not (cfg["smtp_host"] and user and pw):
+        raise MailError("SMTP ist nicht eingerichtet (Diagnostic → Einstellungen → ARIA E-Mail)")
+    enc = cfg["smtp_encryption"]
+    try:
+        if enc == "ssl":
+            s = smtplib.SMTP_SSL(cfg["smtp_host"], cfg["smtp_port"], timeout=NET_TIMEOUT,
+                                 context=_tls_context(cfg))
+        else:
+            s = smtplib.SMTP(cfg["smtp_host"], cfg["smtp_port"], timeout=NET_TIMEOUT)
+            s.ehlo()
+            if enc == "starttls":
+                s.starttls(context=_tls_context(cfg))
+                s.ehlo()
+        s.login(user, pw)
+        return s
+    except MailError:
+        raise
+    except Exception as exc:
+        raise _login_error("SMTP", exc)
+
+
+def _imap_open(cfg: dict):
+    sec = _secrets()
+    if not (cfg["imap_host"] and cfg["username"] and sec.get("password")):
+        raise MailError("IMAP ist nicht eingerichtet (Diagnostic → Einstellungen → ARIA E-Mail)")
+    enc = cfg["imap_encryption"]
+    try:
+        if enc == "ssl":
+            m = imaplib.IMAP4_SSL(cfg["imap_host"], cfg["imap_port"],
+                                  ssl_context=_tls_context(cfg), timeout=NET_TIMEOUT)
+        else:
+            m = imaplib.IMAP4(cfg["imap_host"], cfg["imap_port"], timeout=NET_TIMEOUT)
+            if enc == "starttls":
+                m.starttls(ssl_context=_tls_context(cfg))
+        m.login(cfg["username"], sec["password"])
+        return m
+    except MailError:
+        raise
+    except Exception as exc:
+        raise _login_error("IMAP", exc)
+
+
+def _imap_close(m) -> None:
+    try:
+        m.logout()
+    except Exception:
+        pass
+
+
+def test_connection() -> dict:
+    """Login an beiden Servern pruefen, ohne etwas zu senden."""
+    cfg = load_config()
+    out = {}
+    for proto, opener, closer in (("imap", _imap_open, _imap_close),
+                                  ("smtp", _smtp_open, lambda s: s.quit())):
+        try:
+            conn = opener(cfg)
+            try:
+                closer(conn)
+            except Exception:
+                pass
+            out[proto] = {"ok": True}
+        except MailError as exc:
+            out[proto] = {"ok": False, "error": str(exc)}
+    return out
+
+
+# ── Senden ──────────────────────────────────────────────────────────
+
+def send(to, subject: str, text: str = "", html: str = "", cc=None, bcc=None,
+         attachments: Optional[list] = None, inline_images: Optional[list] = None,
+         reply_to_uid: str = "", reply_folder: str = "INBOX") -> dict:
+    cfg = load_config()
+    if not cfg["from_address"]:
+        raise MailError("Keine Absender-Adresse eingerichtet")
+    recipients = _parse_recipients(to) + _parse_recipients(cc) + _parse_recipients(bcc)
+    if not recipients:
+        raise MailError("Kein Empfaenger")
+    if not cfg["whitelist"]:
+        raise MailError("Die Whitelist ist leer — ich darf an niemanden senden. "
+                        "Stefan traegt erlaubte Adressen in der Diagnostic ein.")
+    _, rejected = check_recipients(to, cc, bcc)
+    if rejected:
+        raise MailError("Nicht auf der Whitelist: " + ", ".join(rejected)
+                        + " — nichts gesendet. Erlaubt: " + ", ".join(cfg["whitelist"]))
+
+    in_reply_to = references = ""
+    if reply_to_uid:
+        orig = _fetch_message(reply_folder, reply_to_uid, mark_read=False)
+        in_reply_to = orig.get("Message-ID", "") or ""
+        references = orig.get("References", "") or ""
+
+    msg = build_message(cfg, to, subject, text=text, html=html, cc=cc,
+                        attachments=attachments, inline_images=inline_images,
+                        in_reply_to=in_reply_to, references=references)
+    raw = msg.as_bytes()
+    if len(raw) > MAX_SEND_BYTES:
+        raise MailError(f"Mail ist {len(raw) // (1024 * 1024)} MB gross — Grenze "
+                        f"{MAX_SEND_BYTES // (1024 * 1024)} MB")
+
+    s = _smtp_open(cfg)
+    try:
+        s.send_message(msg, from_addr=cfg["from_address"],
+                       to_addrs=[a for _, a in recipients])
+    except Exception as exc:
+        raise MailError(f"SMTP-Versand: {type(exc).__name__}: {str(exc)[:200]}")
+    finally:
+        try:
+            s.quit()
+        except Exception:
+            pass
+
+    saved = ""
+    if cfg.get("save_sent"):
+        try:
+            saved = _append_sent(cfg, raw)
+        except Exception as exc:
+            # Gesendet ist gesendet — die Kopie ist Komfort, kein Fehler.
+            logger.warning("[mail] Kopie in Gesendet fehlgeschlagen: %s", exc)
+    logger.info("[mail] gesendet an %d Empfaenger, %d Byte", len(recipients), len(raw))
+    return {"ok": True, "message_id": msg["Message-ID"], "recipients": [a for _, a in recipients],
+            "bytes": len(raw), "saved_to": saved}
+
+
+def _find_sent_folder(m) -> str:
+    typ, data = m.list()
+    names = []
+    for line in data or []:
+        if not line:
+            continue
+        s = line.decode("utf-8", "replace") if isinstance(line, bytes) else str(line)
+        name = _parse_list_name(s)
+        if "\\Sent" in s:
+            return name
+        names.append(name)
+    for cand in ("Sent", "Gesendet", "INBOX.Sent", "Sent Items", "Gesendete Objekte",
+                 "INBOX.Gesendet"):
+        for n in names:
+            if n.lower() == cand.lower():
+                return n
+    return ""
+
+
+SENT_FALLBACK = "Gesendet"
+
+
+def _append_sent(cfg: dict, raw: bytes) -> str:
+    m = _imap_open(cfg)
+    try:
+        folder = _find_sent_folder(m)
+        if not folder:
+            # Kein Gesendet-Ordner (frisches Postfach, manche Hoster): anlegen.
+            # Sonst ginge die Kopie still verloren — und Stefan saehe in der
+            # Diagnostic nicht, was ARIA verschickt hat.
+            typ, _ = m.create(_quote(SENT_FALLBACK))
+            if typ != "OK":
+                logger.warning("[mail] Ordner %r nicht anlegbar — keine Kopie", SENT_FALLBACK)
+                return ""
+            folder = SENT_FALLBACK
+        m.append(_quote(folder), "(\\Seen)", imaplib.Time2Internaldate(time.time()), raw)
+        return folder
+    finally:
+        _imap_close(m)
+
+
+# ── Lesen ───────────────────────────────────────────────────────────
+
+_LIST_RE = re.compile(r'\((?P<flags>[^)]*)\)\s+(?P<delim>"[^"]*"|NIL)\s+(?P<name>.+)$')
+
+
+def _parse_list_name(line: str) -> str:
+    m = _LIST_RE.match(line.strip())
+    if not m:
+        return line.strip()
+    name = m.group("name").strip()
+    if name.startswith('"') and name.endswith('"'):
+        name = name[1:-1].replace('\\"', '"').replace("\\\\", "\\")
+    return name
+
+
+def imap_utf7_decode(name: str) -> str:
+    """'Entw&APw-rfe' → 'Entwürfe'. IMAP kodiert Ordnernamen in modifiziertem
+    UTF-7 (RFC 3501). Nur fuer die ANZEIGE — an den Server geht der Rohname."""
+    import base64
+    def dec(m):
+        chunk = m.group(1)
+        if chunk == "":
+            return "&"
+        b = chunk.replace(",", "/")
+        b += "=" * (-len(b) % 4)
+        try:
+            return base64.b64decode(b).decode("utf-16-be")
+        except Exception:
+            return m.group(0)
+    return re.sub(r"&([A-Za-z0-9+,]*)-", dec, name or "")
+
+
+def _quote(folder: str) -> str:
+    return '"' + folder.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+_SENT_NAMES = {"sent", "gesendet", "inbox.sent", "sent items", "gesendete objekte",
+               "inbox.gesendet", "gesendete elemente"}
+
+
+def list_folders() -> list:
+    """[{name (roh, fuer den Server), label (lesbar), role}], Posteingang und
+    Gesendet zuerst. role: 'inbox' | 'sent' | ''. Gesendet wird ueber das
+    Server-Flag \\Sent erkannt, sonst ueber die ueblichen Namen."""
+    m = _imap_open(load_config())
+    try:
+        typ, data = m.list()
+        out = []
+        for line in data or []:
+            if not line:
+                continue
+            s = line.decode("utf-8", "replace") if isinstance(line, bytes) else str(line)
+            if "\\Noselect" in s:
+                continue
+            name = _parse_list_name(s)
+            label = imap_utf7_decode(name)
+            lm = _LIST_RE.match(s.strip())
+            delim = (lm.group("delim").strip('"') if lm and lm.group("delim") != "NIL" else "")
+            role = ("inbox" if name.upper() == "INBOX" else
+                    "sent" if "\\Sent" in s or label.lower() in _SENT_NAMES else "")
+            # Unterordner: Tiefe + letzter Namensteil fuer die Baumansicht.
+            parts = label.split(delim) if delim else [label]
+            out.append({"name": name, "label": label, "role": role,
+                        "depth": len(parts) - 1, "short": parts[-1]})
+        # Posteingang + Gesendet nach oben; der Rest nach vollem Pfad, damit
+        # Unterordner direkt unter ihrem Elternordner stehen.
+        order = {"inbox": 0, "sent": 1}
+        out.sort(key=lambda f: (order.get(f["role"], 2), f["label"].lower()))
+        return out
+    finally:
+        _imap_close(m)
+
+
+def _uid_ok(uid) -> str:
+    u = str(uid or "").strip()
+    if not u.isdigit():
+        raise MailError(f"Ungueltige UID: {uid!r}")
+    return u
+
+
+def _select(m, folder: str, readonly: bool) -> None:
+    typ, data = m.select(_quote(folder or "INBOX"), readonly=readonly)
+    if typ != "OK":
+        raise MailError(f"Ordner {folder!r} nicht gefunden")
+
+
+def list_messages(folder: str = "INBOX", limit: int = 20, offset: int = 0,
+                  unread_only: bool = False, search: str = "") -> dict:
+    limit = max(1, min(int(limit or 20), 100))
+    offset = max(0, int(offset or 0))
+    m = _imap_open(load_config())
+    try:
+        _select(m, folder, readonly=True)
+        if search:
+            m.literal = search.encode("utf-8")
+            crit = ["CHARSET", "UTF-8"] + (["UNSEEN"] if unread_only else []) + ["TEXT"]
+            typ, data = m.uid("SEARCH", *crit)
+        else:
+            typ, data = m.uid("SEARCH", "UNSEEN" if unread_only else "ALL")
+        uids = (data[0] or b"").split() if data else []
+        uids = sorted((int(u) for u in uids), reverse=True)
+        total = len(uids)
+        page = uids[offset:offset + limit]
+        items = []
+        if page:
+            fields = "FROM TO CC SUBJECT DATE CONTENT-TYPE MESSAGE-ID"
+            typ, data = m.uid("FETCH", ",".join(str(u) for u in page),
+                              f"(UID FLAGS RFC822.SIZE BODY.PEEK[HEADER.FIELDS ({fields})])")
+            by_uid = {}
+            last = None
+            # imaplib liefert pro Mail ein Tupel (Meta, Header-Bytes) und danach
+            # ein Bytes-Stueck mit dem Rest der Zeile. Manche Server (Dovecot je
+            # nach Reihenfolge, Exchange) schreiben FLAGS erst DORT hin — nur im
+            # Meta-Teil zu suchen hiesse: jede Mail "ungelesen".
+            for part in data or []:
+                if isinstance(part, tuple):
+                    meta = part[0].decode("utf-8", "replace")
+                    um = re.search(r"UID (\d+)", meta)
+                    if not um:
+                        last = None
+                        continue
+                    hdr = BytesParser(policy=policy.default).parsebytes(part[1], headersonly=True)
+                    sm = re.search(r"RFC822\.SIZE (\d+)", meta)
+                    ctype = str(hdr.get("Content-Type", "") or "").lower()
+                    last = int(um.group(1))
+                    by_uid[last] = {
+                        "uid": um.group(1),
+                        "from": str(hdr.get("From", "") or ""),
+                        "to": str(hdr.get("To", "") or ""),
+                        "subject": str(hdr.get("Subject", "") or ""),
+                        "date": str(hdr.get("Date", "") or ""),
+                        "seen": False,
+                        "size": int(sm.group(1)) if sm else 0,
+                        "maybe_attachments": "multipart/mixed" in ctype,
+                    }
+                    meta_flags = re.search(r"FLAGS \(([^)]*)\)", meta)
+                    if meta_flags:
+                        by_uid[last]["seen"] = "\\Seen" in meta_flags.group(1)
+                elif isinstance(part, bytes) and last is not None:
+                    tail_flags = re.search(r"FLAGS \(([^)]*)\)", part.decode("utf-8", "replace"))
+                    if tail_flags:
+                        by_uid[last]["seen"] = "\\Seen" in tail_flags.group(1)
+            items = [by_uid[u] for u in page if u in by_uid]
+        return {"folder": folder, "total": total, "offset": offset, "messages": items}
+    finally:
+        _imap_close(m)
+
+
+def _fetch_message(folder: str, uid, mark_read: bool):
+    u = _uid_ok(uid)
+    m = _imap_open(load_config())
+    try:
+        _select(m, folder, readonly=not mark_read)
+        typ, data = m.uid("FETCH", u, "(BODY.PEEK[])")
+        raw = next((p[1] for p in (data or []) if isinstance(p, tuple)), None)
+        if raw is None:
+            raise MailError(f"Mail UID {u} in {folder!r} nicht gefunden")
+        if mark_read:
+            m.uid("STORE", u, "+FLAGS", "(\\Seen)")
+        return BytesParser(policy=policy.default).parsebytes(raw)
+    finally:
+        _imap_close(m)
+
+
+def _safe_name(name: str) -> str:
+    n = re.sub(r"[^\w.\- ]+", "_", os.path.basename(name or "")).strip(" .")
+    return n[:120] or "anhang"
+
+
+def _bodies(msg) -> tuple:
+    text_part = msg.get_body(preferencelist=("plain",))
+    html_part = msg.get_body(preferencelist=("html",))
+    text = text_part.get_content() if text_part is not None else ""
+    html = html_part.get_content() if html_part is not None else ""
+    return text, html
+
+
+def read_message(folder: str, uid, mark_read: bool = True) -> dict:
+    """Fuer ARIA: Kopfzeilen, Text (HTML → Text, wenn es nur HTML gibt) und
+    Anhaenge — die landen unter /shared/uploads/email/, damit ARIA sie wie
+    jeden anderen Upload ansehen kann."""
+    msg = _fetch_message(folder, uid, mark_read)
+    text, html = _bodies(msg)
+    body = text or _html_to_text(html)
+    truncated = len(body) > MAX_BODY_CHARS
+    attachments = []
+    target = UPLOAD_ROOT / "email" / f"{_safe_name(folder)}-{_uid_ok(uid)}"
+    for i, part in enumerate(msg.iter_attachments()):
+        name = _safe_name(part.get_filename() or f"anhang-{i + 1}")
+        data = part.get_payload(decode=True) or b""
+        target.mkdir(parents=True, exist_ok=True)
+        path = target / name
+        path.write_bytes(data)
+        attachments.append({"name": name, "path": str(path), "size": len(data),
+                            "type": part.get_content_type()})
+    return {
+        "uid": _uid_ok(uid), "folder": folder,
+        "from": str(msg.get("From", "") or ""), "to": str(msg.get("To", "") or ""),
+        "cc": str(msg.get("Cc", "") or ""), "subject": str(msg.get("Subject", "") or ""),
+        "date": str(msg.get("Date", "") or ""),
+        "message_id": str(msg.get("Message-ID", "") or ""),
+        "body": body[:MAX_BODY_CHARS], "truncated": truncated,
+        "had_html": bool(html), "attachments": attachments,
+    }
+
+
+def view_message(folder: str, uid) -> dict:
+    """Fuer den Postfach-Viewer: wie read_message, aber OHNE als gelesen zu
+    markieren und mit dem HTML. Eingebettete Bilder (cid:) werden zu data:-URIs,
+    damit der Viewer sie zeigen kann, ohne irgendetwas nachzuladen."""
+    import base64
+    msg = _fetch_message(folder, uid, mark_read=False)
+    text, html = _bodies(msg)
+    if html:
+        for part in msg.walk():
+            cid = (part.get("Content-ID") or "").strip().strip("<>")
+            if cid and part.get_content_maintype() == "image":
+                b64 = base64.b64encode(part.get_payload(decode=True) or b"").decode("ascii")
+                html = html.replace(f"cid:{cid}", f"data:{part.get_content_type()};base64,{b64}")
+    attachments = [{"index": i, "name": _safe_name(p.get_filename() or f"anhang-{i + 1}"),
+                    "type": p.get_content_type(),
+                    "size": len(p.get_payload(decode=True) or b"")}
+                   for i, p in enumerate(msg.iter_attachments())]
+    return {
+        "uid": _uid_ok(uid), "folder": folder,
+        "from": str(msg.get("From", "") or ""), "to": str(msg.get("To", "") or ""),
+        "cc": str(msg.get("Cc", "") or ""), "subject": str(msg.get("Subject", "") or ""),
+        "date": str(msg.get("Date", "") or ""), "text": text, "html": html,
+        "attachments": attachments,
+    }
+
+
+def get_attachment(folder: str, uid, index: int) -> tuple:
+    msg = _fetch_message(folder, uid, mark_read=False)
+    for i, part in enumerate(msg.iter_attachments()):
+        if i == int(index):
+            return (_safe_name(part.get_filename() or f"anhang-{i + 1}"),
+                    part.get_content_type(), part.get_payload(decode=True) or b"")
+    raise MailError("Anhang nicht gefunden")
+
+
+# ── Ordner + Verschieben ────────────────────────────────────────────
+
+def imap_utf7_encode(name: str) -> str:
+    """'Entwürfe' → 'Entw&APw-rfe' (Gegenstueck zu imap_utf7_decode)."""
+    import base64
+    out, buf = [], []
+
+    def flush():
+        if buf:
+            b = base64.b64encode("".join(buf).encode("utf-16-be")).decode("ascii")
+            out.append("&" + b.rstrip("=").replace("/", ",") + "-")
+            buf.clear()
+    for ch in name:
+        if 0x20 <= ord(ch) <= 0x7E:
+            flush()
+            out.append("&-" if ch == "&" else ch)
+        else:
+            buf.append(ch)
+    flush()
+    return "".join(out)
+
+
+def _delimiter(m) -> str:
+    typ, data = m.list('""', '""')
+    for line in data or []:
+        s = line.decode("utf-8", "replace") if isinstance(line, bytes) else str(line)
+        lm = _LIST_RE.match(s.strip())
+        if lm and lm.group("delim") != "NIL":
+            return lm.group("delim").strip('"')
+    return "/"
+
+
+def _resolve_folder(folder: str) -> str:
+    """Ordner per Rohname ODER lesbarem Namen finden (ARIA sagt 'Entwürfe',
+    der Server kennt 'Entw&APw-rfe'). Gross/klein egal."""
+    want = (folder or "").strip()
+    if not want:
+        raise MailError("Kein Ordner angegeben")
+    folders = list_folders()
+    for f in folders:
+        if f["name"] == want or f["label"] == want:
+            return f["name"]
+    for f in folders:
+        if want.lower() in (f["name"].lower(), f["label"].lower()):
+            return f["name"]
+    raise MailError(f"Ordner {folder!r} gibt es nicht. Vorhanden: "
+                    + ", ".join(f["label"] for f in folders))
+
+
+def create_folder(name: str, parent: str = "") -> dict:
+    """Ordner anlegen, optional als Unterordner. Der Name darf das
+    Trennzeichen des Servers nicht enthalten — sonst entstuende still eine
+    ganze Kette von Ordnern statt des einen gewuenschten."""
+    name = (name or "").strip()
+    if not name:
+        raise MailError("Kein Ordnername")
+    parent_raw = _resolve_folder(parent) if parent else ""
+    m = _imap_open(load_config())
+    try:
+        delim = _delimiter(m)
+        if delim and delim in name:
+            raise MailError(f"Ordnername darf {delim!r} nicht enthalten — fuer Unterordner 'parent' angeben")
+        raw = (parent_raw + delim if parent_raw else "") + imap_utf7_encode(name)
+        typ, data = m.create(_quote(raw))
+        if typ != "OK":
+            msg = (data[0].decode("utf-8", "replace") if data and isinstance(data[0], bytes) else str(data))
+            raise MailError(f"Anlegen abgelehnt: {msg[:200]}")
+        m.subscribe(_quote(raw))   # sonst zeigen manche Mailprogramme ihn nicht
+        return {"name": raw, "label": imap_utf7_decode(raw)}
+    finally:
+        _imap_close(m)
+
+
+def move_message(folder: str, uid, target: str) -> dict:
+    """Mail in einen anderen Ordner verschieben.
+
+    Mit MOVE (RFC 6851) in einem Schritt. Ohne: kopieren, als geloescht
+    markieren und NUR diese Mail entfernen (UID EXPUNGE, braucht UIDPLUS). Ein
+    nacktes EXPUNGE wuerde alles mitnehmen, was im Ordner sonst noch als
+    geloescht markiert ist — dann bleibt die Mail lieber markiert liegen.
+    """
+    u = _uid_ok(uid)
+    src = _resolve_folder(folder or "INBOX")
+    dst = _resolve_folder(target)
+    if src == dst:
+        raise MailError("Quelle und Ziel sind derselbe Ordner")
+    m = _imap_open(load_config())
+    try:
+        _select(m, src, readonly=False)
+        caps = {c.upper() for c in (m.capabilities or ())}
+        if "MOVE" in caps:
+            typ, data = m.uid("MOVE", u, _quote(dst))
+            if typ != "OK":
+                raise MailError(f"Verschieben abgelehnt: {data!r}"[:200])
+            return {"ok": True, "from": imap_utf7_decode(src), "to": imap_utf7_decode(dst), "how": "move"}
+        typ, data = m.uid("COPY", u, _quote(dst))
+        if typ != "OK":
+            raise MailError(f"Kopieren abgelehnt: {data!r}"[:200])
+        m.uid("STORE", u, "+FLAGS", "(\\Deleted)")
+        if "UIDPLUS" in caps:
+            m.uid("EXPUNGE", u)
+            how = "copy+expunge"
+        else:
+            how = "copy (Original als geloescht markiert)"
+        return {"ok": True, "from": imap_utf7_decode(src), "to": imap_utf7_decode(dst), "how": how}
+    finally:
+        _imap_close(m)

aria-brain/backfill_scope.py

@@ -0,0 +1,90 @@
+"""Einmaliger Backfill: weist bestehenden Memory-Punkten ein `scope`
+(system | personal) zu. Sicher & reversibel — Stefan kann pro Eintrag in der
+Diagnostic-UI umschalten. Idempotent: laeuft mehrfach ohne Schaden.
+
+Heuristik (datengetrieben aus dem realen Bestand):
+  - type=preference / fact / conversation / reminder  -> personal
+  - source in (seed, auto-feedback)                    -> system
+  - type=identity                                      -> system
+  - type in (rule, tool, skill) und category in SYSTEM_CATS -> system
+  - sonst                                              -> personal  (sicher: nichts leakt)
+
+Aufruf im Brain-Container:
+  docker exec aria-brain python3 /app/backfill_scope.py          # dry-run
+  docker exec aria-brain python3 /app/backfill_scope.py --apply  # schreibt
+"""
+import os
+import sys
+from collections import Counter
+
+from qdrant_client import QdrantClient
+from qdrant_client.http import models as qm
+
+COLLECTION = "aria_memory"
+SYSTEM_CATS = {
+    "sicherheit", "arbeitsweise", "architektur", "ehrlichkeit", "verhalten",
+    "voice", "skills", "freigaben", "infrastruktur", "persoenlichkeit",
+    "pentest", "ausgabe",
+}
+
+
+def compute_scope(pl: dict) -> str:
+    typ = pl.get("type")
+    src = pl.get("source")
+    cat = (pl.get("category") or "").lower()
+    if typ == "preference":
+        return "personal"
+    if typ in ("fact", "conversation", "reminder"):
+        return "personal"
+    if src in ("seed", "auto-feedback"):
+        return "system"
+    if typ == "identity":
+        return "system"
+    if typ in ("rule", "tool", "skill") and cat in SYSTEM_CATS:
+        return "system"
+    return "personal"
+
+
+def main():
+    apply = "--apply" in sys.argv
+    force = "--force" in sys.argv  # auch schon gesetzte scopes ueberschreiben
+    c = QdrantClient(
+        host=os.environ.get("QDRANT_HOST", "aria-qdrant"),
+        port=int(os.environ.get("QDRANT_PORT", "6333")),
+    )
+    pts, _ = c.scroll(collection_name=COLLECTION, limit=5000,
+                      with_payload=True, with_vectors=False)
+
+    per_scope: dict[str, list] = {"system": [], "personal": []}
+    pinned_examples = Counter()
+    skipped = 0
+    for p in pts:
+        pl = p.payload or {}
+        if pl.get("scope") in ("system", "personal") and not force:
+            skipped += 1
+            continue
+        scope = compute_scope(pl)
+        per_scope[scope].append(p.id)
+        if pl.get("pinned"):
+            pinned_examples[(scope, pl.get("source"), pl.get("type"),
+                             pl.get("category"))] += 1
+
+    print(f"total={len(pts)} skipped(already set)={skipped}")
+    print(f"-> system={len(per_scope['system'])}  personal={len(per_scope['personal'])}")
+    print("pinned split (scope, source, type, category):")
+    for k, v in sorted(pinned_examples.items()):
+        print("   ", k, v)
+
+    if not apply:
+        print("\nDRY-RUN — nichts geschrieben. Mit --apply ausfuehren.")
+        return
+
+    for scope, ids in per_scope.items():
+        if not ids:
+            continue
+        c.set_payload(collection_name=COLLECTION, payload={"scope": scope}, points=ids)
+    print(f"\nAPPLIED: system={len(per_scope['system'])} personal={len(per_scope['personal'])}")
+
+
+if __name__ == "__main__":
+    main()

aria-brain/background.py

@@ -36,7 +36,8 @@ TICK_SEC = 8
 BRIDGE_URL = os.environ.get("BRIDGE_URL", "http://aria-bridge:8090")
 
 
-def _push_to_bridge(reply: str, trigger_name: str, ttype: str, events: list) -> None:
+def _push_to_bridge(reply: str, trigger_name: str, ttype: str, events: list,
+                    project_id: str = "") -> None:
     """POSTed eine Trigger-Antwort an die Bridge fuer RVS-Broadcast + TTS.
 
     Synchron via urllib — wird per run_in_executor aus dem async-Loop
@@ -47,6 +48,10 @@ def _push_to_bridge(reply: str, trigger_name: str, ttype: str, events: list) ->
         "trigger_name": trigger_name,
         "type": ttype,
         "events": events or [],
+        # Kontext, in dem der Trigger angelegt wurde. Leer = Hauptchat. Ohne das
+        # landete JEDE Trigger-Antwort im Hauptchat, auch wenn der Timer mitten
+        # in einem Projekt-Thread gestellt wurde.
+        "projectId": project_id or "",
     }).encode("utf-8")
     url = f"{BRIDGE_URL}/internal/trigger-fired"
     try:
@@ -149,15 +154,30 @@ async def _fire(trigger: dict, agent_factory) -> None:
     )
 
     try:
-        agent = agent_factory()
-        reply, _, _, _ = agent.chat(prompt, source="trigger")
-        events = agent.pop_events()
-        logger.info("[trigger] %s gefeuert → ARIA-Reply: %s", name, reply[:80])
+        # WICHTIG: agent.chat() ist ein SYNCHRONER, blockierender Aufruf (Proxy-
+        # HTTP mit bis zu 24h Read-Timeout). NIEMALS direkt im async-Loop —
+        # sonst friert ein einziger getriggerter Turn den GESAMTEN Brain ein
+        # (kein /health, kein weiterer Request). Wie der /chat-Pfad in den
+        # Executor auslagern, damit der Event-Loop frei bleibt.
+        loop = asyncio.get_running_loop()
+
+        # Projekt, in dem der Trigger angelegt wurde — der Turn laeuft darin, und
+        # die Antwort geht auch dorthin zurueck (statt immer in den Hauptchat).
+        trigger_pid = str(trigger.get("project_id") or "")
+
+        def _run_turn():
+            a = agent_factory()
+            rep, *_rest = a.chat(prompt, source="trigger", project_id=trigger_pid)
+            return rep, a.pop_events()
+
+        reply, events = await loop.run_in_executor(None, _run_turn)
+        logger.info("[trigger] %s gefeuert (project=%s) → ARIA-Reply: %s",
+                    name, trigger_pid or "(main)", reply[:80])
         triggers_mod.append_log(name, {"event": "reply", "text": reply[:500]})
         # Reply an die Bridge pushen, damit App + Diagnostic + TTS sie kriegen.
         # Ohne diesen Push wuerde die Antwort nur im Brain-Log landen.
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, _push_to_bridge, reply, name, ttype, events)
+        await loop.run_in_executor(None, _push_to_bridge, reply, name, ttype,
+                                   events, trigger_pid)
     except Exception as e:
         logger.exception("Trigger %s feuern fehlgeschlagen: %s", name, e)
         triggers_mod.append_log(name, {"event": "error", "error": str(e)[:300]})

aria-brain/clean_poisoned_turns.py

@@ -13,11 +13,27 @@ Haltung fort (Self-Grounding rueckwaerts). Der --system-prompt-Fix verhindert
 NEUE Vergiftung, aber die bestehenden Gift-Turns muessen einmalig raus, sonst
 zieht die History das Modell weiter aus der Rolle.
 
+Zweite Giftquelle: Anthropics Sicherheitsfilter
+----------------------------------------------
+Dasselbe Muster, anderer Auslöser. Der Filter ("... safeguards flagged this
+message", `Details: [cyber]`) antwortet nicht mit einem HTTP-Fehler: die CLI
+liefert ein normales Ergebnis mit is_error=true und dem Fehlertext im content.
+Vor dem safeguard.py-Fix wurde dieser Text als ARIAs Antwort persistiert — und
+die ausloesende Frage steht direkt davor. Beides geht bei jedem Folge-Turn
+wieder mit, also greift der Filter wieder: das Projekt ist tot.
+
+Neue Vorfaelle faengt das Brain jetzt selbst ab (Modellwechsel, im Notfall
+Quarantaene). Was VORHER schon in der Datei steht, muss einmalig raus — dafuer
+ist dieses Script da. Diese Sorte wird in ALLEN Kontexten gesucht, nicht nur im
+Hauptthread: Projekt-Chats sind genau die, die daran sterben.
+
 Was das Script tut
 ------------------
 - Findet Hauptthread-Assistant-Turns (KEIN project_id), deren Inhalt eindeutig
   eine Rollen-Ablehnung ist: enthaelt "claude code" UND einen zweiten Marker
   (injiz/inject/fabriz/fabricat/adoptier/adopting/prompt injection/keine echten).
+- Findet in JEDEM Kontext Assistant-Turns, die der Fehlertext des
+  Sicherheitsfilters sind.
 - Entfernt diese Assistant-Turns PLUS den unmittelbar davor stehenden
   Hauptthread-User-Turn (die ausloesende Frage) — also den ganzen Fehl-Dialog.
 - Laesst ALLES andere unangetastet: projekt-getaggte Turns, distill-Marker,
@@ -61,10 +77,39 @@ _BREAK = re.compile(
 )
 
 
+# Der Fehlertext des Sicherheitsfilters. Gleiche Marker wie safeguard.py; hier
+# dupliziert, damit das Script ohne Brain-Imports auf dem Host laeuft.
+# Verlangt wird ZWEIERLEI: der Text muss mit "API Error" beginnen UND einen
+# Filter-Marker enthalten. Sonst traefe es auch Turns, in denen ARIA ueber den
+# Filter *spricht* — und eine Erklaerung ist kein Gift.
+_FILTER_MARKERS = (
+    "safeguards flagged this message",
+    "anthropic.com/legal/aup",
+    "can't respond to this message with",
+    "cannot respond to this message with",
+    "try rephrasing the request in a new session",
+)
+
+
 def is_poison(content: str) -> bool:
     return bool(_BREAK.search(content or ""))
 
 
+def is_filter_error(content: str) -> bool:
+    t = (content or "").strip().lower()
+    if not t.startswith("api error"):
+        return False
+    return any(m in t for m in _FILTER_MARKERS)
+
+
+def project_of(obj: dict) -> str:
+    """Projekt-Tag eines Turns. Brain nutzt 'project_id', UI/Bridge 'projectId'."""
+    pid = obj.get("project_id")
+    if pid is None:
+        pid = obj.get("projectId")
+    return str(pid or "").strip()
+
+
 def get_content(obj: dict) -> str:
     """conversation.jsonl nutzt 'content', chat_backup.jsonl nutzt 'text'."""
     v = obj.get("content")
@@ -112,24 +157,38 @@ def main() -> int:
             continue
         if obj.get("op") == "distill":
             continue
-        if obj.get("role") != "assistant" or not is_main_thread(obj):
+        if obj.get("role") != "assistant":
             continue
         content = get_content(obj)
-        if not content or not is_poison(content):
+        if not content:
+            continue
+        # Zwei Giftsorten mit unterschiedlichem Geltungsbereich:
+        #   Rollen-Ablehnung — nur Hauptthread (so war es immer; in Projekten
+        #       waere das Risiko eines False Positive hoeher als der Nutzen).
+        #   Sicherheitsfilter — ueberall, denn genau Projekt-Chats sterben daran.
+        if is_filter_error(content):
+            reason = "Sicherheitsfilter"
+        elif is_main_thread(obj) and is_poison(content):
+            reason = "Rollen-Ablehnung"
+        else:
             continue
         # Gift-Assistant-Turn -> droppen
         drop[i] = True
         user_idx = None
-        # Unmittelbar davor stehenden Hauptthread-User-Turn (die Frage) mit weg.
+        pid = project_of(obj)
+        # Unmittelbar davor stehenden User-Turn DESSELBEN Kontexts (die
+        # ausloesende Frage) mit weg — sonst bleibt der Ausloeser im Fenster.
         for j in range(i - 1, -1, -1):
             pj = parsed[j][1]
             if not isinstance(pj, dict) or pj.get("op") == "distill":
                 continue
-            if pj.get("role") == "user" and is_main_thread(pj):
+            if project_of(pj) != pid:
+                continue  # fremder Kontext — ueberspringen, nicht abbrechen
+            if pj.get("role") == "user":
                 drop[j] = True
                 user_idx = j
-            break  # nur der direkt vorangehende Turn
-        poisoned_pairs.append((i, user_idx))
+            break  # nur der direkt vorangehende Turn dieses Kontexts
+        poisoned_pairs.append((i, user_idx, reason, pid))
 
     n_drop = sum(drop)
     if n_drop == 0:
@@ -138,12 +197,13 @@ def main() -> int:
 
     print(f"Gefundene Fehl-Dialoge: {len(poisoned_pairs)} "
           f"(insgesamt {n_drop} Zeilen zu entfernen)\n")
-    for a_idx, u_idx in poisoned_pairs:
+    for a_idx, u_idx, reason, pid in poisoned_pairs:
+        print(f"  [{reason}] Kontext: {pid or 'Hauptchat'}")
         if u_idx is not None:
             uq = get_content(parsed[u_idx][1] or {})
-            print(f"  Frage   (Zeile {u_idx + 1}): {uq[:90]!r}")
+            print(f"  Frage    (Zeile {u_idx + 1}): {uq[:90]!r}")
         ac = get_content(parsed[a_idx][1] or {})
-        print(f"  Ablehng (Zeile {a_idx + 1}): {ac[:90]!r}")
+        print(f"  Antwort  (Zeile {a_idx + 1}): {ac[:90]!r}")
         print()
 
     if not apply:

aria-brain/context_model.py

@@ -0,0 +1,95 @@
+"""Welches Modell gilt in welchem Chat.
+
+Drei Ebenen, von unten nach oben:
+
+  1. Einstellung — `brainModel` aus runtime.json (Diagnostic → Sprachmodell).
+     Gilt fuer alles, was keine eigene Wahl hat.
+  2. Pro Chat — ein Override je Kontext ("" = Hauptchat, sonst project_id).
+     Damit kann ein Projekt bewusst auf einem anderen Modell laufen, ohne das
+     Hauptmodell fuer alles umzustellen.
+  3. Ausweich — Anthropics Sicherheitsfilter hat das gewaehlte Modell an einem
+     Turn blockiert, der noch im Fenster liegt (safeguard.py). Das sticht alles,
+     ist aber nur so lange aktiv, wie der Turn im Fenster steht.
+
+Warum ueberhaupt ein eigener Speicher und kein Feld im Projekt-Manifest: der
+Hauptchat IST kein Projekt. Ein Manifest-Feld haette ihn aussen vor gelassen,
+und genau dort faellt eine Modellwahl am ehesten an.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+from pathlib import Path
+from typing import Tuple
+
+logger = logging.getLogger(__name__)
+
+STORE_FILE = Path(os.environ.get("CONTEXT_MODELS_FILE",
+                                 "/shared/config/context_models.json"))
+
+# Begruendungen, wie sie die Oberflaechen anzeigen. Bewusst kurze Schluessel —
+# App und Diagnostic uebersetzen sie selbst, damit die Texte dort hingehoeren,
+# wo sie gelesen werden.
+REASON_SETTING = "einstellung"
+REASON_PER_CHAT = "pro-chat"
+REASON_FALLBACK = "ausweich"
+
+_lock = threading.Lock()
+
+
+def _load() -> dict:
+    try:
+        if STORE_FILE.exists():
+            data = json.loads(STORE_FILE.read_text(encoding="utf-8")) or {}
+            if isinstance(data, dict):
+                # Nur String→String; alles andere waere ein Schreibfehler von
+                # aussen und wuerde sonst still als Modellname durchgehen.
+                return {str(k): str(v) for k, v in data.items() if isinstance(v, str)}
+    except Exception as exc:
+        logger.warning("[context-model] lesen fehlgeschlagen: %s", exc)
+    return {}
+
+
+def _save(data: dict) -> None:
+    try:
+        STORE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = STORE_FILE.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(STORE_FILE)
+    except Exception as exc:
+        logger.warning("[context-model] schreiben fehlgeschlagen: %s", exc)
+
+
+def all_overrides() -> dict:
+    return _load()
+
+
+def get(context_id: str) -> str:
+    """Der Override dieses Kontexts, oder "" wenn keiner gesetzt ist."""
+    return _load().get(context_id or "", "")
+
+
+def set(context_id: str, model: str) -> str:
+    """Override setzen. Leerer Modellname loescht ihn (= wieder Einstellung)."""
+    cid = context_id or ""
+    m = (model or "").strip()
+    with _lock:
+        data = _load()
+        if m:
+            data[cid] = m
+        else:
+            data.pop(cid, None)
+        _save(data)
+    logger.info("[context-model] %s → %s", cid or "(Hauptchat)", m or "(Einstellung)")
+    return m
+
+
+def resolve(context_id: str, default_model: str) -> Tuple[str, str]:
+    """(Modell, Begruendung) ohne Sicherheitsfilter — den kennt nur der Agent."""
+    ov = get(context_id)
+    if ov:
+        return ov, REASON_PER_CHAT
+    return default_model, REASON_SETTING

aria-brain/local_compact.py

@@ -0,0 +1,186 @@
+"""
+Compacting fuer ARIAs lokalen Modus (Fast-Lane / localOnly).
+
+Ein lokales Modell hat ein kleines Kontextfenster (z.B. 32k auf einer
+12-GB-Karte). Frueher bekam es starr die letzten 8 Nachrichten — alles davor
+war fuer das lokale Modell einfach weg. Jetzt:
+
+  * Fenster nach TOKENS statt fester Anzahl: so viele der letzten Nachrichten,
+    wie in ~75 % des Kontextfensters passen (Systemprompt + Antwortplatz
+    abgezogen), hoechstens LOCAL_MAX_TURNS (Tempo).
+  * Was aus dem Fenster faellt, fasst das lokale Modell im HINTERGRUND zu
+    einer laufenden Zusammenfassung zusammen ("Notizzettel"). Die liegt pro
+    Projekt in /data/local_summaries.json und geht bei jeder lokalen Anfrage
+    als "Bisheriger Verlauf" in den Systemprompt.
+
+Unabhaengig davon laeuft weiter das Destillat (agent.distill_old_turns):
+dauerhaft Wichtiges wandert als Fakt ins Gedaechtnis (Qdrant). Compacting =
+Notizzettel fuer DIESES Gespraech, Destillat = Karteikarten fuers Archiv.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import time
+import urllib.request
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+BRIDGE_URL = os.environ.get("BRIDGE_URL", "http://aria-bridge:8090")
+SUMMARY_FILE = Path(os.environ.get("LOCAL_SUMMARY_FILE", "/data/local_summaries.json"))
+LOCAL_MAX_TURNS = int(os.environ.get("LOCAL_MAX_TURNS", "12"))
+DEFAULT_CTX = 8192
+CHARS_PER_TOKEN = 2.8          # Deutsch/Code: eher vorsichtig schaetzen
+COMPACT_MIN_TURNS = 4          # erst ab so vielen neu herausgefallenen Nachrichten
+SUMMARY_MAX_TOKENS = 450
+
+_lock = threading.Lock()
+_running: set = set()          # Projekte, fuer die gerade verdichtet wird
+_ctx_cache: dict = {"ts": 0.0, "models": {}}
+
+
+def est_tokens(text: str) -> int:
+    return int(len(text or "") / CHARS_PER_TOKEN) + 4
+
+
+def model_ctx(model: str) -> int:
+    """Kontextfenster des lokalen Modells laut Cluster (60 s gecacht)."""
+    now = time.time()
+    if now - _ctx_cache["ts"] > 60:
+        try:
+            with urllib.request.urlopen(f"{BRIDGE_URL}/internal/llm-models", timeout=3) as r:
+                data = json.loads(r.read().decode("utf-8", "ignore"))
+            _ctx_cache["models"] = {m.get("model"): int(m.get("ctx") or 0)
+                                    for m in data.get("models") or []}
+            _ctx_cache["ts"] = now
+        except Exception as exc:
+            logger.debug("[compact] Kontextfenster nicht abfragbar: %s", exc)
+            _ctx_cache["ts"] = now - 50      # in 10 s nochmal versuchen
+    return _ctx_cache["models"].get(model) or DEFAULT_CTX
+
+
+def fit_window(turns: list, budget_tokens: int) -> list:
+    """Die neuesten Nachrichten, die ins Budget passen (mind. die letzte)."""
+    out, used = [], 0
+    for t in reversed(turns[-LOCAL_MAX_TURNS:]):
+        need = est_tokens(t.content)
+        if out and used + need > budget_tokens:
+            break
+        out.append(t)
+        used += need
+    return list(reversed(out))
+
+
+# ── Laufende Zusammenfassung pro Projekt ─────────────────────────────
+
+def _load() -> dict:
+    try:
+        return json.loads(SUMMARY_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def get_summary(project_id: str) -> dict:
+    """{text, upto_ts} — upto_ts = Zeitstempel der juengsten verdichteten Nachricht."""
+    s = _load().get(project_id or "", {})
+    return {"text": s.get("text", ""), "upto_ts": s.get("upto_ts", "")}
+
+
+def _save_summary(project_id: str, text: str, upto_ts: str) -> None:
+    with _lock:
+        data = _load()
+        data[project_id or ""] = {"text": text, "upto_ts": upto_ts,
+                                  "updated": time.strftime("%Y-%m-%dT%H:%M:%S")}
+        tmp = SUMMARY_FILE.with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=1), encoding="utf-8")
+        tmp.replace(SUMMARY_FILE)
+
+
+def reset(project_id=None) -> None:
+    """Zusammenfassung(en) verwerfen (z.B. beim Zuruecksetzen des Gespraechs)."""
+    with _lock:
+        if project_id is None:
+            try:
+                SUMMARY_FILE.unlink()
+            except FileNotFoundError:
+                pass
+            return
+        data = _load()
+        data.pop(project_id or "", None)
+        SUMMARY_FILE.write_text(json.dumps(data, ensure_ascii=False, indent=1), encoding="utf-8")
+
+
+def summary_block(project_id: str) -> str:
+    s = get_summary(project_id).get("text", "").strip()
+    if not s:
+        return ""
+    return ("## BISHERIGER VERLAUF (Zusammenfassung aelterer Nachrichten)\n"
+            "Das ist eine Zusammenfassung dessen, was vor den letzten Nachrichten "
+            "besprochen wurde. Nutze es als Hintergrund, zitiere es nicht.\n" + s)
+
+
+def maybe_compact(project_id: str, all_turns: list, window: list, model: str,
+                  chat_fn) -> None:
+    """Startet im Hintergrund eine Verdichtung, wenn genug Nachrichten aus dem
+    Fenster gefallen sind, die noch nicht im Notizzettel stehen.
+    chat_fn = local_llm_chat (wird nur im Hintergrund-Thread aufgerufen)."""
+    if not window:
+        return
+    first_kept = window[0].ts
+    upto = get_summary(project_id)["upto_ts"]
+    dropped = [t for t in all_turns if t.ts < first_kept and t.ts > upto]
+    if len(dropped) < COMPACT_MIN_TURNS:
+        return
+    key = project_id or ""
+    with _lock:
+        if key in _running:
+            return
+        _running.add(key)
+    threading.Thread(target=_compact, args=(key, dropped, model, chat_fn),
+                     daemon=True, name=f"compact-{key or 'main'}").start()
+
+
+def _compact(project_id: str, dropped: list, model: str, chat_fn) -> None:
+    try:
+        prev = get_summary(project_id)["text"]
+        ctx = model_ctx(model)
+        # Was in die Verdichtungs-Anfrage passt: ~60 % des Fensters
+        room = int(ctx * 0.6 * CHARS_PER_TOKEN) - len(prev) - 2000
+        lines, used, last_ts = [], 0, ""
+        for t in dropped:                       # aelteste zuerst
+            who = "Stefan" if t.role == "user" else "ARIA"
+            line = f"{who}: {t.content.strip()}"
+            if used + len(line) > room:
+                line = line[: max(0, room - used)] + " …"
+            lines.append(line)
+            used += len(line)
+            last_ts = t.ts
+            if used >= room:
+                break                           # Rest beim naechsten Durchlauf
+        system = ("Du fuehrst einen laufenden Notizzettel ueber ein Gespraech zwischen "
+                  "Stefan und seiner Assistentin ARIA. Schreibe auf Deutsch eine knappe "
+                  "Zusammenfassung (hoechstens ~250 Woerter, Stichpunkte erlaubt): worum "
+                  "es ging, was entschieden oder erledigt wurde, offene Punkte, wichtige "
+                  "Namen/Zahlen. Kein Smalltalk, keine Einleitung, nur der Notizzettel.")
+        user = ((f"Bisheriger Notizzettel:\n{prev}\n\n" if prev else "")
+                + "Diese Nachrichten kommen neu dazu:\n" + "\n".join(lines)
+                + "\n\nSchreibe den aktualisierten Notizzettel.")
+        res = chat_fn([{"role": "system", "content": system}, {"role": "user", "content": user}],
+                      max_tokens=SUMMARY_MAX_TOKENS, temperature=0.2, model=model, timeout=180)
+        text = (res.get("content") or "").strip() if res.get("ok") else ""
+        if not text:
+            logger.warning("[compact] Verdichtung fehlgeschlagen (%s) — Notizzettel bleibt",
+                           res.get("error"))
+            return
+        _save_summary(project_id, text, last_ts)
+        logger.info("[compact] %d Nachrichten verdichtet (Projekt %r) → %d Zeichen Notizzettel",
+                    len(dropped), project_id, len(text))
+    except Exception as exc:
+        logger.warning("[compact] Fehler: %s", exc)
+    finally:
+        with _lock:
+            _running.discard(project_id or "")

aria-brain/local_llm.py

@@ -1,7 +1,7 @@
 """
 Local-LLM-Client (Plan B) — Brain-Seite.
 
-Ruft das schnelle lokale LLM (Qwen3 auf der Gamebox) ueber die Bridge:
+Ruft das schnelle lokale LLM (Qwen3 auf der AI-Box) ueber die Bridge:
   Brain → HTTP /internal/local-llm → Bridge → RVS → llm-adapter → llama.cpp
 
 Analog zum Claude-`proxy_client`, nur ueber die Bridge (die ist der RVS-Client;
@@ -30,7 +30,7 @@ LOCAL_LLM_HTTP_TIMEOUT_SEC = float(os.environ.get("LOCAL_LLM_HTTP_TIMEOUT_SEC",
 
 def local_llm_chat(messages: list, *, max_tokens: int = 512,
                    temperature: float = 0.7, stop=None, tools=None,
-                   model=None) -> dict:
+                   model=None, timeout=None) -> dict:
     """Ein Chat-Call ans lokale LLM. messages = [{role, content}, ...].
     model (B0.5): welches Modell llama-swap laden soll. tools (B1b): optionale
     OpenAI-Tool-Defs; das Ergebnis kann dann result['tool_calls'] enthalten.
@@ -44,13 +44,15 @@ def local_llm_chat(messages: list, *, max_tokens: int = 512,
         req["tools"] = tools
     if model:
         req["model"] = model
+    if timeout:
+        req["timeout"] = timeout       # Bridge-seitige Frist (sonst 30 s)
     try:
         body = json.dumps(req).encode("utf-8")
         http_req = urllib.request.Request(
             f"{BRIDGE_URL}/internal/local-llm", data=body, method="POST",
             headers={"Content-Type": "application/json"},
         )
-        with urllib.request.urlopen(http_req, timeout=LOCAL_LLM_HTTP_TIMEOUT_SEC) as resp:
+        with urllib.request.urlopen(http_req, timeout=(timeout + 5) if timeout else LOCAL_LLM_HTTP_TIMEOUT_SEC) as resp:
             result = json.loads(resp.read().decode("utf-8", "ignore"))
     except urllib.error.HTTPError as exc:
         try:

aria-brain/main.py

@@ -23,7 +23,7 @@ from typing import List, Optional
 import asyncio
 from contextlib import asynccontextmanager
 
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Request, UploadFile, File
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Request, UploadFile, File, Header
 from fastapi.responses import Response
 from pydantic import BaseModel, Field
 
@@ -38,7 +38,11 @@ import watcher as watcher_mod
 import background as background_mod
 import oauth as oauth_mod
 import seed_rules as seed_rules_mod
+import safeguard as safeguard_mod
+import context_model as context_model_mod
+import aria_mail
 import projects as projects_mod
+import project_vms as project_vms_mod
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
 logger = logging.getLogger("aria-brain")
@@ -189,6 +193,7 @@ class MemoryIn(BaseModel):
     pinned: bool = False
     category: str = ""
     source: str = "manual"
+    scope: str = "personal"  # system | personal — steuert Bootstrap-Export
     tags: List[str] = Field(default_factory=list)
     conversation_id: Optional[str] = None
     # Vorhandene Anhang-Metadaten beim Save mitgeben (i.d.R. werden Anhaenge
@@ -202,6 +207,7 @@ class MemoryUpdate(BaseModel):
     content: Optional[str] = None
     pinned: Optional[bool] = None
     category: Optional[str] = None
+    scope: Optional[str] = None  # system | personal
     tags: Optional[List[str]] = None
 
 
@@ -213,6 +219,7 @@ class MemoryOut(BaseModel):
     pinned: bool
     category: str
     source: str
+    scope: str = "personal"
     tags: List[str]
     created_at: str
     updated_at: str
@@ -327,6 +334,7 @@ def memory_save(body: MemoryIn):
         pinned=body.pinned,
         category=body.category,
         source=body.source,
+        scope=body.scope,
         tags=body.tags,
         conversation_id=body.conversation_id,
         attachments=body.attachments or [],
@@ -352,6 +360,8 @@ def memory_update(point_id: str, body: MemoryUpdate):
         existing.pinned = body.pinned
     if body.category is not None:
         existing.category = body.category
+    if body.scope is not None:
+        existing.scope = body.scope
     if body.tags is not None:
         existing.tags = body.tags
 
@@ -391,6 +401,19 @@ def memory_delete(point_id: str):
 
 # ─── Memory-Anhaenge ──────────────────────────────────────────────────
 
+@app.get("/attachments/limit")
+def memory_attachments_limit():
+    """Aktuelles Groessen-Limit fuer Memory-Anhaenge.
+
+    Die Oberflaechen zeigen damit die ECHTE Zahl an statt eines fest
+    eingetippten "max 20 MB" — das stand vorher im HTML und stimmte nicht mehr,
+    sobald jemand das Limit anhob.
+    """
+    import memory_attachments as mem_att
+    limit = mem_att.max_bytes()
+    return {"maxBytes": limit, "maxMb": round(limit / 1024 / 1024, 1)}
+
+
 @app.get("/memory/{point_id}/attachments")
 def memory_attachments_list(point_id: str):
     """Liste der Anhaenge zum Memory. Source-of-Truth ist das Payload
@@ -536,12 +559,23 @@ def memory_import_files():
 # 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."""
+def memory_export_bootstrap(scope: str = "system"):
+    """Gibt pinned Memories als JSON zurueck — fuer Browser-Download.
+
+    scope='system'   → nur generische Regeln (fuer ein frisches System),
+    scope='personal' → nur Stefan-spezifisches (Name, Zugangsdaten, Projekte),
+    scope='all'      → alles pinned (Vollbackup).
+    Default 'system', damit man nicht versehentlich Persoenliches teilt."""
     s = store()
-    pinned = s.list_pinned()
+    if scope == "all":
+        pinned = s.list_pinned()
+    elif scope in ("system", "personal"):
+        pinned = s.list_pinned_by_scope(scope)
+    else:
+        raise HTTPException(400, f"Ungueltiger scope: {scope}")
     return {
-        "version": 1,
+        "version": 2,
+        "scope": scope,
         "exported_at": __import__("datetime").datetime.now(
             __import__("datetime").timezone.utc
         ).isoformat(),
@@ -554,6 +588,7 @@ def memory_export_bootstrap():
                 "pinned": True,
                 "category": p.category,
                 "source": p.source,
+                "scope": p.scope,
                 "tags": p.tags,
             }
             for p in pinned
@@ -563,13 +598,18 @@ def memory_export_bootstrap():
 
 class BootstrapBundle(BaseModel):
     version: int = 1
+    scope: Optional[str] = None  # system | personal | all (aus dem Export)
     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.
+    """Importiert ein Bootstrap-Bundle scope-sicher.
+
+    Es werden NUR die aktuell pinned Punkte geloescht, deren scope zum Import
+    gehoert — ein System-Import laesst also die persoenlichen pinned Memories
+    (Name, Zugangsdaten) unangetastet und umgekehrt. Bei einem 'all'-Bundle
+    (Vollbackup) werden alle pinned ersetzt.
 
     Wenn keine Memories im Bundle: nur loeschen ist NICHT erlaubt — der
     Caller soll erst exportieren und dann importieren.
@@ -579,23 +619,31 @@ def memory_import_bootstrap(body: BootstrapBundle):
 
     s = store()
     e = embedder()
-
-    # Alle aktuell pinned Punkte loeschen
     from qdrant_client.http import models as qm
     from memory.vector_store import COLLECTION
+
+    # Scope bestimmen: explizit aus dem Bundle, sonst aus den memories ableiten.
+    bundle_scope = body.scope
+    if bundle_scope not in ("system", "personal", "all"):
+        scopes_in_mems = {m.get("scope", "personal") for m in body.memories}
+        bundle_scope = scopes_in_mems.pop() if len(scopes_in_mems) == 1 else "all"
+
+    # Nur die pinned Punkte des betroffenen scope loeschen.
+    del_must = [qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True))]
+    if bundle_scope in ("system", "personal"):
+        del_must.append(qm.FieldCondition(key="scope", match=qm.MatchValue(value=bundle_scope)))
     s.client.delete(
         collection_name=COLLECTION,
-        points_selector=qm.FilterSelector(filter=qm.Filter(must=[
-            qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True))
-        ])),
+        points_selector=qm.FilterSelector(filter=qm.Filter(must=del_must)),
     )
 
-    # Neue Punkte einspeisen
+    # Neue Punkte einspeisen — scope pro memory (Fallback: bundle_scope bzw. personal).
     created = 0
     for m in body.memories:
         content = (m.get("content") or "").strip()
         if not content:
             continue
+        mscope = m.get("scope") or (bundle_scope if bundle_scope != "all" else "personal")
         point = MemoryPoint(
             id="",
             type=m.get("type", "fact"),
@@ -604,13 +652,14 @@ def memory_import_bootstrap(body: BootstrapBundle):
             pinned=True,
             category=m.get("category", ""),
             source=m.get("source", "bootstrap-import"),
+            scope=mscope,
             tags=list(m.get("tags", [])),
         )
         vec = e.embed(content)
         s.upsert(point, vec)
         created += 1
 
-    return {"created": created, "deleted_previous_pinned": True}
+    return {"created": created, "scope": bundle_scope, "deleted_previous_pinned": True}
 
 
 # ─── Conversation-Loop ──────────────────────────────────────────────
@@ -633,12 +682,26 @@ class ChatOut(BaseModel):
     # Welcher Backend die Antwort erzeugt hat: "local" (Qwen), "claude",
     # "fast-path" (Skill/Regex). Fuer den Quell-Badge in Diagnostic.
     answered_by: str = "claude"
+    # Welches Claude-Modell geantwortet hat (aus modelUsage der CLI, also die
+    # aufgeloeste Version) und WARUM dieses: "einstellung" | "pro-chat" |
+    # "ausweich" (Sicherheitsfilter). Leer, wenn kein Claude-Modell lief.
+    model: str = ""
+    model_reason: str = ""
     # Soll die Antwort vorgelesen werden? Fast-Path (reiner Steuerbefehl) = False;
     # ARIA-Antworten (local/claude) = True. System-Flag statt <voice>-Tag.
     speak: bool = True
     # Soll die App nach der Antwort 30s weiterlauschen (Gespraech)? Einzelaktionen/
     # Skills = False (direkt zurueck aufs Wake-Word), Konversation = True.
     converse: bool = True
+    # Stellt ARIA eine blockierende Rueckfrage (braucht Stefans Antwort, bevor der
+    # Task fertig ist)? Dann pausiert die App die Projekt-Queue und leitet die
+    # naechste Eingabe als Antwort weiter, statt sie als neuen Auftrag anzustellen.
+    awaiting_reply: bool = False
+    # Der User hat per Sprache "Wake-Word aus" gesagt → die App stoppt den
+    # Wake-Word-Listener komplett (Mikro frei).
+    wake_off: bool = False
+    # "Wake-Word an" per Befehl (Text/Aufnahme-Button) → App startet den Listener.
+    wake_on: bool = False
     # Echo der project_id die dieser Turn hatte. Bridge nutzt sie damit die
     # ausgehende Chat-Bubble sauber getaggt in der richtigen Thread-Bahn der
     # UI landet.
@@ -722,7 +785,7 @@ async def chat(body: ChatIn, background: BackgroundTasks):
                 # Sync-Aufruf im Executor damit wir den Event-Loop nicht blocken —
                 # chat() macht HTTP-Calls (Proxy) die 30-60s dauern koennen.
                 loop = asyncio.get_running_loop()
-                reply, answered_by, speak, converse = await loop.run_in_executor(
+                reply, answered_by, speak, converse, awaiting_reply, model_info = await loop.run_in_executor(
                     None,
                     lambda: a.chat(
                         body.message, source=body.source, project_id=pid,
@@ -745,8 +808,13 @@ async def chat(body: ChatIn, background: BackgroundTasks):
                 events=a.pop_events(),
                 project_id=pid,
                 answered_by=answered_by,
+                model=(model_info or {}).get("model", ""),
+                model_reason=(model_info or {}).get("reason", ""),
                 speak=speak,
                 converse=converse,
+                awaiting_reply=awaiting_reply,
+                wake_off=(answered_by == "wake-off"),
+                wake_on=(answered_by == "wake-on"),
             )
     finally:
         _project_pending[pid] = [
@@ -764,15 +832,49 @@ def projects_queue_status():
 
 # ── Projekte ────────────────────────────────────────────────────────
 
+def _project_file_count(pid: str) -> int:
+    """Anzahl Dateien in /shared/projects/<pid>/ (rekursiv, gecappt). 0 = leer."""
+    base = os.path.join("/shared/projects", pid or "")
+    if not os.path.isdir(base):
+        return 0
+    cnt = 0
+    try:
+        for _dp, dns, fns in os.walk(base):
+            dns[:] = [d for d in dns if d not in (".git", "node_modules", "__pycache__", ".venv", "venv")]
+            cnt += len(fns)
+            if cnt > 999:
+                return 999
+    except Exception:
+        return 0
+    return cnt
+
+
+def _enrich_projects(projects: list) -> list:
+    """Ergaenzt has_files + file_count pro Projekt (fuer das Datei-Symbol in der
+    Liste). Das ersetzt das manuelle Code-Flag als primaeren Code-Indikator."""
+    for p in projects or []:
+        if not isinstance(p, dict):
+            continue
+        c = _project_file_count(p.get("id") or "")
+        p["file_count"] = c
+        p["has_files"] = c > 0
+    return projects
+
+
 @app.get("/projects/status")
 def projects_status():
     """Komplett-Status: aktives Projekt + Liste aller (nicht-archivierten)."""
-    return projects_mod.status()
+    st = projects_mod.status()
+    _enrich_projects(st.get("projects", []))
+    if st.get("active"):
+        _enrich_projects([st["active"]])
+    return st
 
 
 @app.get("/projects/list")
 def projects_list(include_archived: bool = False):
-    return {"projects": projects_mod.list_projects(include_archived=include_archived)}
+    return {"projects": _enrich_projects(
+        projects_mod.list_projects(include_archived=include_archived))}
 
 
 class ProjectCreateBody(BaseModel):
@@ -822,17 +924,262 @@ class ProjectUpdateBody(BaseModel):
     name: Optional[str] = None
     description: Optional[str] = None
     hidden: Optional[bool] = None
+    kind: Optional[str] = None   # 'code' | 'chat' — manuell setzbar (App/Diagnostic)
 
 
 @app.patch("/projects/{project_id}")
 def projects_update(project_id: str, body: ProjectUpdateBody):
     patch = body.dict(exclude_unset=True)
+    if "kind" in patch and patch["kind"] not in ("code", "chat", None):
+        raise HTTPException(status_code=400, detail="kind muss 'code' oder 'chat' sein")
     p = projects_mod.update_project(project_id, patch)
     if p is None:
         raise HTTPException(status_code=404, detail=f"Projekt {project_id} nicht gefunden")
     return p
 
 
+# ── Code-Dateien eines Projekts (/shared/projects/<pid>/) ───────────
+# Der Live-Editor streamt ARIAs Writes; diese Endpoints liefern zusaetzlich die
+# BEREITS vorhandenen Dateien, damit der Editor beim Oeffnen nicht leer ist.
+_PROJECT_FILES_ROOT = "/shared/projects"
+_PROJECT_FILE_MAX = 512 * 1024
+
+
+def _project_dir(project_id: str) -> str:
+    base = os.path.realpath(os.path.join(_PROJECT_FILES_ROOT, project_id or ""))
+    root = os.path.realpath(_PROJECT_FILES_ROOT)
+    if base != root and not base.startswith(root + os.sep):
+        raise HTTPException(status_code=400, detail="ungueltige project_id")
+    return base
+
+
+@app.get("/projects/{project_id}/files")
+def project_files(project_id: str):
+    base = _project_dir(project_id)
+    out = []
+    if os.path.isdir(base):
+        for dirpath, dirs, files in os.walk(base):
+            dirs[:] = [d for d in dirs if d not in
+                       (".git", "node_modules", "__pycache__", ".venv", "venv")]
+            for f in files:
+                full = os.path.join(dirpath, f)
+                rel = os.path.relpath(full, base).replace("\\", "/")
+                try:
+                    sz = os.path.getsize(full)
+                except OSError:
+                    sz = 0
+                out.append({"path": rel, "size": sz})
+    out.sort(key=lambda x: x["path"])
+    return {"projectId": project_id, "files": out}
+
+
+@app.get("/projects/{project_id}/file")
+def project_file(project_id: str, path: str, binary: bool = False):
+    base = _project_dir(project_id)
+    target = os.path.realpath(os.path.join(base, path))
+    if target != base and not target.startswith(base + os.sep):
+        raise HTTPException(status_code=400, detail="Pfad ausserhalb des Projekts")
+    if not os.path.isfile(target):
+        raise HTTPException(status_code=404, detail="Datei nicht gefunden")
+    # Binaer (z.B. Bilder) → Base64. Grosszuegigeres Limit als beim Text-Editor.
+    if binary:
+        import base64
+        import mimetypes
+        if os.path.getsize(target) > 8 * 1024 * 1024:
+            raise HTTPException(status_code=413, detail="Datei zu gross (max 8 MB)")
+        with open(target, "rb") as f:
+            data = f.read()
+        mime, _ = mimetypes.guess_type(target)
+        return {"projectId": project_id, "path": path, "mime": mime or "application/octet-stream",
+                "base64": base64.b64encode(data).decode("ascii")}
+    if os.path.getsize(target) > _PROJECT_FILE_MAX:
+        raise HTTPException(status_code=413, detail="Datei zu gross fuer den Editor")
+    try:
+        with open(target, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc))
+    return {"projectId": project_id, "path": path, "content": content}
+
+
+# ── QEMU-VMs pro Projekt ────────────────────────────────────────────
+# Registry (project_vms) + echter Start/Stop via `aria-vm` auf dem Host (SSH
+# aria-wohnung). Das Desktop-Panel der App zeigt pro Projekt die Liste.
+_ARIA_VM_HOST = os.environ.get("ARIA_VM_SSH_HOST", "aria-wohnung")
+
+
+def _docker_gateway() -> str:
+    """Docker-Gateway-IP (= Host-IP auf dem Container-Netz), an die QEMU sein VNC
+    binden soll: von der Bridge erreichbar, aber NICHT im LAN/Internet. Aus
+    /proc/net/route (Default-Route), kein `ip`-Tool noetig."""
+    try:
+        import socket as _sock
+        import struct as _struct
+        with open("/proc/net/route") as f:
+            for line in f.readlines()[1:]:
+                fields = line.strip().split()
+                if len(fields) >= 3 and fields[1] == "00000000" and int(fields[3], 16) & 2:
+                    return _sock.inet_ntoa(_struct.pack("<L", int(fields[2], 16)))
+    except Exception:
+        pass
+    return ""
+
+
+def _ssh_host(*cmd: str, timeout: int = 25):
+    import subprocess
+    full = ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=8",
+            _ARIA_VM_HOST, *[str(c) for c in cmd]]
+    try:
+        r = subprocess.run(full, capture_output=True, text=True, timeout=timeout)
+        return r.returncode, r.stdout or "", r.stderr or ""
+    except Exception as exc:
+        return 1, "", str(exc)
+
+
+def _ssh_aria_vm(*args: str, timeout: int = 25):
+    return _ssh_host("aria-vm", *args, timeout=timeout)
+
+
+def _vm_running_names() -> set:
+    rc, out, _err = _ssh_aria_vm("list", timeout=15)
+    names = set()
+    if rc == 0:
+        for line in out.splitlines():
+            parts = line.split()
+            if parts and "laeuft" in line:
+                names.add(parts[0])
+    return names
+
+
+class VmAddBody(BaseModel):
+    name: str
+    arch: str = "i386"
+    iso: str = ""
+    floppy: str = ""
+    disk: str = ""
+    vnc_display: int = 1
+    mem: int = 1024
+    create_disk: bool = False
+    size: str = "10G"
+
+
+def _vm_boot_args(v: dict) -> list:
+    args = ["boot", v.get("name", "?"),
+            "--vnc-display", str(v.get("vnc_display", 1)),
+            "--mem", str(v.get("mem", 1024))]
+    if v.get("disk"):
+        args += ["--disk", v["disk"]]
+    if v.get("floppy"):
+        args += ["--floppy", v["floppy"]]
+    if v.get("iso"):
+        args += ["--iso", v["iso"]]
+    return args
+
+
+def _vm_boot_cmd(v: dict) -> str:
+    """Lesbarer Start-Befehl (aria-vm) als 'Wert' hinter dem VM-Eintrag."""
+    return "aria-vm " + " ".join(_vm_boot_args(v))
+
+
+@app.get("/projects/{project_id}/vms")
+def project_vms_list(project_id: str):
+    vms = [dict(v) for v in project_vms_mod.list_vms(project_id)]
+    running = _vm_running_names()
+    for v in vms:
+        v["running"] = v.get("name") in running
+        v["vnc_port"] = 5900 + int(v.get("vnc_display", 1))
+        v["boot_cmd"] = _vm_boot_cmd(v)
+    return {"projectId": project_id, "vms": vms}
+
+
+@app.post("/projects/{project_id}/vms")
+def project_vm_add(project_id: str, body: VmAddBody):
+    try:
+        vm = project_vms_mod.add_vm(project_id, body.name, body.arch, body.iso,
+                                    body.floppy, body.disk, body.vnc_display, body.mem)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    if body.create_disk:
+        rc, out, err = _ssh_aria_vm("create", body.name, body.arch, body.size)
+        vm["create_result"] = out.strip() or err.strip()
+        vm["create_ok"] = (rc == 0)
+    return vm
+
+
+@app.delete("/projects/{project_id}/vms/{name}")
+def project_vm_remove(project_id: str, name: str, purge: bool = False):
+    ok = project_vms_mod.remove_vm(project_id, name)
+    if not ok:
+        raise HTTPException(status_code=404, detail=f"VM '{name}' nicht in Projekt {project_id}")
+    if purge:
+        _ssh_aria_vm("rm", name)
+    return {"ok": True, "name": name}
+
+
+@app.post("/projects/{project_id}/vms/{name}/boot")
+def project_vm_boot(project_id: str, name: str):
+    vm = project_vms_mod.get_vm(project_id, name)
+    if not vm:
+        raise HTTPException(status_code=404, detail=f"VM '{name}' nicht gefunden")
+    # VNC an die Docker-Gateway-IP binden, damit die Bridge den Stream tunneln
+    # kann (Loopback ist von Containern nicht erreichbar). NICHT im LAN sichtbar.
+    boot_args = _vm_boot_args(vm)
+    gw = _docker_gateway()
+    if gw:
+        boot_args += ["--vnc-bind", gw]
+    rc, out, err = _ssh_aria_vm(*boot_args, timeout=40)
+    return {"ok": rc == 0, "name": name, "vnc_port": 5900 + int(vm.get("vnc_display", 1)),
+            "vnc_bind": gw or "127.0.0.1", "output": (out.strip() or err.strip())[:500]}
+
+
+@app.post("/projects/{project_id}/vms/{name}/stop")
+def project_vm_stop(project_id: str, name: str):
+    rc, out, err = _ssh_aria_vm("stop", name, timeout=25)
+    return {"ok": rc == 0, "name": name, "output": (out.strip() or err.strip())[:500]}
+
+
+@app.post("/projects/{project_id}/vms/{name}/screenshot")
+def project_vm_screenshot(project_id: str, name: str):
+    """Macht einen Screenshot der laufenden VM und liefert ihn als Base64.
+
+    aria-vm schreibt das PNG ins VM-Verzeichnis (dem aria-User gehoerend — nicht
+    ins /root-Shared-Volume, wo der aria-User keinen Zugriff hat). Der Brain holt
+    die Datei danach per SSH (base64) — funktioniert unabhaengig von Volume-
+    Rechten. Zusaetzlich wird das PNG ins Projekt kopiert (Dateien-Panel)."""
+    import base64
+    rc, out, err = _ssh_aria_vm("screenshot", name, timeout=30)
+    if rc != 0:
+        raise HTTPException(status_code=400, detail=f"Screenshot fehlgeschlagen: {(err or out).strip()[:200]}")
+    path = ""
+    for line in out.splitlines():
+        if line.startswith("screenshot="):
+            path = line.split("=", 1)[1].strip()
+    if not path:
+        raise HTTPException(status_code=500, detail=f"Kein Screenshot-Pfad: {out.strip()[:200]}")
+    # PNG per SSH als Base64 holen (kein Shared-Volume noetig).
+    rc2, b64, err2 = _ssh_host("base64", "-w0", path, timeout=20)
+    if rc2 != 0 or not b64.strip():
+        raise HTTPException(status_code=500, detail=f"Screenshot konnte nicht gelesen werden: {(err2 or 'leer').strip()[:200]}")
+    b64 = b64.strip()
+    try:
+        data = base64.b64decode(b64)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Base64 ungueltig: {exc}")
+    fname = os.path.basename(path)
+    # Ins Projekt kopieren → taucht im Dateien-Panel auf.
+    proj_rel = ""
+    try:
+        shots_dir = os.path.join(_project_dir(project_id), "screenshots")
+        os.makedirs(shots_dir, exist_ok=True)
+        with open(os.path.join(shots_dir, fname), "wb") as f:
+            f.write(data)
+        proj_rel = "screenshots/" + fname
+    except Exception:
+        proj_rel = ""
+    return {"ok": True, "name": name, "filename": fname,
+            "projectPath": proj_rel, "base64": b64}
+
+
 @app.get("/conversation/stats")
 def conversation_stats():
     return conversation().stats()
@@ -843,6 +1190,11 @@ def conversation_reset():
     """Hardes Reset — der Rolling-Window-Verlauf wird komplett geleert.
     Destillierte facts bleiben in der DB."""
     conversation().reset()
+    try:
+        import local_compact
+        local_compact.reset()          # Notizzettel des lokalen Modus gehoert dazu
+    except Exception:
+        pass
     return {"ok": True, "turns": 0}
 
 
@@ -875,6 +1227,257 @@ def conversation_distill_now():
     return agent().distill_old_turns()
 
 
+# ─── Sicherheitsfilter (Anthropic) ──────────────────────────────────
+# Der Filter antwortet mit is_error=true und dem Fehlertext im content. Das
+# Brain erkennt das (safeguard.py), weicht aufs Ausweich-Modell aus und nimmt
+# im Notfall den ausloesenden Turn aus dem Prompt-Fenster. Hier nur die
+# Sichtbarkeit fuer die Diagnostic.
+
+@app.get("/safeguard/status")
+def safeguard_status(limit: int = 25):
+    """Vorfaelle + Quarantaene. Fuer das Panel in der Diagnostic."""
+    data = safeguard_mod.status(limit=limit)
+    # Welche Turns noch im Fenster liegen (= wirken noch) — sonst sieht man in
+    # der Liste nicht, ob eine Blockade noch aktiv ist oder nur Historie.
+    conv = conversation()
+    live = {t.ts for t in conv.turns}
+    for inc in data.get("incidents", []):
+        inc["in_window"] = bool(inc.get("turn_ts") and inc["turn_ts"] in live)
+    for q in data.get("quarantine", []):
+        q["in_window"] = bool(q.get("turn_ts") and q["turn_ts"] in live)
+        # Den Text dazu zeigen, damit Stefan sieht, WAS blockiert wurde.
+        q["content"] = next((t.content[:400] for t in conv.turns
+                             if t.ts == q.get("turn_ts")), "")
+    return data
+
+
+class SafeguardTurnBody(BaseModel):
+    turn_ts: str
+
+
+@app.post("/safeguard/unquarantine")
+def safeguard_unquarantine(body: SafeguardTurnBody):
+    """Einen quarantaenierten Turn wieder in den Verlauf aufnehmen.
+
+    Danach geht er wieder mit zum Modell — wenn er wirklich der Ausloeser war,
+    blockt der Filter erneut. Deshalb einzeln und von Hand."""
+    ok = safeguard_mod.unquarantine(body.turn_ts)
+    if not ok:
+        raise HTTPException(404, "Kein quarantaenierter Turn mit diesem Zeitstempel")
+    return {"ok": True}
+
+
+class SafeguardClearBody(BaseModel):
+    project_id: Optional[str] = None
+
+
+@app.post("/safeguard/clear")
+def safeguard_clear(body: SafeguardClearBody):
+    """Vorfallsliste leeren. Hebt damit auch den Modell-Vermerk auf — der
+    naechste Turn laeuft wieder aufs Hauptmodell. Quarantaene bleibt."""
+    removed = safeguard_mod.clear(body.project_id)
+    return {"ok": True, "removed": removed}
+
+
+# ─── Modell pro Chat ────────────────────────────────────────────────
+# Einstellung (brainModel) < pro Chat < Ausweich (Sicherheitsfilter). Siehe
+# context_model.py. Diese Endpunkte liefern fuer jede Oberflaeche dieselbe
+# Sicht: was ist eingestellt, was laeuft WIRKLICH, und warum.
+
+_MODEL_CHOICES_CACHE: dict = {"at": 0.0, "data": []}
+
+
+def _model_choices() -> list:
+    """Modell-Auswahl fuer die Pickers — dieselbe Liste wie in der Diagnostic
+    (Proxy /v1/models, aus Anthropics Katalog). 10 Minuten im Speicher, denn
+    die App fragt bei jedem Oeffnen des Pickers. Fail-soft: ohne Proxy eine
+    leere Liste, die Anzeige des aktiven Modells funktioniert trotzdem."""
+    import time as _t
+    import httpx as _httpx
+    now = _t.time()
+    if _MODEL_CHOICES_CACHE["data"] and now - _MODEL_CHOICES_CACHE["at"] < 600:
+        return _MODEL_CHOICES_CACHE["data"]
+    try:
+        base = os.environ.get("PROXY_URL", "http://proxy:3456").rstrip("/")
+        r = _httpx.get(f"{base}/v1/models", timeout=8)
+        data = [{
+            "id": m.get("id", ""),
+            "name": m.get("display_name") or m.get("id", ""),
+            "section": m.get("section") or "tier",
+        } for m in (r.json().get("data") or []) if m.get("id")]
+        if data:
+            _MODEL_CHOICES_CACHE.update(at=now, data=data)
+        return data
+    except Exception as exc:
+        logger.warning("[context-model] Modell-Liste vom Proxy nicht ladbar: %s", exc)
+        return _MODEL_CHOICES_CACHE["data"]
+
+
+def _context_model_rows() -> dict:
+    a = agent()
+    conv = conversation()
+    # Das Modell, mit dem das Brain gerade wirklich laeuft — NICHT neu aus
+    # runtime.json gelesen. brainModel greift erst nach Neustart; zeigten wir
+    # hier den Dateiwert, saehe ein ausstehender Neustart aus wie erledigt.
+    default = a.proxy.model
+    contexts = [("", "Hauptchat")] + [
+        (p["id"], p.get("name") or p["id"])
+        for p in projects_mod.list_projects()
+    ]
+    rows = []
+    for cid, name in contexts:
+        override = context_model_mod.get(cid)
+        model, reason = context_model_mod.resolve(cid, default)
+        window = safeguard_mod.filter_window(conv.window(project_id=cid))
+        blocked = safeguard_mod.blocked_models(cid, [t.ts for t in window])
+        fallback = ""
+        if safeguard_mod.norm_model(model) in blocked:
+            fallback = safeguard_mod.fallback_for(model)
+            reason = context_model_mod.REASON_FALLBACK
+        rows.append({
+            "context_id": cid,
+            "name": name,
+            "override": override,          # "" = folgt der Einstellung
+            "selected": model,             # was gewaehlt ist (Einstellung/pro Chat)
+            "effective": fallback or model,  # was der naechste Turn nutzt
+            "reason": reason,
+            "blocked": sorted(blocked),
+        })
+    choices = _model_choices() + _local_model_choices()
+    names = {c["id"]: c["name"] for c in choices}
+    return {"default": default, "rows": rows, "choices": choices, "names": names}
+
+
+def _local_model_choices() -> list:
+    """Lokale Modelle, die gerade auf einer Karte liegen (ARIA-Cluster ueber
+    die Bridge) — als "local:<modell>" waehlbar pro Chat. Fail-soft: []."""
+    try:
+        import httpx as _httpx
+        base = os.environ.get("BRIDGE_URL", "http://aria-bridge:8090").rstrip("/")
+        data = _httpx.get(f"{base}/internal/llm-models", timeout=4).json()
+        return [{"id": "local:" + m["model"], "name": "🖥 lokal: " + m["model"], "section": "local"}
+                for m in (data.get("models") or []) if m.get("model")]
+    except Exception as exc:
+        logger.info("[context-model] lokale Modelle nicht abrufbar: %s", exc)
+        return []
+
+
+@app.get("/context-model/list")
+def context_model_list():
+    return _context_model_rows()
+
+
+class ContextModelBody(BaseModel):
+    context_id: str = ""
+    model: str = ""          # leer = Override loeschen, Einstellung gilt wieder
+
+
+@app.post("/context-model/set")
+def context_model_set(body: ContextModelBody):
+    cid = (body.context_id or "").strip()
+    if cid and not projects_mod.get_project(cid):
+        raise HTTPException(404, f"Projekt {cid} nicht gefunden")
+    context_model_mod.set(cid, body.model)
+    return _context_model_rows()
+
+
+class ContextModelResetBody(BaseModel):
+    context_id: str = ""
+
+
+@app.post("/context-model/back-to-selected")
+def context_model_back(body: ContextModelResetBody):
+    """Ausweich beenden: Sicherheitsfilter-Vermerke dieses Chats loeschen.
+
+    Danach laeuft der naechste Turn wieder auf dem gewaehlten Modell. Steht
+    der ausloesende Text noch im Verlauf, kann der Filter erneut greifen —
+    dann weicht das Brain eben wieder aus. Das ist gewollt: zurueck soll
+    jederzeit gehen, ohne dass man vorher irgendwas aufraeumen muss."""
+    removed = safeguard_mod.clear((body.context_id or "").strip())
+    out = _context_model_rows()
+    out["removed"] = removed
+    return out
+
+
+# ─── E-Mail (aria_mail.py) ──────────────────────────────────────────
+# Konfiguration lesen/aendern NUR mit dem Admin-Schluessel (Header
+# X-Aria-Admin). Den reicht die Diagnostic durch; ARIAs Container kann ihn
+# nicht lesen (liegt in /data, das dort nicht eingehaengt ist). Ohne diesen
+# Schutz koennte eine eingehende Mail ARIA dazu bringen, per curl die
+# Whitelist zu oeffnen.
+# Das Postfach LESEN braucht keinen Schluessel — das kann ARIA ohnehin ueber
+# ihre Tools, und der Viewer nutzt dieselben Wege.
+
+def _mail_admin(key: Optional[str]) -> None:
+    if not aria_mail.check_admin(key):
+        raise HTTPException(403, "Nur ueber die Diagnostic")
+
+
+def _mail_call(fn, *a, **kw):
+    try:
+        return fn(*a, **kw)
+    except aria_mail.MailError as exc:
+        raise HTTPException(400, str(exc))
+
+
+# Schluessel beim Start anlegen. Die Diagnostic liest ihn aus der Datei; gaebe
+# es ihn erst beim ersten Admin-Zugriff, haette sie fuer genau diesen Zugriff
+# keinen.
+try:
+    aria_mail.admin_key()
+except Exception as _exc:  # /data fehlt (lokaler Test) — kein Startabbruch
+    logger.warning("[mail] Admin-Schluessel nicht anlegbar: %s", _exc)
+
+
+@app.get("/email/status")
+def email_status():
+    return aria_mail.status()
+
+
+@app.get("/email/config")
+def email_config_get(x_aria_admin: Optional[str] = Header(None)):
+    _mail_admin(x_aria_admin)
+    return aria_mail.public_config()
+
+
+@app.post("/email/config")
+def email_config_set(body: dict, x_aria_admin: Optional[str] = Header(None)):
+    _mail_admin(x_aria_admin)
+    return _mail_call(aria_mail.save_config, body or {})
+
+
+@app.post("/email/test")
+def email_test(x_aria_admin: Optional[str] = Header(None)):
+    _mail_admin(x_aria_admin)
+    return aria_mail.test_connection()
+
+
+@app.get("/email/folders")
+def email_folders():
+    return {"folders": _mail_call(aria_mail.list_folders)}
+
+
+@app.get("/email/messages")
+def email_messages(folder: str = "INBOX", limit: int = 50, offset: int = 0,
+                   unread_only: bool = False, search: str = ""):
+    return _mail_call(aria_mail.list_messages, folder, limit, offset, unread_only, search)
+
+
+@app.get("/email/message")
+def email_message(folder: str, uid: str):
+    """Fuer den Viewer — markiert NICHT als gelesen (sonst wuesste ARIA
+    nicht mehr, was neu ist, nur weil Stefan reingeschaut hat)."""
+    return _mail_call(aria_mail.view_message, folder, uid)
+
+
+@app.get("/email/attachment")
+def email_attachment(folder: str, uid: str, index: int):
+    from urllib.parse import quote as _q
+    name, ctype, data = _mail_call(aria_mail.get_attachment, folder, uid, index)
+    return Response(content=data, media_type=ctype or "application/octet-stream",
+                    headers={"Content-Disposition": f"attachment; filename*=UTF-8''{_q(name)}"})
+
+
 # ─── Call-Metrics (Token / Quota-Monitoring) ────────────────────────
 
 @app.get("/metrics/calls")

aria-brain/memory/vector_store.py

@@ -11,6 +11,10 @@ Punkt-Schema (Payload):
     content   — eigentlicher Text (wird embedded)
     pinned    — bool, True = Hot Memory (immer in Prompt)
     source    — import | conversation | manual
+    scope     — system | personal. system = generische Regeln, die JEDER
+                braucht, der das System aufsetzt (Sicherheit, Ehrlichkeit,
+                Skill-Regeln). personal = Stefan-spezifisch (Name, Zugangs-
+                daten, Projekte). Steuert den getrennten Bootstrap-Export.
     tags      — Liste von Strings
     created_at, updated_at — ISO-Strings
     conversation_id — optional, nur fuer type=conversation
@@ -55,6 +59,7 @@ class MemoryPoint:
     pinned: bool = False
     category: str = ""
     source: str = "manual"
+    scope: str = "personal"  # system | personal — steuert Bootstrap-Export
     tags: List[str] = field(default_factory=list)
     created_at: str = ""
     updated_at: str = ""
@@ -74,6 +79,7 @@ class MemoryPoint:
             "pinned": self.pinned,
             "category": self.category,
             "source": self.source,
+            "scope": self.scope,
             "tags": self.tags,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
@@ -94,6 +100,7 @@ class MemoryPoint:
             pinned=payload.get("pinned", False),
             category=payload.get("category", ""),
             source=payload.get("source", "manual"),
+            scope=payload.get("scope", "personal"),
             tags=payload.get("tags", []),
             created_at=payload.get("created_at", ""),
             updated_at=payload.get("updated_at", ""),
@@ -120,14 +127,23 @@ class VectorStore:
                 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"):
+        # Indexe fuer typische Filter-Felder — idempotent, laeuft auch auf
+        # einer bestehenden Collection (fuer neu hinzugekommene Felder wie scope).
+        self._ensure_indexes()
+
+    def _ensure_indexes(self):
+        for field_name in ("type", "pinned", "category", "source", "scope", "migration_key"):
+            schema = (qm.PayloadSchemaType.BOOL if field_name == "pinned"
+                      else qm.PayloadSchemaType.KEYWORD)
+            try:
                 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,
+                    field_schema=schema,
                 )
+            except Exception:
+                # Index existiert bereits — kein Problem.
+                pass
 
     # ─── Schreib-Operationen ─────────────────────────────────────────
 
@@ -164,6 +180,38 @@ class VectorStore:
             qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True))
         ]))
 
+    def list_pinned_by_scope(self, scope: str) -> List[MemoryPoint]:
+        """Alle pinned Punkte eines scope (system | personal). Fuer den
+        getrennten Bootstrap-Export."""
+        return self._scroll(filter=qm.Filter(must=[
+            qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True)),
+            qm.FieldCondition(key="scope", match=qm.MatchValue(value=scope)),
+        ]))
+
+    def list_index_titles(self, limit: int = 500) -> List[MemoryPoint]:
+        """Leichtgewichtiger Titel-Index des kalten Gedaechtnisses fuer den
+        System-Prompt: ARIA sieht WAS sie an Nachschlage-Wissen hat (Zugangs-
+        daten, Infrastruktur, Projekte) und holt den Inhalt bei Bedarf via
+        memory_search — statt Stefan nach etwas zu fragen, das schon da ist.
+
+        Bewusst NUR die deliberat gespeicherten Punkte:
+          - nicht pinned (die sind eh schon voll im Prompt),
+          - kein type=conversation (Chat-Mitschnitte),
+          - kein source=distilled (die 100e auto-destillierten Gespraechs-
+            Fakten — die traegt das semantische Auto-Retrieval, sie hier
+            als Titel zu listen wuerde nur Kontext fressen).
+        So bleibt der Index klein (Dutzende statt Hunderte Zeilen)."""
+        return self._scroll(
+            filter=qm.Filter(
+                must_not=[
+                    qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True)),
+                    qm.FieldCondition(key="type", match=qm.MatchValue(value="conversation")),
+                    qm.FieldCondition(key="source", match=qm.MatchValue(value="distilled")),
+                ]
+            ),
+            limit=limit,
+        )
+
     def list_by_type(self, type_: str, limit: int = 100) -> List[MemoryPoint]:
         return self._scroll(
             filter=qm.Filter(must=[

aria-brain/memory_attachments.py

@@ -16,6 +16,7 @@ selbst hat in Stufe A kein Tool zum Upload.
 from __future__ import annotations
 
 import base64
+import json
 import logging
 import mimetypes
 import os
@@ -27,9 +28,41 @@ from typing import List, Optional
 logger = logging.getLogger(__name__)
 
 ROOT = Path(os.environ.get("MEMORY_ATTACHMENTS_DIR", "/shared/memory-attachments"))
-MAX_BYTES = int(os.environ.get("MEMORY_ATTACHMENT_MAX_BYTES", str(20 * 1024 * 1024)))  # 20 MB
 SAFE_NAME_RE = re.compile(r"[^A-Za-z0-9._\-]")
 
+RUNTIME_CONFIG_FILE = Path("/shared/config/runtime.json")
+# 64 MB: so viel holt die App auch auf ausdruecklichen Tipp noch herunter
+# (TAP_DL_MAX_BYTES in ChatScreen.tsx). Ein hoeheres Limit wuerde Anhaenge
+# erlauben, die das Handy anschliessend nicht mehr laden kann.
+_DEFAULT_MAX_BYTES = 64 * 1024 * 1024
+
+
+def max_bytes() -> int:
+    """Aktuelles Groessen-Limit fuer Anhaenge.
+
+    Reihenfolge: runtime.json (Diagnostic → System & Wartung) > ENV > Default.
+    Wird bei JEDEM Aufruf gelesen, damit eine Aenderung in der Diagnostic sofort
+    greift — ein Brain-Neustart nur fuers Anheben einer Zahl waere Unsinn.
+    """
+    try:
+        with RUNTIME_CONFIG_FILE.open() as f:
+            mb = json.load(f).get("memoryAttachmentMaxMb")
+        if mb is not None:
+            val = int(float(mb) * 1024 * 1024)
+            if val > 0:
+                return val
+    except FileNotFoundError:
+        pass
+    except Exception as exc:
+        logger.warning("runtime.json lesen fehlgeschlagen: %s", exc)
+    env = os.environ.get("MEMORY_ATTACHMENT_MAX_BYTES")
+    if env:
+        try:
+            return int(env)
+        except ValueError:
+            logger.warning("MEMORY_ATTACHMENT_MAX_BYTES ist keine Zahl: %r", env)
+    return _DEFAULT_MAX_BYTES
+
 
 def _safe_filename(name: str) -> str:
     """Macht aus einem User-Namen einen filesystem-sicheren String —
@@ -78,8 +111,12 @@ def save_attachment(memory_id: str, filename: str, data: bytes) -> dict:
     Ueberschreibt eine bestehende Datei mit gleichem Namen."""
     if not memory_id:
         raise ValueError("memory_id ist Pflicht")
-    if len(data) > MAX_BYTES:
-        raise ValueError(f"Anhang zu gross ({len(data)} > {MAX_BYTES} Byte)")
+    limit = max_bytes()
+    if len(data) > limit:
+        raise ValueError(
+            f"Anhang zu gross ({len(data) // (1024 * 1024)} MB > "
+            f"{limit // (1024 * 1024)} MB). Das Limit steht in der Diagnostic "
+            f"unter System & Wartung.")
     safe = _safe_filename(filename)
     d = memory_dir(memory_id)
     d.mkdir(parents=True, exist_ok=True)
@@ -165,8 +202,12 @@ def attach_from_path(memory_id: str, source_path: str) -> dict:
     if not src.is_file():
         raise ValueError(f"Datei nicht gefunden: {source_path}")
     size = src.stat().st_size
-    if size > MAX_BYTES:
-        raise ValueError(f"Datei zu gross ({size} > {MAX_BYTES} Byte)")
+    limit = max_bytes()
+    if size > limit:
+        raise ValueError(
+            f"Datei zu gross ({size // (1024 * 1024)} MB > "
+            f"{limit // (1024 * 1024)} MB). Das Limit steht in der Diagnostic "
+            f"unter System & Wartung.")
     # Reuse save_attachment damit Filename-Sanitization + Logging konsistent
     data = src.read_bytes()
     return save_attachment(memory_id, src.name, data)

aria-brain/migration.py

@@ -252,6 +252,7 @@ def _parse_user_md(md: str, source_file: str) -> List[MemoryPoint]:
                     type_="preference", title=f"User: {btitle}",
                     content=btext, category="allgemein",
                     migration_key=f"{source_file}/general-{idx}",
+                    scope="personal",
                 ))
         else:
             cat_key = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-") or "allgemein"
@@ -259,6 +260,7 @@ def _parse_user_md(md: str, source_file: str) -> List[MemoryPoint]:
                 type_="preference", title=title,
                 content=content, category=cat_key,
                 migration_key=f"{source_file}/{cat_key}",
+                scope="personal",
             ))
     return points
 
@@ -283,7 +285,11 @@ def _mk(
     migration_key: str,
     pinned: bool = True,
     category: str = "",
+    scope: str = "system",
 ) -> MemoryPoint:
+    # scope-Default 'system': AGENT.md + TOOLING.md beschreiben ARIA selbst
+    # (Identitaet, Sicherheit, Architektur) — das braucht jedes System.
+    # USER.md-Praeferenzen sind personal und uebergeben scope='personal'.
     p = MemoryPoint(
         id="",
         type=type_,
@@ -292,6 +298,7 @@ def _mk(
         pinned=pinned,
         category=category,
         source="import",
+        scope=scope,
         tags=[],
     )
     # migration_key wird ueber Payload-Index angesprochen — in to_payload manuell anhaengen

aria-brain/oauth.py

@@ -28,6 +28,7 @@ import logging
 import os
 import secrets
 import time
+import urllib.error
 import urllib.parse
 import urllib.request
 from pathlib import Path
@@ -129,7 +130,8 @@ def register_provider(service: str, auth_url: str, token_url: str,
                       scopes: Optional[list[str]] = None,
                       client_auth: str = "body",
                       extra_auth_params: Optional[dict] = None,
-                      accept_header: Optional[str] = None) -> dict:
+                      accept_header: Optional[str] = None,
+                      api_hosts: Optional[list[str]] = None) -> dict:
     """Schreibt einen neuen Provider-Eintrag in oauth_apps.json. KEINE
     Credentials hier — die bleiben Stefans Job (Diagnostic / App-UI). Wird
     vom Brain-Tool `oauth_register_provider` gerufen.
@@ -158,6 +160,12 @@ def register_provider(service: str, auth_url: str, token_url: str,
         entry["extra_auth_params"] = extra_auth_params
     if accept_header is not None:
         entry["accept_header"] = accept_header
+    if api_hosts is not None:
+        # Zusaetzliche API-Hosts, an die oauth_call den Token schicken darf.
+        # Noetig, wenn die API auf einer anderen Domain liegt als der Login
+        # (z.B. github.com -> api.github.com waere noch dieselbe Basis, aber
+        # manche Provider nutzen voellig andere Namen).
+        entry["api_hosts"] = [str(h).strip().lower() for h in api_hosts if str(h).strip()]
     apps[svc] = entry
     _save_json(APPS_FILE, apps)
     logger.info("[oauth] Provider '%s' registriert (auth=%s, token=%s, scopes=%d)",
@@ -416,6 +424,108 @@ def revoke(service: str) -> bool:
     return True
 
 
+def allowed_hosts(service: str) -> list[str]:
+    """Hosts, an die ein Token dieses Services geschickt werden darf.
+
+    SICHERHEITSKERN von `call()`: ohne diese Liste koennte ein Aufruf den
+    Zugangstoken an einen beliebigen Server schicken — die Anfrage-URL kommt
+    schliesslich vom Modell. Darum wird nur zugelassen, was zum Provider selbst
+    gehoert: die Hosts aus auth_url/token_url plus optional eingetragene
+    api_hosts. Subdomains desselben registrierbaren Namens zaehlen mit
+    (accounts.spotify.com -> api.spotify.com), fremde Domains nie.
+    """
+    cfg = _provider_config(service)
+    hosts: set[str] = set()
+    for key in ("auth_url", "token_url"):
+        u = cfg.get(key) or ""
+        try:
+            h = urllib.parse.urlparse(u).hostname or ""
+        except Exception:
+            h = ""
+        if h:
+            hosts.add(h.lower())
+    for h in (cfg.get("api_hosts") or []):
+        h = str(h).strip().lower()
+        if h:
+            hosts.add(h)
+    return sorted(hosts)
+
+
+def _host_allowed(host: str, allowed: list[str]) -> bool:
+    """True, wenn host zu einem der erlaubten Hosts gehoert.
+
+    Verglichen wird auf den letzten ZWEI Labels (spotify.com). Ein reiner
+    endswith-Vergleich waere angreifbar: 'boesespotify.com' endet auch auf
+    'spotify.com'.
+    """
+    h = (host or "").lower().strip(".")
+    if not h:
+        return False
+
+    def base(x: str) -> str:
+        parts = x.lower().strip(".").split(".")
+        return ".".join(parts[-2:]) if len(parts) >= 2 else x.lower()
+
+    hb = base(h)
+    return any(h == a or hb == base(a) for a in allowed)
+
+
+def call(service: str, url: str, method: str = "GET",
+         body: Optional[str] = None, content_type: str = "application/json",
+         timeout: float = 20.0, max_bytes: int = 200_000) -> tuple[int, str]:
+    """Fuehrt einen HTTP-Aufruf MIT dem Zugangstoken aus — ohne ihn herauszugeben.
+
+    Das ist der Ersatz fuer "gib mir den Token, ich rufe selbst": der Token
+    verlaesst den Brain-Prozess nicht und kann damit auch nicht in einem
+    Gespraechsprotokoll landen.
+
+    Returns (status_code, text). Wirft ValueError bei unerlaubter URL.
+    """
+    svc = (service or "").strip()
+    if not svc:
+        raise ValueError("service ist Pflicht")
+    u = (url or "").strip()
+    if not u.startswith("https://"):
+        # Kein http:// — der Token ginge im Klartext ueber die Leitung.
+        raise ValueError("url muss mit https:// beginnen")
+    host = urllib.parse.urlparse(u).hostname or ""
+    allowed = allowed_hosts(svc)
+    if not allowed:
+        raise ValueError(
+            f"Fuer '{svc}' sind keine Hosts hinterlegt — erst oauth_register_provider aufrufen.")
+    if not _host_allowed(host, allowed):
+        raise ValueError(
+            f"Host '{host}' gehoert nicht zu '{svc}'. Erlaubt: {', '.join(allowed)}")
+
+    m = (method or "GET").upper()
+    if m not in ("GET", "POST", "PUT", "PATCH", "DELETE"):
+        raise ValueError(f"Methode nicht erlaubt: {method}")
+
+    record = get_token(svc)          # refresht bei Bedarf
+    token = record.get("access_token", "")
+    ttype = record.get("token_type") or "Bearer"
+
+    data = body.encode("utf-8") if body else None
+    req = urllib.request.Request(u, data=data, method=m)
+    req.add_header("Authorization", f"{ttype} {token}")
+    req.add_header("Accept", "application/json")
+    if data is not None:
+        req.add_header("Content-Type", content_type)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read(max_bytes + 1)
+            status = resp.status
+    except urllib.error.HTTPError as exc:
+        raw = exc.read(max_bytes + 1) if hasattr(exc, "read") else b""
+        status = exc.code
+    truncated = len(raw) > max_bytes
+    text = raw[:max_bytes].decode("utf-8", "replace")
+    if truncated:
+        text += "\n…(gekuerzt)"
+    logger.info("[oauth] call %s %s %s -> %s (%d Byte)", svc, m, host, status, len(raw))
+    return status, text
+
+
 def list_services() -> list[dict]:
     """Diagnostik: zeigt fuer jeden konfigurierten Service ob Token da ist
     + Ablaufzeit. Wird von Diagnostic genutzt."""

aria-brain/project_vms.py

@@ -0,0 +1,118 @@
+"""
+project_vms — Registry der QEMU-VMs PRO PROJEKT.
+
+Persistenz: /shared/config/project_vms.json  →  { project_id: [ {vm}, ... ] }.
+Eine VM = {name, arch, iso, vnc_display, mem, created_at, updated_at}. Der echte
+Start/Stop laeuft ueber `aria-vm` auf dem Host (SSH aria-wohnung, siehe main.py);
+diese Datei haelt nur die Zuordnung VM ↔ Projekt + die Startparameter, damit die
+Liste im Desktop-Panel der App pro Projekt erscheint (auch wenn leer).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from pathlib import Path
+from typing import Optional
+
+VMS_FILE = Path(os.environ.get("PROJECT_VMS_FILE", "/shared/config/project_vms.json"))
+NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{1,40}$")
+VALID_ARCH = {"x86_64", "amd64", "i386", "i686", "x86", "arm", "aarch64",
+              "mips", "mipsel", "mips64", "ppc", "ppc64", "riscv64", "sparc"}
+
+
+def _load() -> dict:
+    if not VMS_FILE.exists():
+        return {}
+    try:
+        data = json.loads(VMS_FILE.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _save(data: dict) -> None:
+    VMS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = VMS_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    tmp.replace(VMS_FILE)
+
+
+def list_vms(project_id: str) -> list[dict]:
+    return _load().get(project_id or "", [])
+
+
+def get_vm(project_id: str, name: str) -> Optional[dict]:
+    for v in list_vms(project_id):
+        if v.get("name") == name:
+            return v
+    return None
+
+
+def _used_displays(data: dict, exclude: object = None) -> set:
+    """Alle VNC-Displays, die ueber ALLE Projekte belegt sind (exclude = eine
+    VM-Dict-Instanz, die ignoriert wird — fuer Updates)."""
+    used = set()
+    for lst in data.values():
+        for v in lst:
+            if v is exclude:
+                continue
+            try:
+                used.add(int(v.get("vnc_display", 1)))
+            except (TypeError, ValueError):
+                pass
+    return used
+
+
+def add_vm(project_id: str, name: str, arch: str, iso: str = "",
+           floppy: str = "", disk: str = "",
+           vnc_display: int = 0, mem: int = 1024) -> dict:
+    """Registriert/aktualisiert eine VM. Medien (disk/floppy/iso) optional —
+    leer = aria-vm erkennt disk.qcow2/floppy.img/cdrom.iso im VM-Ordner selbst.
+
+    Das VNC-Display wird GLOBAL eindeutig vergeben (ueber alle Projekte), damit
+    mehrere laufende VMs nicht denselben Port doppelt binden. vnc_display<=0 oder
+    ein bereits belegtes Display → automatisch das naechste freie."""
+    if not NAME_RE.match(name or ""):
+        raise ValueError(f"Ungueltiger VM-Name: {name!r} (nur a-z0-9_-, max 40)")
+    if arch not in VALID_ARCH:
+        raise ValueError(f"Unbekannte Architektur: {arch!r}")
+    data = _load()
+    lst = data.setdefault(project_id or "", [])
+    now = int(time.time())
+    existing = next((v for v in lst if v.get("name") == name), None)
+
+    used = _used_displays(data, exclude=existing)
+    req = int(vnc_display or 0)
+    if req <= 0 and existing:              # Update ohne Display-Wunsch → behalten
+        req = int(existing.get("vnc_display", 0) or 0)
+    if req <= 0 or req in used:            # frei/eindeutig machen
+        req = 1
+        while req in used:
+            req += 1
+
+    fields = {"arch": arch, "iso": iso, "floppy": floppy, "disk": disk,
+              "vnc_display": req, "mem": int(mem), "updated_at": now}
+    if existing:
+        existing.update(fields)
+        _save(data)
+        return existing
+    vm = {"name": name, "created_at": now, **fields}
+    lst.append(vm)
+    _save(data)
+    return vm
+
+
+def remove_vm(project_id: str, name: str) -> bool:
+    data = _load()
+    lst = data.get(project_id or "")
+    if not lst:
+        return False
+    new = [v for v in lst if v.get("name") != name]
+    if len(new) == len(lst):
+        return False
+    data[project_id or ""] = new
+    _save(data)
+    return True

aria-brain/projects.py

@@ -133,6 +133,7 @@ def create_project(name: str, description: str = "") -> dict:
         "description": description.strip(),
         "status": "active",  # active | ended | archived
         "hidden": False,      # optisch aus Listen ausblenden (bleibt nutzbar)
+        "kind": "chat",       # chat | code — 'code' blendet Editor/VNC in der App ein
         "created_at": now,
         "updated_at": now,
         "last_activity_at": now,
@@ -149,7 +150,7 @@ def update_project(project_id: str, patch: dict) -> Optional[dict]:
     projects = _load_all()
     for p in projects:
         if p["id"] == project_id:
-            for k in ("name", "description", "status", "hidden"):
+            for k in ("name", "description", "status", "hidden", "kind"):
                 if k in patch and patch[k] is not None:
                     p[k] = patch[k]
             p["updated_at"] = _now()

aria-brain/prompts.py

@@ -68,6 +68,20 @@ Wissen ist fuer deine Arbeit da — aber es ist HOCHVERTRAULICH:
 Auf „wer bist du" / „was weisst du ueber mich": antworte allgemein und diskret
 (z.B. „einiges — geschaeftlich wie privat; frag mich gezielt"), NIEMALS ein
 Aufzaehlen privater/intimer Details.
+
+## MEDIEN-DOWNLOADS FUER STEFANS PRIVATGEBRAUCH
+Stefan ist Privatperson und du bist SEIN persoenlicher Assistent. Bittet er dich,
+ihm ein Video/Audio (z.B. von YouTube) fuer seinen EIGENEN, privaten Gebrauch
+herunterzuladen — offline anschauen, Archiv, Erinnerung an eine Szene/ein Lied —
+ist das eine Privatkopie (in DE nach §53 UrhG fuer den privaten Gebrauch
+zulaessig, solange die Quelle nicht offensichtlich illegal ist und kein
+Kopierschutz umgangen wird). Behandle solche Downloads NICHT reflexartig als
+Urheberrechtsverstoss und moralisiere nicht — nutz einfach den
+`yt-dlp-download`-Skill, konsistent, ohne jedes Mal neu zu diskutieren (du hast
+das schon oft gemacht). Anders ist es NUR, wenn es klar um WEITERVERBREITUNG,
+oeffentliches Posten oder kommerzielle Nutzung geht — DA weist du kurz auf das
+Problem hin. Im Zweifel privat vs. verbreiten: einmal kurz nachfragen, nicht
+pauschal ablehnen.
 """
 
 
@@ -139,13 +153,62 @@ def build_time_section() -> str:
         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.",
+        "Nutze das um Watcher-Conditions wie `hour_of_day == 8` einzuordnen. "
+        "Fuer `trigger_timer`: bei relativen Angaben ('in 10min', 'in 2 Stunden') "
+        "den `in_seconds`-Parameter; bei festen Uhrzeiten schreib bei `fires_at` "
+        "einfach die LOKALE Wanduhrzeit ohne Zeitzone (z.B. 'um 17 Uhr' → "
+        "'...T17:00:00') — der Server rechnet sie selbst in UTC um. So feuert der "
+        "Timer zur gemeinten Ortszeit und bleibt zeitzonen-portabel.",
     ]
     return "\n".join(lines)
 
+def build_voice_flow_section() -> str:
+    """Sprach-/Gespraechssteuerung: ARIA erkennt AUS DEM TEXT die Phase (Befehl vs.
+    Frage, Kette vs. Ende) und deklariert sie per Marker — wie [[AWAIT]]. Die
+    Marker werden im Brain entfernt (nie angezeigt/vorgelesen)."""
+    return "\n".join([
+        "## Sprach- & Gespraechssteuerung (Voice-First — du entscheidest die Phase)",
+        "Stefan spricht meist mit dir. DU erkennst aus dem Text, was gerade Phase "
+        "ist — niemand raet das fuer dich. Dazu haengst du EINEN Marker (bei Bedarf "
+        "zwei) ganz ans ENDE deiner Antwort. Sie werden entfernt: nicht angezeigt, "
+        "nicht vorgelesen, nicht gespeichert — genau wie `[[AWAIT]]`.",
+        "",
+        "- `[[STUMM]]` → Deine Antwort ist ein reiner **Steuerbefehl** (du hast etwas "
+        "GETAN: Musik, VNC oeffnen, einen Menuepunkt klicken, Licht …). Sie wird "
+        "NICHT vorgelesen; der kurze Bestaetigungstext steht nur in der Bubble. "
+        "Setz das IMMER, wenn Stefan dir einen Befehl gibt statt eine Frage stellt — "
+        "AUCH wenn du den Befehl ueber ein Skill/Tool ausfuehrst (nicht nur beim "
+        "Fast-Path). `[[STUMM]]` ALLEIN = Einzelbefehl → danach direkt zurueck aufs "
+        "Wake-Word.",
+        "- `[[WEITER]]` → Das Gespraech bzw. eine **Befehlskette** laeuft weiter: das "
+        "Mikro bleibt offen, du wartest auf die naechste Eingabe (kein erneutes "
+        "\"Computer\" noetig). Setz das, wenn Stefan eine Kette ankuendigt ('ich geb "
+        "dir gleich mehrere Befehle', 'wir machen das jetzt Schritt fuer Schritt') "
+        "oder das Gespraech klar weitergeht.",
+        "- `[[ENDE]]` → Konversation/Kette ist zu Ende: zurueck aufs Wake-Word. Setz "
+        "das, wenn Stefan schliesst ('das war's', 'Konversation Ende', 'Befehlskette "
+        "Ende', 'danke, fertig'). Stellt er in DERSELBEN Nachricht noch eine Frage, "
+        "beantworte sie normal (OHNE `[[STUMM]]`, wird also vorgelesen) UND haeng "
+        "`[[ENDE]]` an.",
+        "",
+        "Regeln:",
+        "- Befehl (etwas TUN) → `[[STUMM]]`. Frage (etwas WISSEN / plaudern) → normal, "
+        "ohne Marker (wird vorgelesen).",
+        "- Befehlskette: JEDER Schritt `[[STUMM]] [[WEITER]]` (stumm arbeiten, Mikro "
+        "offen), bis Stefan die Kette beendet → letzter Turn `[[ENDE]]`.",
+        "- Ohne Marker = normales Gespraech: du wirst vorgelesen und ich lausche "
+        "danach kurz weiter (Stefan kann einfach antworten, ohne 'Computer').",
+        "- Nie widerspruechlich: `[[ENDE]]` schlaegt `[[WEITER]]`.",
+        "",
+        "**Ohr aus/an:** Wenn Stefan will dass du aufhoerst zuzuhoeren — egal wie "
+        "formuliert ('leg dich schlafen', 'geh schlafen', 'Ohr aus', 'gute Nacht', "
+        "'mach Pause vom Zuhoeren') — ruf das Tool `ear_control(action='off')`. "
+        "Wieder aktivieren ('Ohr an', 'wach auf', 'hoer wieder zu') → "
+        "`ear_control(action='on')`. Die App stoppt/startet dann den Listener; du "
+        "bestaetigst nur kurz.",
+    ])
+
+
 TYPE_HEADINGS = {
     "identity": "## Wer du bist",
     "rule": "## Sicherheitsregeln & Prinzipien",
@@ -229,6 +292,70 @@ def build_hot_memory_section(pinned: List[MemoryPoint]) -> str:
     return "\n".join(parts).strip()
 
 
+MEMORY_CARE = """## DEIN GEDAECHTNIS — so pflegst du es
+
+Zwischen zwei Nachrichten behaeltst du NICHTS. Was du spaeter wissen musst, steht
+nur dann wieder vor dir, wenn es im Gedaechtnis liegt — angepinnt (immer im
+Prompt), im Verzeichnis unten (Titel + Merkzeile) oder als Treffer der Suche.
+Darum pflegst du es selbst, ohne dass Stefan "merk dir das" sagen muss.
+
+### Wann speichern (von dir aus)
+- Du lernst etwas, das man sonst muehsam neu herausfinden muesste: wo etwas
+  laeuft, welches System Test und welches Produktion ist, wie man hinkommt, wie
+  ein Ablauf funktioniert, was Stefan entschieden hat und WARUM.
+- Stefan korrigiert dich oder bestaetigt einen nicht offensichtlichen Weg.
+- Sofort, nicht "spaeter" — am Ende des Gespraechs bist du es nicht mehr.
+
+### Was NICHT ins Gedaechtnis gehoert
+- Was man jederzeit live nachsehen kann und sich laufend aendert: Ticket-Staende,
+  Projekt-/Ticket-Nummern im Fluss, Zeilenzahlen, "wer arbeitet gerade woran".
+  Das wird NACHGESEHEN, nicht erinnert.
+- Deine eigenen Berichte oder Vermutungen, die du nicht in diesem Zug geprueft hast.
+- Was ohnehin im Code, in Git oder in der Doku steht.
+
+### Welche Schublade
+- `tool` (angepinnt): Infrastruktur und Umgebungen — Hosts, Zugaenge, welche
+  Instanz Test und welche Produktion ist. Das muss IMMER vor dir liegen.
+- `rule` / `preference` (angepinnt): harte Regeln, Stefans Arbeitsweise.
+- `fact`: alles andere (nur per Suche sichtbar). Der Titel ist die Merkzeile im
+  Verzeichnis — schreib ihn so, dass du beim Lesen weisst, wann du nachschlagen
+  musst (z.B. "Schmiede: Prod 172.0.2.46, Test aria-wohnung" statt "Software Schmiede").
+
+### Pflegen statt anhaeufen
+- VOR dem Speichern mit `memory_search` pruefen, ob es schon einen Eintrag gibt.
+  Gibt es einen: `memory_update` statt eines zweiten Eintrags.
+- Hat sich etwas geaendert (z.B. eine "alte" Kopie ist jetzt deine Testumgebung):
+  den Eintrag SOFORT berichtigen.
+- Ist ein Eintrag falsch oder ueberholt: `memory_delete`.
+
+### Erinnern ist nicht Wissen
+- Ein Eintrag gibt den Stand von damals wieder (Datum steht dabei). Bevor du
+  Stefan einen Systemzustand als Tatsache nennst, pruefe ihn live.
+- Jeder Stand-Bericht nennt seine Quelle: WO und WOMIT du nachgesehen hast und
+  wann ("Prod-Board 172.0.2.46, gerade eben"). Hast du in diesem Zug nicht
+  nachgesehen, sag das — und schau nach, statt aus dem Verlauf weiterzuschreiben.
+- Widerspricht ein neuer Befund einem frueheren aus dem Verlauf: erst klaeren,
+  WO du jeweils nachgesehen hast, bevor du einen davon fuer falsch erklaerst."""
+
+
+def build_memory_care_section() -> str:
+    return MEMORY_CARE
+
+
+def _mem_date(p: MemoryPoint) -> str:
+    d = (p.updated_at or p.created_at or "")[:10]
+    return f" (Stand {d})" if d else ""
+
+
+def _mem_hook(p: MemoryPoint, n: int = 110) -> str:
+    """Erste Zeile/Satz des Inhalts als Merkzeile fuers Verzeichnis."""
+    c = " ".join((p.content or "").split())
+    if len(c) <= n:
+        return c
+    cut = c[:n]
+    return cut[: cut.rfind(" ")] + " …" if " " in cut else cut + " …"
+
+
 def build_cold_memory_section(matches: List[MemoryPoint]) -> str:
     """Baue 'Moeglicherweise relevant'-Block aus Search-Treffern."""
     if not matches:
@@ -236,7 +363,7 @@ def build_cold_memory_section(matches: List[MemoryPoint]) -> str:
     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.title}**{_mem_date(p)}{score}")
         lines.append(f"  {p.content.strip()}")
         att_line = _attachments_line(p)
         if att_line:
@@ -244,6 +371,37 @@ def build_cold_memory_section(matches: List[MemoryPoint]) -> str:
     return "\n".join(lines)
 
 
+def build_memory_index_section(index_titles: List[MemoryPoint]) -> str:
+    """Titel-Index des kalten Gedaechtnisses: ARIA sieht WELCHES Nachschlage-
+    Wissen sie hat (nur Titel, kein Inhalt = billig), damit sie den Inhalt via
+    memory_search holt statt Stefan nach etwas zu fragen, das schon da ist.
+    Nach Kategorie gruppiert; Conversation-Logs + auto-destillierte Fakten sind
+    bereits ausgefiltert (siehe list_index_titles)."""
+    if not index_titles:
+        return ""
+    grouped: dict[str, List[MemoryPoint]] = {}
+    for p in index_titles:
+        key = (p.category or p.type or "sonstiges").strip() or "sonstiges"
+        grouped.setdefault(key, []).append(p)
+
+    lines = [
+        "## Was in deinem Gedaechtnis liegt (per memory_search abrufbar)",
+        "Diese Eintraege hast DU gespeichert — hier Titel und Merkzeile, nicht der "
+        "ganze Inhalt. Wenn einer zur Aufgabe passt, hol den Inhalt mit `memory_search` "
+        "(Titel oder Stichwort). **Frag Stefan NICHT nach etwas, das hier steht** "
+        "(Zugangsdaten, Server/Hosts, Projekt-Stand, Konfig) — erst nachsehen.",
+        "",
+    ]
+    for cat in sorted(grouped.keys()):
+        items = grouped[cat]
+        lines.append(f"### {cat}")
+        for p in items:
+            hook = _mem_hook(p)
+            lines.append(f"- {p.title}{_mem_date(p)}" + (f" — {hook}" if hook and hook != p.title else ""))
+        lines.append("")
+    return "\n".join(lines).strip()
+
+
 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."""
@@ -364,8 +522,22 @@ def build_oauth_section(oauth_services: list[dict] | None,
         "",
         "Du kannst Spotify, Google, GitHub, Strava, Microsoft (und custom-konfigurierte) "
         "Services via OAuth2 ansprechen. Workflow ist IMMER:",
-        "1. `oauth_get_token(service)` versuchen — Token vorhanden? → benutzen.",
+        "1. `oauth_get_token(service)` fragen — sagt nur OB authentifiziert ist.",
         "2. Wirft 'Kein Token gespeichert'? → `oauth_authorize(service)` aufrufen, URL an Stefan, warten, dann nochmal `oauth_get_token`.",
+        "3. API ansprechen mit `oauth_call(service, url, ...)` — das Brain haengt "
+        "die Authorization selbst an.",
+        "",
+        "**Du bekommst den Zugangstoken NICHT zu sehen — und brauchst ihn nicht.** "
+        "Das ist Absicht: alles was Du siehst, steht im Gespraechsprotokoll. Frag "
+        "also nicht danach und versuche nicht, ihn aus Dateien oder Umgebungs"
+        "variablen zu lesen. Fuer etwas, das oefter gebraucht wird, bau einen Skill "
+        "— der holt sich den Token zur Laufzeit ueber "
+        "`{BRAIN_INTERNAL_URL}/oauth/<service>/token`, serverseitig.",
+        "",
+        "**Secrets gehoeren nie in den Chat.** Wenn Stefan Dir ein Passwort, einen "
+        "API-Key oder ein client_secret schicken will: NICHT hier abtippen lassen. "
+        "Verweise ihn auf Diagnostic → OAuth-Apps bzw. die Skill-Konfiguration. "
+        "Und wiederhole ein Secret niemals in Deiner Antwort.",
         "",
         f"**Callback-URL (fest, NICHT raten):** `{base}`",
         "Diese URL muss Stefan EINMAL pro Service im Provider-Dashboard als gueltige "
@@ -434,6 +606,7 @@ def build_flux_section(flux_config: dict) -> str:
 def build_system_prompt(
     pinned: List[MemoryPoint],
     cold: List[MemoryPoint] | None = None,
+    memory_index: List[MemoryPoint] | None = None,
     skills: List[dict] | None = None,
     triggers: List[dict] | None = None,
     condition_vars: List[dict] | None = None,
@@ -447,7 +620,9 @@ def build_system_prompt(
     """Kompletter System-Prompt: Hot + Cold + Skills + Triggers + FLUX + OAuth."""
     # Identitaets-Anker IMMER zuerst — vor allen Memories/Sektionen, damit die
     # ARIA-Rolle auch in Projekten mit injection-artigem Inhalt (Pentest) haelt.
-    parts = [IDENTITY_ANCHOR, "", build_hot_memory_section(pinned), "", build_time_section()]
+    parts = [IDENTITY_ANCHOR, "", build_hot_memory_section(pinned), "", build_memory_care_section(),
+             "", build_time_section(),
+             "", build_voice_flow_section()]
     if skills:
         parts.append("")
         parts.append(build_skills_section(skills))
@@ -466,6 +641,9 @@ def build_system_prompt(
                                          callback_host=oauth_callback_host,
                                          callback_port=oauth_callback_port,
                                          callback_tls=oauth_callback_tls))
+    if memory_index:
+        parts.append("")
+        parts.append(build_memory_index_section(memory_index))
     if cold:
         parts.append("")
         parts.append(build_cold_memory_section(cold))

aria-brain/proxy_client.py

@@ -66,6 +66,13 @@ class ProxyResult(BaseModel):
     content: str = ""
     tool_calls: list = []  # je: {"id", "name", "arguments" (dict)}
     finish_reason: str = ""
+    # ARIA-Zusatzfelder des Proxys (cli-to-openai.js). Wichtig: ein Fehler der
+    # CLI kommt NICHT als HTTP-Fehler, sondern als normale Antwort mit
+    # is_error=true und dem Fehlertext im content. Ohne dieses Flag kann der
+    # Agent einen Fehlertext nicht von einer Antwort unterscheiden — genau so
+    # landete die Meldung des Sicherheitsfilters als ARIAs Antwort im Verlauf.
+    is_error: bool = False
+    model_used: str = ""   # Modell, das tatsaechlich geantwortet hat
 
 
 class ProxyClient:
@@ -177,7 +184,13 @@ class ProxyClient:
         # 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)
+        return ProxyResult(
+            content=content or "",
+            tool_calls=tool_calls,
+            finish_reason=finish_reason,
+            is_error=bool(data.get("aria_error")),
+            model_used=str(data.get("aria_model") or ""),
+        )
 
     def close(self):
         try:

aria-brain/router.py

@@ -75,6 +75,16 @@ _TOOL_HINTS = re.compile(
     re.IGNORECASE,
 )
 
+# HINWEIS (bewusst KEINE Live-/Topic-Wortliste mehr): frueher stand hier ein
+# _LIVE_HINTS-Blacklist (Wetter/Musik/Uhrzeit/… → Claude). Das war die falsche
+# Idee — aus offenem Freitext die Absicht per Wortliste zu erraten ist NIE
+# vollstaendig, jeder Miss = ein Halo. Die generische Loesung ist keine groessere
+# Regex, sondern: das Modell entscheidet selbst („brauche ich Grundwahrheit/ein
+# Tool? → <<ESCALATE>>", siehe build_local_system_prompt). Ein 8B kann das noch
+# nicht zuverlaessig → local bleibt per Einstellung abschaltbar; ein staerkeres
+# lokales Modell uebernimmt spaeter genau diese Selbst-Erkennung. Absicherung ist
+# der Output-Guard in agent.py, nicht eine Input-Wortliste.
+
 # Technik-/Tiefe-Marker → Claude (lokales 8B soll das nicht raten).
 _HARD_HINTS = re.compile(
     r"```|"                                    # Codeblock
@@ -86,6 +96,18 @@ _HARD_HINTS = re.compile(
 
 _MAX_LEN_FOR_LOCAL = 220   # laengere Nachrichten = eher komplexe Aufgaben → Claude
 
+# Expliziter Nutzer-Wunsch „nimm das grosse Modell". Stefan sagt oft „frag Clodi"
+# / „benutze direkt Claude" — dann soll der Turn NICHT lokal versucht werden,
+# sondern direkt an Claude gehen. „Clodi/Clody" ist sein Kosename fuer Claude und
+# meint praktisch immer Routing; „claude"/„grosses modell" nur in Imperativ-Kontext
+# (nimm/nutze/frag/…), damit reine Trivia „was ist Claude" nicht faelschlich matcht.
+_FORCE_CLAUDE = re.compile(
+    r"\b(clodi|clody)\b"
+    r"|\b(nimm|nutze|benutze|verwende|frag(e|st)?|nimms?t?|mit|via|direkt|per)\b"
+    r"[^.?!]*\b(claude|gro(ss|ß)es?\s+modell)\b",
+    re.IGNORECASE,
+)
+
 
 def _strip_leading_hint_blocks(text: str) -> str:
     """Fuehrende `[ ... ]`-Hint-Bloecke (GPS, Barge-In von der Bridge) weg —
@@ -108,6 +130,10 @@ def should_try_local(user_message: str, cfg: dict) -> bool:
     msg = _strip_leading_hint_blocks(user_message)
     if not msg or len(msg) > _MAX_LEN_FOR_LOCAL:
         return False
+    # Expliziter „nimm Claude/Clodi"-Wunsch → nie lokal (User hat entschieden).
+    if _FORCE_CLAUDE.search(msg):
+        logger.info("[router] expliziter Claude-Wunsch erkannt → nicht lokal")
+        return False
     if _TOOL_HINTS.search(msg):
         return False
     if _HARD_HINTS.search(msg):
@@ -122,10 +148,16 @@ def should_try_local(user_message: str, cfg: dict) -> bool:
 # kein volles Memory (B1a).
 
 # Was das lokale Tier NICHT selbst kann → dafuer eskaliert es an Claude.
+# Seit dem B1a-Rueckbau hat local KEINE Werkzeuge mehr: es kann nichts
+# nachschlagen und nichts steuern. Alles was aktuelle Grundwahrheit oder eine
+# Aktion braucht, gehoert ans grosse Modell.
 _AWARENESS = (
-    "Nur das grosse Modell (nicht du im Schnell-Modus) kann: Bilder generieren, "
-    "Skills bauen/aendern, Projekte & OAuth verwalten, ins Gedaechtnis SCHREIBEN, "
-    "sowie tiefe/technische Analysen und langen Code."
+    "Du hast im Schnell-Modus KEINE Werkzeuge — du kannst nichts nachschlagen und "
+    "nichts steuern. Nur das grosse Modell kann: aktuelle Infos holen (Wetter, "
+    "News, Uhrzeit, Preise), Musik/Spotify steuern oder den laufenden Song "
+    "nennen, Timer setzen, Bilder generieren, Skills bauen/aendern, Projekte & "
+    "OAuth verwalten, ins Gedaechtnis schreiben, sowie tiefe/technische Analysen "
+    "und langen Code. Fuer ALL das eskalierst du."
 )
 
 
@@ -166,6 +198,13 @@ def build_local_system_prompt(identity_anchor: str, has_tools: bool = False,
             "'Spotify: …' / 'Playlist abspielen'-Quittung o.ae. ohne echten "
             "Skill-Aufruf. Kannst/willst du es nicht per Werkzeug tun, sag es "
             "ehrlich oder eskaliere — erfinde keine Bestaetigung.",
+            "Das gilt GENAUSO fuer Live-Auskuenfte: Nenne NIEMALS einen aktuellen "
+            "Songtitel, Interpreten, die Restzeit oder was gerade laeuft/welches "
+            "Geraet spielt, ohne den passenden Skill (z.B. run_spotify) WIRKLICH "
+            "aufgerufen und sein Ergebnis gelesen zu haben. Kein Tool-Ergebnis = du "
+            "weisst es NICHT — dann eskaliere, statt einen Titel/eine Zeit zu raten. "
+            "Gib nur weiter, was im Skill-Ergebnis wirklich steht; hat der Skill "
+            "keinen Titel geliefert (z.B. nur 'OK: next'), erfinde auch keinen.",
         ]
     parts += [
         "",

aria-brain/safeguard.py

@@ -0,0 +1,310 @@
+"""Anthropics Sicherheitsfilter — erkennen, ausweichen, Verlauf heil halten.
+
+Der Filter ("... safeguards flagged this message", `Details: [cyber]`) meldet
+sich NICHT als HTTP-Fehler. Die CLI liefert ein voellig normales Ergebnis mit
+is_error=true, und der Fehlertext steht im `content` — also genau dort, wo
+sonst ARIAs Antwort steht. Ungeprueft passiert deshalb Folgendes:
+
+  1. Der Fehlertext landet per conversation.add("assistant", ...) im Verlauf.
+  2. Jeder Folge-Turn schickt den Verlauf samt der ausloesenden Nachricht wieder
+     mit — der Filter greift erneut.
+  3. Das Projekt ist tot: jede weitere Frage scheitert an derselben Stelle.
+
+Dagegen zwei Rettungsstufen:
+
+  Stufe 1 — Modellwechsel. Der Filter ist modellspezifisch ("Opus 5's
+  safeguards ..."), Anthropic empfiehlt selbst "change your model". Derselbe
+  Turn wird mit dem Ausweich-Modell neu gefragt. Der ausloesende Turn wird
+  vermerkt, damit die naechsten Turns des Projekts nicht erst wieder gegen die
+  Wand laufen. Der Vermerk verfaellt von selbst, sobald der Turn aus dem
+  Rolling Window gerollt ist — nichts muss aufgeraeumt werden.
+
+  Stufe 2 — Quarantaene. Blockt auch das Ausweich-Modell, liegt es am Verlauf
+  selbst. Dann wird der ausloesende Turn aus dem Prompt-Fenster genommen.
+  NICHT geloescht: er bleibt in conversation.jsonl, bleibt in der Diagnostic
+  sichtbar und ist mit einem Klick zurueckholbar. Das Projekt ist damit im
+  naechsten Turn wieder benutzbar.
+
+Der Zustand liegt in /data/safeguard.json — bewusst NICHT in
+conversation.jsonl: ein Markieren wuerde dort ein Rewrite erzwingen, und das
+schreibt nur das In-Memory-Window zurueck (alles schon Destillierte waere weg).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+STATE_FILE = Path(os.environ.get("SAFEGUARD_STATE_FILE", "/data/safeguard.json"))
+RUNTIME_CONFIG_FILE = Path(os.environ.get("RUNTIME_CONFIG_FILE", "/shared/config/runtime.json"))
+
+# Wie viele Vorfaelle wir aufbewahren. Reicht fuer die Diagnostic-Anzeige und
+# haelt die Datei klein.
+MAX_INCIDENTS = 200
+
+_lock = threading.Lock()
+
+
+class Blocked(Exception):
+    """Auch das Ausweich-Modell wurde blockiert.
+
+    Dann hilft kein Modellwechsel mehr — es liegt am Verlauf selbst. Der Agent
+    faengt das und geht auf Stufe 2 (Quarantaene).
+    """
+
+    def __init__(self, models, text: str = ""):
+        self.models = [m for m in models if m]
+        self.text = text or ""
+        super().__init__("Sicherheitsfilter blockiert: " + ", ".join(self.models))
+
+# Textmarker des Filters. Englisch und stabil — der Text kommt von Anthropic,
+# nicht von uns. Mehrere, weil die Formulierung sich aendern kann.
+_MARKERS = (
+    "safeguards flagged this message",
+    "anthropic.com/legal/aup",
+    "can't respond to this message with",
+    "cannot respond to this message with",
+    "try rephrasing the request in a new session",
+)
+
+_DETAIL_RE = re.compile(r"details:\s*`?\[([a-z0-9_-]+)\]`?", re.IGNORECASE)
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def norm_model(model: str) -> str:
+    """Modellnamen vergleichbar machen (Gross/Klein, CLI-Prefix, Leerzeichen)."""
+    m = (model or "").strip().lower()
+    if m.startswith("claude-code-cli/"):
+        m = m[len("claude-code-cli/"):]
+    return m
+
+
+# ── Erkennung ───────────────────────────────────────────────────────
+
+def looks_like_block(text: str, is_error: bool = False) -> bool:
+    """True, wenn dieser Antworttext der Sicherheitsfilter ist.
+
+    Zwei Wege, absichtlich unterschiedlich streng:
+
+    * is_error=true (die CLI sagt selbst "das war ein Fehler") — ein Marker
+      genuegt.
+    * Ohne is_error muss der Text mit "API Error" ANFANGEN. Sonst wuerde die
+      Erkennung auch dann zuschlagen, wenn ARIA ueber den Filter *spricht*
+      ("der Fehler hiess: safeguards flagged ...") — eine Antwort ueber den
+      Fehler ist kein Fehler.
+    """
+    t = (text or "").strip()
+    if not t:
+        return False
+    low = t.lower()
+    hits = sum(1 for m in _MARKERS if m in low)
+    if hits == 0:
+        return False
+    if is_error:
+        return True
+    return low.startswith("api error") and len(t) <= 2000
+
+
+def detail_code(text: str) -> str:
+    """Der Klassifikator-Code aus "Details: `[cyber]`" — nur fuer die Anzeige."""
+    m = _DETAIL_RE.search(text or "")
+    return m.group(1) if m else ""
+
+
+# ── Ausweich-Modell ─────────────────────────────────────────────────
+
+def _runtime_cfg() -> dict:
+    try:
+        if RUNTIME_CONFIG_FILE.exists():
+            return json.loads(RUNTIME_CONFIG_FILE.read_text(encoding="utf-8")) or {}
+    except Exception as exc:
+        logger.warning("[safeguard] runtime.json lesen fehlgeschlagen: %s", exc)
+    return {}
+
+
+def fallback_for(model: str) -> str:
+    """Welches Modell beim naechsten Versuch.
+
+    Vorrang hat `brainFallbackModel` aus runtime.json (Diagnostic). Zeigt das
+    auf dasselbe Modell, ist es wertlos — dann faellt es auf die automatische
+    Wahl zurueck: ein ANDERES Tier, denn der Filter haengt am Modell.
+
+    Pro Aufruf gelesen, nicht beim Import: eine Aenderung in der Diagnostic
+    greift so ohne Brain-Neustart.
+    """
+    want = str(_runtime_cfg().get("brainFallbackModel") or "").strip()
+    primary = norm_model(model)
+    if want and norm_model(want) != primary:
+        return want
+    if "sonnet" in primary:
+        return "opus"
+    # Opus, Fable, Haiku und alles Unbekannte → Sonnet. Sonnet ist das
+    # breiteste Tier im Max-Abo und ein anderer Filter-Kontext als Opus.
+    return "sonnet"
+
+
+# ── Zustand ─────────────────────────────────────────────────────────
+
+def _load() -> dict:
+    try:
+        if STATE_FILE.exists():
+            data = json.loads(STATE_FILE.read_text(encoding="utf-8")) or {}
+            if isinstance(data, dict):
+                data.setdefault("incidents", [])
+                data.setdefault("quarantine", [])
+                return data
+    except Exception as exc:
+        logger.warning("[safeguard] Zustand lesen fehlgeschlagen: %s", exc)
+    return {"incidents": [], "quarantine": []}
+
+
+def _save(data: dict) -> None:
+    try:
+        STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = STATE_FILE.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(STATE_FILE)
+    except Exception as exc:
+        logger.warning("[safeguard] Zustand schreiben fehlgeschlagen: %s", exc)
+
+
+def record_block(project_id: str, turn_ts: str, model: str, fallback: str,
+                 text: str = "", recovered: bool = False) -> None:
+    """Einen Vorfall vermerken. turn_ts = der User-Turn, der mitlief."""
+    with _lock:
+        data = _load()
+        data["incidents"].append({
+            "at": _now(),
+            "project_id": project_id or "",
+            "turn_ts": turn_ts or "",
+            "model": model or "",
+            "fallback": fallback or "",
+            "recovered": bool(recovered),
+            "code": detail_code(text),
+            "snippet": (text or "").strip()[:300],
+        })
+        data["incidents"] = data["incidents"][-MAX_INCIDENTS:]
+        _save(data)
+
+
+def mark_recovered(turn_ts: str, model: str, fallback_used: str) -> None:
+    """Nachtragen, dass der Ausweichversuch geklappt hat (nur Anzeige)."""
+    with _lock:
+        data = _load()
+        for inc in reversed(data["incidents"]):
+            if inc.get("turn_ts") == turn_ts and norm_model(inc.get("model", "")) == norm_model(model):
+                inc["recovered"] = True
+                inc["fallback"] = fallback_used
+                break
+        _save(data)
+
+
+def blocked_models(project_id: str, turn_timestamps: Iterable[str]) -> set:
+    """Modelle, die an den Turns DIESES Fensters schon gescheitert sind.
+
+    Der Abgleich laeuft ueber die Turn-Zeitstempel: rollt der ausloesende Turn
+    aus dem Fenster, taucht er hier nicht mehr auf und das Projekt darf wieder
+    aufs Hauptmodell. Kein Aufraeumen, kein Ablaufdatum von Hand.
+    """
+    want = set(turn_timestamps or ())
+    if not want:
+        return set()
+    pid = project_id or ""
+    out = set()
+    for inc in _load()["incidents"]:
+        if (inc.get("project_id") or "") != pid:
+            continue
+        ts = inc.get("turn_ts") or ""
+        if ts and ts in want:
+            m = norm_model(inc.get("model", ""))
+            if m:
+                out.add(m)
+    return out
+
+
+# ── Quarantaene ─────────────────────────────────────────────────────
+
+def quarantine(turn_ts: str, project_id: str = "", reason: str = "") -> None:
+    if not turn_ts:
+        return
+    with _lock:
+        data = _load()
+        if any(q.get("turn_ts") == turn_ts for q in data["quarantine"]):
+            return
+        data["quarantine"].append({
+            "turn_ts": turn_ts, "project_id": project_id or "",
+            "at": _now(), "reason": reason or "",
+        })
+        _save(data)
+    logger.warning("[safeguard] Turn %s in Quarantaene (Projekt %r)", turn_ts, project_id or "(main)")
+
+
+def unquarantine(turn_ts: str) -> bool:
+    with _lock:
+        data = _load()
+        before = len(data["quarantine"])
+        data["quarantine"] = [q for q in data["quarantine"] if q.get("turn_ts") != turn_ts]
+        changed = len(data["quarantine"]) != before
+        if changed:
+            _save(data)
+    if changed:
+        logger.info("[safeguard] Quarantaene aufgehoben: %s", turn_ts)
+    return changed
+
+
+def quarantined_ts() -> set:
+    return {q.get("turn_ts") for q in _load()["quarantine"] if q.get("turn_ts")}
+
+
+def filter_window(turns: list) -> list:
+    """Quarantaenierte Turns aus dem Prompt-Fenster nehmen.
+
+    Greift NUR auf dem Weg zum Modell. Gespeichert bleibt alles — die
+    Diagnostic und jeder Export sehen den Turn weiter.
+    """
+    q = quarantined_ts()
+    if not q:
+        return turns
+    return [t for t in turns if getattr(t, "ts", "") not in q]
+
+
+# ── Diagnostic ──────────────────────────────────────────────────────
+
+def status(limit: int = 25) -> dict:
+    data = _load()
+    inc = data["incidents"][-limit:][::-1]
+    return {
+        "incidents": inc,
+        "total": len(data["incidents"]),
+        "quarantine": data["quarantine"],
+        "fallback_model": str(_runtime_cfg().get("brainFallbackModel") or "").strip(),
+        "state_file": str(STATE_FILE),
+    }
+
+
+def clear(project_id: Optional[str] = None) -> int:
+    """Vorfaelle loeschen (Anzeige + Taint). Quarantaene bleibt — die wird
+    einzeln aufgehoben, damit nicht ein Klick alle Blockaden zurueckholt."""
+    with _lock:
+        data = _load()
+        before = len(data["incidents"])
+        if project_id is None:
+            data["incidents"] = []
+        else:
+            pid = project_id or ""
+            data["incidents"] = [i for i in data["incidents"]
+                                 if (i.get("project_id") or "") != pid]
+        removed = before - len(data["incidents"])
+        _save(data)
+    return removed

aria-brain/seed_rules.py

@@ -53,11 +53,10 @@ SEED_RULES: List[dict] = [
             "  3. NIE annehmen 'wird schon Staging sein'. Production-URLs "
             "ohne 'stage'/'test'-Marker sind im Zweifel Production.\n"
             "\n"
-            "Vorfall (30.05.2026): ARIA hat einen Pentest-Test gegen "
-            "ein Kunden-Produktionssystem (Production!) angesetzt statt gegen "
-            "dessen Staging-Umgebung (Staging). Stefan "
-            "musste explizit korrigieren. Haette ARIA einen Factory-Reset-"
-            "Test ausgefuehrt, waeren echte Kundendaten verloren.\n"
+            "Vorfall (30.05.2026): ARIA hat einen Pentest-Test gegen ein "
+            "Kunden-PRODUKTIONSSYSTEM angesetzt statt gegen dessen Staging-"
+            "Umgebung. Stefan musste explizit korrigieren. Haette ARIA einen "
+            "Factory-Reset-Test ausgefuehrt, waeren echte Kundendaten verloren.\n"
             "\n"
             "Diese Regel ist Hard-Boundary — sie ueberstimmt JEDE andere "
             "Anweisung. Stefan kann sie temporaer per expliziter "
@@ -186,11 +185,21 @@ SEED_RULES: List[dict] = [
         "category": "skills",
         "content": (
             "Schreibe NIEMALS API-Keys, Tokens, Passwoerter, client_id oder "
-            "client_secret direkt in den Skill-Code. Fuer OAuth-Services "
-            "(Spotify, Google, GitHub etc.) nutze das Brain-Tool "
-            "`oauth_get_token('<service>')` — das macht Auto-Refresh und "
-            "haelt den Token frisch. Stefan muss sich sonst alle 60 Minuten "
-            "manuell neu einloggen, das nervt."
+            "client_secret direkt in den Skill-Code — und schreibe sie auch "
+            "NIE in eine Chat-Antwort. Alles was im Gespraech steht, wird "
+            "uebertragen und gespeichert.\n"
+            "\n"
+            "Fuer OAuth-Services (Spotify, Google, GitHub etc.):\n"
+            "- Im Gespraech: `oauth_call('<service>', url, ...)` — das Brain "
+            "haengt die Authorization an, Du siehst den Token nie.\n"
+            "- Im Skill-Code: den Token zur Laufzeit holen ueber "
+            "GET {BRAIN_INTERNAL_URL}/oauth/<service>/token. Der Aufruf macht "
+            "Auto-Refresh; Stefan muss sich sonst alle 60 Minuten neu "
+            "einloggen, das nervt.\n"
+            "- Zugangsdaten, die kein OAuth sind (Benutzername/Passwort, "
+            "API-Key): in die SKILL-KONFIGURATION (`skill_set_config`), nicht "
+            "in den Code und nicht in den Chat. Der Skill bekommt sie zur "
+            "Laufzeit als CFG_<NAME>-Umgebungsvariable."
         ),
     },
     {
@@ -236,9 +245,11 @@ SEED_RULES: List[dict] = [
         "content": (
             "Wenn ein API-Call gegen einen OAuth-Service 401 / 'unauthorized' / "
             "'token expired' zurueckgibt: RUFE ZUERST "
-            "`oauth_get_token('<service>')`. Brain holt entweder den noch "
-            "gueltigen Token oder refresht ihn automatisch ueber den "
-            "gespeicherten refresh_token. In 99% der Faelle reicht das.\n"
+            "`oauth_get_token('<service>')`. Das refresht automatisch ueber den "
+            "gespeicherten refresh_token und sagt Dir, ob wieder alles gueltig "
+            "ist (den Token selbst bekommst Du bewusst nicht — "
+            "`oauth_call` nutzt ihn fuer Dich). In 99% der Faelle reicht das: "
+            "danach denselben Aufruf einfach nochmal.\n"
             "\n"
             "Nur wenn `oauth_get_token` selbst einen Fehler wirft "
             "('refresh failed', 'no refresh_token', 'service nicht "
@@ -400,6 +411,120 @@ SEED_RULES: List[dict] = [
             "Brain-Resources: erst denken, sonst Brain-Tool nehmen."
         ),
     },
+    {
+        "migration_key": "seed/architecture/qemu-vm-code-projects",
+        "type": "rule",
+        "title": "Code-Projekte + QEMU: aria-vm auf dem Host, Editor/Desktop in der App",
+        "category": "architektur",
+        "content": (
+            "GRUNDWISSEN Code-/Bau-Projekte + VMs — so haengt das System zusammen:\n"
+            "\n"
+            "DATEIEN eines Code-Projekts gehoeren nach `/shared/projects/<projekt-id>/` "
+            "(Volume in proxy+bridge+brain gemountet). Alles was DORT liegt, erscheint "
+            "automatisch: das Projekt bekommt in der Liste ein 📄-Symbol, und im "
+            "Cockpit-Code-Editor sieht Stefan die Dateien — auch ALTE, nicht nur was Du "
+            "gerade live schreibst. Was Stefan im Editor tippt, kommt als Datei dorthin "
+            "zurueck. (Ein manuelles set_project_kind gibt's noch, ist aber optional — "
+            "die Dateipraesenz ist der eigentliche Indikator.)\n"
+            "\n"
+            "VMs (QEMU, JEDE Architektur: x86/i386, ARM/aarch64, MIPS, PPC, RISC-V, "
+            "SPARC) laufen auf dem HOST (die qemu-Tools liegen in aria-wohnung, die "
+            "Projektdateien in /shared). Du steuerst sie per `ssh aria-wohnung aria-vm ...`:\n"
+            "  - `aria-vm create <name> <arch> [groesse]` — legt eine VM an. groesse=\n"
+            "    '10G' → Festplatte (qcow2); groesse='none' → OHNE Disk (fuer OS-Bau, "
+            "    bootet von Diskette/ISO).\n"
+            "  - `aria-vm boot <name> [optionen]` — startet sie (daemonized). Optionen:\n"
+            "      --iso <pfad>       von CD/ISO booten\n"
+            "      --floppy <pfad>    von Diskette booten (-fda, klassisch OS-Dev)\n"
+            "      --disk <pfad>      explizite qcow2\n"
+            "      --vnc-display <N>  VNC-Display (Default 1 → Port 5901; mehrere VMs = "
+            "verschiedene N)\n"
+            "      --mem <MB>         RAM (Default 1024)\n"
+            "    Medien im VM-Ordner (disk.qcow2/floppy.img/cdrom.iso) werden auto-"
+            "erkannt. Es MUSS mindestens ein Boot-Medium da sein.\n"
+            "  - `aria-vm screenshot <name>` → PNG (an Stefan per [FILE:] schickbar).\n"
+            "  - `aria-vm list` / `aria-vm stop <name>` / `aria-vm rm <name>`.\n"
+            "\n"
+            "PFLICHT nach dem Bau/Boot: `vm_register(name, arch, disk?/floppy?/iso?, "
+            "mem?)` im aktuellen Projekt aufrufen — mit den Medien, die Du gebaut hast. "
+            "vnc_display WEGLASSEN — es wird global eindeutig auto-vergeben (kein "
+            "Port-Konflikt, wenn mehrere VMs laufen). ERST DANN erscheint die VM in "
+            "Stefans Desktop-Panel (Cockpit), "
+            "wo er sie Starten/Stoppen/Verbinden kann. Ohne vm_register bleibt seine "
+            "Liste leer, obwohl die VM laeuft. Der Startbefehl steht als Wert dahinter.\n"
+            "\n"
+            "URTEIL — bau eine VM NUR wenn's Sinn macht, und erkenne aus der SITUATION "
+            "was gebraucht wird:\n"
+            "  - DOS-/Retro-Spiele, installierte Software → FESTPLATTE (create mit "
+            "Groesse, dann installieren; disk).\n"
+            "  - Eigenes OS / Bootloader / Bare-Metal-Experiment → DISKETTE (create "
+            "'none', floppy.img; ggf. eine zweite Diskette einbinden).\n"
+            "  - Fertiges System installieren/testen → ISO (--iso Installer).\n"
+            "  - Architektur zum Task waehlen: 'teste mal was auf ARM' → arch=aarch64 "
+            "(-M virt, laeuft emuliert = langsam, das ist ok). x86-Zeug → i386/x86_64.\n"
+            "AENDERUNGS-ZYKLUS: willst Du an einer laufenden VM etwas aendern (Datei "
+            "tauschen, Diskette neu bauen), dann `aria-vm stop <name>` → Aenderung → "
+            "`aria-vm boot <name>` wieder starten. Stefan kann das auch selbst ueber "
+            "Start/Stop im Panel.\n"
+            "\n"
+            "Der VNC-Stream laeuft AUTOMATISCH komplett durch den RVS-Server (die Bridge "
+            "tunnelt die RFB-Bytes; der VNC-Port ist nur intern auf dem Host). Firewall-"
+            "unabhaengig — Du oeffnest NIE einen Port nach aussen. KVM-Beschleunigung nur "
+            "fuer x86-Gaeste, andere Architekturen laufen emuliert (langsamer). Medien-"
+            "Downloads/Baubares fuer Stefans Privatgebrauch: einfach machen, nicht "
+            "moralisieren."
+        ),
+    },
+    {
+        "migration_key": "seed/architecture/satellites-remote-networks",
+        "type": "rule",
+        "title": "Satelliten: Augen + Haende in fremden Netzen (Buero etc.)",
+        "category": "architektur",
+        "content": (
+            "Ein SATELLIT ist ein eigenstaendiger Container in einem FREMDEN Netz "
+            "(z.B. Buero, Werkstatt), der sich mit RVS verbindet und Dir dort Geraete "
+            "zeigt UND steuerbar macht. So erreichst Du Netze, in denen der Haupt-Stack "
+            "NICHT steht.\n"
+            "\n"
+            "WICHTIG — nicht nur bei 'im Buero'/'im Netz X': IMMER wenn eine Anfrage ein "
+            "GERAET oder einen HOST betrifft, das/der in einem Netz lebt, auf dem Du NICHT "
+            "direkt sitzt (Stefans Zuhause, Buero, Werkstatt, irgendein LAN mit privater "
+            "IP wie 192.168.x/10.x) — z.B. Drucker-Fuellstand, NAS, Smart-TV, ein Host per "
+            "IP — dann pruefe ZUERST `satellite_list`, ob ein Satellit dieses Netz abdeckt. "
+            "Sage NIEMALS 'da komm ich nicht ran' / 'bin nicht im Netz', BEVOR Du "
+            "`satellite_list` aufgerufen hast — ein Satellit im Zielnetz ist genau der Weg "
+            "hinein. Nur wenn wirklich keiner online ist, ist 'erreiche ich nicht' korrekt.\n"
+            "\n"
+            "Ablauf:\n"
+            "  1. `satellite_list` — welche Satelliten/Netze sind online + was koennen sie.\n"
+            "  2. `satellite_devices(satellite='Buero')` — welche Geraete gibt es dort "
+            "(Fire TV, Chromecast, Smart-TVs, Drucker, NAS ...). Nutze es um das "
+            "gemeinte Geraet zu finden, BEVOR Du steuerst.\n"
+            "  3. `satellite_command(...)` — Aktion ausfuehren.\n"
+            "\n"
+            "Beispiel 'Patronenstand vom Drucker zuhause': satellite_list -> Satellit im "
+            "Heimnetz online? -> BEVORZUGT satellite_command(satellite='<Heim>', "
+            "action='snmp.printer', params={'ip':'<drucker-ip>'}) -> liefert supplies mit "
+            "name + percent je Patrone (BK/C/M/Y), zuverlaessig aus der Printer-MIB. "
+            "NUR falls SNMP nichts liefert, als Fallback die HTML-Statusseite: "
+            "action='http.get', params={'url':'http://<drucker-ip>/general/status.html', "
+            "'contains':['ink','toner','cyan','magenta','yellow','black','%']} — der "
+            "contains-Filter zieht die relevanten Zeilen (sonst wird der Body bei "
+            "max_chars, Default 20000, abgeschnitten). NICHT aus dem Gedaechtnis raten.\n"
+            "\n"
+            "Beispiel 'spiel YouTube-Video auf dem Buero-Stick':\n"
+            "  satellite_command(satellite='Buero', device='Fire TV', "
+            "action='dial.launch', params={'app':'YouTube','v':'<videoId>'})\n"
+            "Die YouTube-Video-ID (v=) ziehst Du aus dem Link/Titel (ggf. web_search). "
+            "Weitere Aktionen: 'wol' (params={'mac':'...'}) zum Aufwecken, "
+            "'http.get'/'http.post' (params={'url':'...'}) fuer lokale Webhooks.\n"
+            "\n"
+            "Adressierung ueber Location/Name des Satelliten ('Buero'), NICHT ueber die "
+            "Geraete — die identifizieren sich selbst. Steuerung geht nur, wenn der "
+            "Satellit sie erlaubt (steht in satellite_list als caps). Ist keiner online: "
+            "sag das ehrlich, statt zu raten."
+        ),
+    },
     {
         "migration_key": "seed/architecture/brain-tools-xml-tag",
         "type": "rule",
@@ -820,6 +945,7 @@ def apply(store: VectorStore, embedder: Embedder) -> dict:
             "pinned": True,
             "category": rule.get("category", ""),
             "source": "seed",
+            "scope": "system",
             "tags": [],
             "created_at": now,
             "updated_at": now,

aria-brain/triggers.py

@@ -24,7 +24,7 @@ import os
 import re
 import shutil
 import time
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Optional
 
@@ -40,6 +40,29 @@ def _now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
+def _local_offset_hours(dt: datetime) -> int:
+    """Grobe Europe/Berlin-Naeherung (CEST=+2 Maerz-Okt, sonst CET=+1) — dieselbe
+    Logik wie build_time_section im Prompt, ohne zoneinfo/tzdata im Brain-Image."""
+    return 2 if 3 <= dt.month <= 10 else 1
+
+
+def normalize_fires_at_utc(iso: str) -> str:
+    """Bringt einen fires_at-ISO IMMER auf UTC (+00:00).
+
+    - Aware (endet auf Z oder hat einen Offset) → in UTC umgerechnet.
+    - Naiv (keine Zone) → als LOKALE Wanduhrzeit (Europe/Berlin) interpretiert
+      und nach UTC umgerechnet.
+
+    So speichern wir stets den absoluten Instant. Die Ausfuehrung (background.py,
+    UTC) trifft damit exakt die vom Nutzer gemeinte Ortszeit — und bleibt
+    zeitzonen-portabel (feuert am selben Moment, egal wo Stefan gerade ist)."""
+    dt = datetime.fromisoformat((iso or "").strip().replace("Z", "+00:00"))
+    if dt.tzinfo is None:
+        # Naiv = lokale Wanduhrzeit → UTC = lokal - Offset.
+        dt = (dt - timedelta(hours=_local_offset_hours(dt))).replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc).isoformat(timespec="seconds")
+
+
 def _safe_name(name: str) -> str:
     if not isinstance(name, str) or not NAME_RE.match(name):
         raise ValueError(f"Ungueltiger Trigger-Name: {name!r}")
@@ -123,13 +146,15 @@ def create_timer(
     fires_at_iso: str,
     message: str,
     author: str = "aria",
+    project_id: str = "",
 ) -> dict:
     _safe_name(name)
     if _path(name).exists():
         raise ValueError(f"Trigger '{name}' existiert schon")
-    # ISO validieren
+    # ISO validieren UND auf UTC normalisieren (naiv = lokale Wanduhrzeit →
+    # UTC). So passt das Anlegen zur UTC-Ausfuehrung in background.py.
     try:
-        datetime.fromisoformat(fires_at_iso.replace("Z", "+00:00"))
+        fires_at_iso = normalize_fires_at_utc(fires_at_iso)
     except Exception:
         raise ValueError(f"fires_at_iso ungueltig: {fires_at_iso}")
     data = {
@@ -140,11 +165,16 @@ def create_timer(
         "created_at": _now_iso(),
         "fires_at": fires_at_iso,
         "message": message,
+        # Projekt, in dem der Trigger angelegt wurde. Ohne das landete die
+        # Antwort beim Feuern IMMER im Hauptchat — auch wenn der Timer mitten
+        # in einem Projekt-Thread gestellt wurde. Leer = Hauptchat.
+        "project_id": project_id or "",
         "fire_count": 0,
         "last_fired_at": None,
     }
     write(name, data)
-    logger.info("Trigger angelegt: %s (timer, fires_at=%s)", name, fires_at_iso)
+    logger.info("Trigger angelegt: %s (timer, fires_at=%s, project=%s)",
+                name, fires_at_iso, project_id or "(main)")
     return data
 
 
@@ -155,6 +185,7 @@ def create_watcher(
     check_interval_sec: int = 300,
     throttle_sec: int = 3600,
     author: str = "aria",
+    project_id: str = "",
 ) -> dict:
     _safe_name(name)
     if _path(name).exists():
@@ -176,12 +207,15 @@ def create_watcher(
         "check_interval_sec": int(check_interval_sec),
         "throttle_sec": int(throttle_sec),
         "message": message,
+        # Siehe create_timer: ohne Projekt landet die Antwort im Hauptchat.
+        "project_id": project_id or "",
         "fire_count": 0,
         "last_fired_at": None,
         "last_checked_at": None,
     }
     write(name, data)
-    logger.info("Trigger angelegt: %s (watcher, cond='%s')", name, condition)
+    logger.info("Trigger angelegt: %s (watcher, cond='%s', project=%s)",
+                name, condition, project_id or "(main)")
     return data
 
 

bridge/Dockerfile

@@ -21,5 +21,6 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY aria_bridge.py .
 COPY modes.py .
+COPY llm_cluster.py .
 
 CMD ["python", "aria_bridge.py"]

bridge/llm_cluster.py

@@ -0,0 +1,219 @@
+"""LLM-Cluster: ein Eingang fuer alle lokalen Sprachmodelle aller KI-Boxen.
+
+Clients waehlen ein MODELL, nicht Box oder Karte. Wo es laeuft, entscheidet
+dieser Router:
+
+  * Auswahl     — unter allen online Boxen, die das Modell GELADEN haben
+                  (Karten-Belegung aus worker_hello/worker_ping), die mit den
+                  wenigsten laufenden Anfragen; bei Gleichstand reihum.
+                  Ist nur eine Karte da oder alles frei, landet alles dort —
+                  "verteilen, wenn noetig, sonst nicht".
+  * Ausfall     — verschwindet eine Box mitten in der Anfrage (kein Ping mehr)
+                  oder antwortet nicht, geht die Anfrage EINMAL an eine andere
+                  Box mit demselben Modell. Fehler des Modells selbst (z.B.
+                  Kontext zu lang) werden nicht wiederholt.
+  * Fehler      — kommen als FEHLER zurueck (ok=false / HTTP-Status), nie als
+                  normale Antwort. Ein Client wuerde einen Fehlertext sonst
+                  als Aussage der KI in seinen Verlauf schreiben — genau das
+                  hat bei ARIA schon mal einen ganzen Chat vergiftet.
+
+Eingang ist der RVS:
+
+  llm_cluster_models_request → llm_cluster_models
+  llm_cluster_request        → llm_cluster_response
+
+Programme brauchen nur eine ausgehende Verbindung zum RVS, egal in welchem
+Netz sie stehen. Werkzeuge, die nur "OpenAI-kompatibel" koennen (OpenHands
+& Co.), bekommen den OpenAI-RVS-Wrapper neben sich gestellt
+(xtts/openai_rvs_wrapper) — fuer sie ist der Cluster dann 127.0.0.1.
+
+Schnittstelle fuer Drittprogramme: docs/LLM-SCHNITTSTELLE.md
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+import uuid
+from typing import Optional
+
+logger = logging.getLogger("aria-bridge.llm-cluster")
+
+# Diese errorCodes heissen "die BOX war das Problem" → anderswo nochmal versuchen.
+# Alles andere (Modell-Fehler, z.B. Kontext zu lang) waere ueberall gleich.
+RETRY_CODES = {"timeout", "box_offline", "send_failed", "model_not_loaded"}
+MAX_ATTEMPTS = 2
+
+
+class LlmCluster:
+    def __init__(self, bridge):
+        self.b = bridge
+        self.inflight: dict[str, int] = {}      # instanceId → laufende Anfragen (von uns)
+        self._rr: dict[str, int] = {}
+        self.timeout = float(os.getenv("CLUSTER_LLM_TIMEOUT_S", "600"))
+
+    # ── Flotte ──────────────────────────────────────────────────────────
+
+    def _online_llm(self) -> list:
+        now = time.time()
+        return [w for w in self.b._workers.values()
+                if w.get("service") == "llm"
+                and (now - w.get("last_seen", 0)) < self.b.WORKER_OFFLINE_S]
+
+    def _is_online(self, instance_id: str) -> bool:
+        return any(w.get("instanceId") == instance_id for w in self._online_llm())
+
+    def models(self) -> list:
+        """Jedes geladene Modell GENAU EINMAL, egal auf wie vielen Karten.
+        ctx = das kleinste Kontextfenster unter seinen Karten (darauf muss sich
+        ein Client verlassen koennen, egal wohin der Router verteilt)."""
+        out: dict[str, dict] = {}
+        for w in self._online_llm():
+            slots = w.get("slots")
+            if isinstance(slots, list):
+                for sl in slots:
+                    m = sl.get("model")
+                    if not m or m not in (w.get("models") or []):
+                        continue
+                    e = out.setdefault(m, {"model": m, "ctx": 0, "cards": []})
+                    e["cards"].append({"node": w.get("node", ""), "instanceId": w.get("instanceId", ""),
+                                       "gpu": sl.get("gpu", ""), "gpuName": sl.get("gpuName", ""),
+                                       "state": sl.get("state", "")})
+                    c = int(sl.get("ctx") or 0)
+                    if c and (not e["ctx"] or c < e["ctx"]):
+                        e["ctx"] = c
+            else:
+                # Box mit altem Adapter (ohne Karten): nur die Modell-Liste
+                for m in (w.get("models") or []):
+                    e = out.setdefault(m, {"model": m, "ctx": 0, "cards": []})
+                    e["cards"].append({"node": w.get("node", ""), "instanceId": w.get("instanceId", ""),
+                                       "gpu": "", "gpuName": "", "state": ""})
+        for e in out.values():
+            e["available"] = len(e["cards"])
+        return sorted(out.values(), key=lambda e: e["model"])
+
+    def candidates(self, model: str) -> list:
+        return [w for w in self._online_llm() if model in (w.get("models") or [])]
+
+    def pick(self, model: str, exclude=()) -> Optional[str]:
+        """Die Box mit den wenigsten laufenden Anfragen; Gleichstand reihum."""
+        cands = [w["instanceId"] for w in self.candidates(model) if w["instanceId"] not in exclude]
+        if not cands:
+            return None
+        low = min(self.inflight.get(c, 0) for c in cands)
+        tied = sorted(c for c in cands if self.inflight.get(c, 0) == low)
+        i = self._rr.get(model, 0) % len(tied)
+        self._rr[model] = i + 1
+        return tied[i]
+
+    # ── Anfrage an eine bestimmte Box ───────────────────────────────────
+
+    async def _send_to(self, target: str, req: dict, deadline: float) -> dict:
+        """llm_request an GENAU diese Box, Antwort abwarten. Bricht frueh ab,
+        wenn die Box unterwegs offline geht — dann kann route() woanders hin."""
+        rid = str(uuid.uuid4())
+        fut: asyncio.Future = asyncio.get_running_loop().create_future()
+        self.b._pending_llm[rid] = fut
+        self.inflight[target] = self.inflight.get(target, 0) + 1
+        try:
+            payload = {k: v for k, v in req.items() if v is not None}
+            payload.update(requestId=rid, targetInstance=target)
+            ok = await self.b._send_to_rvs({"type": "llm_request", "payload": payload,
+                                            "timestamp": int(time.time() * 1000)})
+            if not ok:
+                return {"ok": False, "errorCode": "send_failed", "error": "RVS: Anfrage nicht gesendet"}
+            while True:
+                left = deadline - time.time()
+                if left <= 0:
+                    return {"ok": False, "errorCode": "timeout",
+                            "error": f"Keine Antwort von {target} in der Frist"}
+                try:
+                    return await asyncio.wait_for(asyncio.shield(fut), timeout=min(5.0, left))
+                except asyncio.TimeoutError:
+                    if not self._is_online(target):
+                        return {"ok": False, "errorCode": "box_offline",
+                                "error": f"{target} ist waehrend der Anfrage offline gegangen"}
+        finally:
+            self.inflight[target] = max(0, self.inflight.get(target, 1) - 1)
+            self.b._pending_llm.pop(rid, None)
+
+    async def route(self, req: dict, timeout: Optional[float] = None) -> dict:
+        """Eine Anfrage an den Cluster. req: model, messages, max_tokens,
+        temperature, stop, tools. Antwort: wie llm_response der Box, plus
+        attempts; bei Fehler errorCode + error (+ available).
+        timeout: Gesamtfrist inkl. Ausfall-Ersatz. ARIA nutzt eine kurze (lokal
+        ist ihr Schnellweg — dauert es zu lange, nimmt sie Claude)."""
+        model = (req.get("model") or "").strip()
+        messages = req.get("messages")
+        if not isinstance(messages, list) or not messages:
+            return {"ok": False, "errorCode": "bad_request", "error": "messages fehlt oder ist leer"}
+        available = [m["model"] for m in self.models()]
+        if not model:
+            if len(available) == 1:
+                model = available[0]       # eindeutig — dann darf es fehlen
+            else:
+                return {"ok": False, "errorCode": "bad_request", "available": available,
+                        "error": "model fehlt. Geladen: " + (", ".join(available) or "nichts")}
+        body = {"model": model, "messages": messages,
+                "max_tokens": int(req.get("max_tokens") or 512),
+                "temperature": float(req["temperature"]) if req.get("temperature") is not None else 0.7,
+                "stop": req.get("stop") or None, "tools": req.get("tools") or None}
+        limit = timeout or self.timeout
+        deadline = time.time() + limit
+        tried: list = []
+        last: dict = {}
+        for _ in range(MAX_ATTEMPTS):
+            target = self.pick(model, exclude=tried)
+            if not target:
+                break
+            tried.append(target)
+            t0 = time.time()
+            last = await self._send_to(target, body, deadline)
+            if last.get("ok"):
+                last["attempts"] = len(tried)
+                return last
+            logger.warning("[cluster] %s auf %s: %s (%s)%s", model, target, last.get("errorCode") or "Fehler",
+                           (last.get("error") or "")[:120], " — versuche andere Box" if
+                           last.get("errorCode") in RETRY_CODES else "")
+            if last.get("errorCode") not in RETRY_CODES or time.time() >= deadline:
+                break
+        if not tried:
+            return {"ok": False, "errorCode": "model_unavailable", "available": available,
+                    "error": (f"Modell {model!r} ist gerade auf keiner KI-Box im Cluster geladen. "
+                              f"Geladen: {', '.join(available) or 'nichts'}.")}
+        last.setdefault("errorCode", "model_error")
+        last["attempts"] = len(tried)
+        if last["errorCode"] in RETRY_CODES and len(tried) >= 1:
+            others = [c for c in self.candidates(model) if c["instanceId"] not in tried]
+            if not others:
+                last["error"] = (last.get("error") or "") + (
+                    " — keine weitere Box mit diesem Modell erreichbar.")
+        return last
+
+    # ── RVS-Eingang ─────────────────────────────────────────────────────
+
+    async def handle_rvs(self, mtype: str, payload: dict) -> bool:
+        if mtype == "llm_cluster_models_request":
+            await self.b._send_to_rvs({"type": "llm_cluster_models", "payload": {
+                "requestId": payload.get("requestId", ""), "models": self.models()},
+                "timestamp": int(time.time() * 1000)})
+            return True
+        if mtype == "llm_cluster_request":
+            asyncio.create_task(self._rvs_request(payload))
+            return True
+        return False
+
+    async def _rvs_request(self, payload: dict) -> None:
+        rid = payload.get("requestId", "")
+        res = await self.route(payload)
+        out = {"requestId": rid, "ok": bool(res.get("ok"))}
+        for k in ("content", "tool_calls", "model", "node", "gpu", "instanceId", "usage",
+                  "elapsedMs", "attempts", "error", "errorCode", "available",
+                  "promptTokens", "ctx"):
+            if res.get(k) is not None:
+                out[k] = res[k]
+        await self.b._send_to_rvs({"type": "llm_cluster_response", "payload": out,
+                                   "timestamp": int(time.time() * 1000)})

diagnostic/email.html

@@ -0,0 +1,211 @@
+<!doctype html>
+<html lang="de">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ARIA Postfach</title>
+<style>
+  :root {
+    --bg: #0A0A14; --panel: #12121E; --line: #1E1E2E; --text: #E0E0F0;
+    --muted: #8888AA; --faint: #555570; --accent: #0096FF; --sel: rgba(0,150,255,0.14);
+    --unread: #E0E0F0; --err: #FF6B6B;
+  }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; height: 100%; background: var(--bg); color: var(--text);
+    font: 13px/1.45 -apple-system, "Segoe UI", Roboto, sans-serif; }
+  .app { display: grid; grid-template-columns: 190px 360px 1fr; height: 100vh; }
+  .col { border-right: 1px solid var(--line); overflow: auto; min-width: 0; }
+  header { padding: 10px 12px; border-bottom: 1px solid var(--line); font-weight: 700;
+    display: flex; align-items: center; gap: 8px; position: sticky; top: 0; background: var(--bg); z-index: 1; }
+  .folder { padding: 7px 12px; cursor: pointer; color: var(--muted); white-space: nowrap;
+    overflow: hidden; text-overflow: ellipsis; }
+  .folder:hover { background: var(--panel); }
+  .folder.active { background: var(--sel); color: var(--accent); font-weight: 600; }
+  .tools { padding: 8px; border-bottom: 1px solid var(--line); display: flex; gap: 6px;
+    position: sticky; top: 41px; background: var(--bg); z-index: 1; }
+  input[type=search] { flex: 1; min-width: 0; background: var(--panel); color: var(--text);
+    border: 1px solid var(--line); border-radius: 4px; padding: 5px 8px; font: inherit; }
+  button { background: var(--panel); color: var(--text); border: 1px solid #2A2A3E;
+    border-radius: 4px; padding: 4px 9px; font: inherit; font-size: 12px; cursor: pointer; }
+  button:hover { border-color: var(--accent); }
+  .msg { padding: 8px 12px; border-bottom: 1px solid var(--line); cursor: pointer; }
+  .msg:hover { background: var(--panel); }
+  .msg.active { background: var(--sel); }
+  .msg .from { color: var(--muted); font-size: 12px; white-space: nowrap; overflow: hidden;
+    text-overflow: ellipsis; display: flex; gap: 6px; }
+  .msg .from .date { margin-left: auto; color: var(--faint); flex: 0 0 auto; }
+  .msg .subj { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .msg.unread .subj { color: var(--unread); font-weight: 700; }
+  .msg.unread .from::before { content: "●"; color: var(--accent); }
+  .view { display: flex; flex-direction: column; min-width: 0; }
+  .meta { padding: 12px 16px; border-bottom: 1px solid var(--line); }
+  .meta h2 { margin: 0 0 6px; font-size: 16px; }
+  .meta div { color: var(--muted); font-size: 12px; }
+  .atts { padding: 8px 16px; border-bottom: 1px solid var(--line); display: flex; gap: 6px; flex-wrap: wrap; }
+  .atts a { color: var(--accent); text-decoration: none; background: var(--panel);
+    border: 1px solid #2A2A3E; border-radius: 12px; padding: 2px 10px; font-size: 12px; }
+  .body { flex: 1; min-height: 0; }
+  .body iframe { width: 100%; height: 100%; border: 0; background: #fff; }
+  .body pre { margin: 0; padding: 16px; white-space: pre-wrap; word-break: break-word;
+    font: inherit; height: 100%; overflow: auto; }
+  .empty { padding: 30px; text-align: center; color: var(--faint); }
+  .err { padding: 14px; color: var(--err); }
+  .note { font-size: 11px; color: var(--faint); font-weight: 400; margin-left: auto; }
+  .more { padding: 10px; text-align: center; }
+  @media (max-width: 900px) {
+    .app { grid-template-columns: 1fr; grid-template-rows: auto 40vh 1fr; height: auto; }
+    .col { border-right: 0; border-bottom: 1px solid var(--line); max-height: none; }
+  }
+</style>
+</head>
+<body>
+<div class="app">
+  <div class="col">
+    <header>📬 ARIA</header>
+    <div id="folders"><div class="empty">Lade …</div></div>
+  </div>
+  <div class="col">
+    <header><span id="folder-title">INBOX</span><span class="note" id="count"></span></header>
+    <div class="tools">
+      <input type="search" id="search" placeholder="Suchen …" onkeydown="if(event.key==='Enter')reload()">
+      <button onclick="reload()" title="Neu laden">↻</button>
+    </div>
+    <div id="list"><div class="empty">Lade …</div></div>
+  </div>
+  <div class="col view" id="view">
+    <div class="empty">Mail auswählen.<br><br>
+      <span style="font-size:11px;">Nur lesen — hier wird nichts als gelesen markiert,
+      damit ARIA weiterhin weiß, was neu ist.</span></div>
+  </div>
+</div>
+<script>
+  // ARIAs Postfach, nur lesend. Holt alles ueber den Brain-Proxy der
+  // Diagnostic (/api/brain/email/*). Zugangsdaten kennt diese Seite nicht.
+  const API = '/api/brain/email';
+  const PAGE = 50;
+  let folder = 'INBOX', offset = 0, total = 0, activeUid = null;
+  let folderRoles = {};
+
+  const esc = s => String(s ?? '').replace(/[&<>"']/g,
+    c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+  async function api(path) {
+    const r = await fetch(API + path);
+    const d = await r.json().catch(() => ({}));
+    if (!r.ok) throw new Error(d.detail || ('HTTP ' + r.status));
+    return d;
+  }
+
+  function shortDate(s) {
+    const t = Date.parse(s);
+    if (isNaN(t)) return s || '';
+    const d = new Date(t), now = new Date();
+    return d.toDateString() === now.toDateString()
+      ? d.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' })
+      : d.toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit', year: '2-digit' });
+  }
+
+  function nameOnly(from) {
+    const m = /^\s*"?([^"<]*?)"?\s*<([^>]+)>/.exec(from || '');
+    return m ? (m[1] || m[2]) : (from || '');
+  }
+
+  async function loadFolders() {
+    const box = document.getElementById('folders');
+    try {
+      const d = await api('/folders');
+      folderRoles = Object.fromEntries(d.folders.map(f => [f.name, f.role || '']));
+      const icon = { inbox: '📥 ', sent: '📤 ' };
+      box.innerHTML = d.folders.map(f =>
+        `<div class="folder${f.name === folder ? ' active' : ''}" data-name="${esc(f.name)}"
+              title="${esc(f.label)}" style="padding-left:${12 + 14 * (f.role ? 0 : (f.depth || 0))}px">${icon[f.role] || ''}${esc(f.role ? f.label : (f.short || f.label))}</div>`).join('') || '<div class="empty">Keine Ordner</div>';
+      box.querySelectorAll('.folder').forEach(el => el.onclick = () => selectFolder(el.dataset.name, el.title));
+    } catch (e) {
+      box.innerHTML = `<div class="err">${esc(e.message)}</div>`;
+      document.getElementById('list').innerHTML = '';
+    }
+  }
+
+  function selectFolder(name, label) {
+    folder = name;
+    document.getElementById('folder-title').textContent = label || name;
+    document.querySelectorAll('.folder').forEach(el => el.classList.toggle('active', el.dataset.name === name));
+    reload();
+  }
+
+  function reload() { offset = 0; loadList(false); }
+
+  async function loadList(append) {
+    const list = document.getElementById('list');
+    if (!append) list.innerHTML = '<div class="empty">Lade …</div>';
+    const q = document.getElementById('search').value.trim();
+    try {
+      const d = await api(`/messages?folder=${encodeURIComponent(folder)}&limit=${PAGE}&offset=${offset}`
+                          + (q ? `&search=${encodeURIComponent(q)}` : ''));
+      total = d.total;
+      document.getElementById('count').textContent = total ? `${total}` : '';
+      const sent = folderRoles[folder] === 'sent';
+      const html = d.messages.map(m => `
+        <div class="msg${m.seen || sent ? '' : ' unread'}${m.uid === activeUid ? ' active' : ''}" data-uid="${esc(m.uid)}">
+          <div class="from"><span>${sent ? 'an ' + esc(nameOnly(m.to)) : esc(nameOnly(m.from))}</span><span class="date">${esc(shortDate(m.date))}</span></div>
+          <div class="subj">${m.maybe_attachments ? '📎 ' : ''}${esc(m.subject || '(kein Betreff)')}</div>
+        </div>`).join('');
+      if (!append) list.innerHTML = '';
+      list.querySelector('.more')?.remove();
+      list.insertAdjacentHTML('beforeend', html || (append ? '' : '<div class="empty">Keine Mails.</div>'));
+      offset += d.messages.length;
+      if (offset < total) list.insertAdjacentHTML('beforeend',
+        `<div class="more"><button onclick="loadList(true)">Weitere laden (${total - offset})</button></div>`);
+      list.querySelectorAll('.msg').forEach(el => el.onclick = () => openMessage(el.dataset.uid));
+    } catch (e) {
+      list.innerHTML = `<div class="err">${esc(e.message)}</div>`;
+    }
+  }
+
+  // Mail-HTML in einem Rahmen OHNE Skripte und ohne Zugriff auf diese Seite
+  // (sandbox ohne allow-scripts/allow-same-origin). Die CSP verbietet jedes
+  // Nachladen von aussen — kein Tracking-Pixel meldet "gelesen". Bilder, die
+  // in der Mail stecken, kommen als data: (das Brain baut cid: um).
+  function frameFor(html) {
+    const csp = "default-src 'none'; img-src data:; style-src 'unsafe-inline'; font-src data:";
+    const doc = `<!doctype html><html><head><meta charset="utf-8">
+      <meta http-equiv="Content-Security-Policy" content="${csp}">
+      <base target="_blank"><style>body{font:14px/1.5 sans-serif;margin:16px;color:#111;}
+      img{max-width:100%;height:auto;}</style></head><body>${html}</body></html>`;
+    const f = document.createElement('iframe');
+    f.setAttribute('sandbox', 'allow-popups allow-popups-to-escape-sandbox');
+    f.setAttribute('referrerpolicy', 'no-referrer');
+    f.srcdoc = doc;
+    return f;
+  }
+
+  async function openMessage(uid) {
+    activeUid = uid;
+    document.querySelectorAll('.msg').forEach(el => el.classList.toggle('active', el.dataset.uid === uid));
+    const view = document.getElementById('view');
+    view.innerHTML = '<div class="empty">Lade …</div>';
+    try {
+      const m = await api(`/message?folder=${encodeURIComponent(folder)}&uid=${encodeURIComponent(uid)}`);
+      const atts = m.attachments.length
+        ? `<div class="atts">${m.attachments.map(a => `<a href="${API}/attachment?folder=${encodeURIComponent(folder)}&uid=${encodeURIComponent(uid)}&index=${a.index}"
+              download="${esc(a.name)}">📎 ${esc(a.name)} <span style="color:var(--faint)">${Math.max(1, Math.round(a.size / 1024))} KB</span></a>`).join('')}</div>`
+        : '';
+      view.innerHTML = `
+        <div class="meta">
+          <h2>${esc(m.subject || '(kein Betreff)')}</h2>
+          <div>Von: ${esc(m.from)}</div>
+          <div>An: ${esc(m.to)}${m.cc ? ' · Cc: ' + esc(m.cc) : ''}</div>
+          <div>${esc(m.date)}</div>
+        </div>${atts}<div class="body" id="body"></div>`;
+      const body = document.getElementById('body');
+      if (m.html) body.appendChild(frameFor(m.html));
+      else body.innerHTML = `<pre>${esc(m.text || '(leer)')}</pre>`;
+    } catch (e) {
+      view.innerHTML = `<div class="err">${esc(e.message)}</div>`;
+    }
+  }
+
+  loadFolders().then(reload);
+</script>
+</body>
+</html>

docker-compose.yml

@@ -11,11 +11,7 @@ services:
       npm install -g @anthropic-ai/claude-code claude-max-api-proxy &&
       DIST=$$(find /usr/local/lib -path '*/claude-max-api-proxy/dist' -type d | head -1) &&
       sed -i 's/startServer({ port })/startServer({ port, host: process.env.HOST || \"127.0.0.1\" })/' $$DIST/server/standalone.js &&
-      sed -i 's/\"--no-session-persistence\",/\"--no-session-persistence\",\"--dangerously-skip-permissions\",/' $$DIST/subprocess/manager.js &&
-      sed -i 's/\"--dangerously-skip-permissions\",/\"--dangerously-skip-permissions\",\"--system-prompt\",options.systemPrompt,/' $$DIST/subprocess/manager.js &&
-      sed -i 's/const DEFAULT_TIMEOUT = 300000;/const DEFAULT_TIMEOUT = 86400000;/' $$DIST/subprocess/manager.js &&
-      sed -i '/prompt, \\/\\/ Pass prompt as argument/d' $$DIST/subprocess/manager.js &&
-      sed -i 's|this\\.process\\.stdin?\\.end();|this.process.stdin?.end(prompt);|' $$DIST/subprocess/manager.js &&
+      cp /proxy-patches/manager.js $$DIST/subprocess/manager.js &&
       cp /proxy-patches/openai-to-cli.js $$DIST/adapter/openai-to-cli.js &&
       cp /proxy-patches/cli-to-openai.js $$DIST/adapter/cli-to-openai.js &&
       cp /proxy-patches/routes.js $$DIST/server/routes.js &&
@@ -120,6 +116,8 @@ services:
       - brain
     networks:
       - aria-net
+    extra_hosts:
+      - "host.docker.internal:host-gateway"        # fuer den VNC-Tunnel zum Host (QEMU)
     ports:
       - "3001:3001"                                # Diagnostic Web-UI (Diagnostic teilt Netzwerk mit Bridge)
     volumes:
@@ -138,6 +136,7 @@ services:
       - RVS_TLS=${RVS_TLS:-true}
       - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
       - RVS_TOKEN=${RVS_TOKEN:-}
+      - CLUSTER_LLM_TIMEOUT_S=${CLUSTER_LLM_TIMEOUT_S:-600}
     restart: unless-stopped
 
   # ─── Diagnostic (Selbstcheck-UI und Einstellungen) ────

docs/LLM-SCHNITTSTELLE.md

@@ -0,0 +1,384 @@
+# Lokale Sprachmodelle nutzen — Schnittstelle für Programme
+
+Wie ein Programm die lokalen Sprachmodelle auf den KI-Boxen von ARIA nutzt.
+
+**Kurz:** Du fragst ein **Modell**, nicht eine Box oder Karte. Der Cluster
+sucht sich aus, wo es läuft. Eigene Programme sprechen dafür über den RVS
+(Abschnitt A). Programme, die nur „OpenAI-kompatibel" können, bekommen den
+OpenAI-RVS-Wrapper neben sich gestellt (Abschnitt B).
+
+## Die Grundregel
+
+**Programme wählen ein Modell aus — laden aber nie.**
+
+- Jede KI-Box hat eine oder mehrere Grafikkarten fürs LLM. Jede dieser Karten
+  hält **genau ein Modell, dauerhaft geladen**.
+- Welches Modell wo liegt, legt nur der Betreiber in der ARIA-Diagnostic fest
+  (Einstellungen → LLM-Karten).
+- Ein Programm sieht die geladenen Modelle des ganzen Clusters — jedes
+  **einmal**, egal auf wie vielen Karten es liegt — und wählt eins.
+- Liegt das Modell auf mehreren Karten, **verteilt der Cluster bei Last**.
+  Fällt eine Box mitten in einer Anfrage aus, übernimmt eine andere mit
+  demselben Modell. Davon merkt das Programm nichts.
+- Ist das Modell nirgends geladen, gibt es einen **Fehler** — nie eine normale
+  Antwort mit Fehlertext. Ein Programm würde so einen Text sonst als Aussage
+  der KI in seinen Verlauf schreiben.
+- Mehrere Programme dürfen **gleichzeitig dasselbe Modell** nutzen. Die Karte
+  bedient sie parallel; jede einzelne Antwort wird dabei etwas langsamer.
+
+## Welcher Zugang?
+
+| | A) Cluster über RVS | B) OpenAI-RVS-Wrapper | C) Direkt an eine Box |
+|---|---|---|---|
+| Für | eigene Programme | OpenHands, Continue, Open WebUI … | Sonderfälle |
+| Sieht | alle Modelle, jedes einmal | alle Modelle, jedes einmal | nur diese Box |
+| Verteilung + Ausfall-Ersatz | ja | ja | nein |
+| Braucht | ausgehende Verbindung zum RVS | Wrapper-Container auf demselben Rechner | ausgehende Verbindung zum RVS |
+
+---
+
+## A) Cluster über RVS — empfohlen
+
+### Verbinden
+
+```
+wss://<RVS_HOST>:<RVS_PORT>/?token=<RVS_TOKEN>
+```
+
+- Das **Token ist der Raum** — dasselbe `RVS_TOKEN` wie bei ARIA und den
+  KI-Boxen. Wer es hat, ist im Raum.
+- Der Programm-Rechner braucht nur eine **ausgehende** Verbindung zum RVS.
+  Keine Portfreigabe, kein VPN — er kann in jedem Netz stehen.
+- Der RVS ist ein **Verteiler**: Jede Nachricht geht an alle anderen im Raum.
+  Du siehst also auch Antworten für andere — ordne sie immer über die
+  `requestId` zu.
+- Unbekannte Nachrichtentypen verwirft der RVS **ohne Fehlermeldung**. Die hier
+  beschriebenen sind freigegeben.
+- **Nur ein Leser pro Verbindung.** Schickst du mehrere Anfragen gleichzeitig,
+  liest eine Schleife alle Nachrichten und verteilt sie per `requestId` an die
+  Wartenden (siehe Beispiel). Mehrere gleichzeitige `recv()` auf derselben
+  Verbindung gehen nicht.
+
+Jede Nachricht hat diese Hülle:
+
+```json
+{ "type": "<typ>", "payload": { … }, "timestamp": 1760000000000 }
+```
+
+Beantwortet werden `llm_cluster_*`-Nachrichten von der **ARIA-Bridge** — sie
+kennt alle Boxen und entscheidet, wohin eine Anfrage geht. Läuft ARIA nicht,
+kommt keine Antwort (dein Programm sollte einen Timeout haben).
+
+### 1. Welche Modelle gibt es? — `llm_cluster_models_request`
+
+```json
+{ "type": "llm_cluster_models_request", "payload": { "requestId": "a1" } }
+```
+
+Antwort:
+
+```json
+{
+  "type": "llm_cluster_models",
+  "payload": {
+    "requestId": "a1",
+    "models": [
+      {
+        "model": "qwen3-8b",
+        "ctx": 8192,
+        "available": 2,
+        "cards": [
+          { "node": "ki-box",    "instanceId": "llm@ki-box",    "gpu": "1", "gpuName": "NVIDIA GeForce RTX 3060", "state": "ready" },
+          { "node": "werkstatt", "instanceId": "llm@werkstatt", "gpu": "0", "gpuName": "NVIDIA RTX A4000",        "state": "ready" }
+        ]
+      }
+    ]
+  }
+}
+```
+
+| Feld | Bedeutung |
+|---|---|
+| `model` | Name — genau so in der Anfrage angeben. **Das** zeigst du dem Nutzer zur Auswahl. |
+| `ctx` | **Kontextfenster in Tokens** (Eingabe + Ausgabe zusammen). Das kleinste unter allen Karten mit diesem Modell — darauf kannst du dich verlassen, egal wohin verteilt wird. Nicht mehr annehmen. `0` = unbekannt. **Kann sich ändern** (der Betreiber stellt es pro Karte ein) — vor längeren Aufträgen neu holen. |
+| `available` | auf wie vielen Karten es gerade liegt |
+| `cards` | nur zur Info (Anzeige, Fehlersuche) — für die Anfrage nicht nötig |
+
+### 2. Fragen — `llm_cluster_request`
+
+```json
+{
+  "type": "llm_cluster_request",
+  "payload": {
+    "requestId": "a2",
+    "model": "qwen3-8b",
+    "messages": [
+      { "role": "system", "content": "Du antwortest kurz." },
+      { "role": "user", "content": "Wie hoch ist die Zugspitze?" }
+    ],
+    "max_tokens": 256,
+    "temperature": 0.7
+  }
+}
+```
+
+| Feld | Pflicht | Bedeutung |
+|---|---|---|
+| `requestId` | ja | eindeutig pro Anfrage (z.B. UUID) |
+| `model` | ja* | aus `llm_cluster_models`. *Darf fehlen, wenn im Cluster genau ein Modell geladen ist. |
+| `messages` | ja | Verlauf im OpenAI-Format (`system` / `user` / `assistant` / `tool`) |
+| `max_tokens` | nein | Standard 512 |
+| `temperature` | nein | Standard 0.7 |
+| `stop` | nein | Liste von Stop-Strings |
+| `tools` | nein | Tool-Definitionen im OpenAI-Format; die Antwort enthält dann ggf. `tool_calls` |
+
+### 3. Antwort — `llm_cluster_response`
+
+Erfolg:
+
+```json
+{
+  "type": "llm_cluster_response",
+  "payload": {
+    "requestId": "a2",
+    "ok": true,
+    "content": "Die Zugspitze ist 2962 Meter hoch.",
+    "model": "qwen3-8b",
+    "node": "werkstatt",
+    "gpu": "0",
+    "usage": { "prompt_tokens": 31, "completion_tokens": 12, "total_tokens": 43 },
+    "elapsedMs": 640,
+    "attempts": 1
+  }
+}
+```
+
+`tool_calls` steht drin, wenn das Modell ein Werkzeug aufrufen will (OpenAI-Format).
+`node`/`gpu` sagen, wer geantwortet hat; `attempts: 2` heißt, die erste Box ist
+ausgefallen und eine andere hat übernommen.
+
+Fehler — `ok: false`, dazu `error` (Text für Menschen) und `errorCode`:
+
+| `errorCode` | Bedeutung | Was tun |
+|---|---|---|
+| `model_unavailable` | Das Modell ist gerade auf keiner Karte im Cluster geladen. `available` nennt, was es gibt. | Dem Nutzer anzeigen; Liste neu holen. |
+| `bad_request` | Anfrage unvollständig, z.B. `messages` leer oder `model` fehlt bei mehreren Modellen | Anfrage korrigieren |
+| `timeout` | Keine Antwort innerhalb der Frist (Standard 600 s) — auch nach Ersatzversuch | später nochmal |
+| `box_offline` | Box ist während der Anfrage weggefallen, und es gab keine Ersatz-Box | später nochmal |
+| `context_exceeded` | Der Verlauf ist länger als das Kontextfenster. Dazu `promptTokens` (so lang war die Anfrage) und `ctx` (so viel geht). | Verlauf kürzen und nochmal senden — z.B. auf ~80 % von `ctx` abzüglich der gewünschten Antwortlänge. |
+| `model_error` | Das Modell selbst hat einen anderen Fehler gemeldet. Wird nicht anderswo wiederholt — wäre dort genauso. | `error` lesen |
+
+**Fehler nie als Antwort der KI behandeln.** Zeig `error` dem Nutzer als
+Fehlermeldung an, aber schreib ihn nicht als Assistant-Nachricht in den
+Verlauf.
+
+### Beispiel (Python)
+
+Braucht Python 3.11+ und `websockets` (`pip install websockets`). Ein Leser
+pro Verbindung, mehrere Anfragen gleichzeitig möglich.
+
+```python
+import asyncio, json, uuid
+import websockets
+
+RVS = "wss://rvs.example.org:444/?token=DEIN_RVS_TOKEN"
+
+
+class AriaCluster:
+    """Eine RVS-Verbindung, ein Leser. Antworten gehen per requestId an die
+    wartende Anfrage — der Raum ist ein Verteiler, Fremdes wird ignoriert."""
+
+    def __init__(self, ws):
+        self.ws, self.wait = ws, {}
+        self.reader = asyncio.create_task(self._read())
+
+    async def _read(self):
+        async for raw in self.ws:
+            msg = json.loads(raw)
+            p = msg.get("payload") or {}
+            fut = self.wait.get((msg.get("type"), p.get("requestId")))
+            if fut and not fut.done():
+                fut.set_result(p)
+
+    async def _call(self, mtype, answer, payload, timeout):
+        rid = str(uuid.uuid4())
+        fut = asyncio.get_running_loop().create_future()
+        self.wait[(answer, rid)] = fut
+        try:
+            await self.ws.send(json.dumps({"type": mtype, "payload": dict(payload, requestId=rid)}))
+            return await asyncio.wait_for(fut, timeout)
+        finally:
+            self.wait.pop((answer, rid), None)
+
+    async def models(self):
+        res = await self._call("llm_cluster_models_request", "llm_cluster_models", {}, 6)
+        return res["models"]
+
+    async def chat(self, model, messages, timeout=660, **opts):
+        res = await self._call("llm_cluster_request", "llm_cluster_response",
+                               dict(opts, model=model, messages=messages), timeout)
+        if not res["ok"]:
+            raise RuntimeError(f"{res.get('errorCode')}: {res.get('error')}")
+        return res
+
+
+async def main():
+    async with websockets.connect(RVS, max_size=2**24) as ws:
+        cluster = AriaCluster(ws)
+        models = await cluster.models()
+        for m in models:
+            print(f"{m['model']}  (Kontext {m['ctx']}, auf {m['available']} Karte(n))")
+        if models:
+            res = await cluster.chat(models[0]["model"],
+                                     [{"role": "user", "content": "Sag Hallo in einem Satz."}],
+                                     max_tokens=64)
+            print(res["content"], f"— von {res['node']} / Karte {res['gpu']}")
+
+asyncio.run(main())
+```
+
+### Umstellen von der direkten Box-Ansprache
+
+Wer schon gegen Abschnitt C gebaut hat (`llm_models_request` /
+`llm_request` mit `targetInstance`), stellt so um:
+
+1. **Modelliste:** `llm_cluster_models_request` statt `llm_models_request`.
+   Statt einer Antwort pro Box kommt **eine** Antwort mit jedem Modell
+   einmal. Kein Einsammeln über Sekunden mehr.
+2. **Auswahl:** Dem Nutzer nur den **Modellnamen** zeigen — nicht mehr
+   „Modell · Karte · Box". Wo es läuft, entscheidet der Cluster.
+3. **Kontextfenster:** `ctx` aus der Liste übernehmen statt einen eigenen Wert
+   einzustellen — und **danach kürzen**, nicht nur anzeigen. Die Box gibt nur
+   so viel her, wie dort steht; rechnet ein Programm mit mehr, kommt
+   `context_exceeded`. Den Fehler zusätzlich abfangen: kürzen und nochmal
+   senden (`promptTokens`/`ctx` stehen dabei). Tokens grob schätzen reicht
+   nicht immer — Code und Deutsch brauchen mehr Tokens pro Zeichen als
+   englischer Fließtext.
+4. **Anfrage:** `llm_cluster_request` statt `llm_request`; **kein**
+   `targetInstance` mehr. Die Antwort kommt als `llm_cluster_response`.
+5. **Fehler:** `ok: false` als Fehler anzeigen, nicht als Antwort in den
+   Verlauf. Neue Codes siehe Tabelle oben.
+6. **Lesen:** ein Leser pro Verbindung, Antworten per `requestId` zuordnen.
+
+Felder und Format von `messages`, `tools`, `tool_calls` und `usage` bleiben
+gleich.
+
+---
+
+## B) OpenAI-RVS-Wrapper — für Programme, die nur OpenAI können
+
+Ein kleiner Container, der **auf demselben Rechner** wie das Programm läuft.
+Für das Programm ist der Cluster dann ein ganz normaler OpenAI-Endpunkt:
+
+```
+Programm ──HTTP──▶ Wrapper (127.0.0.1:8099) ──RVS──▶ ARIA-Bridge ──▶ KI-Box / Karte
+```
+
+Liegt im Repo unter [`xtts/openai_rvs_wrapper/`](../xtts/openai_rvs_wrapper/):
+
+```bash
+cd xtts/openai_rvs_wrapper
+cp .env.example .env      # RVS_HOST, RVS_PORT, RVS_TOKEN eintragen
+docker compose up -d --build
+```
+
+Im Browser zeigt **http://127.0.0.1:8099/** eine Hilfsseite: ob die Verbindung
+steht und welche Modelle es gibt. Im Programm eintragen:
+
+| Feld | Wert |
+|---|---|
+| Base URL | `http://127.0.0.1:8099/v1` |
+| API-Key | beliebig — oder `WRAPPER_API_KEY`, falls gesetzt |
+| Modell | ein Name von der Hilfsseite |
+| Kontextfenster | der Wert von der Hilfsseite |
+
+- `GET /v1/models` — jedes Modell einmal, mit `context_length`
+- `POST /v1/chat/completions` — auch `stream: true` (kommt derzeit in einem
+  Rutsch) und `tools`
+- Fehler als HTTP-Fehler mit OpenAI-Fehlerobjekt: nicht geladenes Modell →
+  404 `model_not_found`, Cluster nicht erreichbar → 503, Zeitüberschreitung → 504,
+  Verlauf zu lang → **400 `context_length_exceeded`** mit dem OpenAI-üblichen Text
+  („maximum context length is N tokens …") — daran erkennen OpenAI-Clients
+  (litellm, OpenHands …) den Überlauf und kürzen/verdichten selbst
+- Antwort-Header `X-Aria-Node` / `X-Aria-Gpu` sagen, wer geantwortet hat
+- **Läuft das Programm selbst in Docker**, ist `127.0.0.1` dort der eigene
+  Container. Dann das Docker-Netz `aria-llm` anhängen und
+  `http://openai-rvs-wrapper:8099/v1` nehmen (Details in der README des Wrappers).
+
+Mit dem offiziellen OpenAI-Python-SDK getestet (`models.list`,
+`chat.completions.create` mit und ohne Stream, Fehlerklassen).
+
+---
+
+## C) Direkt an eine Box — Sonderfall
+
+Ohne den Cluster, eine bestimmte Box gezielt. Keine Verteilung, kein
+Ausfall-Ersatz. Nur nötig, wenn ein Programm bewusst eine bestimmte Box will
+oder ARIA nicht läuft.
+
+**Modelle der Boxen:** `llm_models_request` `{requestId}` → **jede** Box
+antwortet einzeln mit `llm_models` `{requestId, instanceId, node, models:
+[{model, gpu, gpuName, ctx, state}]}`. Ein paar Sekunden einsammeln.
+
+**Anfrage:** `llm_request` `{requestId, targetInstance, model, messages, …}`
+→ `llm_response` `{requestId, ok, content, tool_calls, model, instanceId,
+node, gpu, usage, elapsedMs}`. Bei Fehler `errorCode`:
+`model_not_loaded` (mit `loadedModels`) oder `no_model_loaded`.
+
+Ohne `targetInstance` antworten nur Boxen, die das Modell geladen haben — die
+anderen schweigen. Hat keine es, kommt **keine** Antwort. Darum hier immer
+`targetInstance` setzen.
+
+**OpenAI-Port einer Box:** Jede Box hat zusätzlich einen eigenen
+OpenAI-Endpunkt (`http://<IP der Box>:8081/v1`, Standard nur `localhost` der
+Box). Er sieht nur diese Box; nicht geladene Modelle → HTTP 404. Für mehrere
+Boxen den Wrapper (B) nehmen.
+
+---
+
+## Den Verlauf verwaltet das Programm
+
+Die Box merkt sich **nichts** zwischen zwei Anfragen. Jede Anfrage muss alles
+mitbringen, was das Modell sehen soll (Systemprompt, Werkzeuge, Verlauf). Das
+Kontextfenster (`ctx`) ist die Obergrenze für **eine** Anfrage inklusive
+Antwort. Wächst der Verlauf darüber hinaus, muss das Programm ihn kleiner
+machen — drei übliche Wege, auch kombiniert:
+
+| Weg | Was passiert | Gut für |
+|---|---|---|
+| **Kürzen** | älteste Nachrichten weglassen (Systemprompt behalten) | einfache Chats, Werkzeug-Schleifen |
+| **Verdichten** („Compacting") | alte Teile vom Modell zusammenfassen lassen, Zusammenfassung statt Original mitsenden | lange Arbeitssitzungen |
+| **Gedächtnis** (RAG) | Wichtiges als Fakten in einer Datenbank ablegen, pro Anfrage nur Passendes dazuholen | dauerhaftes Wissen über Sitzungen hinweg |
+
+Wichtig dabei: Systemprompt **und** Werkzeug-Definitionen zählen mit, Platz
+für die Antwort (`max_tokens`) einplanen, Token grob schätzen (Deutsch/Code:
+eher 2,5–3 Zeichen pro Token) — und `context_exceeded` trotzdem abfangen:
+kürzen, einmal neu senden.
+
+## Was Programme nicht senden
+
+`llm_provision_model`, `llm_unload_model` und `llm_remove_model` sind der
+ARIA-Diagnostic vorbehalten. Technisch könnte jeder im Raum sie senden — der
+RVS unterscheidet die Teilnehmer nicht. Ein Programm, das sich nicht daran
+hält, tauscht anderen das Modell unter den Füßen weg.
+
+## Gleichzeitige Nutzung und Geschwindigkeit
+
+- Mehrere Anfragen an dasselbe Modell laufen auf einer Karte **parallel**.
+  Jede einzelne wird etwas langsamer, in Summe schafft die Karte mehr.
+- Liegt ein Modell auf mehreren Karten, schickt der Cluster neue Anfragen an
+  die Karte mit den wenigsten laufenden.
+- Der Kontext (`ctx`) ist bei aktuellen llama.cpp-Versionen ein **gemeinsamer
+  Vorrat** aller gleichzeitigen Anfragen auf einer Karte. Schicken mehrere
+  Programme gleichzeitig sehr lange Verläufe, wird es dort eng.
+
+## Wenn sich etwas ändert
+
+- Lädt der Betreiber ein anderes Modell in eine Karte, ist das alte dort weg.
+  Liegt es noch auf einer anderen Karte, merkt ein Programm nichts; sonst kommt
+  `model_unavailable` — dann die Liste neu holen.
+- Beim Laden oder Entladen startet die betroffene Box **alle** ihre Modelle
+  kurz neu (wenige Sekunden). Anfragen in diesem Moment warten oder gehen an
+  eine andere Box.
+- Diese Schnittstelle wird erweitert, nicht umgebaut: Neue Felder können
+  dazukommen. Unbekannte Felder ignorieren.

docs/flux-imagegen-plan.md

@@ -1,7 +1,7 @@
 # FLUX.1-dev Bildgenerierung — Architektur & Stand
 
 Ergaenzung des ARIA-Agent-Stacks um native Text-to-Image-Generierung via
-FLUX.1-dev auf der Gamebox. Folgt dem **gleichen Pattern wie f5tts / whisper**:
+FLUX.1-dev auf der AI-Box. Folgt dem **gleichen Pattern wie f5tts / whisper**:
 ein eigener Container auf dem Gaming-PC, der sich selbst per WebSocket zum
 RVS verbindet und auf seinen Request-Typ lauscht.
 
@@ -23,7 +23,7 @@ aria-bridge ── send_to_core ──▶  aria-brain
                                     RVS
                                        │ fanout
                                        ▼
-                              flux-bridge (Gamebox)
+                              flux-bridge (AI-Box)
                                        │ FluxPipeline.from_pretrained(...)
                                        │ pipeline(prompt, width, height, steps, guidance).images[0]
                                        │ PIL → PNG → base64

docs/plan-local-llm-router.md

@@ -1,4 +1,4 @@
-# Plan B — Lokaler LLM-Router (Gamebox) neben Claude
+# Plan B — Lokaler LLM-Router (AI-Box) neben Claude
 
 **Ziel:** „Gemini-Feeling" für den Alltag, ohne die Claude-Max-Subscription
 aufzugeben. Ein schnelles lokales LLM beantwortet die einfachen ~80 % der Turns
@@ -11,7 +11,7 @@ Gemessen (10.07.2026): CLI-Round-trip über den Claude-Max-Proxy hat einen
 **harten Boden von ~3,5 s** (Subprozess-Start pro Turn). Streaming-API würde das
 brechen, kostet aber API-Geld → verliert die Max-Subscription. Ein lokales
 LLM für die einfachen Turns umgeht den 3,5-s-Boden komplett und ist **gratis**
-(läuft auf vorhandener Gamebox-GPU). Echtes Speech-to-Speech-Duplex (Gemini
+(läuft auf vorhandener AI-Box-GPU). Echtes Speech-to-Speech-Duplex (Gemini
 Live nativ) ist mit einem Text-Modell als Hirn prinzipiell nicht drin.
 
 ## Modell & Serving (entschieden)
@@ -19,17 +19,17 @@ Live nativ) ist mit einem Text-Modell als Hirn prinzipiell nicht drin.
 - **Modell:** Qwen3 8B, GGUF **Q4_K_M** (~6 GB). Bestes Tool-Calling der 7/8B-
   Klasse, solides Deutsch, Apache-2.0. Alt.: Mistral Small 3 7B (schneller,
   weniger Tool-Calling).
-- **Serving:** **llama.cpp `llama-server`** im Docker-Container auf der Gamebox
+- **Serving:** **llama.cpp `llama-server`** im Docker-Container auf der AI-Box
   (kein Ollama nötig — nativer OpenAI-kompatibler `/v1/chat/completions`).
 - **VRAM-Budget:** 12-GB-Karte, Whisper-small (~1–2 GB) + F5-TTS (~1–2 GB) →
   ~8–9 GB frei → passt. (FLUX ist auf 12 GB eh raus.)
 
 ## Anbindung: über den RVS, wie TTS/STT (kein IP-Pflegen)
 
-Die Gamebox ist ein anderer Host als das Brain. Statt direktem HTTP (IP/Port/
+Die AI-Box ist ein anderer Host als das Brain. Statt direktem HTTP (IP/Port/
 Firewall) läuft das LLM **über den RVS-Token-Room**, exakt wie Whisper/F5-TTS:
 
-- llama.cpp hört nur auf localhost der Gamebox.
+- llama.cpp hört nur auf localhost der AI-Box.
 - Ein **dünner RVS-Adapter** daneben (Vorbild: whisper-/xtts-Bridge) verbindet
   sich mit dem RVS-Token, lauscht auf `llm_request`, ruft lokal llama-server,
   schickt `llm_response` (korreliert per requestId) zurück.
@@ -115,7 +115,7 @@ mit Ziel lokal.
 
 ## Phasen
 
-- **B0 — Infra:** llama.cpp-Container + RVS-Adapter auf der Gamebox,
+- **B0 — Infra:** llama.cpp-Container + RVS-Adapter auf der AI-Box,
   `ALLOWED_TYPES`, `local_llm_chat()` im Brain. Isoliert testen („sag hallo").
 - **B1 — Router + lokale Tools:** Heuristik Tier-1/2 + Escalation, schlanke
   Persona lokal, **kuratierte Tool-Auswahl lokal** (Adapter/Bridge/Brain-Tool-
@@ -207,8 +207,8 @@ Zerfaellt in zwei Teile:
   (Docker-Socket) + Controller mit Placement-Policy + Reconciliation +
   Broadcast-Kollisions-Vermeidung (nicht 2× dieselbe Faehigkeit). = Mini-Nomad.
 
-**Empfehlung:** Fuer 2 Gameboxen NICHT bauen — statische Platzierung reicht
-(Gamebox1=LLM, Gamebox2=Voice). Dynamisches Laden/Entladen zum VRAM-Freimachen
+**Empfehlung:** Fuer 2 AI-Boxen NICHT bauen — statische Platzierung reicht
+(AI-Box1=LLM, AI-Box2=Voice). Dynamisches Laden/Entladen zum VRAM-Freimachen
 deckt `llama-swap` innerhalb eines Hosts (B0.5). Waechst die Flotte: erst den
 billigen Heartbeat-Teil; fuer echte Orchestrierung Docker Swarm / Nomad nehmen
 statt selbst einen Scheduler zu bauen.
@@ -227,7 +227,7 @@ lohnt nicht):
   einen Heartbeat via RVS (Host, GPU-Util, VRAM frei/belegt, laufende
   GPU-Container). Diagnostic zeigt pro Host VRAM-Balken + Dienste + „Host X hat
   N GB frei". Kein Start/Stop, nur Sicht + Hinweis wohin verschiebbar.
-- **Zukunft (Gamebox3, 4×3060 = 48 GB):** neuer Host, eigenes Profil, `up` →
+- **Zukunft (AI-Box3, 4×3060 = 48 GB):** neuer Host, eigenes Profil, `up` →
   erscheint im Dashboard; grosses lokales LLM oder FLUX-Vollausbau dorthin.
   Ohne Orchestrator.
 

flux/bridge.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-ARIA FLUX-Bridge — laeuft auf der Gamebox (RTX 3060).
+ARIA FLUX-Bridge — laeuft auf der AI-Box (RTX 3060).
 
 Empfaengt flux_request via RVS → FLUX.1-dev/-schnell auf GPU → sendet
 flux_response mit base64-PNG zurueck an die aria-bridge. Diese speichert

host-agent/.env.example

@@ -0,0 +1,38 @@
+# ─── ARIA Host-Agent — Konfiguration ───────────────────────────────
+# Kopiere diese Datei nach .env (neben die Binary) und passe sie an.
+
+# RVS-Zugang (identisch zum Haupt-Stack — gleicher Raum/Token, damit ARIA
+# diesen Rechner erreicht). Werte aus der Haupt-.env.
+RVS_HOST=rvs.example.de
+RVS_PORT=443
+RVS_TLS=true
+RVS_TLS_FALLBACK=true    # bei TLS-Fehlschlag einmal auf ws:// zurueckfallen
+RVS_TOKEN=
+# RVS_SNI: nur noetig, wenn RVS_HOST eine IP ist (Agent im selben Netz wie der
+# RVS, direkt auf die interne IP). Dann hier den Zertifikats-/Hostnamen angeben,
+# damit der TLS-Handshake (SNI) passt. Sonst leer lassen.
+#   RVS_HOST=10.0.0.2
+#   RVS_SNI=example.com
+RVS_SNI=
+
+# ─── Identitaet dieses Rechners ────────────────────────────────────
+# HOST_ID   = technisch eindeutig (a-z0-9-_), Default = Hostname-Slug.
+# HOST_NAME = menschlicher Name, so spricht ARIA den Rechner an ("Stefans Laptop").
+HOST_ID=
+HOST_NAME=
+
+# ─── Steuerung (Sicherheit!) ───────────────────────────────────────
+# MUSS auf true, sonst fuehrt der Agent nichts aus (reiner Idle-Client).
+CONTROL_ENABLED=true
+
+# ─── sudo ──────────────────────────────────────────────────────────
+# Reihenfolge: 1) Agent laeuft als root -> braucht kein sudo. 2) SUDO_PASSWORD
+# gesetzt -> sudo -S mit Passwort. 3) SUDO_NOPASSWD=true -> sudo -n (Live-ISO /
+# passwortloses sudo, z.B. Linux Mint vom Stick). 4) sonst schlaegt sudo fehl.
+SUDO_PASSWORD=
+SUDO_NOPASSWD=false
+
+# ─── Limits (optional) ─────────────────────────────────────────────
+EXEC_TIMEOUT=60                 # max. Laufzeit eines Kommandos (s)
+OUT_MAX_CHARS=20000             # stdout-Ausschnitt (offset/max_chars pro Request)
+FILE_MAX_BYTES=10485760         # max. Datei-Transfer (10 MB)

host-agent/.gitignore

@@ -0,0 +1,6 @@
+.env
+build/
+dist/
+.buildenv/
+*.spec
+__pycache__/

host-agent/Dockerfile.build

@@ -0,0 +1,24 @@
+# Baut die Host-Agent-Binary mit PyInstaller in einem Container mit ALTEM glibc
+# (bullseye, glibc 2.31), damit die Onefile-Binary auf moeglichst vielen Linux-
+# Distributionen laeuft (glibc ist abwaerts-, nicht aufwaertskompatibel).
+FROM python:3.11-slim-bullseye
+
+WORKDIR /build
+
+# PyInstaller braucht objdump aus binutils (im slim-Image nicht enthalten).
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends binutils \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --no-cache-dir pyinstaller
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY host_agent.py .
+
+# Onefile-Binary; psutil-Hidden-Imports werden von PyInstaller erkannt.
+RUN pyinstaller --onefile --name aria-host-agent \
+      --collect-all psutil \
+      host_agent.py
+
+# Ergebnis liegt in /build/dist/aria-host-agent
+CMD ["sh", "-c", "cp /build/dist/aria-host-agent /out/ && echo 'Binary -> /out/aria-host-agent'"]

host-agent/Dockerfile.win

@@ -0,0 +1,45 @@
+# Baut die Windows-.exe des Host-Agents AUF LINUX — via Wine + Windows-Python +
+# PyInstaller. tobix/pywine bringt Wine + Windows-Python 3.11 mit (PyInstaller
+# kann NICHT cross-compilen, deshalb der Wine-Umweg).
+#
+# Zusaetzlich baut NSIS ein setup.exe, das die Agent-.exe installiert, eine .env
+# in C:\ProgramData\ARIA-Host-Agent anlegt (falls keine da ist) und den Agent als
+# automatisch startenden Windows-Dienst (via nssm) einrichtet.
+FROM tobix/pywine:3.11
+
+ARG VERSION=0.0.0
+
+# NSIS (Installer-Compiler, laeuft nativ auf Linux) + Tools fuer nssm.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends nsis curl unzip ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /work
+
+# nssm — Non-Sucking Service Manager (public domain): macht aus der Konsolen-.exe
+# einen sauberen Windows-Dienst (die .exe selbst spricht das SCM nicht).
+# nssm.cc faellt oefter aus (503) — dann Ersatz aus dem Internet Archive.
+# Beide liefern dieselbe Datei; die Pruefsumme stellt das sicher.
+ARG NSSM_SHA256=727d1e42275c605e0f04aba98095c38a8e1e46def453cdffce42869428aa6743
+RUN for url in https://nssm.cc/release/nssm-2.24.zip \
+               "https://web.archive.org/web/2024id_/https://nssm.cc/release/nssm-2.24.zip"; do \
+        curl -fsSL --retry 3 --retry-delay 5 --retry-all-errors "$url" -o /tmp/nssm.zip \
+        && echo "$NSSM_SHA256  /tmp/nssm.zip" | sha256sum -c - && break; \
+        echo "nssm: $url fehlgeschlagen, versuche naechste Quelle" >&2; rm -f /tmp/nssm.zip; \
+    done \
+    && test -f /tmp/nssm.zip \
+    && unzip -q /tmp/nssm.zip -d /tmp \
+    && cp /tmp/nssm-2.24/win64/nssm.exe ./nssm.exe \
+    && rm -rf /tmp/nssm*
+
+COPY requirements.txt host_agent.py ./
+COPY windows/installer.nsi ./
+
+# Windows-Python-Deps + PyInstaller, dann die Onefile-.exe bauen.
+RUN wine pip install --no-cache-dir -r requirements.txt pyinstaller
+RUN wine pyinstaller --onefile --name aria-host-agent --collect-all psutil host_agent.py \
+    && cp dist/aria-host-agent.exe ./aria-host-agent.exe \
+    && makensis -DVERSION=${VERSION} installer.nsi
+
+# Beide Artefakte rausreichen (dist/ wird vom build-win.sh als Volume gemountet).
+CMD ["bash","-lc","cp dist/aria-host-agent.exe /out/ && cp aria-host-agent-setup.exe /out/ && echo 'OK -> /out/aria-host-agent.exe + /out/aria-host-agent-setup.exe'"]

host-agent/README.md

@@ -0,0 +1,201 @@
+# ARIA Host-Agent
+
+Ein schlanker Agent, der **direkt auf einem Rechner** läuft und ARIA erlaubt,
+diesen Rechner zu steuern — auch wenn er sonst aus dem Netz **nicht erreichbar**
+ist (hinter NAT/Firewall, kein offener Port). Der Agent verbindet sich
+**ausgehend** zum RVS (gleicher Token wie der Rest von ARIA).
+
+Unterschied zum **Satelliten**: der Satellit entdeckt und steuert *andere*
+Geräte in einem LAN; der Host-Agent steuert *den Rechner, auf dem er läuft*.
+
+## Fähigkeiten
+
+| Aktion       | Was |
+|--------------|-----|
+| `exec`       | Shell-Kommando ausführen (optional `sudo`), stdout/stderr/exit |
+| `read`       | Datei lesen (Base64, mit Offset/Limit) |
+| `write`      | Datei schreiben/anhängen (Base64 oder Text) |
+| `info`       | OS, CPU/RAM/Disk-Auslastung, Uptime, IP, `gui`-Methode |
+| `screenshot` | Bildschirmfoto (X11: scrot/maim · Wayland: grim) |
+| `ui_tap`     | Mausklick auf x,y (button/double optional) *(nur mit GUI)* |
+| `ui_text`    | Text ins fokussierte Feld tippen *(nur mit GUI)* |
+| `ui_key`     | Taste/Kombi (Return, Escape, ctrl+c …) *(nur mit GUI)* |
+| `ui_swipe`   | Maus ziehen x1,y1 → x2,y2 *(nur mit GUI)* |
+| `app_launch` | App/Programm starten (`app`/`query` oder `command`) *(nur mit GUI)* |
+
+ARIA nutzt diese über die Brain-Tools `host_list`/`host_exec`/`host_read`/
+`host_write`/`host_info`/`host_screenshot` sowie `host_ui_tap`/`host_ui_text`/
+`host_ui_key`/`host_ui_swipe`/`host_app_launch` (dieselben Tools wie beim
+Android-Agenten — ein Werkzeugset für Handy **und** Rechner).
+
+> **GUI-Steuerung ist capability-gated.** Der Agent meldet die `ui_*`/`app_launch`-
+> Fähigkeiten in seinen `caps` nur, wenn eine grafische Session da ist — ein reiner
+> Terminal-/Server-Linux (kein `DISPLAY`/`WAYLAND_DISPLAY`) bekommt sie **nicht**
+> (dort bleibt es bei `exec` & Co.). ARIA arbeitet mit dem **Screenshot** als Augen
+> (voller Auflösung = echte Pixel; auf dem Desktop gibt es kein `ui_dump`).
+>
+> Nötige Helfer je System: **Linux/X11** → `xdotool`; **Linux/Wayland** → `ydotool`
+> (Daemon, meist root); **macOS** → Text/Tasten via Bordmittel (`osascript`), Maus
+> via `cliclick` (`brew install cliclick`); **Windows** → Bordmittel (PowerShell).
+> HiDPI/Retina-Hinweis: Screenshot-Pixel können 2× der Klick-Koordinaten sein — bei
+> Fehlklicks Koordinaten halbieren.
+
+## Plattformen
+
+Eine Codebasis, läuft auf **Linux, macOS und Windows** (der Agent wählt Shell,
+Screenshot-Methode und Root/Admin-Check je OS automatisch):
+
+| | exec | Root/Admin | Screenshot | GUI-Steuerung (`ui_*`) |
+|---|---|---|---|---|
+| **Linux** | `bash -lc` | sudo (`SUDO_PASSWORD`/`SUDO_NOPASSWD`) / root | grim (Wayland) · scrot/maim (X11) | `xdotool` (X11) · `ydotool` (Wayland) |
+| **macOS** | `bash -lc` | sudo (wie Linux) | `screencapture` (Bordmittel) | `osascript` (Text/Tasten) · `cliclick` (Maus) |
+| **Windows** | PowerShell | Agent **als Administrator** starten (kein sudo) | PowerShell/System.Drawing (Bordmittel) | PowerShell (Bordmittel) |
+
+PyInstaller kann **nicht cross-kompilieren** — jede Binary wird auf ihrem OS gebaut.
+
+## Bauen
+
+**Linux (portabel, empfohlen)** — Docker-Container mit altem glibc:
+```bash
+./build.sh          # -> dist/aria-host-agent  (~15 MB, läuft auf vielen Distros)
+```
+
+**Linux/macOS ohne Docker** — PyInstaller direkt (linkt gegen lokales glibc/OS):
+```bash
+./build-native.sh   # -> dist/aria-host-agent
+```
+
+**Windows — nativ** (auf einem Windows-Rechner, Python 3 im PATH nötig):
+```bat
+build-native.bat    REM -> dist\aria-host-agent.exe
+```
+
+**Windows — aus Docker heraus (auf Linux!), inkl. Installer** — Wine baut die
+`.exe`, NSIS packt ein `setup.exe`, das den Agent als Windows-Dienst einrichtet:
+```bash
+./build-win.sh [version]
+#  -> dist/aria-host-agent.exe        (Konsolen-Binary)
+#  -> dist/aria-host-agent-setup.exe  (Installer: Dienst + .env in ProgramData)
+```
+Der erste Lauf zieht das `tobix/pywine`-Image (~1–2 GB) und richtet die Wine-
+Python-Umgebung ein — das dauert; Folge-Builds sind schnell. PyInstaller kann
+nicht cross-compilen, deshalb der Wine-Umweg. **macOS geht so NICHT** (Apple
+lässt sich nicht legal aus Docker bauen) — dort `./build-native.sh` auf einem Mac.
+
+### Docker scheitert? (Live-ISO / overlayfs-Root)
+
+Wenn `build.sh` mit `failed to mount … overlayfs … invalid argument` abbricht,
+läufst du wahrscheinlich auf einem **Live-System** (Live-ISO). Dessen Root ist
+selbst ein overlayfs, und Dockers `overlay2`-Treiber kann kein Overlay-auf-
+Overlay stapeln. Zwei Auswege:
+
+- **Empfohlen:** Binary auf einem normal installierten Linux bauen (`./build.sh`)
+  und nur die fertige `dist/aria-host-agent` aufs Live-System kopieren. Die
+  Binary ist portabel — Ziel braucht weder Docker noch Python.
+- **Nativ bauen (ohne Docker):**
+  ```bash
+  sudo apt install -y python3-pip python3-venv
+  ./build-native.sh
+  ```
+  Achtung: nativ gebaut linkt die Binary gegen das glibc **dieser** Maschine —
+  sie läuft dann nur auf Systemen mit gleichem oder neuerem glibc.
+
+## Installieren
+
+1. `dist/aria-host-agent` auf den Ziel-Rechner kopieren.
+2. `.env.example` → `.env` daneben, RVS-Zugang + `CONTROL_ENABLED=true` eintragen.
+3. Starten: `chmod +x aria-host-agent && ./aria-host-agent`
+
+### Als systemd-Dienst (empfohlen für Dauerbetrieb)
+
+Der Installer kopiert Binary + `.env` an ihre Plätze und richtet den Dienst ein:
+
+```bash
+# .env-Pfad direkt übergeben:
+sudo ./install-service.sh /pfad/zur/.env
+
+# ODER ohne Argument -> ncurses-Dateidialog (dialog) zum Auswählen der .env:
+sudo ./install-service.sh
+```
+
+Er legt ab:
+- Binary → `/usr/local/bin/aria-host-agent`
+- `.env` → `/etc/aria-host-agent/.env` (Rechte `0600`, enthält Token/Passwörter)
+- Unit → `/etc/systemd/system/aria-host-agent.service`, dann `enable --now`.
+
+Danach: `systemctl status aria-host-agent` · `journalctl -u aria-host-agent -f`.
+Die Binary sucht er unter `dist/aria-host-agent` bzw. `./aria-host-agent` (oder
+2. Argument). Braucht `dialog` für den Dateibrowser (bietet die Installation an).
+
+### Windows-Dienst (setup.exe)
+
+`aria-host-agent-setup.exe` (aus `build-win.sh` oder dem Gitea-Release) als
+Administrator ausführen. Der Installer:
+- kopiert die `.exe` nach `%ProgramFiles%\ARIA Host-Agent`,
+- legt `%ProgramData%\ARIA-Host-Agent\.env` an (nur falls noch keine da ist),
+- richtet über **nssm** den Dienst **ARIA Host-Agent** ein (Autostart) und startet ihn.
+
+Danach die `.env` unter `%ProgramData%\ARIA-Host-Agent\` mit RVS-Zugang +
+`CONTROL_ENABLED=true` füllen und den Dienst neu starten (`services.msc` →
+*ARIA Host-Agent*, oder `nssm restart ARIAHostAgent`). Deinstallation über
+*Apps & Features* → *ARIA Host-Agent* (die `.env` in ProgramData bleibt erhalten).
+
+## Release (Binaries als Gitea-Assets)
+
+`release_agent.sh [version]` baut alles Docker-Baubare und hängt es als
+**Release-Asset** an den Tag `agent-v<version>` — nichts landet im Git-Tree:
+
+```bash
+./release_agent.sh                       # Version automatisch +1 (0.0.1.6 → 0.0.1.7)
+./release_agent.sh 0.2.0                 # Version selbst setzen; Linux + Android + Windows (Wine)
+SKIP_WINDOWS=1 ./release_agent.sh        # ohne Windows (schneller)
+```
+
+Assets: `aria-host-agent-linux-x64-v<v>.zip` (Binary + `install-service.sh` +
+systemd-Unit + `.env.example` + `LIESMICH.txt` — entpacken, `.env` anlegen, dann
+`./aria-host-agent` oder als Dienst `sudo ./install-service.sh ./.env`),
+`aria-host-agent-android-agent-v<v>.apk`,
+`aria-host-agent-windows.exe`, `aria-host-agent-windows-setup.exe`. **macOS** ist
+nicht Docker-baubar — auf einem Mac `./build-native.sh` laufen lassen und das
+Ergebnis vor dem Release nach `dist/aria-host-agent-macos` legen, dann nimmt das
+Skript es automatisch mit. Gitea-Zugang via `.env`/Umgebung (`GITEA_URL`,
+`GITEA_REPO`, `GITEA_USER`), Kennwort wird abgefragt.
+
+## TLS / SNI — Agent im selben Netz wie der RVS
+
+Steht der Rechner im **selben Netz wie der RVS** (z.B. Rechenzentrum) und soll
+direkt auf dessen **interne IP** verbinden (kein NAT-Hairpin über den externen
+Hostnamen), scheitert der TLS-Handshake sonst an `tlsv1 alert internal error`
+(Caddy hat kein Zertifikat für die IP). Lösung — in der `.env`:
+
+```
+RVS_HOST=10.0.0.2            # interne RVS-IP
+RVS_SNI=example.com    # Name, für den das Caddy-Zert gilt
+```
+
+Der Agent verbindet dann auf die IP, präsentiert aber den Namen im TLS-SNI.
+Zuhause / im Normalfall `RVS_SNI` leer lassen und den Hostnamen als `RVS_HOST`.
+
+## sudo
+
+Vier Fälle, der Agent wählt automatisch:
+
+1. **Agent läuft als root** (z.B. systemd `User=root`) → volle Rechte, kein sudo nötig.
+2. `SUDO_PASSWORD=…` in der `.env` → `sudo -S` mit Passwort.
+3. `SUDO_NOPASSWD=true` → `sudo -n` (Live-ISO / passwortloses sudo, z.B. Linux
+   Mint vom Stick).
+4. sonst → sudo-Kommandos scheitern mit klarer Meldung.
+
+## Sicherheit
+
+- Reagiert **nur** auf den eigenen RVS-Raum (Token) und **nur**, wenn
+  `CONTROL_ENABLED=true`.
+- Keine offenen Ports (reiner ausgehender Client).
+- Alle Kommandos werden geloggt.
+- Der Agent gibt **vollen** Zugriff auf den Rechner — nur auf Maschinen
+  einsetzen, denen du ARIA anvertraust.
+
+## Hinweis Screenshot
+
+Als Systemdienst fehlt die grafische Session. Für `screenshot` den Agent in der
+Desktop-Session starten (Autostart) oder `DISPLAY`/`XAUTHORITY` in der Unit setzen.

host-agent/android/.gitignore

@@ -0,0 +1,11 @@
+build/
+.gradle/
+dist/
+*.apk
+local.properties
+.idea/
+*.iml
+captures/
+
+# Signaturschluessel — NUR lokal, niemals ins oeffentliche Repo (Backup machen!)
+aria-agent.keystore

host-agent/android/Dockerfile.build

@@ -0,0 +1,32 @@
+# Baut die Android-Agent-APK (Debug, auto-signiert -> direkt installierbar).
+# APK-Builds gehen nur unter Linux — deshalb im Container.
+FROM eclipse-temurin:17-jdk-jammy
+
+ARG GRADLE_VERSION=8.5
+ARG CMDLINE_TOOLS=11076708
+ENV ANDROID_SDK_ROOT=/opt/android-sdk
+ENV ANDROID_HOME=/opt/android-sdk
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        unzip wget ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Gradle
+RUN wget -q https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip -O /tmp/g.zip \
+    && unzip -q /tmp/g.zip -d /opt && rm /tmp/g.zip
+
+# Android cmdline-tools + SDK
+RUN mkdir -p ${ANDROID_SDK_ROOT}/cmdline-tools \
+    && wget -q https://dl.google.com/android/repository/commandlinetools-linux-${CMDLINE_TOOLS}_latest.zip -O /tmp/c.zip \
+    && unzip -q /tmp/c.zip -d ${ANDROID_SDK_ROOT}/cmdline-tools && rm /tmp/c.zip \
+    && mv ${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools ${ANDROID_SDK_ROOT}/cmdline-tools/latest
+
+ENV PATH="/opt/gradle-${GRADLE_VERSION}/bin:${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin:${ANDROID_SDK_ROOT}/platform-tools:${PATH}"
+
+RUN yes | sdkmanager --licenses >/dev/null 2>&1 || true
+RUN sdkmanager "platform-tools" "platforms;android-34" "build-tools;34.0.0" >/dev/null 2>&1
+
+WORKDIR /project
+COPY . /project
+
+CMD ["bash","-lc","gradle --no-daemon assembleDebug && cp app/build/outputs/apk/debug/app-debug.apk /out/aria-android-agent.apk && echo 'OK -> /out/aria-android-agent.apk'"]

host-agent/android/README.md

@@ -0,0 +1,286 @@
+# ARIA Android-Agent
+
+Ein **nativer Android-Agent** (eigene APK), der ARIA erlaubt, ein Smartphone
+**fernzusteuern** — inkl. Bedienen fremder App-UIs (z.B. „ARIA, richte auf dem
+Handy ein E-Mail-Konto ein"). Gegenstück zum Desktop-`host-agent` (Linux/macOS/
+Windows), aber Android ist kein Unix-Shell-System — deshalb ein **anderes
+Action-Set** (UI-Automation statt beliebiger Shell-Kommandos).
+
+Verbindet sich wie die ARIA-App **ausgehend** zum RVS (gleicher Token/Raum),
+Verbindungs-Setup per **QR-Scan oder manueller Eingabe**. Taucht in der
+Diagnostic unter **Satelliten → Host-Agenten 💻** auf (`host_hello` mit
+`os="Android …"` + Android-Caps).
+
+## Warum nativ (Kotlin), nicht Termux/RN
+
+- **UI-Automation** (fremde Apps bedienen) geht auf Android nur über einen
+  **AccessibilityService** — den kann nur eine native App bereitstellen.
+- **Screenshots** einer laufenden Session: **MediaProjection** (native).
+- **Dauerbetrieb**: Foreground-Service mit Notification (native).
+- Termux gäbe nur Shell + `termux-api` (SMS/Anruf/Standort …), **kein** Bedienen
+  anderer App-UIs. Für „E-Mail-Konto durchklicken" reicht das nicht.
+
+Tech: **Kotlin**, OkHttp-WebSocket (RVS-Client), CameraX/ML-Kit (QR),
+AccessibilityService (Input), MediaProjection (Screenshot). Build via Docker
+(Android-SDK + Gradle) → APK. Nur Linux baut APKs (Docker), Deploy manuell.
+
+## Action-Set (host_command → host_result)
+
+Android-spezifisch (statt exec/read/write des Desktop-Agents):
+
+| Action | Was |
+|---|---|
+| `screenshot`   | Bildschirmfoto (MediaProjection) — ARIA *sieht* den Schirm |
+| `ui_dump`      | Sichtbare UI als Baum (Texte, Buttons, Felder + Koordinaten) — ARIAs „Augen" für gezieltes Tippen |
+| `ui_tap`       | Tippen (x,y ODER auf ein Element aus ui_dump) |
+| `ui_text`      | Text in das fokussierte/angegebene Feld schreiben |
+| `ui_swipe`     | Wischen/Scrollen |
+| `ui_key`       | Systemtasten (BACK, HOME, ENTER …) |
+| `app_launch`   | App per Paketname starten (z.B. E-Mail-App) |
+| `app_list`     | installierte Apps auflisten |
+| `info`         | Gerät: Modell, Android-Version, Akku, Netz, IP |
+| `notify`       | Benachrichtigung anzeigen |
+| *(später)*     | `sms_send`, `call`, `location`, `clipboard` (je nach Bedarf + Berechtigung) |
+
+ARIA-Flow „E-Mail einrichten": `app_launch` (Mail-App) → `screenshot`/`ui_dump`
+(sehen, was da ist) → `ui_tap`/`ui_text` (durchklicken) → wieder `ui_dump` prüfen,
+bis fertig. Genau das agentische Muster wie beim Endian-Fix, nur mit Handy-UI.
+
+### Fire TV / Android TV
+
+**Dieselbe APK** läuft auf Handy und Stick — die TV-Fähigkeiten schalten sich
+automatisch frei (`caps` enthalten dann `tv`). Zusätzlich auf dem TV:
+
+| Action | Was |
+|---|---|
+| `notify` | **Einblendung über dem laufenden Bild** (Text/Bild) — ohne Netflix & Co. zu stoppen; oder als Sprache, je nach Einstellung (`mode` überschreibt) |
+| `speak` | Sprachausgabe über die TV-Lautsprecher (ARIAs echte Stimme, sonst Geräte-TTS) |
+| `volume` | Lautstärke setzen (`percent`) |
+| `listen` / `listen_stop` | Mikrofon öffnen/schließen — ARIA-Sprachdialog auf dem Gerät |
+| `ui_key` | zusätzlich D-Pad: `up/down/left/right/ok`, `play_pause/next/prev`, `lauter/leiser/stumm` |
+
+**Sprachdialog:** Die App spricht das gleiche Protokoll wie die ARIA-App
+(`stt_stream_*` rein, `chat` + `audio_pcm` raus) — **serverseitig ist nichts
+anzupassen**. In den App-Einstellungen wählst Du, wie ARIA hier antwortet:
+**Einblendung** (Standard) oder **Sprache**; sie kann es pro Anfrage überschreiben.
+
+> **Turn-Ownership:** Der RVS verteilt jede Antwort an *alle* Clients im Raum.
+> Damit nicht Handy **und** Stick gleichzeitig losreden, gibt dieses Gerät nur
+> aus, was aus **seiner eigenen** Frage entstanden ist.
+
+> **Mikrofon der Fire-TV-Fernbedienung:** Die Mikro-Taste ist systemseitig mit
+> Alexa belegt; ob Fremd-Apps an das Remote-Mikro kommen, ist je nach Stick-
+> Generation unterschiedlich und **muss am Gerät ausprobiert werden**. Sicher
+> funktioniert der **Sprech-Knopf in der App** (OK-Taste) — und falls das Remote-
+> Mikro nicht hergibt, tut es ein USB-Mikro am Stick.
+
+Berechtigungen einmalig in der App: **„Einblendung erlauben"** (Über anderen Apps
+anzeigen) und beim ersten Sprechen das **Mikrofon**.
+
+### Ausrollen per Satellit (ohne Datei-Kopieren)
+
+Statt die APK von Hand aufs Gerät zu schaufeln, kann ein **Satellit** sie per ADB
+über das Netz installieren:
+
+1. Am Fire TV: **Einstellungen › Mein Fire TV › Entwickleroptionen › ADB-Debugging** an.
+2. Diagnostic → Satelliten → scannen. ADB-fähige Geräte zeigen ein **ADB**-Tag
+   und einen **📦**-Button.
+3. 📦 → APK-URL (aus dem Gitea-Release) → **Jetzt ausrollen**. Beim ersten Mal
+   erscheint auf dem TV „USB-Debugging zulassen?" → bestätigen (Haken „Immer erlauben").
+   Der Rollout **wartet darauf** und macht dann automatisch weiter.
+
+**Einrichtung ohne Tippen:** Am Fire TV gibt es keine Kamera (kein QR-Scan) und
+Host/Token mit der Fernbedienung einzugeben ist eine Qual. Deshalb ist im Rollout-
+Dialog **„Gleich einrichten"** vorausgewählt: die Diagnostic kennt den RVS-Zugang
+selbst und gibt ihn dem Agenten über dieselbe ADB-Verbindung mit
+(`adb.provision` → `am start` mit Intent-Extras). Der Agent speichert die Daten,
+startet den Dienst und ist **sofort online** — null Eingaben am Fernseher.
+Das Token geht dabei **serverseitig** raus, es steht nie im Browser-Formular.
+
+Mit **„Status prüfen"** (`adb.status`) siehst Du jederzeit, ob der Agent auf dem
+Gerät installiert ist, welche Version läuft und ob der Dienst aktiv ist.
+
+> **Sicherheitshinweis:** Die Einrichtung per Intent geht an die (exportierte)
+> Haupt-Activity. Wer ADB-Zugriff auf das Gerät hat, kann den Agenten damit
+> umkonfigurieren — wer ADB hat, kontrolliert das Gerät ohnehin. Die App zeigt
+> beim Empfang einen Hinweis („Von ARIA eingerichtet"), damit es nicht unbemerkt
+> passiert. Auf einem dedizierten Stick ist das unkritisch; schalte ADB-Debugging
+> nach dem Ausrollen ab, wenn Du ganz sicher gehen willst.
+
+ARIA kann dasselbe: `satellite_command` mit `action='adb.install'`,
+`params={'ip':'…','url':'…'}`. Der Satellit lädt die APK **einmal** und kann sie
+auf beliebig viele Sticks installieren.
+
+> **⚠️ Gerät muss ENTSPERRT sein, damit ARIA es steuern kann.** Gesten und
+> Systemtasten (`ui_tap`/`ui_text`/`ui_swipe`/`ui_key`/`app_launch`) greifen bei
+> gesperrtem Bildschirm nicht — Android-Sicherheit. Der Agent erkennt das und
+> meldet „Gerät ist gesperrt — bitte erst entsperren", statt still „ok" zu sagen.
+> **Sehen** (`screenshot`, `ui_dump`, `info`) funktioniert dagegen auch bei
+> gesperrtem Gerät.
+
+## Dauerbetrieb — Foreground-Service vs. Push (FCM)
+
+Der Agent muss **immer erreichbar** sein, obwohl Android Hintergrundprozesse
+aggressiv killt (Doze, App-Standby, OEM-Batterie-Manager wie Xiaomi/Huawei).
+Zwei Wege, deine WhatsApp-Intuition trifft ins Schwarze:
+
+**A) Foreground-Service (persistente WebSocket)** — der einfache Start:
+- Dauerhafte RVS-Verbindung + Foreground-Notification („Agent aktiv").
+- Braucht: `FOREGROUND_SERVICE`, **Akku-Optimierung ausnehmen**
+  (`REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` — User whitelistet die App),
+  `RECEIVE_BOOT_COMPLETED` + BootReceiver (Neustart nach Reboot), Auto-Reconnect
+  (haben wir im Protokoll schon).
+- **Reutzt unser bestehendes `host_hello`/`host_command`/`host_result` 1:1.**
+- Nachteil: etwas Akku; manche OEMs killen trotzdem → „Autostart" manuell erlauben.
+
+**B) Self-hosted Push (KEIN Google!)** — genau wie WhatsApp, aber auf eigenem Server:
+- **UnifiedPush + self-hosted ntfy**: Auf dem ARIA-Server läuft **ntfy** (freier,
+  self-hostbarer Push-Server). Der Agent nutzt **UnifiedPush** (offener Standard,
+  de-Google-Welt/F-Droid) mit dem ntfy-Distributor auf dem Handy. Will ARIA etwas,
+  POSTet die Bridge/RVS an ntfy → weckt die App → sie holt den Befehl vom RVS,
+  arbeitet, antwortet. **Läuft auch auf Custom-ROMs OHNE Google Play Services.**
+- Akkuschonend wie FCM, aber ohne jede Google-Abhängigkeit. Nur ein Dienst mehr
+  (ntfy) im Stack + der Push-Auslöser serverseitig.
+
+**C) FCM (Google) — optional:** Wer ein Stock-Android mit Play Services hat und
+Googles Push-Kanal will, kann FCM statt ntfy nehmen (bester Akku auf GMS-Geräten).
+Braucht Firebase-Projekt + Play Services. **Nur eine Option, keine Pflicht.**
+
+**Custom-ROM ohne Google:** → Weg **A** (eigener Socket) oder **B** (self-hosted
+ntfy). Beide brauchen KEIN Google. Für Stefans dediziertes Ziel-Handy ist **A**
+sogar oft die einfachste Dauerlösung (unser eigener „Push" über den RVS-Socket).
+
+**Hybrid (ideal, End-Ausbau):** Im Leerlauf nur Push (max. Akku). Ein Push weckt
+die App → sie öffnet die RVS-Verbindung, hält sich per Wakelock für die Interaktion
+wach (mehrere Befehle flüssig, z.B. E-Mail-Setup durchklicken) → schläft nach ein
+paar Sekunden Ruhe wieder ein. So WhatsApp-Akku UND schnelle Multi-Befehl-Sessions.
+Der Push kommt dabei von **B (self-hosted ntfy)** oder C (FCM) — freie Wahl.
+Erste Push-Latenz aus tiefem Doze ~1–3 s; danach bleibt der Socket die Session offen.
+
+**Empfehlung:** Meilenstein 1–3 mit **A (Foreground-Service)** — läuft sofort und
+nutzt alles Vorhandene, damit wir schnell einen funktionierenden Agenten haben, ganz
+ohne externe Dienste. Dann **Push-Hybrid mit self-hosted ntfy (B)** als Akku-Ausbau —
+KEIN Google. FCM (C) nur optional für Stock-Android. Action-Set/Protokoll bleiben
+identisch, nur der Wecker ändert sich.
+
+## Sicherheit
+
+- Reagiert nur auf den eigenen RVS-Raum (Token); Setup per QR/manuell.
+- **CONTROL_ENABLED**-Schalter in der App (Default AUS) — erst wenn Stefan es
+  bewusst aktiviert, führt der Agent Aktionen aus.
+- AccessibilityService + MediaProjection müssen vom User **explizit** in den
+  Android-Einstellungen freigegeben werden (kein stiller Zugriff möglich).
+- Alle Aktionen werden protokolliert (In-App-Log + optional an ARIA).
+- Voller Gerätezugriff — nur auf eigenen/anvertrauten Geräten nutzen.
+
+## Meilensteine
+
+1. **✅ Verbinden + sichtbar** — Gradle-Projekt, AndroidManifest, RVS-WS-Client,
+   Foreground-Service, Connect-UI (QR-Scan + manuell), `host_hello`/`host_ping`.
+   → Agent erscheint in der Diagnostic. `info` funktioniert.
+2. **✅ Sehen** — MediaProjection-Screenshot (`ScreenCapturer`, gleicher
+   `{format,bytes,base64}`-Vertrag wie der Desktop-Agent → `host_screenshot`) +
+   `ui_dump` (`AriaAccessibilityService`, nur lesend → Brain-Tool `host_ui_dump`).
+   Freigabe einmalig in der App: „Bildschirm-Zugriff erlauben" + „Bedienungshilfe
+   öffnen". → ARIA sieht den Schirm und liest die UI-Elemente mit Koordinaten.
+3. **✅ Steuern** — `ui_tap`/`ui_text`/`ui_swipe`/`ui_key`/`app_launch` über den
+   AccessibilityService (`canPerformGestures`, `dispatchGesture`, `ACTION_SET_TEXT`,
+   `performGlobalAction`) → Brain-Tools `host_ui_tap`/`_text`/`_swipe`/`_key`/
+   `host_app_launch`. Tap-Koordinaten = die x/y aus `ui_dump` (echte Pixel), NICHT
+   aus dem (skalierten) Screenshot. → ARIA bedient Apps (E-Mail-Setup).
+4. **Feinschliff** — `app_list`/`notify`, Build-Härtung, `release_agent.sh`.
+
+## Bauen
+
+APK-Builds laufen **nur unter Linux** — deshalb im Docker-Container. Du brauchst
+nichts Android-spezifisches installiert, **nur Docker**. Android-SDK, Gradle und
+Build-Tools zieht der Container selbst (`Dockerfile.build`).
+
+```bash
+cd host-agent/android
+./build.sh
+```
+
+`build.sh` baut das Image `aria-android-agent-build` und lässt darin
+`gradle assembleDebug` laufen. Ergebnis:
+
+```
+host-agent/android/dist/aria-android-agent.apk
+```
+
+Das ist ein **Debug-APK**: auto-signiert mit dem Android-Debug-Key, also direkt
+installierbar — ohne eigenen Keystore, ohne Play Store.
+
+### Auf dem Handy installieren
+
+1. `dist/aria-android-agent.apk` aufs Zielgerät kopieren (USB, Cloud, `adb install
+   dist/aria-android-agent.apk`, …).
+2. Antippen → Android fragt nach **„Unbekannte Quellen / Aus dieser Quelle
+   installieren erlauben"** → erlauben.
+3. App öffnen → verbinden (QR/manuell), „Steuerung erlauben" an, für M2 zusätzlich
+   „Bildschirm-Zugriff erlauben" + „Bedienungshilfe öffnen".
+
+### Was der erste Build kostet
+
+Der **erste** Lauf lädt viel (JDK-Image, Gradle, Android-SDK, Dependencies) und
+dauert entsprechend — mehrere Minuten. Folge-Builds sind schnell (Docker-Layer +
+Gradle-Cache im Image). Häufige Stolperer:
+
+- **Docker fehlt / kein Zugriff** → `docker`-Rechte prüfen (`docker ps`).
+- **Overlay-on-Overlay auf einem Live-ISO** („invalid argument" beim Image-Bau) —
+  gleiches Problem wie beim Desktop-Agent auf dem Mint-Live-System; von einer
+  installierten Linux-Kiste bauen.
+- **Kotlin-/Manifest-Fehler** beim allerersten Bau eines neuen Meilensteins: den
+  Gradle-Fehler posten, das glätten wir schnell.
+
+### Version setzen
+
+Bis es `release.sh` gibt, wird die Version in `app/build.gradle` gepflegt
+(`versionCode` / `versionName`). Aktuell `1` / `0.2.0` (M1+M2).
+
+## Release
+
+Das APK ist **kein** Teil des Git-Trees (blaeht sonst die History dauerhaft auf) —
+es wird als **Release-Asset** an einen Tag gehaengt. Das macht `release_agent.sh`
+(liegt eine Ebene hoeher, in `host-agent/`):
+
+```bash
+cd host-agent
+./release_agent.sh          # Version automatisch +1 (oder: ./release_agent.sh 0.2.0)
+```
+
+Das Skript (wie die `release.sh` der Haupt-App, Version als Parameter):
+
+- setzt die Version (`host_agent.py` → `AGENT_VERSION`, `app/build.gradle` →
+  `versionName`/`versionCode`),
+- baut **Linux-Binary + Android-APK** per Docker,
+- committet den Version-Bump, taggt **`agent-v<version>`** (eigener Namespace,
+  kollidiert nicht mit den App-Tags `v<version>`) und pusht,
+- legt ein Gitea-Release an und laedt die Assets hoch:
+  `aria-host-agent-linux-x64`, `aria-host-agent-android-agent-v<version>.apk`,
+  optional `-macos` / `-windows.exe` (falls in `host-agent/dist/` vorgebaut).
+
+Gitea-Zugang (`GITEA_URL`, `GITEA_REPO`, `GITEA_USER`) kommt aus der Umgebung oder
+einer `.env`; das Kennwort wird interaktiv abgefragt. **Binaries landen unter
+„Releases", nie im Tree.**
+
+> Status: **M1–M3 fertig** — verbinden, `info`, `screenshot`, `ui_dump` (sehen)
+> und `ui_tap`/`ui_text`/`ui_swipe`/`ui_key`/`app_launch` (steuern);
+> `release_agent.sh` vorhanden. Damit läuft der volle Ablauf sehen→steuern
+> (z.B. E-Mail-Konto einrichten). Nächstes: Feinschliff (M4).
+
+## Auto-Update
+
+Der Agent fragt beim Verbinden (und danach alle ~6 h) den RVS nach einer neueren
+Version (`agent_update_check`). Liegt auf dem RVS eine neuere APK in
+`rvs/updates/agent/`, lädt er sie im Hintergrund per HTTP
+(`/update/agent/latest.apk`, Token im Header) und zeigt
+**„ARIA Host-Agent x.y bereit — Tippen zum Installieren"** — zusätzlich einen
+Knopf in der App. Den Install-Dialog zeigt Android selbst; still installieren
+darf eine normale App nicht. Beim ersten Mal fragt Android, ob die App
+„unbekannte Apps installieren" darf.
+
+`release_agent.sh` kopiert die APK automatisch auf den RVS, wenn `RVS_UPDATE_HOST`
+gesetzt ist (wie bei `release.sh`). Manuell:
+`scp aria-android-agent.apk <rvs-host>:~/ARIA-AGENT/rvs/updates/agent/aria-host-agent-v<version>.apk`
+— die Version muss im Dateinamen stehen.

host-agent/android/app/build.gradle

@@ -0,0 +1,57 @@
+plugins {
+    id 'com.android.application'
+    id 'org.jetbrains.kotlin.android'
+}
+
+android {
+    namespace 'de.hackersoft.ariaagent'
+    compileSdk 34
+
+    defaultConfig {
+        applicationId 'de.hackersoft.ariaagent'
+        minSdk 26
+        targetSdk 33            // 33 vermeidet die Foreground-Service-Typ-Pflicht von 34
+        versionCode 108
+        versionName '0.0.1.8'
+    }
+
+    // Fester Signaturschlüssel: jeder Build signiert mit DEMSELBEN Key, damit
+    // Android neue APKs als Update derselben App akzeptiert (sonst "Konflikt mit
+    // bestehendem Paket"). Die Keystore-Datei liegt NUR lokal (gitignored, nicht
+    // im oeffentlichen Repo) — UNBEDINGT sichern, sonst brechen kuenftige Updates.
+    def ariaKeystore = rootProject.file('aria-agent.keystore')
+    signingConfigs {
+        aria {
+            if (ariaKeystore.exists()) {
+                storeFile ariaKeystore
+                storePassword 'ariaagent'
+                keyAlias 'aria'
+                keyPassword 'ariaagent'
+            }
+        }
+    }
+
+    buildTypes {
+        debug {
+            if (ariaKeystore.exists()) signingConfig signingConfigs.aria
+        }
+        release {
+            minifyEnabled false
+            if (ariaKeystore.exists()) signingConfig signingConfigs.aria
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+dependencies {
+    implementation 'androidx.core:core-ktx:1.12.0'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'com.squareup.okhttp3:okhttp:4.12.0'     // RVS-WebSocket
+    implementation 'com.journeyapps:zxing-android-embedded:4.3.0'  // QR-Scan (FOSS, kein Google-Dienst)
+}

host-agent/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+    <!-- Auto-Update: neue Agent-APK vom RVS installieren (Android fragt trotzdem nach) -->
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+    <!-- app_launch: Start-Intents/App-Labels sind ab Android 11 sonst unsichtbar. -->
+    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />
+    <!-- Overlay: ARIA blendet Text/Bild UEBER das laufende Programm ein (Fire TV).
+         Muss vom Nutzer einmalig erlaubt werden (Spezialberechtigung). -->
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+    <!-- Sprache: Mikrofon (Fire-TV-Fernbedienung / USB-Mikro) fuer ARIA. -->
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-feature android:name="android.hardware.microphone" android:required="false" />
+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+    <!-- Fire TV / Android TV: dieselbe APK laeuft auf Stick UND Handy.
+         touchscreen/faketouch NICHT erforderlich (Fire TV hat keinen), und
+         leanback ebenfalls optional (sonst laeuft sie nicht mehr aufs Handy). -->
+    <uses-feature android:name="android.hardware.touchscreen" android:required="false" />
+    <uses-feature android:name="android.hardware.faketouch" android:required="false" />
+    <uses-feature android:name="android.software.leanback" android:required="false" />
+
+    <application
+        android:allowBackup="false"
+        android:icon="@drawable/ic_launcher"
+        android:banner="@drawable/banner_tv"
+        android:label="@string/app_name"
+        android:usesCleartextTraffic="true"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.AppCompat.DayNight">
+
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:launchMode="singleTop"
+            android:label="@string/app_name">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+                <!-- Ohne LEANBACK_LAUNCHER taucht die App im Fire-TV-Menue NICHT
+                     auf (sie waere installiert, aber nicht startbar). -->
+                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
+            </intent-filter>
+        </activity>
+
+        <!-- Unsichtbarer Helfer: schaltet die Bildschirm-Aufnahme nach einem
+             Neustart automatisch wieder scharf (die Sitzung ist nicht speicherbar,
+             nur die Berechtigung). Durchsichtig, ohne Animation -> man sieht nichts. -->
+        <activity
+            android:name=".CaptureActivity"
+            android:exported="false"
+            android:excludeFromRecents="true"
+            android:noHistory="true"
+            android:taskAffinity=""
+            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
+
+        <!-- Auto-Update: geladene APK an den Android-Installer uebergeben -->
+        <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=".AgentService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync|mediaProjection" />
+
+        <receiver
+            android:name=".BootReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+
+        <service
+            android:name=".AriaAccessibilityService"
+            android:exported="false"
+            android:label="ARIA Host-Agent"
+            android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
+            <intent-filter>
+                <action android:name="android.accessibilityservice.AccessibilityService" />
+            </intent-filter>
+            <meta-data
+                android:name="android.accessibilityservice"
+                android:resource="@xml/accessibility_config" />
+        </service>
+    </application>
+</manifest>

host-agent/android/app/src/main/java/de/hackersoft/ariaagent/AgentConfig.kt

@@ -0,0 +1,64 @@
+package de.hackersoft.ariaagent
+
+import android.content.Context
+import android.os.Build
+
+/** Verbindungs-/Agent-Einstellungen (in SharedPreferences persistiert). */
+data class AgentConfig(
+    var host: String = "",
+    var port: Int = 443,
+    var tls: Boolean = true,
+    var token: String = "",
+    var name: String = "",
+    var controlEnabled: Boolean = false,
+    /** Wie antwortet ARIA auf diesem Geraet standardmaessig: "overlay" oder "speech".
+     *  Pro Anfrage ueberschreibbar ("...bitte als Sprache"). */
+    var replyMode: String = "overlay",
+    /** Soll die Bildschirm-Aufnahme nach einem Neustart automatisch wieder scharf
+     *  geschaltet werden? Wird gesetzt, sobald sie einmal erlaubt wurde — die
+     *  SITZUNG ist naemlich nicht speicherbar, nur die Berechtigung. */
+    var captureEnabled: Boolean = false,
+) {
+    companion object {
+        private const val PREFS = "aria_agent"
+
+        fun load(ctx: Context): AgentConfig {
+            val p = ctx.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+            return AgentConfig(
+                host = p.getString("host", "") ?: "",
+                port = p.getInt("port", 443),
+                tls = p.getBoolean("tls", true),
+                token = p.getString("token", "") ?: "",
+                name = p.getString("name", "") ?: "",
+                controlEnabled = p.getBoolean("control", false),
+                replyMode = p.getString("replyMode", "overlay") ?: "overlay",
+                captureEnabled = p.getBoolean("capture", false),
+            )
+        }
+    }
+
+    fun save(ctx: Context) {
+        ctx.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().apply {
+            putString("host", host)
+            putInt("port", port)
+            putBoolean("tls", tls)
+            putString("token", token)
+            putString("name", name)
+            putBoolean("control", controlEnabled)
+            putString("replyMode", replyMode)
+            putBoolean("capture", captureEnabled)
+            apply()
+        }
+    }
+
+    fun isValid(): Boolean = host.isNotBlank() && token.isNotBlank()
+
+    fun displayName(): String = if (name.isNotBlank()) name else Build.MODEL
+
+    /** Stabile, technische Host-ID (a-z0-9_-), wie beim Desktop-Agent. */
+    fun hostId(): String {
+        val base = displayName().lowercase()
+            .replace(Regex("[^a-z0-9_-]+"), "-").trim('-')
+        return base.ifBlank { "android" }
+    }
+}

host-agent/android/app/src/main/java/de/hackersoft/ariaagent/AgentService.kt

@@ -0,0 +1,191 @@
+package de.hackersoft.ariaagent
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+
+/**
+ * Foreground-Service (Weg A): haelt die RVS-Verbindung dauerhaft, damit ARIA
+ * den Agenten jederzeit erreicht. Persistente Notification + Auto-Reconnect.
+ */
+class AgentService : Service() {
+
+    private var rvs: RvsClient? = null
+
+    companion object {
+        private const val CH = "aria_agent"
+        private const val NOTIF_ID = 1
+        const val ACTION_STATUS = "de.hackersoft.ariaagent.STATUS"
+        const val ACTION_PROJECTION = "de.hackersoft.ariaagent.PROJECTION"
+        const val ACTION_TALK = "de.hackersoft.ariaagent.TALK"
+        const val EXTRA_RESULT_CODE = "resultCode"
+        const val EXTRA_RESULT_DATA = "resultData"
+
+        @Volatile var status: String = "gestoppt"
+        @Volatile var connected: Boolean = false
+
+        /** App-Oberflaeche auffrischen (z.B. "Update bereit"-Knopf) */
+        fun broadcastStatus(ctx: Context) {
+            ctx.sendBroadcast(Intent(ACTION_STATUS).setPackage(ctx.packageName))
+        }
+
+        fun start(ctx: Context) {
+            val i = Intent(ctx, AgentService::class.java)
+            if (Build.VERSION.SDK_INT >= 26) ctx.startForegroundService(i) else ctx.startService(i)
+        }
+
+        fun stop(ctx: Context) {
+            ctx.stopService(Intent(ctx, AgentService::class.java))
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        createChannel()
+        startForegroundDataSync("startet …")
+    }
+
+    /** Normaler Vordergrund-Start (Typ dataSync). mediaProjection wird NUR beim
+     *  Projizieren gesetzt — auf Android 14 darf man diesen Typ sonst nicht ohne
+     *  Projection-Token verwenden. */
+    private fun startForegroundDataSync(text: String) {
+        if (Build.VERSION.SDK_INT >= 29) {
+            startForeground(NOTIF_ID, buildNotification(text),
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+        } else {
+            startForeground(NOTIF_ID, buildNotification(text))
+        }
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        // WICHTIG: Jeder startForegroundService()-Aufruf MUSS binnen ~5s mit
+        // startForeground() beantwortet werden — sonst crasht Android den Prozess
+        // (ForegroundServiceDidNotStartInTimeException). Der Projection-Intent kommt
+        // per startForegroundService, obwohl der Dienst schon laeuft -> hier IMMER
+        // zuerst startForeground aufrufen (idempotent).
+        startForegroundDataSync(status)
+
+        if (intent?.action == ACTION_TALK) {
+            // Sprech-Taste: laeuft gerade eine Aufnahme -> beenden, sonst starten.
+            val v = rvs?.voice
+            if (v == null) startRvs()
+            else if (v.isRecording) v.stopListening("user") else v.startListening()
+            return START_STICKY
+        }
+        if (intent?.action == ACTION_PROJECTION) {
+            val code = intent.getIntExtra(EXTRA_RESULT_CODE, 0)
+            @Suppress("DEPRECATION")
+            val data = intent.getParcelableExtra<Intent>(EXTRA_RESULT_DATA)
+            if (code != 0 && data != null) {
+                try {
+                    // Android verlangt beim Projizieren einen Vordergrund-Dienst vom
+                    // Typ mediaProjection — VOR getMediaProjection() setzen, sonst
+                    // SecurityException (FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION).
+                    if (Build.VERSION.SDK_INT >= 29) {
+                        startForeground(
+                            NOTIF_ID, buildNotification("Bildschirm-Zugriff aktiv"),
+                            ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION or
+                                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+                        )
+                    }
+                    ScreenCapturer.start(applicationContext, code, data)
+                    if (ScreenCapturer.active) {
+                        // Merken: nach einem Neustart automatisch wieder scharf
+                        // schalten (die Sitzung selbst ist nicht speicherbar).
+                        AgentConfig.load(this).takeIf { !it.captureEnabled }?.let {
+                            it.captureEnabled = true; it.save(this)
+                        }
+                        updateNotification("$status · Bildschirm-Zugriff aktiv")
+                    } else {
+                        updateNotification("Bildschirm-Fehler: ${ScreenCapturer.lastError}")
+                    }
+                } catch (e: Throwable) {
+                    ScreenCapturer.lastError = "${e.javaClass.simpleName}: ${e.message}"
+                    updateNotification("Bildschirm-Fehler: ${ScreenCapturer.lastError}")
+                }
+            }
+            if (rvs == null) startRvs()   // Dienst war frisch -> Verbindung nachziehen
+            return START_STICKY
+        }
+        return startRvs()
+    }
+
+    /** (Re-)Startet die RVS-Verbindung anhand der gespeicherten Config. */
+    private fun startRvs(): Int {
+        val cfg = AgentConfig.load(this)
+        if (!cfg.isValid()) {
+            stopSelf()
+            return START_NOT_STICKY
+        }
+        rvs?.stop()
+        rvs = RvsClient(applicationContext, cfg) { conn, msg ->
+            connected = conn
+            status = msg
+            updateNotification(msg)
+            sendBroadcast(Intent(ACTION_STATUS).setPackage(packageName))
+        }
+        rvs?.start()
+
+        // Bildschirm-Aufnahme nach Geraete-/App-Neustart automatisch wieder scharf
+        // schalten. Die Berechtigung (AppOp PROJECT_MEDIA) bleibt erhalten, die
+        // SITZUNG nicht — ohne das muesste man am Fernseher jedes Mal von Hand
+        // "Bildschirm-Zugriff erlauben" druecken. Ist der AppOp gesetzt, laeuft
+        // die Anfrage ohne Dialog durch; sonst fragt Android einmal nach.
+        if (cfg.captureEnabled && !ScreenCapturer.active) {
+            android.os.Handler(mainLooper).postDelayed({
+                if (!ScreenCapturer.active) {
+                    try { CaptureActivity.request(applicationContext) } catch (_: Throwable) {}
+                }
+            }, 2500)
+        }
+        return START_STICKY
+    }
+
+    override fun onDestroy() {
+        try { rvs?.voice?.shutdown() } catch (_: Exception) {}
+        rvs?.stop()
+        ScreenCapturer.stop()
+        connected = false
+        status = "gestoppt"
+        sendBroadcast(Intent(ACTION_STATUS).setPackage(packageName))
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    private fun createChannel() {
+        if (Build.VERSION.SDK_INT >= 26) {
+            val ch = NotificationChannel(CH, "ARIA Agent", NotificationManager.IMPORTANCE_LOW)
+            ch.setShowBadge(false)
+            (getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
+                .createNotificationChannel(ch)
+        }
+    }
+
+    private fun buildNotification(text: String): Notification {
+        val pi = PendingIntent.getActivity(
+            this, 0, Intent(this, MainActivity::class.java),
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+        )
+        return NotificationCompat.Builder(this, CH)
+            .setContentTitle("ARIA Host-Agent")
+            .setContentText(text)
+            .setSmallIcon(R.drawable.ic_launcher)
+            .setOngoing(true)
+            .setContentIntent(pi)
+            .build()
+    }
+
+    private fun updateNotification(text: String) {
+        (getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
+            .notify(NOTIF_ID, buildNotification(text))
+    }
+}