release(agent): bump to 0.0.1.5

feat(android-agent): Einblendung geht weg, wenn Stefan etwas tut — statt nach fester Zeit
Eine feste Anzeigedauer ist immer geraten: mal zu kurz zum Lesen, mal steht sie laengst im Weg. `seconds=0` liess die Einblendung bisher einfach stehen. Jetzt heisst seconds=0: bleibt, bis der Nutzer etwas tut. - Fernbedienung: der Accessibility-Dienst bekommt onKeyEvent und raeumt die Einblendung weg. Er gibt die Taste mit `return false` WEITER an den Film — es geht also kein Tastendruck verloren und der Player bleibt bedienbar. Dafuer brauchte der Dienst canRequestFilterKeyEvents + flagRequestFilterKeyEvents. - Touch: FLAG_WATCH_OUTSIDE_TOUCH meldet eine Beruehrung ausserhalb. Die geht dank FLAG_NOT_TOUCHABLE gleichzeitig an die App darunter durch. - 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. Genau das soll sie nicht. host_notify beschreibt seconds=0 jetzt als den richtigen Wert fuer alles zum Lesen (Wetter, Listen, Zahlen) und die feste Dauer fuer kurze Hinweise. APK baut durch. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-10-03 12:40:58 +02:00 · 2026-10-03 12:29:14 +02:00 · 2026-10-03 11:38:04 +02:00 · 2026-10-03 11:27:12 +02:00 · 2026-10-03 11:21:47 +02:00 · 2026-10-03 11:16:41 +02:00
82 changed files with 9234 additions and 327 deletions
@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(ssh root@10.0.0.1 \"ls -la /root/ARIA-AGENT/aria-shared/logs/\")"
-    ]
-  }
-}
@@ -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/",
@@ -97,6 +97,7 @@ ARIA hat zwei Rollen:
 | 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) |

 > Compute-Nodes sind optional: ohne sie faellt STT auf lokales Whisper (CPU,
@@ -482,11 +483,18 @@ 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
@@ -514,6 +522,9 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 - **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)
 - **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
@@ -819,6 +830,24 @@ Jeder Dienst haengt an einem Compose-Profil. Ein Node startet ueber
 | `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)

@@ -970,7 +999,24 @@ cp .env.example .env      # RVS-Zugang + CONTROL_ENABLED=true eintragen
 chmod +x aria-host-agent && ./aria-host-agent
 ```

-Oder als Dienst: `host-agent/aria-host-agent.service` (systemd).
+**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

@@ -987,6 +1033,92 @@ keine offenen Ports; alle Kommandos werden geloggt. Gibt **vollen** Rechnerzugri

 > 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`) |
+
+> 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 0.0.1.4
+```
+
+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
@@ -1056,14 +1188,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.

 ---

@@ -1173,6 +1319,47 @@ 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"
+
+#### 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)
@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 20409
-        versionName "0.2.4.9"
+        versionCode 20505
+        versionName "0.2.5.5"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -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
@@ -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) {
+    }
+  }
 }
@@ -25,6 +25,7 @@ class MainApplication : Application(), ReactApplication {
              add(OpenWakeWordPackage())
              add(PhoneCallPackage())
              add(BackgroundAudioPackage())
+              add(ShareIntentPackage())
            }

        override fun getJSMainModuleName(): String = "index"
@@ -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) {}
+}
@@ -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()
+    }
+}
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.2.4.9",
+  "version": "0.2.5.5",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -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;
@@ -49,6 +49,8 @@ import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
 import CameraUpload, { PhotoData } from '../components/CameraUpload';
+import ShareModal, { SharedItem } from '../components/ShareModal';
+import shareIntent from '../services/shareIntent';
 import MessageText from '../components/MessageText';
 import { loadTtsSpeed, TTS_SPEED_DEFAULT, loadSttEndpointMs, loadMaxRecordingMs, loadBargeInEnabled } from '../services/audio';
 import Geolocation from '@react-native-community/geolocation';
@@ -185,7 +187,10 @@ function stripSystemHints(text: string): string {
    if (!m) break;
    out = out.slice(m[0].length);
  }
-  return out;
+  // Bestand die Nachricht NUR aus Klammer-Bloecken (z.B. "[Tool-Loop-Limit ...]"
+  // oder "[Fehler: ...]"), waere sie jetzt leer → dann das ORIGINAL zeigen. Sonst
+  // haette der User eine leere Bubble. Fehler-/Meta-Meldungen sollen sichtbar sein.
+  return out.trim() ? out : text;
 }
 /** Sekunden → "M:SS" fuer die Sprachnachricht-Dauer. */
 function formatDur(sec: number): string {
@@ -195,6 +200,35 @@ function formatDur(sec: number): string {
  return `${m}:${r.toString().padStart(2, '0')}`;
 }

+// ─── Grenzen fuer den Anhang-Re-Download ────────────────────────────
+//
+// Ein Re-Download kommt als base64 in EINER WebSocket-Nachricht. Die muss die
+// App komplett im Speicher puffern und dann durch JSON.parse schicken — bei
+// einem 150-MB-Video sind das ~200 MB base64, und das Handy stirbt daran mit
+// einem nativen OOM (kein JS-Fehler, darum tauchte nie ein Stacktrace auf).
+//
+// Genau das war die Absturzschleife: App startet → Auto-Re-Download fordert
+// ungefragt das 150-MB-Video an → OOM → Android startet den Vordergrund-
+// Dienst neu → App startet → von vorn. Alle ~70s, stundenlang.
+//
+// Darum zwei Grenzen:
+//   AUTO  — was die App OHNE Nachfrage holt. Klein halten; Bilder und
+//           Dokumente passen rein, Videos nicht.
+//   TAP   — was sie auf ausdruecklichen Tipp holt. Hoeher, aber immer noch
+//           weit unter der Schmerzgrenze. Drueber gibt's eine ehrliche
+//           Meldung statt eines Absturzes.
+/** Signatur von sendPendingAttachments — fuer den Ref weiter unten. */
+type SendAttachmentsFn = (
+  messageText: string,
+  explicitAttachments?: { file: any; isPhoto: boolean }[],
+  voiceMode?: { audioRequestId: string; clientMsgId: string },
+) => Promise<void>;
+
+const AUTO_DL_MAX_BYTES = 25 * 1024 * 1024;
+const TAP_DL_MAX_BYTES = 64 * 1024 * 1024;
+
+const fmtMB = (n: number) => `${(n / 1024 / 1024).toFixed(0)} MB`;
+
 const DEFAULT_ATTACHMENT_DIR = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
 const STORAGE_PATH_KEY = 'aria_attachment_storage_path';

@@ -345,6 +379,10 @@ const ChatScreen: React.FC = () => {
  } | null>(null);
  const [searchIndex, setSearchIndex] = useState(0);  // welcher Treffer aktiv ist
  const [pendingAttachments, setPendingAttachments] = useState<{file: any, isPhoto: boolean}[]>([]);
+  // Teilen-Ziel: Inhalte, die aus anderen Apps hereingereicht wurden.
+  const [shareItems, setShareItems] = useState<SharedItem[]>([]);
+  const [shareText, setShareText] = useState('');
+  const [shareVisible, setShareVisible] = useState(false);
  const [agentActivity, setAgentActivity] = useState<{activity: string, tool: string}>({activity: 'idle', tool: ''});
  // Multi-Threading: Activity pro Kontext (key = projectId, '' = Hauptchat).
  // Der Indikator zeigt nur den fokussierten Kontext — nicht global.
@@ -360,6 +398,16 @@ const ChatScreen: React.FC = () => {
  // Service-Status (AI-Box: F5-TTS / Whisper Lade-Status) + Banner-Sichtbarkeit
  const [serviceStatus, setServiceStatus] = useState<Record<string, {state: string, model?: string, loadSeconds?: number, error?: string, downloading?: boolean, freshlyDownloaded?: boolean}>>({});
  const [serviceBannerDismissed, setServiceBannerDismissed] = useState(false);
+  // Zwischenruf per Sprache: der 📣-Knopf ohne Text "spannt" die naechste
+  // Aufnahme als Zwischenruf. Mit Text schickt er sofort (wie bisher). Der Ref
+  // wird gelesen, wenn die Aufnahme startet — der State nur fuer die Optik.
+  const [interjectArmed, setInterjectArmed] = useState(false);
+  const interjectArmedRef = useRef(false);
+  // sendPendingAttachments ueber einen Ref: handleVoiceButtonStart steht weiter
+  // oben in der Datei und wuerde die Funktion sonst in ihrer Temporal Dead Zone
+  // greifen (TS2448 — siehe Kommentar an sendTextMessage). Umsortieren waere
+  // riskanter als dieser Ref, weil an der Reihenfolge mehrere Callbacks haengen.
+  const sendPendingAttachmentsRef = useRef<SendAttachmentsFn | null>(null);
  // Gerätelokale TTS-Config: globaler Toggle (aus Settings) + temporäres Muten (Mund-Button)
  const [ttsDeviceEnabled, setTtsDeviceEnabled] = useState(true);
  const [ttsMuted, setTtsMuted] = useState(false);
@@ -416,6 +464,33 @@ const ChatScreen: React.FC = () => {
  // Intent geoeffnet (PDF-Viewer, Galerie, etc.).
  const autoOpenPaths = useRef<Set<string>>(new Set());

+  /**
+   * Re-Download anfordern — mit Groessen-Bremse.
+   * Gibt false zurueck (und sagt warum), wenn die Datei zu gross fuer einen
+   * Transfer durch die WebSocket ist. Ohne das holt sich die App ein 150-MB-
+   * Video als ~200 MB base64 und stirbt am nativen OOM (siehe TAP_DL_MAX_BYTES).
+   */
+  const requestAttachment = useCallback((att: Attachment, reqId: string): boolean => {
+    if (!att.serverPath) {
+      if (Platform.OS === 'android') {
+        ToastAndroid.show('Datei kann nicht nachgeladen werden (kein serverPath)', ToastAndroid.LONG);
+      }
+      return false;
+    }
+    if (typeof att.size === 'number' && att.size > TAP_DL_MAX_BYTES) {
+      if (Platform.OS === 'android') {
+        ToastAndroid.show(
+          `${att.name}: ${fmtMB(att.size)} — zu gross fuers Handy. `
+          + `Liegt auf dem Server unter ${att.serverPath}`,
+          ToastAndroid.LONG,
+        );
+      }
+      return false;
+    }
+    rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: reqId });
+    return true;
+  }, []);
+
  // Eindeutige Message-ID generieren
  const nextId = (): string => {
    messageIdCounter.current += 1;
@@ -851,13 +926,26 @@ const ChatScreen: React.FC = () => {
      setTimeout(() => {
        setMessages(prev => {
          const missing: {id: string, serverPath: string}[] = [];
+          const skipped: string[] = [];
          for (const msg of prev) {
            for (const att of msg.attachments || []) {
-              if (att.serverPath && !att.uri) {
-                missing.push({ id: msg.id, serverPath: att.serverPath });
+              if (!att.serverPath || att.uri) continue;
+              // Grosse Dateien NICHT ungefragt holen (siehe AUTO_DL_MAX_BYTES).
+              // Sie bleiben als "tippen zum Laden" stehen — der User
+              // entscheidet, ob er sie wirklich aufs Handy zieht.
+              if (typeof att.size === 'number' && att.size > AUTO_DL_MAX_BYTES) {
+                skipped.push(`${att.name} (${fmtMB(att.size)})`);
+                continue;
              }
+              missing.push({ id: msg.id, serverPath: att.serverPath });
            }
          }
+          if (skipped.length > 0) {
+            console.log('[Chat] Auto-Download uebersprungen (zu gross): %s', skipped.join(', '));
+            import('../services/logger')
+              .then(m => m.reportAppDebug('chat.autodl', `uebersprungen: ${skipped.join(', ')}`))
+              .catch(() => {});
+          }
          if (missing.length > 0) {
            console.log(`[Chat] ${missing.length} fehlende Anhaenge — lade nach...`);
            for (const m of missing) {
@@ -1253,7 +1341,11 @@ const ChatScreen: React.FC = () => {
            return;
          }
          setMessages(prev => {
-            const newText = `\uD83C\uDFA4 ${sttText}`;
+            // Zwischenruf per Sprache bekommt das Megafon statt des Mikros \u2014
+            // sonst sieht die Bubble wie eine normale Frage aus, obwohl sie in
+            // den laufenden Turn gegangen ist und keine eigene Antwort bekommt.
+            const isInterject = !!(message.payload as any).interject;
+            const newText = isInterject ? `\uD83D\uDCE3 Zwischenruf: ${sttText}` : `\uD83C\uDFA4 ${sttText}`;
            // Primaer: matche per audioRequestId (eindeutig pro Aufnahme).
            // So gibt's keine Verwechslung wenn zwei Audios kurz hintereinander
            // gesendet wurden und ihre STT-Results ueberlappen.
@@ -1268,7 +1360,9 @@ const ChatScreen: React.FC = () => {
            // Fallback: alte Bridge-Version ohne audioRequestId \u2014 match per Substring,
            // nimmt die ERSTE noch unaufgeloeste Placeholder.
            const idx = prev.findIndex(m =>
-              m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
+              m.sender === 'user'
+              && (m.text.includes('Spracheingabe wird verarbeitet')
+                  || m.text.includes('Zwischenruf wird verarbeitet'))
            );
            if (idx >= 0) {
              const next = prev.slice();
@@ -1300,6 +1394,10 @@ const ChatScreen: React.FC = () => {
              sender: 'user',
              text: diagText,
              timestamp: message.timestamp,
+              // projectId MUSS mit: die Chat-Ansicht filtert danach. Ohne das
+              // landete die Nachricht im Hauptchat-Topf und war in jedem Projekt
+              // unsichtbar — man sah nur ARIAs Antwort, nicht die eigene Frage.
+              projectId: (message.payload.projectId as string) || '',
            }]));
          }
          return;
@@ -1799,9 +1897,20 @@ const ChatScreen: React.FC = () => {
        // dem STT-Text gefuellte Bubble NICHT loeschen, sonst verschwindet die
        // Sprachnachricht obwohl ARIA schon an der Antwort arbeitet.
        if (ev.audioRequestId) {
-          setMessages(prev => prev.filter(m =>
-            !(m.audioRequestId === ev.audioRequestId
-              && m.text.includes('Spracheingabe wird verarbeitet'))));
+          // 'no-response' heisst: die Spracherkennung hat GAR NICHT geantwortet
+          // (Worker neu gestartet / nicht erreichbar) — die Aufnahme ist also
+          // wirklich verloren gegangen, Du hast nicht etwa nichts gesagt. Das
+          // zeigen wir an, statt die Bubble stillschweigend zu entfernen; sonst
+          // wirkt es, als waere die Nachricht nie gesendet worden.
+          const lost = String(ev.reason || '').includes('no-response');
+          setMessages(prev => lost
+            ? prev.map(m => (m.audioRequestId === ev.audioRequestId
+                && m.text.includes('Spracheingabe wird verarbeitet'))
+                ? { ...m, text: '⚠️ Aufnahme ging verloren — die Spracherkennung war gerade nicht erreichbar. Bitte nochmal aufnehmen.' }
+                : m)
+            : prev.filter(m =>
+                !(m.audioRequestId === ev.audioRequestId
+                  && m.text.includes('Spracheingabe wird verarbeitet'))));
        }
        // Passiv-Lauschen: leeres Endpoint (no-speech / Silero-Musik / speaker_
        // mismatch). NICHT sofort beenden — solange die Stille-Toleranz ab
@@ -2327,11 +2436,18 @@ const ChatScreen: React.FC = () => {
  // produziert das Brain weiter TTS, die ins offene Mikro laeuft → genau der
  // "Mischmasch" (ARIA antwortet weiter waehrend ich rede). Fuer bewusstes
  // Nicht-Abbrechen gibt es weiterhin den separaten Zwischenruf-Button (📣).
-  const interruptAriaIfBusy = useCallback(() => {
+  // forInterject: bei einem Zwischenruf darf der laufende Turn NICHT abgebrochen
+  // werden — das ist der ganze Sinn. Die Wiedergabe stoppen wir trotzdem, sonst
+  // redet ARIA in das offene Mikro hinein.
+  const interruptAriaIfBusy = useCallback((forInterject = false) => {
    if (audioService.isPlayingAudio()) {
-      audioService.haltAllPlayback('user startet Aufnahme — Interrupt');
-      rvs.send('cancel_request' as any, { hard: true, source: 'voice-interrupt' });
-      return true;
+      audioService.haltAllPlayback(forInterject
+        ? 'user ruft dazwischen — nur Wiedergabe stoppen'
+        : 'user startet Aufnahme — Interrupt');
+      if (!forInterject) {
+        rvs.send('cancel_request' as any, { hard: true, source: 'voice-interrupt' });
+      }
+      return !forInterject;
    }
    return false;
  }, []);
@@ -2344,18 +2460,35 @@ const ChatScreen: React.FC = () => {
  const handleVoiceButtonStart = useCallback(async (): Promise<boolean> => {
    const audioRequestId = `audio_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
    rememberMyRequest(audioRequestId);
-    const wasInterrupted = interruptAriaIfBusy();
+    const asInterject = interjectArmedRef.current;
+    const wasInterrupted = interruptAriaIfBusy(asInterject);
    const location = await getCurrentLocation();

-    const userMsg: ChatMessage = {
-      id: nextId(),
-      sender: 'user',
-      text: '🎙 Spracheingabe wird verarbeitet...',
-      timestamp: Date.now(),
-      attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
-      audioRequestId,
-    };
-    setMessages(prev => capMessages([...prev, userMsg]));
+    // Warten Anhaenge? Dann sind sie das Thema dieser Aufnahme: sofort hochladen
+    // (laeuft parallel zum Reden) und der Bridge per clientMsgId sagen, dass der
+    // Satz dazu noch kommt. Die Bubble mit den Bildern macht
+    // sendPendingAttachments — sie traegt die audioRequestId und bekommt den
+    // gesprochenen Text spaeter eingesetzt. Also hier KEINE zweite Bubble.
+    let attachmentCmid = '';
+    if (pendingAttachments.length > 0 && !asInterject && sendPendingAttachmentsRef.current) {
+      attachmentCmid = nextClientMsgId();
+      const forVoice = pendingAttachments;
+      setPendingAttachments([]);
+      await sendPendingAttachmentsRef.current('', forVoice, {
+        audioRequestId, clientMsgId: attachmentCmid,
+      });
+    } else {
+      const userMsg: ChatMessage = {
+        id: nextId(),
+        sender: 'user',
+        text: asInterject ? '📣 Zwischenruf wird verarbeitet...'
+                          : '🎙 Spracheingabe wird verarbeitet...',
+        timestamp: Date.now(),
+        attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
+        audioRequestId,
+      };
+      setMessages(prev => capMessages([...prev, userMsg]));
+    }

    const { ok } = await audioService.startStreamingRecording({
      audioRequestId,
@@ -2370,15 +2503,37 @@ const ChatScreen: React.FC = () => {
      endpointMs: await loadSttEndpointMs(),
      hardCapMs: await loadMaxRecordingMs(),
      projectId: focusedProjectIdRef.current,
+      ...(attachmentCmid && { clientMsgId: attachmentCmid }),
+      ...(asInterject && { interject: true }),
    });
    if (!ok) {
+      if (attachmentCmid) {
+        // Die Anhaenge sind SCHON hochgeladen — die Bubble darf nicht weg,
+        // sonst verschwinden die Bilder aus der Ansicht, obwohl sie auf dem
+        // Server liegen. Stattdessen ehrlich kennzeichnen; der Nutzer kann den
+        // Auftrag einfach tippen.
+        setMessages(prev => prev.map(m => m.audioRequestId === audioRequestId
+          ? { ...m, text: '📎 Anhang gesendet — Mikro war belegt, bitte tippen',
+              audioRequestId: undefined }
+          : m));
+        if (Platform.OS === 'android') {
+          ToastAndroid.show('Mikro nicht verfügbar — Anhang ist aber da', ToastAndroid.LONG);
+        }
+        return false;
+      }
      // Mikro nicht verfuegbar (Anruf? OpenWakeWord blockiert?) — Bubble weg.
      setMessages(prev => prev.filter(m => m.audioRequestId !== audioRequestId));
      return false;
    }
+    // Zwischenruf-Scharfschaltung gilt genau fuer EINE Aufnahme.
+    if (asInterject) {
+      interjectArmedRef.current = false;
+      setInterjectArmed(false);
+    }
    scheduleStaleAudioCleanup(audioRequestId, 60000);
    return true;
-  }, [getCurrentLocation, interruptAriaIfBusy, scheduleStaleAudioCleanup]);
+  }, [getCurrentLocation, interruptAriaIfBusy, scheduleStaleAudioCleanup,
+      pendingAttachments]);

  // ARIA schliesst die Aufnahme SELBST — das programmatische Gegenstueck zum
  // Stop-Button. Aufgerufen nach einem stillen Steuerbefehl (speak=false): der
@@ -2453,16 +2608,52 @@ const ChatScreen: React.FC = () => {
    setPendingAttachments(prev => [...prev, { file: photo, isPhoto: true }]);
  }, []);

+  // ── Teilen-Ziel ────────────────────────────────────────────────
+  // Beim Start pruefen (App war zu) und auf spaetere Shares lauschen
+  // (App laeuft schon → onNewIntent im MainActivity).
+  useEffect(() => {
+    let alive = true;
+    const open = (p: { text: string; items: SharedItem[] }) => {
+      if (!alive) return;
+      if (!p.items.length && !p.text) return;   // nichts dabei
+      setShareItems(p.items);
+      setShareText(p.text);
+      setShareVisible(true);
+    };
+    shareIntent.getShared().then(open).catch(() => {});
+    const unsub = shareIntent.onShare(open);
+    // Zweitweg: Teilen holt die App in den Vordergrund. Beim Wechsel nach
+    // 'active' nochmal nachfragen — das greift auch, wenn das native Event
+    // (je nach RN-Architektur) nicht durchkommt. getSharedData() markiert den
+    // Intent als verbraucht, es kann also nicht doppelt aufpoppen.
+    const appSub = AppState.addEventListener('change', st => {
+      if (st === 'active') shareIntent.getShared().then(open).catch(() => {});
+    });
+    return () => { alive = false; unsub(); try { appSub.remove(); } catch (_) {} };
+  }, []);
+
+
  // Alle Pending Anhaenge + Text senden
-  const sendPendingAttachments = useCallback(async (messageText: string) => {
-    if (pendingAttachments.length === 0) return;
-    console.log('[Chat] sendPendingAttachments: %d Anhang/Anhaenge', pendingAttachments.length);
+  const sendPendingAttachments = useCallback(async (
+    messageText: string,
+    // Explizite Liste (Teilen-Weg): der State waere beim direkten Aufruf noch
+    // nicht aktualisiert. Ohne Angabe wie bisher die Pending-Liste.
+    explicitAttachments?: { file: any; isPhoto: boolean }[],
+    // Sprach-Modus: der Nutzer spricht die Beschreibung gerade erst ein. Dann
+    // gehen die Dateien SOFORT raus (der Upload laeuft parallel zum Reden),
+    // aber ohne Text — den liefert spaeter der stt_endpoint, und die Bridge
+    // merged beides ueber die clientMsgId zu einem Turn.
+    voiceMode?: { audioRequestId: string; clientMsgId: string },
+  ) => {
+    const atts = explicitAttachments ?? pendingAttachments;
+    if (atts.length === 0) return;
+    console.log('[Chat] sendPendingAttachments: %d Anhang/Anhaenge', atts.length);
    const location = await getCurrentLocation();
    const msgId = nextId();

    // Alle Attachments fuer die Chat-Nachricht sammeln
    const attachments: Attachment[] = [];
-    for (const { file, isPhoto } of pendingAttachments) {
+    for (const { file, isPhoto } of atts) {
      const isImage = isPhoto || (file.type && file.type.startsWith('image/'));
      const name = isPhoto ? file.fileName : file.name;
      const base64 = file.base64 || '';
@@ -2480,16 +2671,23 @@ const ChatScreen: React.FC = () => {

    // Chat-Nachricht mit allen Anhaengen. clientMsgId nur wenn Text dabei
    // ist — files selber haben (noch) kein ACK-Tracking auf der Bridge.
-    const cmid = messageText ? nextClientMsgId() : undefined;
+    // Im Sprach-Modus kommt sie von aussen: dieselbe ID muss am
+    // stt_stream_start haengen, damit die Bridge Anhang und Satz zusammenfuehrt.
+    const cmid = voiceMode ? voiceMode.clientMsgId : (messageText ? nextClientMsgId() : undefined);
    const activePid = focusedProjectIdRef.current;
    const userMsg: ChatMessage = {
      id: msgId,
      sender: 'user',
-      text: messageText || `${pendingAttachments.length} Anhang/Anhaenge`,
+      // Im Sprach-Modus bekommt DIESE Bubble gleich den gesprochenen Text —
+      // via audioRequestId-Match, genau wie eine normale Sprachnachricht. So
+      // stehen Bild und Satz zusammen in einer Bubble statt in zwei.
+      text: voiceMode ? '🎙 Spracheingabe wird verarbeitet...'
+                      : (messageText || `${atts.length} Anhang/Anhaenge`),
      timestamp: Date.now(),
      attachments,
      projectId: activePid,
-      ...(cmid && {
+      ...(voiceMode && { audioRequestId: voiceMode.audioRequestId }),
+      ...(cmid && !voiceMode && {
        clientMsgId: cmid,
        deliveryStatus: connectionStateRef.current === 'connected' ? 'sending' : 'queued',
        sendAttempts: 1,
@@ -2498,7 +2696,7 @@ const ChatScreen: React.FC = () => {
    setMessages(prev => capMessages([...prev, userMsg]));

    // Alle Dateien an RVS senden + auf Disk speichern
-    for (const { file, isPhoto } of pendingAttachments) {
+    for (const { file, isPhoto } of atts) {
      const name = isPhoto ? file.fileName : file.name;
      const base64 = file.base64 || '';
      const mimeType = file.type || '';
@@ -2527,6 +2725,9 @@ const ChatScreen: React.FC = () => {
        // die Datei genau DIESER Nachricht zuordnet — auch wenn Files (fire-
        // and-forget) und Text (ACK-getrackt, bei Queue verzoegert) desyncen.
        ...(cmid && { clientMsgId: cmid }),
+        // awaitVoice: die Bridge soll den Anhang NICHT nach 0.8s alleine ans
+        // Brain schicken, sondern auf die Sprachnachricht warten.
+        ...(voiceMode && { awaitVoice: true }),
        ...(isPhoto && file.width && { width: file.width, height: file.height }),
        ...(location && { location }),
      });
@@ -2534,8 +2735,8 @@ const ChatScreen: React.FC = () => {

    // Text als separate Nachricht (damit ARIA weiss was zu tun ist) — mit
    // dem clientMsgId der Bubble, damit Bridge+ACK die richtige Bubble
-    // adressieren.
-    if (messageText && cmid) {
+    // adressieren. Im Sprach-Modus gibt es hier noch keinen Text.
+    if (messageText && cmid && !voiceMode) {
      dispatchWithAck(cmid, 'chat', {
        text: messageText,
        voice: localXttsVoiceRef.current,
@@ -2548,11 +2749,41 @@ const ChatScreen: React.FC = () => {
    setPendingAttachments([]);
    setInputText('');
  }, [pendingAttachments, getCurrentLocation, dispatchWithAck]);
+  // Ref aktuell halten — handleVoiceButtonStart greift die Funktion von hier
+  // (steht weiter oben in der Datei, siehe sendPendingAttachmentsRef).
+  sendPendingAttachmentsRef.current = sendPendingAttachments;

  // Reine Text-Nachricht senden. Steht bewusst NACH interruptAriaIfBusy und
  // sendPendingAttachments — beide stehen in seinem deps-Array, und wenn es
  // davor deklariert waere, laendeten sie dort in der Temporal Dead Zone
  // (tsc TS2448/2454; lief nur zufaellig, weil Babel const→var hebt).
+  /** Geteiltes senden: Ziel setzen, Dateien anhaengen, abschicken. */
+  const handleShareSend = useCallback(async (projectId: string, text: string) => {
+    try {
+      // Chat-Focus aufs gewaehlte Ziel — die Nachricht landet dort, und Stefan
+      // steht nach dem Senden gleich im richtigen Kontext.
+      setFocusedProjectId(projectId);
+      focusedProjectIdRef.current = projectId;
+
+      const files = await shareIntent.toFileData(shareItems);
+      if (files.length) {
+        // Liste explizit uebergeben: der State waere hier noch leer.
+        await sendPendingAttachments(text, files.map(f => ({ file: f, isPhoto: false })));
+      } else if (text) {
+        // Reiner Text (z.B. geteilter Link): ins Eingabefeld, Stefan schickt ab.
+        setInputText(text);
+      }
+      shareIntent.clearShareCache();
+    } catch (e) {
+      console.warn('[Share] Senden fehlgeschlagen:', e);
+      Alert.alert('Teilen fehlgeschlagen', String((e as any)?.message || e));
+    } finally {
+      setShareVisible(false);
+      setShareItems([]);
+      setShareText('');
+    }
+  }, [shareItems, sendPendingAttachments]);
+
  const sendTextMessage = useCallback(async () => {
    const text = inputText.trim();

@@ -2787,16 +3018,15 @@ const ChatScreen: React.FC = () => {
            ) : att.type === 'image' && !att.uri ? (
              <TouchableOpacity
                style={styles.attachmentFile}
-                onPress={() => {
-                  if (att.serverPath) {
-                    rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: item.id });
-                  }
-                }}
+                onPress={() => { requestAttachment(att, item.id); }}
              >
                <Text style={styles.attachmentFileIcon}>{'\uD83D\uDDBC\uFE0F'}</Text>
                <Text style={styles.attachmentFileName} numberOfLines={1}>{att.name}</Text>
                <Text style={styles.attachmentFileSize}>
-                  {att.serverPath ? '(tippen zum Laden)' : '(nicht verfuegbar)'}
+                  {!att.serverPath ? '(nicht verfuegbar)'
+                    : typeof att.size === 'number' && att.size > AUTO_DL_MAX_BYTES
+                      ? `(${fmtMB(att.size)} — tippen zum Laden)`
+                      : '(tippen zum Laden)'}
                </Text>
              </TouchableOpacity>
            ) : att.type === 'audio' ? (
@@ -2833,11 +3063,9 @@ const ChatScreen: React.FC = () => {
                  }
                  // Re-Download via file_request \u2192 bei file_response wird die
                  // Datei gespeichert UND geoeffnet (autoOpenPaths-Tracking).
-                  if (att.serverPath) {
-                    autoOpenPaths.current.add(att.serverPath);
-                    rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: item.id });
-                  } else if (Platform.OS === 'android') {
-                    ToastAndroid.show('Datei kann nicht nachgeladen werden (kein serverPath)', ToastAndroid.LONG);
+                  if (att.serverPath) autoOpenPaths.current.add(att.serverPath);
+                  if (!requestAttachment(att, item.id) && att.serverPath) {
+                    autoOpenPaths.current.delete(att.serverPath);
                  }
                }}
              >
@@ -3388,7 +3616,9 @@ const ChatScreen: React.FC = () => {
          style={styles.textInput}
          value={inputText}
          onChangeText={setInputText}
-          placeholder={pendingAttachments.length > 0 ? "Text zu den Anhaengen (optional)..." : "Nachricht an ARIA..."}
+          placeholder={pendingAttachments.length > 0
+            ? "Text zu den Anhaengen — oder einsprechen 🎤"
+            : "Nachricht an ARIA..."}
          placeholderTextColor="#555570"
          multiline
          maxLength={4000}
@@ -3396,29 +3626,52 @@ const ChatScreen: React.FC = () => {
          returnKeyType="send"
        />

-        {/* Senden oder Sprache */}
+        {/* Rechte Knopfreihe.
+            Das Mikro ist jetzt IMMER da \u2014 auch mit Anhang oder getipptem Text.
+            Vorher war es ein Entweder-oder: sobald etwas im Feld stand oder ein
+            Bild dranhing, verschwand das Mikro. Damit ging weder "Bild anhaengen
+            und den Auftrag dazu sprechen" noch ein Zwischenruf per Sprache.
+            Der Senden-Pfeil und die Mund-/Ohr-Knoepfe weichen dafuer je nach
+            Lage, damit die Zeile nicht ueberlaeuft. */}
+
+        {/* Zwischenruf \u2014 sichtbar, wenn ARIA im aktiven Kontext arbeitet (oder
+            noch scharf geschaltet ist). Mit Text: sofort abschicken, wie bisher.
+            Ohne Text: die naechste Aufnahme geht als Zwischenruf in den
+            laufenden Turn, statt sich als neue Anfrage anzustellen. */}
+        {interjectArmed || (agentActivityByCtx[focusedProjectId]?.activity || 'idle') !== 'idle' ? (
+          <TouchableOpacity
+            style={[styles.interjectButton, interjectArmed && styles.interjectButtonArmed]}
+            onPress={() => {
+              if (inputText.trim()) { sendInterject(); return; }
+              const next = !interjectArmedRef.current;
+              interjectArmedRef.current = next;
+              setInterjectArmed(next);
+              if (Platform.OS === 'android') {
+                ToastAndroid.show(
+                  next ? 'N\u00E4chste Aufnahme geht als Zwischenruf raus'
+                       : 'Zwischenruf abgew\u00E4hlt',
+                  ToastAndroid.SHORT);
+              }
+            }}
+            accessibilityLabel={inputText.trim() ? 'Zwischenruf senden' : 'Zwischenruf per Sprache'}
+          >
+            <Text style={styles.interjectIcon}>{'\uD83D\uDCE3'}</Text>
+          </TouchableOpacity>
+        ) : null}
+
+        <VoiceButton
+          onTapStart={handleVoiceButtonStart}
+          onTapStop={handleVoiceButtonStop}
+          disabled={connectionState !== 'connected'}
+          wakeWordActive={wakeWordActive}
+        />
+
        {inputText.trim() || pendingAttachments.length > 0 ? (
-          <>
-            {/* Zwischenruf: nur wenn ARIA im aktiven Kontext gerade arbeitet und
-                Text da ist. Schiebt die Korrektur in den laufenden Turn statt
-                sie anzustellen. */}
-            {inputText.trim() && (agentActivityByCtx[focusedProjectId]?.activity || 'idle') !== 'idle' ? (
-              <TouchableOpacity style={styles.interjectButton} onPress={sendInterject} accessibilityLabel="Zwischenruf">
-                <Text style={styles.interjectIcon}>{'\uD83D\uDCE3'}</Text>
-              </TouchableOpacity>
-            ) : null}
-            <TouchableOpacity style={styles.sendButton} onPress={sendTextMessage}>
-              <Text style={styles.sendIcon}>{'\u2B06\uFE0F'}</Text>
-            </TouchableOpacity>
-          </>
+          <TouchableOpacity style={styles.sendButton} onPress={sendTextMessage}>
+            <Text style={styles.sendIcon}>{'\u2B06\uFE0F'}</Text>
+          </TouchableOpacity>
        ) : (
          <>
-            <VoiceButton
-              onTapStart={handleVoiceButtonStart}
-              onTapStop={handleVoiceButtonStop}
-              disabled={connectionState !== 'connected'}
-              wakeWordActive={wakeWordActive}
-            />
            {/* Mund-Button: TTS auf diesem Geraet muten/aufheben.
                Nur sichtbar wenn TTS in den Settings grundsaetzlich aktiv ist. */}
            {ttsDeviceEnabled && (
@@ -3690,6 +3943,13 @@ const ChatScreen: React.FC = () => {
      {/* Datei-Upload Modal */}
      <Modal visible={showFileUpload} transparent animationType="slide">
        <View style={styles.modalOverlay}>
+          <ShareModal
+            visible={shareVisible}
+            items={shareItems}
+            initialText={shareText}
+            onCancel={() => { setShareVisible(false); setShareItems([]); setShareText(''); }}
+            onSend={handleShareSend}
+          />
          <FileUpload
            onFileSelected={handleFileSelected}
            onCancel={() => setShowFileUpload(false)}
@@ -3937,6 +4197,13 @@ const styles = StyleSheet.create({
    justifyContent: 'center',
    marginRight: 6,
  },
+  // Scharf geschaltet: die naechste Aufnahme geht als Zwischenruf raus. Heller
+  // plus Rand, damit man das vor dem Sprechen sieht und nicht erst danach.
+  interjectButtonArmed: {
+    backgroundColor: '#FFB340',
+    borderWidth: 2,
+    borderColor: '#FFF',
+  },
  interjectIcon: {
    fontSize: 18,
  },
@@ -1141,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 };
@@ -1155,12 +1162,32 @@ 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 →
@@ -1202,20 +1229,17 @@ class AudioService {
        console.warn('[Audio] PcmStreamChunk-Subscription fehlgeschlagen:', err);
      }

-      const started = await PcmStreamRecorder.start();
-      if (!started) {
-        throw new Error('PcmStreamRecorder.start returned false');
+      // 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' };
      }

-      // AudioFocus exklusiv — gleiche Semantik wie beim Legacy-Pfad.
-      // Vorher merken ob Musik lief (fuer Resume am Dialog-Ende).
-      await this._captureMediaActive();
-      this._cancelDeferredFocusRelease();
-      AudioFocus?.requestExclusive().catch(() => {});
-
-      this.setState('recording');
-
-      // stt_stream_start — der Whisper-Bridge mitteilen dass jetzt Chunks kommen.
+      // 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 || '',
@@ -1228,20 +1252,44 @@ class AudioService {
        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');
+      }
+
+      // AudioFocus exklusiv — gleiche Semantik wie beim Legacy-Pfad.
+      // Vorher merken ob Musik lief (fuer Resume am Dialog-Ende).
+      await this._captureMediaActive();
+      this._cancelDeferredFocusRelease();
+      AudioFocus?.requestExclusive().catch(() => {});
+
+
      // 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).
@@ -49,8 +49,15 @@ 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. */
+/** 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;
 }
@@ -104,11 +104,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 +130,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) {
@@ -215,7 +220,12 @@ class RVSConnection {
        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);
@@ -258,8 +268,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;
@@ -302,6 +311,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);
@@ -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 };
@@ -820,13 +820,13 @@ META_TOOLS = [
        "function": {
            "name": "oauth_get_token",
            "description": (
-                "Liefert das aktuelle access_token fuer einen Service. "
-                "Refresht automatisch wenn abgelaufen (oder < 60s Restzeit) "
-                "und der Provider einen refresh_token mitgegeben hat.\n\n"
-                "**Nutze das in Skills** wenn Du Provider-APIs callen willst — "
-                "der token kommt als Bearer-Header in Deinen HTTP-Request, "
-                "z.B. `Authorization: Bearer <token>`.\n\n"
-                "Wirft wenn Service noch nicht authentifiziert ist oder der "
+                "Prueft, ob ein Service authentifiziert ist, und wie lange der "
+                "Token noch gilt. Refresht dabei automatisch, wenn noetig.\n\n"
+                "GIBT DEN TOKEN NICHT HERAUS — und Du brauchst ihn auch nicht: "
+                "fuer API-Aufrufe nimm `oauth_call`, das Brain haengt die "
+                "Authorization selbst an. In einem Skill holst Du ihn zur "
+                "Laufzeit ueber {BRAIN_INTERNAL_URL}/oauth/<service>/token.\n\n"
+                "Wirft, wenn der Service noch nicht authentifiziert ist oder der "
                "Refresh fehlschlaegt → dann erst `oauth_authorize` aufrufen."
            ),
            "parameters": {
@@ -838,6 +838,35 @@ META_TOOLS = [
            },
        },
    },
+    {
+        "type": "function",
+        "function": {
+            "name": "oauth_call",
+            "description": (
+                "Ruft eine Provider-API MIT dem hinterlegten Zugangstoken auf, "
+                "ohne dass Du den Token siehst. Das Brain haengt den "
+                "Authorization-Header an, fuehrt den Request aus und gibt Dir nur "
+                "die Antwort.\n\n"
+                "Nimm das fuer einzelne Aufrufe (z.B. Spotify-Wiedergabe steuern, "
+                "GitHub-Issue anlegen). Fuer etwas, das Du oefter brauchst, bau "
+                "lieber einen Skill.\n\n"
+                "Nur https, und nur Hosts, die zum Service gehoeren — eine fremde "
+                "Domain wird abgelehnt (sonst koennte der Token irgendwohin "
+                "geschickt werden). Antwort wird bei 200 KB gekuerzt."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "service": {"type": "string", "description": "z.B. spotify, github."},
+                    "url": {"type": "string", "description": "Vollstaendige https-URL der API."},
+                    "method": {"type": "string", "description": "GET (Default), POST, PUT, PATCH, DELETE."},
+                    "body": {"type": "string", "description": "Request-Body, meist JSON als String."},
+                    "content_type": {"type": "string", "description": "Default application/json."},
+                },
+                "required": ["service", "url"],
+            },
+        },
+    },
    {
        "type": "function",
        "function": {
@@ -1241,6 +1270,16 @@ META_TOOLS = [
                "oder Key). Fuer Geraete mit hinterlegten Zugangsdaten "
                "(community/v3/Login/SSH) nutzt der Satellit diese automatisch — Du musst "
                "keine Passwoerter mitgeben. "
+                "ANDROID/FIRE TV ausrollen: 'adb.install' (params={'ip':'<geraet>', "
+                "'url':'<apk-url>'}) installiert/aktualisiert eine App auf einem Android-"
+                "Geraet im Netz — so kommt der ARIA-Agent auf einen Fire TV Stick, ohne "
+                "eine Datei von Hand zu kopieren. Voraussetzung: auf dem Geraet ist ADB-"
+                "Debugging aktiv (Fire TV: Einstellungen > Mein Fire TV > Entwickleroptionen) "
+                "und der Dialog 'USB-Debugging zulassen?' wurde bestaetigt. Weiter: "
+                "'adb.devices' (welche Geraete sind verbunden), 'adb.connect' "
+                "(params={'ip':'...'}) und 'adb.shell' (params={'ip':'...','cmd':'...'}) "
+                "fuer Diagnose. In der Geraeteliste (satellite_devices) haben ausrollbare "
+                "Geraete adbCapable=true; Fire TV Sticks type='firetv'. "
                "'http.get'/'http.post' (params={'url':'...'}) fuer lokale Webhooks UND "
                "um Geraete-Statusseiten zu lesen (Fallback fuer Tinte, NAS ...). Bei grossen "
                "Seiten NICHT blind paginieren: setze params['contains'] (String oder "
@@ -1270,7 +1309,8 @@ META_TOOLS = [
            "description": (
                "Zeigt die ARIA-Host-Agenten (Rechner, auf denen ein Agent DIREKT "
                "laeuft und sich per RVS meldet) die ONLINE sind + was sie koennen "
-                "(exec/read/write/info/screenshot). Ein Host-Agent gibt Dir vollen "
+                "(exec/read/write/info/screenshot/ui_dump; Android-Agenten koennen "
+                "screenshot+ui_dump). Ein Host-Agent gibt Dir vollen "
                "Zugriff auf GENAU DIESEN Rechner — auch wenn er hinter NAT/Firewall "
                "sitzt. Nutze das, wenn Stefan etwas 'auf meinem Laptop/PC/Server X' "
                "machen will, das kein Geraet im Netz ist."
@@ -1364,6 +1404,302 @@ META_TOOLS = [
            },
        },
    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_ui_dump",
+            "description": (
+                "Liest die sichtbaren Bedienelemente eines Host-Agenten als strukturierte "
+                "Liste (Text, Beschriftung, Klasse, Bildschirm-Position x/y, Rahmen, ob "
+                "klickbar/editierbar). Vor allem fuer Android-Agenten: ergaenzt "
+                "host_screenshot — der Screenshot zeigt Dir das Bild, ui_dump liefert die "
+                "exakten Element-Texte und Koordinaten, um spaeter gezielt zu tippen. Setzt "
+                "auf dem Geraet eine aktive Bedienungshilfe voraus."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {"host": {"type": "string", "description": "Host-ID/Name."}},
+                "required": ["host"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_ui_tap",
+            "description": (
+                "Klickt/tippt auf einem Host-Agenten auf eine Bildschirm-Position (x,y). "
+                "ANDROID: nimm die Koordinaten aus host_ui_dump (echte Pixel) — NICHT aus "
+                "dem Screenshot (der ist skaliert). DESKTOP (Windows/Linux/Mac): es gibt "
+                "kein ui_dump; nimm die Koordinaten DIREKT aus dem host_screenshot (voller "
+                "Auflösung = echte Pixel). button/double optional (Rechtsklick/Doppelklick)."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name."},
+                    "x": {"type": "integer", "description": "X (Pixel)."},
+                    "y": {"type": "integer", "description": "Y (Pixel)."},
+                    "button": {"type": "string", "description": "left (Default) | right | middle."},
+                    "double": {"type": "boolean", "description": "Doppelklick."},
+                },
+                "required": ["host", "x", "y"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_ui_text",
+            "description": (
+                "Schreibt Text auf einem Host-Agenten. ANDROID: in das Feld an x/y (aus "
+                "host_ui_dump, editable=true). DESKTOP: tippt in das AKTUELL fokussierte "
+                "Feld (x/y optional) — ggf. vorher mit host_ui_tap ins Feld klicken."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name."},
+                    "x": {"type": "integer", "description": "X des Feldes (aus ui_dump)."},
+                    "y": {"type": "integer", "description": "Y des Feldes (aus ui_dump)."},
+                    "text": {"type": "string", "description": "Einzugebender Text."},
+                },
+                "required": ["host", "x", "y", "text"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_ui_swipe",
+            "description": (
+                "Wischt/scrollt auf einem Host-Agenten von (x1,y1) nach (x2,y2). Zum "
+                "Scrollen nach unten z.B. von weiter unten nach weiter oben wischen."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name."},
+                    "x1": {"type": "integer"}, "y1": {"type": "integer"},
+                    "x2": {"type": "integer"}, "y2": {"type": "integer"},
+                    "duration_ms": {"type": "integer", "description": "Dauer in ms (Default 300)."},
+                },
+                "required": ["host", "x1", "y1", "x2", "y2"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_ui_key",
+            "description": (
+                "Drueckt eine Taste auf einem Host-Agenten. ANDROID: back | home | recents "
+                "| notifications. DESKTOP (Win/Linux/Mac): Tastennamen/Kombis wie Return, "
+                "Escape, Tab, Delete, Up/Down, ctrl+c, alt+F4 (Linux/xdotool-Syntax)."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name."},
+                    "key": {"type": "string",
+                            "description": "Android: back/home/recents/notifications. Desktop: Return, Escape, ctrl+c, …"},
+                },
+                "required": ["host", "key"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_app_launch",
+            "description": (
+                "Startet eine App auf einem Host-Agenten. ANDROID: per Paketname (package, "
+                "z.B. 'com.google.android.gm') ODER Namens-Suche (query). DESKTOP "
+                "(Win/Linux/Mac): per App-Name (query, z.B. 'firefox'/'Safari') ODER "
+                "beliebigem Startbefehl (command). Danach mit host_screenshot weiterarbeiten."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name."},
+                    "package": {"type": "string", "description": "Android-Paketname (optional)."},
+                    "query": {"type": "string", "description": "App-Name/Teilstring (optional)."},
+                    "command": {"type": "string", "description": "Desktop: Startbefehl (optional)."},
+                },
+                "required": ["host"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "jellyfin_search",
+            "description": (
+                "Sucht Filme/Serien/Folgen auf einem Jellyfin-Server (Medien-Bibliothek). "
+                "Liefert Titel, Jahr, Typ und die itemId, die Du zum Abspielen brauchst. "
+                "NIMM DAS statt Dich durch die Fire-TV-Oberflaeche zu klicken — das ist "
+                "zuverlaessig und schnell. Server werden im Diagnostic unter "
+                "Integrationen gepflegt; ohne Angabe wird der Standard-Server genutzt."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Suchbegriff, z.B. 'Asterix Kleopatra'."},
+                    "server": {"type": "string", "description": "Server-Name (optional, sonst Standard)."},
+                    "limit": {"type": "integer", "description": "Max. Treffer (Default 10)."},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "jellyfin_devices",
+            "description": (
+                "Zeigt, auf welchen Geraeten gerade eine Jellyfin-App laeuft und damit "
+                "fernsteuerbar ist (Sitzungen) — z.B. der Fire TV im Schlafzimmer. "
+                "WICHTIG: Ein Geraet erscheint nur, wenn die Jellyfin-App dort GEOEFFNET "
+                "ist. Ist sie zu, starte sie zuerst mit host_app_launch (query='Jellyfin') "
+                "und frage dann erneut."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "server": {"type": "string", "description": "Server-Name (optional)."},
+                },
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "jellyfin_play",
+            "description": (
+                "Startet die Wiedergabe eines Titels auf einem Jellyfin-Geraet. Ablauf: "
+                "1. jellyfin_search -> itemId, 2. jellyfin_devices -> Geraet/Sitzung, "
+                "3. jellyfin_play. Prueft selbst nach, ob die Wiedergabe wirklich "
+                "angelaufen ist. GIB IMMER 'host' MIT (Name des Host-Agenten am "
+                "Fernseher, z.B. 'Fire-TV Schlafzimmer'): dann starte ich Jellyfin bei "
+                "einer eingeschlafenen Sitzung automatisch neu und lege nochmal nach, "
+                "statt faelschlich Erfolg zu melden."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "item_id": {"type": "string", "description": "itemId aus jellyfin_search."},
+                    "device": {"type": "string", "description": "Geraete-/Sitzungsname aus jellyfin_devices (z.B. 'Fire TV')."},
+                    "host": {"type": "string", "description": "Host-Agent am Geraet (fuer automatischen Neustart bei toter Sitzung)."},
+                    "server": {"type": "string", "description": "Server-Name (optional)."},
+                    "resume": {"type": "boolean", "description": "Wenn moeglich fortsetzen statt von vorn (Default true)."},
+                },
+                "required": ["item_id", "device"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "jellyfin_control",
+            "description": (
+                "Steuert die laufende Wiedergabe auf einem Jellyfin-Geraet: pause, "
+                "unpause, stop, nextTrack, previousTrack."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "device": {"type": "string", "description": "Geraete-/Sitzungsname."},
+                    "command": {"type": "string", "description": "pause | unpause | stop | nextTrack | previousTrack"},
+                    "server": {"type": "string", "description": "Server-Name (optional)."},
+                },
+                "required": ["device", "command"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_notify",
+            "description": (
+                "Zeigt eine Nachricht AUF einem Host-Agenten an — bei einem Fire TV / "
+                "Android TV als EINBLENDUNG ueber dem laufenden Bild (Netflix & Co. "
+                "laufen weiter), wahlweise als Sprachausgabe. NIMM DIESES TOOL, wenn "
+                "Stefan etwas 'auf dem Fernseher einblenden/anzeigen' will — versuche "
+                "das NICHT ueber host_exec/adb (dort gibt es kein passendes Kommando). "
+                "mode: 'overlay' (einblenden), 'speech' (vorlesen) oder 'both'; ohne "
+                "Angabe gilt die Einstellung am Geraet. Braucht dort einmalig die "
+                "Berechtigung 'Ueber anderen Apps anzeigen'. Mit image_path kann "
+                "ein BILD mit Text darueber eingeblendet werden (z.B. ein "
+                "generiertes Bild oder ein Screenshot) — nur bei Android-Agenten."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name (z.B. 'Fire-TV Schlafzimmer')."},
+                    "text": {"type": "string", "description": "Der anzuzeigende Text."},
+                    "title": {"type": "string", "description": "Ueberschrift (Default 'ARIA')."},
+                    "seconds": {
+                        "type": "integer",
+                        "description": (
+                            "Anzeigedauer in Sekunden (Default 12). "
+                            "0 = stehen lassen, bis Stefan selbst wegdrueckt "
+                            "(Fernbedienung: beliebige Taste, Handy: daneben "
+                            "tippen). Nimm 0 fuer alles zum LESEN — Wetter, "
+                            "Listen, Zahlen: eine feste Dauer ist da immer "
+                            "geraten und meist zu kurz. Kurze Hinweise waehrend "
+                            "eines Films ruhig mit Dauer."
+                        ),
+                    },
+                    "mode": {"type": "string", "description": "overlay | speech | both"},
+                    "focus": {"type": "string", "description": "Bei Sprachausgabe: 'duck' (laufende Medien werden leiser, Standard) | 'pause' (Film/Musik anhalten) | 'none'."},
+                    "image_path": {
+                        "type": "string",
+                        "description": (
+                            "Optional: Pfad zu einem Bild (PNG/JPEG) unter "
+                            "/shared/uploads/, das MIT dem Text eingeblendet wird. "
+                            "Nur Android-Agenten koennen das."
+                        ),
+                    },
+                },
+                "required": ["host", "text"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_speak",
+            "description": (
+                "Laesst einen Host-Agenten Text laut vorlesen (Fire TV: ueber die "
+                "Fernseher-Lautsprecher). Fuer reine Sprachansagen; soll es auch/nur "
+                "sichtbar sein, nimm host_notify."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name."},
+                    "text": {"type": "string", "description": "Was gesprochen werden soll."},
+                    "focus": {"type": "string", "description": "'duck' (Medien leiser, Standard) | 'pause' (Film/Musik anhalten) | 'none'."},
+                },
+                "required": ["host", "text"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "host_volume",
+            "description": "Setzt die Medien-Lautstaerke eines Host-Agenten (Fire TV / Android).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host-ID/Name."},
+                    "percent": {"type": "integer", "description": "0-100."},
+                },
+                "required": ["host", "percent"],
+            },
+        },
+    },
    {
        "type": "function",
        "function": {
@@ -2044,7 +2380,10 @@ class Agent:

    # ── Hauptpfad: ein User-Turn → Tool-Loop → finaler Reply ──

-    MAX_TOOL_ITERATIONS = 8  # Schutz vor Endlos-Loops
+    # Schutz vor Endlos-Loops, aber hoch genug fuer echte agentische Arbeit
+    # (Host-Agent-Exploration, Multi-Datei-Tasks brauchen viele Tool-Runden).
+    # 8 war zu knapp — ARIA brach mitten in laufender Arbeit ab. Env-tunebar.
+    MAX_TOOL_ITERATIONS = int(os.getenv("MAX_TOOL_ITERATIONS", "20"))

    def chat(self, user_message: str, source: str = "",
             project_id: Optional[str] = None,
@@ -2076,6 +2415,11 @@ class Agent:
        # Events vom letzten Turn weglassen
        self._pending_events = []

+        # Trace fuer die Agent-Historie (Diagnostic gruppiert Host-Aktionen pro
+        # dieser einen User-Nachricht). Best-effort, nur Anzeige.
+        self._trace_id = os.urandom(6).hex()
+        self._trace_msg = user_message[:160]
+
        # Projekt-Kontext pro Request statt aus globalem State
        active_project_id = (project_id or "").strip()
        active_project = projects_mod.get_project(active_project_id) if active_project_id else None
@@ -2343,7 +2687,10 @@ class Agent:
                break
            else:
                # Loop-Limit erreicht
-                final_reply = "[Tool-Loop-Limit erreicht — ARIA hat zu viele Tool-Calls gemacht ohne fertig zu werden]"
+                final_reply = (
+                    f"Ich hab die Aufgabe nach {self.MAX_TOOL_ITERATIONS} Arbeitsschritten "
+                    f"gestoppt, damit ich nicht endlos weiterlaufe — war aber noch mittendrin. "
+                    f"Sag mir, ob ich weitermachen oder es anders angehen soll.")
                logger.warning("Tool-Loop hit MAX_TOOL_ITERATIONS=%d", self.MAX_TOOL_ITERATIONS)

            if not final_reply:
@@ -2519,10 +2866,18 @@ class Agent:
            if not sat or not action:
                return "FEHLER: satellite und action sind Pflicht."
            params = arguments.get("params") if isinstance(arguments.get("params"), dict) else {}
+            # Langlaeufer brauchen mehr als den Bridge-Default (20s): eine APK ueber
+            # WLAN zu installieren dauert 30-60s. Ohne das meldet ARIA "Timeout",
+            # obwohl die Installation noch laeuft.
+            # adb.*: Warten auf die Geraete-Autorisierung (bis 90s) + Download +
+            # Installation koennen zusammen mehrere Minuten dauern.
+            sat_timeout = (320.0 if action.startswith("adb.")
+                           else 200.0 if action == "ssh.exec" else 20.0)
            result = _post("/internal/satellite", {
                "op": "command", "satellite": sat,
                "device": arguments.get("device") or "", "action": action, "params": params,
-            }, 30)
+                "timeout": sat_timeout,
+            }, sat_timeout + 20)
            if result.get("ok"):
                r = result.get("result")
                return f"OK — {r}" if r else "OK — Aktion ausgefuehrt."
@@ -2530,9 +2885,276 @@ class Agent:
        except Exception as exc:
            return f"FEHLER: Satellit/Bridge nicht erreichbar: {exc}"

+    # ── Jellyfin (Medien) ─────────────────────────────────────
+    _JELLYFIN_CONFIG = "/shared/config/jellyfin.json"
+
+    def _jellyfin_server(self, wanted: str = "") -> Optional[dict]:
+        """Server aus der Diagnostic-Konfiguration waehlen (Name oder Standard)."""
+        try:
+            with open(self._JELLYFIN_CONFIG, "r", encoding="utf-8") as f:
+                servers = (json.load(f) or {}).get("servers") or []
+        except Exception:
+            return None
+        servers = [s for s in servers if s.get("url")]
+        if not servers:
+            return None
+        w = (wanted or "").strip().lower()
+        if w:
+            for s in servers:
+                if w in (s.get("name") or "").lower() or w in (s.get("url") or "").lower():
+                    return s
+        for s in servers:
+            if s.get("isDefault"):
+                return s
+        return servers[0]
+
+    def _jellyfin_call(self, server: dict, path: str, method: str = "GET",
+                       params: Optional[dict] = None, timeout: float = 15.0):
+        """Ruft die Jellyfin-HTTP-API. Gibt (daten, fehlertext)."""
+        url = server["url"].rstrip("/") + path
+        if params:
+            url += ("&" if "?" in url else "?") + urllib.parse.urlencode(params)
+        req = urllib.request.Request(url, method=method, headers={
+            "Authorization": f'MediaBrowser Token="{server.get("apiKey", "")}"',
+            "Content-Type": "application/json",
+        })
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                raw = resp.read().decode("utf-8", "ignore")
+                return (json.loads(raw) if raw.strip() else {}), ""
+        except urllib.error.HTTPError as exc:
+            if exc.code in (401, 403):
+                return None, ("Jellyfin lehnt den API-Key ab (401/403) — im Diagnostic "
+                              "unter Integrationen pruefen.")
+            return None, f"Jellyfin-Fehler HTTP {exc.code}"
+        except Exception as exc:
+            return None, f"Jellyfin nicht erreichbar: {exc}"
+
+    def _jellyfin_find_session(self, server: dict, device: str, fresh_sec: int = 600):
+        """Sucht die Sitzung eines Geraets. Gibt (session, fehlertext).
+
+        `activeWithinSeconds` filtert eingeschlafene Sitzungen aus: Jellyfin
+        listet Clients noch eine Weile, nachdem die App laengst weg ist — ein
+        Play-Befehl an so eine Karteileiche verpufft wortlos.
+        """
+        sessions, err = self._jellyfin_call(
+            server, "/Sessions", params={"activeWithinSeconds": fresh_sec})
+        if err:
+            return None, err
+        d = (device or "").strip().lower()
+        cands = [s for s in (sessions or []) if s.get("SupportsRemoteControl")]
+        for s in cands:
+            blob = f"{s.get('DeviceName', '')} {s.get('Client', '')}".lower()
+            if d and d in blob:
+                return s, ""
+        if not d and len(cands) == 1:
+            return cands[0], ""
+        names = ", ".join(f"{s.get('DeviceName')} ({s.get('Client')})" for s in cands) or "keine"
+        return None, (f"Kein steuerbares Jellyfin-Geraet fuer '{device}' gefunden. "
+                      f"Aktuell offen: {names}. Tipp: Die Jellyfin-App muss auf dem "
+                      f"Geraet GEOEFFNET sein — sonst vorher host_app_launch "
+                      f"(query='Jellyfin') aufrufen.")
+
+    def _jellyfin_playing(self, server: dict, sess: dict, item_id: str,
+                          tries: int = 4, wait: float = 1.5) -> bool:
+        """Prueft, ob auf der Sitzung wirklich etwas abgespielt wird.
+
+        Jellyfin quittiert einen Play-Befehl auch dann mit 204, wenn die Sitzung
+        laengst tot ist — ohne diese Kontrolle meldet man faelschlich Erfolg.
+        """
+        want = (item_id or "").strip()
+        for _ in range(max(1, tries)):
+            time.sleep(wait)
+            sessions, err = self._jellyfin_call(server, "/Sessions", timeout=10.0)
+            if err:
+                continue
+            for s in (sessions or []):
+                if s.get("Id") != sess.get("Id"):
+                    continue
+                now = s.get("NowPlayingItem") or {}
+                if now and (not want or now.get("Id") == want):
+                    return True
+        return False
+
+    def _dispatch_jellyfin(self, name: str, arguments: dict) -> str:
+        server = self._jellyfin_server(arguments.get("server") or "")
+        if not server:
+            return ("FEHLER: Kein Jellyfin-Server eingerichtet. Im Diagnostic unter "
+                    "Einstellungen → Integrationen → Jellyfin einen Server mit URL und "
+                    "API-Key anlegen.")
+        label = server.get("name") or server.get("url")
+        try:
+            if name == "jellyfin_search":
+                q = (arguments.get("query") or "").strip()
+                if not q:
+                    return "FEHLER: query ist Pflicht."
+                data, err = self._jellyfin_call(server, "/Items", params={
+                    "searchTerm": q, "Recursive": "true",
+                    "IncludeItemTypes": "Movie,Series,Episode",
+                    "Limit": int(arguments.get("limit") or 10),
+                    "Fields": "ProductionYear,Overview",
+                })
+                if err:
+                    return f"FEHLER: {err}"
+                items = (data or {}).get("Items") or []
+                if not items:
+                    return f"Keine Treffer fuer '{q}' auf {label}."
+                lines = []
+                for it in items:
+                    lines.append(f"- {it.get('Name')} ({it.get('ProductionYear') or '?'}) "
+                                 f"[{it.get('Type')}] itemId={it.get('Id')}")
+                return f"Treffer auf {label}:\n" + "\n".join(lines)
+
+            if name == "jellyfin_devices":
+                # Nur Sitzungen, die zuletzt aktiv waren — sonst listet Jellyfin
+                # auch laengst geschlossene Apps, an die kein Befehl mehr geht.
+                sessions, err = self._jellyfin_call(
+                    server, "/Sessions", params={"activeWithinSeconds": 600})
+                if err:
+                    return f"FEHLER: {err}"
+                out = []
+                for s in (sessions or []):
+                    if not s.get("SupportsRemoteControl"):
+                        continue
+                    now = (s.get("NowPlayingItem") or {}).get("Name")
+                    out.append(f"- {s.get('DeviceName')} ({s.get('Client')})"
+                               + (f" — laeuft gerade: {now}" if now else ""))
+                if not out:
+                    return (f"Auf {label} ist gerade kein steuerbares Geraet offen. Die "
+                            f"Jellyfin-App muss auf dem Zielgeraet laufen — starte sie "
+                            f"mit host_app_launch (query='Jellyfin') und frag dann erneut.")
+                return f"Steuerbare Jellyfin-Geraete auf {label}:\n" + "\n".join(out)
+
+            if name == "jellyfin_play":
+                item_id = (arguments.get("item_id") or "").strip()
+                device = (arguments.get("device") or "").strip()
+                if not item_id or not device:
+                    return "FEHLER: item_id und device sind Pflicht."
+                sess, err = self._jellyfin_find_session(server, device)
+                if err:
+                    return f"FEHLER: {err}"
+                play_params = {"itemIds": item_id, "playCommand": "PlayNow"}
+                note = ""
+                if arguments.get("resume") is not False:
+                    # Fortsetzen: gespeicherte Position des Titels mitgeben.
+                    info, _e = self._jellyfin_call(server, "/Items",
+                                                   params={"ids": item_id, "Fields": "UserData"})
+                    items = (info or {}).get("Items") or []
+                    ticks = 0
+                    if items:
+                        ticks = ((items[0].get("UserData") or {}).get("PlaybackPositionTicks") or 0)
+                    if ticks > 0:
+                        play_params["startPositionTicks"] = ticks
+                        note = f" — fortgesetzt bei {int(ticks / 10_000_000 // 60)} min"
+                _, err = self._jellyfin_call(
+                    server, f"/Sessions/{sess['Id']}/Playing", method="POST",
+                    params=play_params)
+                if err:
+                    return f"FEHLER: {err}"
+
+                # Nachsehen, ob wirklich etwas laeuft. Eine eingeschlafene Sitzung
+                # nimmt den Befehl wortlos an, ohne dass der Film startet — genau
+                # der Fall "beim zweiten Mal ging es nicht".
+                if self._jellyfin_playing(server, sess, item_id):
+                    # Ausdruecklich vermerken, dass NICHTS repariert werden musste —
+                    # sonst erzaehlt das Modell gern die Panne aus einem frueheren
+                    # Turn nach ("Session war eingeschlafen"), obwohl alles glatt lief.
+                    return (f"OK — Wiedergabe auf '{sess.get('DeviceName')}' laeuft"
+                            f"{note} (Server {label}). Sitzung war aktiv, kein Neustart "
+                            f"noetig — erwaehne also KEINEN Neustart und KEINE "
+                            f"eingeschlafene Sitzung.")
+
+                # Sitzung war tot. Wenn wir den zugehoerigen Agenten kennen:
+                # Jellyfin dort neu starten, frische Sitzung holen, einmal
+                # nachlegen. Sonst ehrlich sagen, was zu tun ist.
+                host = (arguments.get("host") or "").strip()
+                if not host:
+                    return ("FEHLER: Der Befehl wurde angenommen, aber es laeuft nichts — "
+                            "die Jellyfin-Sitzung auf dem Geraet war eingeschlafen. "
+                            "Starte die Jellyfin-App neu (host_app_launch mit "
+                            "query='Jellyfin') und versuche es erneut. Tipp: Gib "
+                            "jellyfin_play den Parameter 'host' mit (Name des "
+                            "Host-Agenten), dann mache ich das automatisch.")
+                self._dispatch_host("host_app_launch", {"host": host, "query": "Jellyfin"})
+                time.sleep(6)   # App braucht einen Moment, bis sie sich anmeldet
+                sess2, err2 = self._jellyfin_find_session(server, device, fresh_sec=120)
+                if err2:
+                    return (f"FEHLER: Jellyfin auf '{host}' neu gestartet, aber es meldet "
+                            f"sich keine Sitzung: {err2}")
+                self._jellyfin_call(server, f"/Sessions/{sess2['Id']}/Playing",
+                                    method="POST", params=play_params)
+                if self._jellyfin_playing(server, sess2, item_id):
+                    return (f"OK — Wiedergabe laeuft auf '{sess2.get('DeviceName')}'"
+                            f"{note}. (Die Sitzung war eingeschlafen, ich habe Jellyfin "
+                            f"auf '{host}' neu gestartet.)")
+                return (f"FEHLER: Auch nach dem Neustart von Jellyfin auf '{host}' startet "
+                        f"die Wiedergabe nicht. Laeuft die App auf dem Bildschirm? "
+                        f"Ggf. dort einmal anmelden.")
+
+            if name == "jellyfin_control":
+                device = (arguments.get("device") or "").strip()
+                cmd = (arguments.get("command") or "").strip()
+                allowed = {"pause", "unpause", "stop", "nexttrack", "previoustrack",
+                           "playpause", "seek"}
+                if cmd.lower() not in allowed:
+                    return f"FEHLER: command '{cmd}' unbekannt ({', '.join(sorted(allowed))})."
+                sess, err = self._jellyfin_find_session(server, device)
+                if err:
+                    return f"FEHLER: {err}"
+                _, err = self._jellyfin_call(
+                    server, f"/Sessions/{sess['Id']}/Playing/{cmd}", method="POST")
+                if err:
+                    return f"FEHLER: {err}"
+                return f"OK — '{cmd}' an '{sess.get('DeviceName')}' gesendet."
+
+            return f"FEHLER: unbekanntes Jellyfin-Tool {name}"
+        except Exception as exc:
+            return f"FEHLER: Jellyfin-Aufruf fehlgeschlagen: {exc}"
+
    def _dispatch_host(self, name: str, arguments: dict) -> str:
+        """Wrapper um _dispatch_host_inner: fuehrt die Host-Aktion aus und schreibt
+        danach einen Historie-Eintrag an die Bridge (fuer die Diagnostic-Ansicht
+        'was wurde pro Nachricht auf diesem Agent gemacht')."""
+        text = self._dispatch_host_inner(name, arguments)
+        try:
+            self._emit_agent_history(name, arguments, text)
+        except Exception:
+            pass
+        return text
+
+    def _emit_agent_history(self, name: str, arguments: dict, text: str) -> None:
+        """Best-effort: ein Historie-Eintrag pro Host-Aktion an die Bridge."""
+        if name == "host_list":
+            return
+        host = (arguments.get("host") or "").strip()
+        if not host:
+            return
+        ok = not text.lstrip().upper().startswith("FEHLER")
+        m = re.search(r"/shared/uploads/\S+?\.(?:png|jpg|jpeg|webp)", text)
+        body = {
+            "host": host,
+            "trace_id": getattr(self, "_trace_id", ""),
+            "msg": getattr(self, "_trace_msg", ""),
+            "tool": name,
+            "action": name[len("host_"):] if name.startswith("host_") else name,
+            "args": {k: v for k, v in arguments.items() if k != "host"},
+            "ok": ok,
+            "summary": (text.strip().splitlines()[0] if text.strip() else "")[:200],
+            "file": m.group(0) if m else None,
+            "ts": int(time.time() * 1000),
+        }
+        try:
+            data = json.dumps(body).encode("utf-8")
+            req = urllib.request.Request(f"{BRIDGE_URL}/internal/agent-history",
+                                         data=data, method="POST",
+                                         headers={"Content-Type": "application/json"})
+            urllib.request.urlopen(req, timeout=5).close()
+        except Exception:
+            pass
+
+    def _dispatch_host_inner(self, name: str, arguments: dict) -> str:
        """host_list / host_exec / host_read / host_write / host_info /
-        host_screenshot — via Bridge (/internal/host*) → RVS → Host-Agent."""
+        host_screenshot / host_ui_* — via Bridge (/internal/host*) → RVS → Host-Agent."""
        import base64 as _b64

        def _post(path: str, body: dict, timeout: float) -> dict:
@@ -2646,6 +3268,64 @@ class Agent:
                    f"[FILE: {fp}] in deine Antwort — dann erscheint das Bild inline im Chat."
                )

+            if name == "host_ui_dump":
+                result = _post("/internal/host", {"host": host, "action": "ui_dump",
+                                                  "params": {}}, 20)
+                if not result.get("ok"):
+                    return f"FEHLER: {result.get('error')}"
+                r = result.get("result") or {}
+                nodes = r.get("nodes") or []
+                return (
+                    f"UI-Baum von {host} (App: {r.get('package', '?')}, "
+                    f"{r.get('count', len(nodes))} Elemente). Jeder Eintrag hat x/y = "
+                    f"Mittelpunkt zum Antippen:\n"
+                    + json.dumps(nodes, ensure_ascii=False, indent=2)
+                )
+
+            # ── Steuern (Meilenstein 3) ──────────────────────────────
+            _UI_ACTIONS = {
+                "host_ui_tap": ("ui_tap", ["x", "y", "button", "double"]),
+                "host_ui_text": ("ui_text", ["x", "y", "text"]),
+                "host_ui_swipe": ("ui_swipe", ["x1", "y1", "x2", "y2", "duration_ms"]),
+                "host_ui_key": ("ui_key", ["key"]),
+                "host_app_launch": ("app_launch", ["package", "query", "command"]),
+                "host_notify": ("notify", ["text", "title", "seconds", "mode", "focus"]),
+                "host_speak": ("speak", ["text", "focus"]),
+                "host_volume": ("volume", ["percent"]),
+            }
+            if name in _UI_ACTIONS:
+                action, keys = _UI_ACTIONS[name]
+                params = {k: arguments[k] for k in keys if arguments.get(k) is not None}
+                # Bild-Einblendung: ARIA gibt einen Pfad an (damit arbeitet sie
+                # sowieso), der Agent will base64. Hier umwandeln, statt ARIA
+                # megabyteweise base64 durch den Tool-Call schieben zu lassen.
+                img_path = (arguments.get("image_path") or "").strip()
+                if action == "notify" and img_path:
+                    if not img_path.startswith("/shared/uploads/"):
+                        return "FEHLER: image_path muss unter /shared/uploads/ liegen."
+                    if not os.path.isfile(img_path):
+                        return f"FEHLER: Bild nicht gefunden: {img_path}"
+                    # Overlay-Bilder ueber ~4 MB sind sinnlos gross fuer einen
+                    # Fernseher und blaehen die WS-Nachricht unnoetig auf.
+                    _img_size = os.path.getsize(img_path)
+                    if _img_size > 4 * 1024 * 1024:
+                        return (f"FEHLER: Bild zu gross fuer eine Einblendung "
+                                f"({_img_size // (1024 * 1024)} MB > 4 MB). "
+                                f"Vorher verkleinern.")
+                    with open(img_path, "rb") as _f:
+                        params["image_base64"] = _b64.b64encode(_f.read()).decode("ascii")
+                # Sprachausgabe braucht laenger: der Agent meldet erst Erfolg,
+                # wenn wirklich Ton laeuft (TTS-Render + Uebertragung). Mit den
+                # 20s der UI-Aktionen lief die ehrliche Antwort in den Timeout.
+                _timeout = 40 if action in ("speak", "notify") else 20
+                result = _post("/internal/host",
+                               {"host": host, "action": action, "params": params},
+                               _timeout)
+                if not result.get("ok"):
+                    return f"FEHLER: {result.get('error')}"
+                r = result.get("result") or {}
+                return f"OK ({host}): {r.get('message', 'ausgefuehrt')}"
+
            return f"FEHLER: unbekanntes Host-Tool {name}"
        except Exception as exc:
            return f"FEHLER: Host/Bridge nicht erreichbar: {exc}"
@@ -2905,6 +3585,10 @@ class Agent:
                    fires_at_iso=fires_at_iso,
                    message=arguments["message"],
                    author="aria",
+                    # Projekt DIESES Requests mitnehmen: beim Feuern soll die
+                    # Antwort dort landen, wo der Timer gestellt wurde — nicht
+                    # im Hauptchat.
+                    project_id=project_id or "",
                )
                self._pending_events.append({
                    "type": "trigger_created",
@@ -2920,6 +3604,7 @@ class Agent:
                    check_interval_sec=int(arguments.get("check_interval_sec", 300)),
                    throttle_sec=int(arguments.get("throttle_sec", 3600)),
                    author="aria",
+                    project_id=project_id or "",
                )
                self._pending_events.append({
                    "type": "trigger_created",
@@ -2992,13 +3677,29 @@ class Agent:
                    return "(keine Trigger vorhanden)"
                lines = []
                for t in items:
-                    state = "aktiv" if t.get("active", True) else "DEAKTIVIERT"
-                    if t["type"] == "timer":
-                        lines.append(f"- {t['name']} (timer, {state}): feuert {t.get('fires_at')} — \"{t.get('message','')[:50]}\"")
-                    elif t["type"] == "watcher":
-                        lines.append(f"- {t['name']} (watcher, {state}): cond=\"{t.get('condition')}\", throttle={t.get('throttle_sec')}s")
+                    # WICHTIG: ein One-Shot-Timer wird NACH dem Feuern automatisch
+                    # deaktiviert. Stand hier nur "DEAKTIVIERT", sahen "hat sauber
+                    # gefeuert" und "war nie an" identisch aus — und genau das hat
+                    # schon zu einer falschen Auskunft gefuehrt ("ich habe
+                    # vergessen ihn zu aktivieren", obwohl er gefeuert hatte).
+                    # Darum: gefeuert IMMER explizit mit Zeitpunkt und Zaehler.
+                    fired_n = int(t.get("fire_count", 0) or 0)
+                    last_fired = t.get("last_fired_at") or ""
+                    if fired_n > 0:
+                        state = (f"SCHON GEFEUERT ({fired_n}x, zuletzt {last_fired})"
+                                 + ("" if t.get("active", True) else ", danach automatisch deaktiviert"))
+                    elif t.get("active", True):
+                        state = "aktiv, noch nicht gefeuert"
                    else:
-                        lines.append(f"- {t['name']} ({t['type']}, {state})")
+                        state = "DEAKTIVIERT, nie gefeuert"
+                    # Wohin die Antwort beim Feuern geht — leer = Hauptchat.
+                    where = f" [Kontext: {t.get('project_id') or 'Hauptchat'}]"
+                    if t["type"] == "timer":
+                        lines.append(f"- {t['name']} (timer, {state}){where}: feuert {t.get('fires_at')} — \"{t.get('message','')[:50]}\"")
+                    elif t["type"] == "watcher":
+                        lines.append(f"- {t['name']} (watcher, {state}){where}: cond=\"{t.get('condition')}\", throttle={t.get('throttle_sec')}s")
+                    else:
+                        lines.append(f"- {t['name']} ({t['type']}, {state}){where}")
                return "\n".join(lines)
            if name == "oauth_register_provider":
                svc = (arguments.get("service") or "").strip()
@@ -3062,15 +3763,47 @@ class Agent:
                    record = oauth_mod.get_token(svc)
                except RuntimeError as exc:
                    return f"FEHLER: {exc}"
-                tok = record.get("access_token", "")
-                ttype = record.get("token_type", "Bearer")
                exp = record.get("expires_at", 0)
                remain = max(0, int(exp) - int(__import__("time").time()))
+                hosts = ", ".join(oauth_mod.allowed_hosts(svc)) or "(keine hinterlegt)"
+                # Der Token wird hier BEWUSST nicht mehr herausgegeben. Frueher
+                # stand er im Klartext in dieser Tool-Antwort und damit im
+                # Gespraechsprotokoll — also auch bei Anthropic. Fuer API-Aufrufe
+                # gibt es oauth_call: das Brain haengt den Header selbst an.
                return (
-                    f"OK — Token fuer {svc} (Typ: {ttype}, gueltig noch {remain}s).\n"
-                    f"access_token: {tok}\n"
-                    f"Nutze als HTTP-Header: Authorization: {ttype} {tok}"
+                    f"OK — {svc} ist authentifiziert (Token gueltig noch {remain}s).\n"
+                    f"Der Token wird NICHT herausgegeben und ist dafuer auch nicht noetig:\n"
+                    f"- Einzelne API-Aufrufe: `oauth_call(service='{svc}', url=...)` — "
+                    f"das Brain haengt die Authorization an.\n"
+                    f"- In einem Skill: GET {{BRAIN_INTERNAL_URL}}/oauth/{svc}/token "
+                    f"zur Laufzeit holen, nie hartkodieren.\n"
+                    f"Erlaubte Hosts: {hosts}"
                )
+            if name == "oauth_call":
+                svc = (arguments.get("service") or "").strip()
+                url = (arguments.get("url") or "").strip()
+                if not svc or not url:
+                    return "FEHLER: service und url sind Pflicht."
+                body = arguments.get("body")
+                if body is not None and not isinstance(body, str):
+                    body = json.dumps(body, ensure_ascii=False)
+                try:
+                    status, text = oauth_mod.call(
+                        svc, url,
+                        method=(arguments.get("method") or "GET"),
+                        body=body,
+                        content_type=(arguments.get("content_type") or "application/json"),
+                    )
+                except ValueError as exc:
+                    return f"FEHLER: {exc}"
+                except RuntimeError as exc:
+                    return f"FEHLER: {exc}"
+                except Exception as exc:
+                    logger.exception("oauth_call fehlgeschlagen")
+                    return f"FEHLER: Aufruf fehlgeschlagen: {exc}"
+                ok = 200 <= status < 300
+                head = f"HTTP {status}" + ("" if ok else " (Fehler)")
+                return f"{head}\n{text}" if text else head
            if name == "oauth_revoke":
                svc = (arguments.get("service") or "").strip()
                if not svc:
@@ -3442,8 +4175,15 @@ class Agent:
                return f"OK — Projekt '{updated['name']}' ist wieder ein normaler Chat."
            if name in ("satellite_list", "satellite_devices", "satellite_command"):
                return self._dispatch_satellite(name, arguments)
+            if name in ("jellyfin_search", "jellyfin_devices", "jellyfin_play",
+                        "jellyfin_control"):
+                return self._dispatch_jellyfin(name, arguments)
+
            if name in ("host_list", "host_exec", "host_read", "host_write",
-                        "host_info", "host_screenshot"):
+                        "host_info", "host_screenshot", "host_ui_dump",
+                        "host_ui_tap", "host_ui_text", "host_ui_swipe",
+                        "host_ui_key", "host_app_launch",
+                        "host_notify", "host_speak", "host_volume"):
                return self._dispatch_host(name, arguments)
            if name == "vm_register":
                pid = (project_id or "").strip()
@@ -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:
@@ -156,17 +161,23 @@ async def _fire(trigger: dict, agent_factory) -> None:
        # 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")
+            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 → ARIA-Reply: %s", name, reply[:80])
+        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.
-        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]})
@@ -398,6 +398,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
@@ -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)
@@ -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."""
@@ -457,8 +457,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 "
@@ -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 "
@@ -146,6 +146,7 @@ def create_timer(
    fires_at_iso: str,
    message: str,
    author: str = "aria",
+    project_id: str = "",
 ) -> dict:
    _safe_name(name)
    if _path(name).exists():
@@ -164,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


@@ -179,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():
@@ -200,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


@@ -739,6 +739,14 @@ class ARIABridge:
        # weder Meta-Kommando noch Prefix ist und der Sticky abgelaufen,
        # nutzen wir das als Default (Voice folgt dem sichtbaren Kontext).
        self._stt_stream_projects: dict[str, str] = {}
+        # Zusatz-Absicht pro Stream, auch von stt_stream_start:
+        #   cmid      — clientMsgId der Anhaenge, die zu DIESER Aufnahme gehoeren
+        #               (Sprachnachricht als Beschreibung zu einem Bild/Video).
+        #   interject — die Aufnahme ist ein Zwischenruf in den laufenden Turn,
+        #               keine neue Anfrage.
+        # Getrennt von _stt_stream_projects gehalten: der Fokus-Default greift
+        # auch fuer alte App-Versionen, die diese Felder nicht mitschicken.
+        self._stt_stream_meta: dict[str, dict] = {}
        # Voice-Override aus letzter Chat-Nachricht einer App.
        # Wird fuer die direkt folgende ARIA-Antwort genutzt und dann zurueckgesetzt.
        # So kann jedes Geraet seine bevorzugte Stimme bekommen (pro Request).
@@ -808,6 +816,18 @@ class ARIABridge:
        # Projekt landen statt im Hauptchat.
        self._pending_files_project_id: str = ""
        self._PENDING_FILES_WINDOW_SEC: float = 0.8
+        # Wartet ein Upload auf eine SPRACHNACHRICHT als Beschreibung, reichen
+        # 0.8s nicht: der Nutzer spricht erst, und Whisper braucht danach noch
+        # ein paar Sekunden fuers Final-Transkript. Mit dem kurzen Fenster waere
+        # der Anhang laengst alleine rausgegangen ("warte auf seine Anweisung"),
+        # und der gesprochene Text kaeme als zweiter, unverbundener Turn.
+        # Das lange Fenster ist nur eine Notbremse gegen Haengenbleiben, falls
+        # gar kein Endpoint mehr kommt — der Normalfall ist der Merge im
+        # stt_endpoint-Handler. Es MUSS ueber dem Aufnahme-Hard-Cap der App
+        # liegen (Default 5 Minuten) plus Whisper-Final, sonst waeren die
+        # Anhaenge bei einer langen Aufnahme vorher alleine rausgegangen.
+        self._PENDING_FILES_VOICE_WINDOW_SEC: float = 420.0
+        self._pending_files_await_voice: bool = False

    def initialize(self) -> None:
        """Initialisiert alle Komponenten.
@@ -1879,6 +1899,13 @@ class ARIABridge:
        return (f"Stefan hat dir {n} {anhang} geschickt:\n{files_summary}\n\n"
                f"Warte auf seine Anweisung was du damit tun sollst.")

+    def _pending_files_window(self) -> float:
+        """Wie lange auf den zugehoerigen Text gewartet wird, bevor die Anhaenge
+        alleine rausgehen. Lang, wenn eine Sprachnachricht unterwegs ist."""
+        return (self._PENDING_FILES_VOICE_WINDOW_SEC
+                if self._pending_files_await_voice
+                else self._PENDING_FILES_WINDOW_SEC)
+
    async def _flush_pending_files_after(self, delay: float) -> None:
        """Wenn nach `delay`s kein chat-Text gekommen ist: alle noch gepufferten
        Files alleine an aria-core senden ('warte auf Anweisung'-Variante)."""
@@ -1892,13 +1919,15 @@ class ARIABridge:
        text = self._build_pending_files_message("", files)
        self._pending_files = []
        self._pending_files_flush_task = None
+        self._pending_files_await_voice = False
        pid = self._pending_files_project_id
        self._pending_files_project_id = ""
        await self.send_to_core(text, source="app-file", project_id=pid)

    async def _flush_pending_files_with_text(self, user_text: str,
                                             project_id: str = "",
-                                             client_msg_id: str = "") -> bool:
+                                             client_msg_id: str = "",
+                                             require_match: bool = False) -> bool:
        """Wenn ein chat-Text reinkommt waehrend Files gepuffert sind:
        Files + Text zu einer einzigen aria-core-Nachricht mergen.
        Returns True wenn gemerged wurde (Caller soll dann nicht nochmal senden).
@@ -1913,12 +1942,20 @@ class ARIABridge:

        project_id: Projekt-Kontext aus dem chat-Payload (der sichtbare Focus
        beim Absenden). Faellt auf den beim File-Upload gemerkten Kontext zurueck.
+
+        require_match: nur mergen, wenn die cmid wirklich passt. Der Sprach-Pfad
+        nutzt das — sonst wuerde eine Sprachnachricht, die zufaellig waehrend
+        eines fremden Uploads fertig wird, dessen Anhaenge an sich reissen. Beim
+        Text-Pfad bleibt der Fallback (alles mergen) wie bisher, damit nie ein
+        Bild verloren geht.
        """
        if not self._pending_files:
            return False
        cmid = (client_msg_id or "").strip()
        matching = [f for f in self._pending_files if cmid and f[6] == cmid]
        if not matching:
+            if require_match:
+                return False
            # Kein cmid-Treffer → altes Verhalten: alle gepufferten Files mergen.
            matching = list(self._pending_files)
            remaining: list = []
@@ -1935,10 +1972,11 @@ class ARIABridge:
        self._pending_files_flush_task = None
        if remaining:
            self._pending_files_flush_task = asyncio.create_task(
-                self._flush_pending_files_after(self._PENDING_FILES_WINDOW_SEC)
+                self._flush_pending_files_after(self._pending_files_window())
            )
        else:
            self._pending_files_project_id = ""
+            self._pending_files_await_voice = False
        # create_task statt await — sonst blockt der RVS-recv-Loop bis Brain
        # fertig ist (siehe chat-handler oben).
        asyncio.create_task(self.send_to_core(text, source="app-file+chat", project_id=pid))
@@ -2752,10 +2790,17 @@ class ARIABridge:
            # genau SEINER Nachricht zu (Queue-Korrelation, s. _flush_*).
            file_cmid = str(payload.get("clientMsgId") or "")
            self._pending_files.append((file_path, file_name, file_type, size_kb, int(width or 0), int(height or 0), file_cmid))
+            # awaitVoice: der Nutzer spricht gerade die Beschreibung zu diesem
+            # Anhang ein. Dann NICHT nach 0.8s alleine rausschicken, sondern auf
+            # den stt_endpoint warten (siehe _PENDING_FILES_VOICE_WINDOW_SEC).
+            if payload.get("awaitVoice"):
+                self._pending_files_await_voice = True
+                logger.info("[rvs] Anhang wartet auf Sprachnachricht: %s (cmid=%s)",
+                            file_name, file_cmid[:12] or "?")
            if self._pending_files_flush_task and not self._pending_files_flush_task.done():
                self._pending_files_flush_task.cancel()
            self._pending_files_flush_task = asyncio.create_task(
-                self._flush_pending_files_after(self._PENDING_FILES_WINDOW_SEC)
+                self._flush_pending_files_after(self._pending_files_window())
            )

            try:
@@ -3324,8 +3369,18 @@ class ARIABridge:
            focused_pid = str(payload.get("projectId") or "")
            if req_id:
                self._stt_stream_projects[req_id] = focused_pid
-                logger.info("[rvs] stt_stream_start id=%s focus=%s",
-                            req_id[:12], focused_pid or "(main)")
+                # Absicht dieser Aufnahme: gehoert sie zu wartenden Anhaengen,
+                # und ist sie ein Zwischenruf statt einer neuen Anfrage?
+                att_cmid = str(payload.get("clientMsgId") or "")
+                is_interject = bool(payload.get("interject"))
+                if att_cmid or is_interject:
+                    self._stt_stream_meta[req_id] = {
+                        "cmid": att_cmid, "interject": is_interject,
+                    }
+                logger.info("[rvs] stt_stream_start id=%s focus=%s%s%s",
+                            req_id[:12], focused_pid or "(main)",
+                            f" anhang-cmid={att_cmid[:12]}" if att_cmid else "",
+                            " [ZWISCHENRUF]" if is_interject else "")
            return

        elif msg_type == "stt_stream_end":
@@ -3340,10 +3395,10 @@ class ARIABridge:
            if req_id:
                try:
                    loop = asyncio.get_event_loop()
-                    loop.call_later(
-                        20.0,
-                        lambda rid=req_id: self._stt_stream_projects.pop(rid, None),
-                    )
+                    def _drop(rid: str = req_id) -> None:
+                        self._stt_stream_projects.pop(rid, None)
+                        self._stt_stream_meta.pop(rid, None)
+                    loop.call_later(20.0, _drop)
                except Exception:
                    # Kein laufender Loop (sollte im ws-Handler nie passieren) —
                    # dann lieber gar nicht aufraeumen als crashen.
@@ -3407,11 +3462,18 @@ class ARIABridge:
            # weiter auseinander (man hoert den Wechsel erst).
            _norm_txt = " ".join(text.lower().split())
            _now_t = asyncio.get_event_loop().time()
+            # Fenster bewusst KURZ (1.5s): es soll nur den Zwilling abfangen, den
+            # zwei STT-Worker fuer DIESELBE Aufnahme liefern. Mit den frueheren 5s
+            # fielen echte Wiederholungen weg — also genau der Fall "ARIA hat mich
+            # nicht gehoert, ich sag's nochmal" und kurze Kommandos wie "lauter",
+            # "nächstes", "stopp". Die eigentliche Absicherung ist ohnehin die
+            # Idempotenz ueber audioRequestId weiter oben.
+            _DUPE_WINDOW_SEC = 1.5
            if (_norm_txt
                    and _norm_txt == getattr(self, "_last_endpoint_norm", "")
-                    and (_now_t - getattr(self, "_last_endpoint_at", 0.0)) < 5.0):
-                logger.info("[rvs] stt_endpoint Dupe verworfen (gleicher Text <5s): %r",
-                            text[:60])
+                    and (_now_t - getattr(self, "_last_endpoint_at", 0.0)) < _DUPE_WINDOW_SEC):
+                logger.info("[rvs] stt_endpoint Dupe verworfen (gleicher Text <%.1fs): %r",
+                            _DUPE_WINDOW_SEC, text[:60])
                return
            self._last_endpoint_norm = _norm_txt
            self._last_endpoint_at = _now_t
@@ -3420,11 +3482,36 @@ class ARIABridge:
            # App-Version die projectId noch nicht mitschickt: leer = Hauptchat).
            stream_req_id = payload.get("requestId", "") or ""
            focused_pid = self._stt_stream_projects.pop(stream_req_id, "")
+            meta = self._stt_stream_meta.pop(stream_req_id, {})
+
+            # Zwischenruf per Sprache: in den LAUFENDEN Turn schieben, nicht als
+            # neue Anfrage anstellen. Gleicher Weg wie der 📣-Knopf mit Text.
+            if meta.get("interject"):
+                logger.info("[rvs] stt_endpoint ist ein Zwischenruf → project=%s: %s",
+                            focused_pid or "(main)", text[:80])
+                asyncio.create_task(
+                    self._interject_proxy_for_project(focused_pid, text))
+                # Den erkannten Text trotzdem broadcasten, damit die
+                # Sprach-Bubble in der App ihren Text bekommt statt ewig auf
+                # "wird verarbeitet..." zu stehen.
+                asyncio.create_task(self._send_to_rvs({
+                    "type": "chat",
+                    "payload": {
+                        "text": text,
+                        "sender": "stt",
+                        "audioRequestId": audio_request_id,
+                        "projectId": focused_pid,
+                        "interject": True,
+                    },
+                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                }))
+                return

            asyncio.create_task(self._process_endpoint_text(
                text, interrupted, audio_request_id, location,
                client_msg_id=client_msg_id,
-                focused_project_id=focused_pid))
+                focused_project_id=focused_pid,
+                attachment_client_msg_id=str(meta.get("cmid") or "")))
            return

        elif msg_type == "oauth_callback":
@@ -3543,6 +3630,10 @@ class ARIABridge:
        elif msg_type == "sat_hello":
            sid = (payload.get("id") or "").strip()
            if sid:
+                # sat_hello kommt alle ~25s erneut. Nur Neuanmeldungen und echte
+                # Aenderungen loggen — sonst ersaeuft das Bridge-Log in
+                # "Satellit online", und die interessanten Zeilen sind weg.
+                prev = self._satellites.get(sid)
                self._satellites[sid] = {
                    "id": sid,
                    "location": payload.get("location") or sid,
@@ -3550,9 +3641,12 @@ class ARIABridge:
                    "control": bool(payload.get("control")),
                    "last_seen": time.time(),
                }
-                logger.info("[sat] Satellit online: %s (%s) caps=%s control=%s",
-                            sid, self._satellites[sid]["location"],
-                            self._satellites[sid]["caps"], self._satellites[sid]["control"])
+                cur = self._satellites[sid]
+                if prev is None or any(prev.get(k) != cur.get(k)
+                                       for k in ("location", "caps", "control")):
+                    logger.info("[sat] Satellit %s: %s (%s) caps=%s control=%s",
+                                "online" if prev is None else "aktualisiert",
+                                sid, cur["location"], cur["caps"], cur["control"])
            return

        elif msg_type == "host_hello":
@@ -3589,6 +3683,17 @@ class ARIABridge:
                self._hosts[hid]["last_seen"] = time.time()
            return

+        elif msg_type == "agent_history_query":
+            # Diagnostic fragt die gespeicherte Historie eines Agenten ab.
+            hid = (payload.get("host") or "").strip()
+            events = self._agent_history_read(hid) if hid else []
+            await self._send_to_rvs({
+                "type": "agent_history_list",
+                "payload": {"host": hid, "events": events},
+                "timestamp": int(time.time() * 1000),
+            })
+            return
+
        elif msg_type == "worker_hello":
            iid = (payload.get("instanceId") or "").strip()
            if iid:
@@ -3607,9 +3712,16 @@ class ARIABridge:
                    "busy": bool(prev.get("busy", False)),
                    "last_seen": time.time(),
                }
-                logger.info("[worker] online: %s (service=%s node=%s gpus=%s model=%s)",
-                            iid, self._workers[iid]["service"], self._workers[iid]["node"],
-                            self._workers[iid]["gpus"] or "?", self._workers[iid]["model"] or "?")
+                # Wie bei sat_hello: worker_hello wiederholt sich im Takt von
+                # ~30s. Nur neue Boxen und echte Aenderungen (anderes Modell,
+                # andere GPUs) ins Log — der Rest ist Rauschen.
+                cur = self._workers[iid]
+                if not prev or any(prev.get(k) != cur.get(k)
+                                   for k in ("service", "node", "gpus", "model", "models")):
+                    logger.info("[worker] %s: %s (service=%s node=%s gpus=%s model=%s)",
+                                "online" if not prev else "aktualisiert",
+                                iid, cur["service"], cur["node"],
+                                cur["gpus"] or "?", cur["model"] or "?")
            return

        elif msg_type == "stt_lease_request":
@@ -3766,8 +3878,12 @@ class ARIABridge:
        r")\s*[.!?]?\s*$",
        re.IGNORECASE,
    )
+    # Trenner bewusst nur ':' und '-' — NICHT das Komma. Whisper setzt gern
+    # Kommata, und damit matchten normale Saetze wie "In Ordnung, mach mal ..."
+    # als Projekt-Prefix: die Nachricht wanderte still in ein Projekt und war im
+    # Hauptchat unsichtbar ("wird gar nicht verarbeitet").
    _VOICE_META_PROJECT_PREFIX = re.compile(
-        r"^\s*(?:aria[,.]?\s+)?(?:f(?:ü|ue)r|ins?)\s+([\w\-äöüßÄÖÜ]{2,40})[:\-,]\s*(.+?)\s*$",
+        r"^\s*(?:aria[,.]?\s+)?(?:f(?:ü|ue)r|ins?)\s+([\w\-äöüßÄÖÜ]{2,40})\s*[:\-]\s*(.+?)\s*$",
        re.IGNORECASE | re.DOTALL,
    )

@@ -3822,7 +3938,10 @@ class ARIABridge:
                    s = SequenceMatcher(None, q, pname).ratio()
                    if s > best_score:
                        best, best_score = p, s
-                if best and best_score >= 0.6:
+                # Schwelle bewusst hoch (0.82): bei 0.6 reichte schon eine vage
+                # Aehnlichkeit, und die Nachricht verschwand still in einem
+                # fremden Projekt. Lieber im Hauptchat lassen als falsch routen.
+                if best and best_score >= 0.82:
                    pid = best["id"]
                    self._voice_sticky_project_id = pid
                    self._voice_sticky_expires_at = now + self._VOICE_STICKY_TIMEOUT_SEC
@@ -3834,8 +3953,10 @@ class ARIABridge:
            # Kein Match → als normale Nachricht weiter (Sticky wenn aktiv)
        # 3) Kein Meta / Prefix → Sticky oder Default
        if self._voice_sticky_project_id and now < self._voice_sticky_expires_at:
-            # Sticky refreshen
-            self._voice_sticky_expires_at = now + self._VOICE_STICKY_TIMEOUT_SEC
+            # Sticky NICHT verlaengern: frueher hat jede Folgenachricht die Frist
+            # erneuert — ein einziger Fehl-Match und danach landete dauerhaft
+            # alles in diesem Projekt. Jetzt laeuft er nach der urspruenglichen
+            # Zeit aus und der Hauptchat uebernimmt wieder.
            return (True, stripped, self._voice_sticky_project_id, "sticky")
        # Sticky abgelaufen — zurücksetzen
        self._voice_sticky_project_id = ""
@@ -3850,7 +3971,8 @@ class ARIABridge:
                                      audio_request_id: str = "",
                                      location: Optional[dict] = None,
                                      client_msg_id: Optional[str] = None,
-                                      focused_project_id: str = "") -> None:
+                                      focused_project_id: str = "",
+                                      attachment_client_msg_id: str = "") -> None:
        """Phase-2 Brain-Shortcut: Streaming-Whisper hat den finalen Text
        schon ermittelt — wir uebernehmen den Pfad ab broadcast-STT + brain.

@@ -3919,6 +4041,18 @@ class ARIABridge:
        except Exception as e:
            logger.warning("[rvs] STT-Text (endpoint) konnte nicht broadcastet werden: %s", e)

+        # Sprachnachricht als Beschreibung zu Anhaengen: die liegen schon
+        # gepuffert (awaitVoice) und warten genau auf diesen Text — beides geht
+        # als EIN Turn ans Brain, sonst sieht ARIA ein Bild ohne Auftrag und
+        # danach einen Satz ohne Bild.
+        if attachment_client_msg_id and await self._flush_pending_files_with_text(
+                cleaned, project_id=project_id,
+                client_msg_id=attachment_client_msg_id,
+                require_match=True):
+            logger.info("[rvs] Sprachnachricht mit ihren Anhaengen gemerged (cmid=%s)",
+                        attachment_client_msg_id[:12])
+            return
+
        core_text = self._build_core_text(cleaned, interrupted, location)
        await self.send_to_core(core_text,
                                source="app-voice-stream" + (" [barge-in]" if interrupted else ""),
@@ -4484,11 +4618,15 @@ class ARIABridge:
                    trigger_name = data.get("trigger_name", "")
                    ttype = data.get("type", "trigger")
                    events = data.get("events") or []
-                    logger.info("[bridge ← brain] Trigger '%s' (%s) gefeuert, reply=%d chars, events=%d",
-                                trigger_name, ttype, len(reply), len(events))
+                    trigger_pid = str(data.get("projectId") or "")
+                    logger.info("[bridge ← brain] Trigger '%s' (%s) gefeuert, reply=%d chars, "
+                                "events=%d, project=%s",
+                                trigger_name, ttype, len(reply), len(events),
+                                trigger_pid or "(main)")
                    # Async-spawn — HTTP-Antwort nicht durch RVS-Broadcast blockieren
                    asyncio.create_task(
-                        self._handle_trigger_fired(reply, trigger_name, ttype, events)
+                        self._handle_trigger_fired(reply, trigger_name, ttype, events,
+                                                   trigger_pid)
                    )
                    await _send_response(writer, 200, {"ok": True})
                elif method == "POST" and path == "/internal/agent-activity":
@@ -4580,6 +4718,17 @@ class ARIABridge:
                        timeout=float(data.get("timeout") or 60.0),
                    )
                    await _send_response(writer, 200, result)
+                elif method == "POST" and path == "/internal/agent-history":
+                    # Brain: ein Historie-Eintrag pro Host-Aktion (fuer die Diagnostic).
+                    try:
+                        data = json.loads(body.decode("utf-8", "ignore"))
+                    except Exception as exc:
+                        await _send_response(writer, 400, {"error": f"bad json: {exc}"})
+                        return
+                    self._agent_history_append(data)
+                    await self._send_to_rvs({"type": "agent_history", "payload": data,
+                                             "timestamp": int(time.time() * 1000)})
+                    await _send_response(writer, 200, {"ok": True})
                elif method == "POST" and path == "/internal/satellite":
                    # Brain-Tool: Discovery oder Command an einen Satelliten.
                    # body: {op:'discover'|'command', satellite, device?, action?, params?}
@@ -4929,6 +5078,51 @@ class ARIABridge:
            "online": (now - h.get("last_seen", 0)) < 300,
        } for h in self._hosts.values()]

+    _AGENT_HISTORY_DIR = "/shared/config/agent_history"
+    _AGENT_HISTORY_MAX = 200
+
+    def _agent_history_path(self, host: str) -> str:
+        safe = re.sub(r"[^a-zA-Z0-9_-]+", "-", host).strip("-") or "host"
+        return os.path.join(self._AGENT_HISTORY_DIR, f"{safe}.jsonl")
+
+    def _agent_history_append(self, entry: dict) -> None:
+        """Haengt einen Historie-Eintrag an <hostId>.jsonl (Ringpuffer)."""
+        host = (entry.get("host") or "").strip()
+        if not host:
+            return
+        try:
+            os.makedirs(self._AGENT_HISTORY_DIR, exist_ok=True)
+            path = self._agent_history_path(host)
+            lines = []
+            if os.path.exists(path):
+                with open(path, "r", encoding="utf-8") as f:
+                    lines = f.read().splitlines()
+            lines.append(json.dumps(entry, ensure_ascii=False))
+            lines = lines[-self._AGENT_HISTORY_MAX:]
+            with open(path, "w", encoding="utf-8") as f:
+                f.write("\n".join(lines) + "\n")
+        except Exception as exc:
+            logger.warning("[history] append fehlgeschlagen: %s", exc)
+
+    def _agent_history_read(self, host: str, limit: int = 200) -> list:
+        try:
+            path = self._agent_history_path(host)
+            if not os.path.exists(path):
+                return []
+            out = []
+            with open(path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        out.append(json.loads(line))
+                    except Exception:
+                        pass
+            return out[-limit:]
+        except Exception:
+            return []
+
    async def _host_request(self, host: str = "", action: str = "",
                            params: Optional[dict] = None,
                            timeout: float = 60.0) -> dict:
@@ -5043,7 +5237,8 @@ class ARIABridge:
        return {"ok": True, "role": role, "content_preview": content[:80]}

    async def _handle_trigger_fired(self, reply: str, trigger_name: str,
-                                    ttype: str, events: list) -> None:
+                                    ttype: str, events: list,
+                                    project_id: str = "") -> None:
        """Spiegelt eine Brain-Trigger-Antwort wie eine normale ARIA-Antwort.

        Side-Channel-Events zuerst (trigger_created, location_tracking, ...),
@@ -5095,7 +5290,12 @@ class ARIABridge:
        try:
            await self._process_core_response(
                reply,
-                {"metadata": {"trigger_name": trigger_name, "trigger_type": ttype}},
+                {"metadata": {"trigger_name": trigger_name, "trigger_type": ttype},
+                 # Ohne projectId landete jede Trigger-Antwort im Hauptchat —
+                 # auch wenn der Timer in einem Projekt-Thread gestellt wurde.
+                 # Stefan sah dann im Projekt nichts und hielt den Timer fuer
+                 # nicht gefeuert.
+                 "projectId": project_id or ""},
            )
        except Exception:
            logger.exception("[trigger-fire] _process_core_response fehlgeschlagen")
@@ -268,6 +268,9 @@ const RUNTIME_CONFIG_FIELDS = [
  "RVS_HOST", "RVS_PORT", "RVS_TLS", "RVS_TOKEN",
  "ARIA_AUTH_TOKEN", "WHISPER_MODEL", "WHISPER_LANGUAGE",
  "brainModel",
+  // Groessen-Limit fuer Memory-Anhaenge in MB. Das Brain liest es pro Upload
+  // aus derselben Datei — Aenderung greift ohne Neustart.
+  "memoryAttachmentMaxMb",
 ];
 function readRuntimeConfig() {
  const envDefaults = {
@@ -328,6 +331,87 @@ function writeLocalLlmConfig(patch) {
  return cur;
 }

+// ── Jellyfin-Server (Medien-Integration) ─────────────────────
+// /shared/config/jellyfin.json — mehrere Server moeglich (eigener + z.B. vom
+// Kumpel). ARIAs Brain liest dieselbe Datei und spricht die HTTP-API direkt an:
+// Film suchen -> Sitzung des Abspielgeraets finden -> abspielen. Das ist
+// deutlich zuverlaessiger, als sich durch die Fire-TV-Oberflaeche zu klicken.
+const JELLYFIN_CONFIG_FILE = "/shared/config/jellyfin.json";
+function readJellyfinConfig() {
+  try {
+    const p = JSON.parse(fs.readFileSync(JELLYFIN_CONFIG_FILE, "utf-8"));
+    const servers = Array.isArray(p.servers) ? p.servers : [];
+    return {
+      servers: servers.map(s => ({
+        id: String(s.id || ""),
+        name: String(s.name || ""),
+        url: String(s.url || ""),
+        apiKey: String(s.apiKey || ""),
+        isDefault: !!s.isDefault,
+      })).filter(s => s.id && s.url),
+    };
+  } catch {
+    return { servers: [] };
+  }
+}
+function writeJellyfinConfig(cfg) {
+  const servers = (Array.isArray(cfg.servers) ? cfg.servers : [])
+    .map(s => ({
+      id: String(s.id || "").trim() || Math.random().toString(36).slice(2, 10),
+      name: String(s.name || "").trim(),
+      url: String(s.url || "").trim().replace(/\/+$/, ""),   // ohne Slash am Ende
+      apiKey: String(s.apiKey || "").trim(),
+      isDefault: !!s.isDefault,
+    }))
+    .filter(s => s.url);
+  // Genau einen Standard-Server markieren (der erste, falls keiner gesetzt ist).
+  if (servers.length && !servers.some(s => s.isDefault)) servers[0].isDefault = true;
+  let seen = false;
+  for (const s of servers) {
+    if (s.isDefault && seen) s.isDefault = false;
+    if (s.isDefault) seen = true;
+  }
+  fs.mkdirSync("/shared/config", { recursive: true });
+  const tmp = JELLYFIN_CONFIG_FILE + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify({ servers }, null, 2), { mode: 0o600 });
+  fs.renameSync(tmp, JELLYFIN_CONFIG_FILE);
+  try { fs.chmodSync(JELLYFIN_CONFIG_FILE, 0o600); } catch (_) {}  // API-Keys!
+  return { servers };
+}
+
+/** Erreichbarkeit + Version eines Jellyfin-Servers pruefen. */
+function testJellyfin(url, apiKey) {
+  return new Promise((resolve) => {
+    let u;
+    try { u = new URL(url.replace(/\/+$/, "") + "/System/Info"); }
+    catch (e) { return resolve({ ok: false, error: "Ungültige URL" }); }
+    const mod = u.protocol === "https:" ? require("https") : require("http");
+    const req = mod.request(u, {
+      method: "GET",
+      timeout: 8000,
+      headers: { "Authorization": `MediaBrowser Token="${apiKey}"` },
+    }, (res) => {
+      let body = "";
+      res.on("data", c => { body += c; if (body.length > 65536) req.destroy(); });
+      res.on("end", () => {
+        if (res.statusCode === 401 || res.statusCode === 403) {
+          return resolve({ ok: false, error: "API-Key abgelehnt (401/403)" });
+        }
+        if (res.statusCode !== 200) {
+          return resolve({ ok: false, error: `HTTP ${res.statusCode}` });
+        }
+        try {
+          const j = JSON.parse(body);
+          resolve({ ok: true, name: j.ServerName || "", version: j.Version || "" });
+        } catch (e) { resolve({ ok: false, error: "Antwort nicht lesbar" }); }
+      });
+    });
+    req.on("timeout", () => { req.destroy(); resolve({ ok: false, error: "Zeitüberschreitung" }); });
+    req.on("error", (e) => resolve({ ok: false, error: e.message }));
+    req.end();
+  });
+}
+
 // ── Lokale Modell-Liste (Diagnostic-Dropdown) ────────────────
 // /shared/config/local_models.json — kuratierte Liste; muss zu den KEYS in
 // xtts/llama-swap/config.yaml passen. Wird bei Bedarf mit Defaults seeded.
@@ -557,7 +641,7 @@ function hostList() {
  const now = Date.now();
  return Array.from(hosts.values()).map(h => ({
    hostId: h.hostId, name: h.name, os: h.os, caps: h.caps, control: h.control,
-    online: (now - (h.last_seen || 0)) < 300000,
+    ip: h.ip || "", online: (now - (h.last_seen || 0)) < 300000,
  }));
 }

@@ -575,6 +659,8 @@ function workerList() {
  return Array.from(workers.values()).map(w => ({
    instanceId: w.instanceId, service: w.service, node: w.node,
    gpus: w.gpus, model: w.model, models: w.models || [], busy: !!w.busy,
+    openaiPort: w.openaiPort || "", openaiBind: w.openaiBind || "",
+    openaiKeySet: !!w.openaiKeySet, openaiEnvLocked: !!w.openaiEnvLocked,
    online: (now - (w.last_seen || 0)) < WORKER_OFFLINE_MS,
  }));
 }
@@ -1087,7 +1173,8 @@ function connectRVS(forcePlain) {
          const wasKnown = hosts.has(p.hostId);
          hosts.set(p.hostId, {
            hostId: p.hostId, name: p.name || p.hostId, os: p.os || "",
-            caps: p.caps || [], control: !!p.control, last_seen: Date.now(),
+            caps: p.caps || [], control: !!p.control, ip: p.ip || "",
+            last_seen: Date.now(),
          });
          if (!wasKnown) broadcastHosts();
          else hosts.get(p.hostId).last_seen = Date.now();
@@ -1095,6 +1182,18 @@ function connectRVS(forcePlain) {
      } else if (msg.type === "host_ping") {
        const p = msg.payload || {};
        if (p.hostId && hosts.has(p.hostId)) hosts.get(p.hostId).last_seen = Date.now();
+      } else if (msg.type === "rooms_info") {
+        // Antwort des RVS auf rooms_query → an den Browser (Raum-Diagnose).
+        broadcast({ type: "rooms_info", payload: msg.payload || {} });
+      } else if (msg.type === "llm_openai_config_result") {
+        broadcast({ type: "llm_openai_config_result", payload: msg.payload || {} });
+      } else if (msg.type === "sat_result") {
+        // Ergebnis einer Satelliten-Aktion → an den Browser (z.B. APK-Rollout).
+        broadcast({ type: "sat_result", payload: msg.payload || {} });
+      } else if (msg.type === "agent_history" || msg.type === "agent_history_list") {
+        // Live-Event (agent_history) bzw. Abfrage-Antwort (agent_history_list)
+        // der Bridge → an den Browser (Agent-Historie).
+        broadcast({ type: msg.type, payload: msg.payload || {} });
      } else if (msg.type === "sat_devices") {
        // Antwort eines Satelliten auf sat_discover → Geraeteliste an Browser.
        const p = msg.payload || {};
@@ -1117,6 +1216,11 @@ function connectRVS(forcePlain) {
            instanceId: p.instanceId, service: p.service || "",
            node: p.node || "", gpus: p.gpus || "", model: p.model || "",
            models: Array.isArray(p.models) ? p.models : (p.model ? [p.model] : []),
+            // OpenAI-Endpunkt (nur llm-Worker): Port/Bind kommen aus der .env der
+            // Box, der Key wird NIE uebertragen — nur ob einer gesetzt ist und ob
+            // die .env ihn vorgibt (dann ist das Feld hier schreibgeschuetzt).
+            openaiPort: p.openaiPort || "", openaiBind: p.openaiBind || "",
+            openaiKeySet: !!p.openaiKeySet, openaiEnvLocked: !!p.openaiEnvLocked,
            busy: !!prev.busy, last_seen: Date.now(),
          });
          broadcastWorkers();
@@ -1941,6 +2045,19 @@ const server = http.createServer((req, res) => {
      "Expires": "0",
    });
    res.end(fs.readFileSync(htmlPath, "utf-8"));
+  } else if (req.url.startsWith("/uploads/")) {
+    // Screenshots aus der Agent-Historie (nur /shared/uploads, kein Traversal).
+    const base = path.basename(decodeURIComponent(req.url.slice("/uploads/".length)));
+    const file = path.join("/shared/uploads", base);
+    if (!file.startsWith("/shared/uploads/") || !fs.existsSync(file)) {
+      res.writeHead(404); res.end("not found"); return;
+    }
+    const ext = path.extname(file).toLowerCase();
+    const ct = ext === ".png" ? "image/png"
+      : (ext === ".jpg" || ext === ".jpeg") ? "image/jpeg"
+      : ext === ".webp" ? "image/webp" : "application/octet-stream";
+    res.writeHead(200, { "Content-Type": ct, "Cache-Control": "max-age=86400" });
+    res.end(fs.readFileSync(file));
  } else if (req.url === "/api/state") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ state, logs: logs.slice(-100) }));
@@ -2002,6 +2119,39 @@ const server = http.createServer((req, res) => {
      }
    });
    return;
+  } else if (req.url === "/api/jellyfin-config" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(readJellyfinConfig()));
+  } else if (req.url === "/api/jellyfin-config" && req.method === "POST") {
+    let body = "";
+    req.on("data", chunk => { body += chunk; if (body.length > 65536) req.destroy(); });
+    req.on("end", () => {
+      try {
+        const cfg = writeJellyfinConfig(JSON.parse(body));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, config: cfg }));
+        log("info", "server", `Jellyfin-Config: ${cfg.servers.length} Server gespeichert`);
+      } catch (err) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: err.message }));
+      }
+    });
+    return;
+  } else if (req.url === "/api/jellyfin-test" && req.method === "POST") {
+    let body = "";
+    req.on("data", chunk => { body += chunk; if (body.length > 8192) req.destroy(); });
+    req.on("end", async () => {
+      try {
+        const { url, apiKey } = JSON.parse(body);
+        const r = await testJellyfin(String(url || ""), String(apiKey || ""));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(r));
+      } catch (err) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: err.message }));
+      }
+    });
+    return;
  } else if (req.url === "/api/onboarding") {
    // RVS-Credentials fuer QR-Code App-Onboarding
    res.writeHead(200, { "Content-Type": "application/json" });
@@ -2054,22 +2204,27 @@ const server = http.createServer((req, res) => {
      res.end(JSON.stringify({ ok: false, error: err.message }));
    }
    return;
-  } else if (req.url === "/api/models-list" && req.method === "GET") {
+  } else if (req.url.startsWith("/api/models-list") && req.method === "GET") {
    // Kuratierte Model-Liste vom Proxy (/v1/models) — Tier-Auswahl fuers
    // Sprachmodell-Dropdown. ARIA laeuft ueber das Max-Abo/CLI, waehlbar ist
    // der Tier (opus/sonnet/haiku), keine feste Version.
    (async () => {
      try {
-        const r = await fetch(`${PROXY_URL}/v1/models`);
+        // ?refresh=1 weiterreichen: der Proxy umgeht damit seinen Katalog-Cache
+        // und holt die Liste frisch von Anthropic („↻ Aktualisieren").
+        const refresh = /[?&]refresh=1\b/.test(req.url) ? "?refresh=1" : "";
+        const r = await fetch(`${PROXY_URL}/v1/models${refresh}`);
        const d = await r.json();
        const models = (d.data || []).map(m => ({
          id: m.id,
          tier: m.tier || m.id,
          displayName: m.display_name || m.id,
          description: m.description || "",
+          // section: tier | main | overflow — die UI gruppiert danach.
+          section: m.section || "tier",
        }));
        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: true, models }));
+        res.end(JSON.stringify({ ok: true, models, catalogOk: d.catalog_ok !== false }));
      } catch (err) {
        res.writeHead(502, { "Content-Type": "application/json" });
        res.end(JSON.stringify({ ok: false, error: String(err && err.message || err) }));
@@ -2789,6 +2944,59 @@ wss.on("connection", (ws) => {
      } else if (msg.action === "host_list") {
        // Browser will die aktuelle Host-Agenten-Liste.
        ws.send(JSON.stringify({ type: "host_update", hosts: hostList() }));
+      } else if (msg.action === "host_forget") {
+        // Alten/umbenannten Agenten aus der Liste werfen. Meldet er sich wieder
+        // (host_hello), taucht er automatisch neu auf — das ist also gefahrlos.
+        const id = String(msg.hostId || "");
+        if (id && hosts.delete(id)) {
+          log("info", "host", `Agent '${id}' aus der Liste entfernt`);
+          broadcastHosts();
+        }
+      } else if (msg.action === "rooms_query") {
+        // Browser will die RVS-Raum-Diagnose — via persistente rvsWs anfragen,
+        // die Antwort (rooms_info) kommt auf derselben Verbindung zurueck.
+        sendToRVS_raw({ type: "rooms_query", payload: {}, timestamp: Date.now() });
+      } else if (msg.action === "sat_command") {
+        // Browser loest eine Satelliten-Aktion aus (z.B. APK auf Fire TV ausrollen).
+        // Die Antwort (sat_result) kommt ueber die rvsWs zurueck.
+        const params = msg.params && typeof msg.params === "object" ? msg.params : {};
+        // Fern-Einrichtung: der RVS-Zugang wird SERVERSEITIG ergaenzt — so muss
+        // niemand Host/Token im Browser eintippen (und das Token steht nicht im
+        // Browser-Formular). Gilt fuer adb.provision und adb.install mit Setup.
+        if (params.provision === true) {
+          delete params.provision;
+          params.rvs_host = RVS_HOST;
+          params.rvs_port = Number(RVS_PORT) || 443;
+          params.rvs_tls = RVS_TLS === "true";
+          params.rvs_token = RVS_TOKEN;
+        }
+        sendToRVS_raw({
+          type: "sat_command",
+          payload: {
+            satellite: String(msg.satellite || ""),
+            device: String(msg.device || ""),
+            action: String(msg.cmd || ""),
+            params,
+            requestId: String(msg.requestId || ""),
+          },
+          timestamp: Date.now(),
+        });
+      } else if (msg.action === "llm_openai_config") {
+        // Browser setzt den API-Key des OpenAI-Endpunkts einer Box.
+        sendToRVS_raw({
+          type: "llm_openai_config",
+          payload: {
+            instanceId: String(msg.instanceId || ""),
+            apiKey: String(msg.apiKey || ""),
+            requestId: String(msg.requestId || ""),
+          },
+          timestamp: Date.now(),
+        });
+      } else if (msg.action === "agent_history_query") {
+        // Browser will die gespeicherte Historie eines Agenten — die Bridge
+        // antwortet mit agent_history_list (auf derselben rvsWs).
+        sendToRVS_raw({ type: "agent_history_query",
+                       payload: { host: String(msg.host || "") }, timestamp: Date.now() });
      } else if (msg.action === "worker_list") {
        // Browser will die aktuelle Compute-Flotte.
        ws.send(JSON.stringify({ type: "worker_update", workers: workerList() }));
@@ -3007,6 +3215,18 @@ wss.on("connection", (ws) => {
        handleGetModel(ws);
      } else if (msg.action === "set_model") {
        handleSetModel(ws, msg.model);
+      } else if (msg.action === "test_model") {
+        handleTestModel(ws, msg.model);
+      } else if (msg.action === "check_proxy_patches") {
+        handleCheckProxyPatches(ws);
+      } else if (msg.action === "get_privacy_flags") {
+        handleGetPrivacyFlags(ws);
+      } else if (msg.action === "set_privacy_flags") {
+        handleSetPrivacyFlags(ws, msg.flags);
+      } else if (msg.action === "get_attachment_limit") {
+        handleGetAttachmentLimit(ws);
+      } else if (msg.action === "set_attachment_limit") {
+        handleSetAttachmentLimit(ws, msg.maxMb);
      } else if (msg.action === "voice_id_status") {
        // An whisper-bridge weiterleiten + Antwort an Browser zurueck
        const reqId = `vid_${Date.now().toString(36)}`;
@@ -3429,6 +3649,284 @@ function handleSetModel(clientWs, model) {
  return;
 }

+// ── Laufen im Proxy die aktuellen Patches? ──────────────────────────
+//
+// Der Proxy kopiert proxy-patches/*.js beim START ueber den npm-Code (siehe
+// docker-compose.yml, command:). Wer nach einem git pull nur `restart` macht —
+// oder neu startet, BEVOR der Pull durch ist — laeuft still mit der alten
+// Fassung weiter. Das faellt sonst nirgends auf: der Container ist "Up", die
+// Oberflaeche sieht normal aus, nur wirkt die Aenderung nicht.
+//
+// Darum: Zeitstempel der Quelldateien gegen die eingespielten vergleichen.
+const PROXY_PATCH_MAP = [
+  ["routes.js", "server/routes.js"],
+  ["manager.js", "subprocess/manager.js"],
+  ["openai-to-cli.js", "adapter/openai-to-cli.js"],
+  ["cli-to-openai.js", "adapter/cli-to-openai.js"],
+];
+
+async function handleCheckProxyPatches(clientWs) {
+  try {
+    const dist = "/usr/local/lib/node_modules/claude-max-api-proxy/dist";
+    const pairs = PROXY_PATCH_MAP
+      .map(([src, dst]) => `/proxy-patches/${src} ${dist}/${dst}`).join(" ");
+    // %Y = mtime als Unix-Zeit, %n = Dateiname
+    const out = await dockerExec("aria-proxy", `stat -c '%Y %n' ${pairs} 2>/dev/null || true`);
+    const mtime = {};
+    for (const line of String(out || "").split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(.+)$/);
+      if (m) mtime[m[2]] = parseInt(m[1], 10);
+    }
+    const stale = [];
+    for (const [src, dst] of PROXY_PATCH_MAP) {
+      const a = mtime[`/proxy-patches/${src}`];
+      const b = mtime[`${dist}/${dst}`];
+      if (a == null || b == null) continue;
+      // Toleranz 5s: Quelle und Kopie entstehen beim Start kurz nacheinander.
+      if (a > b + 5) stale.push({ file: src, srcAt: a * 1000, activeAt: b * 1000 });
+    }
+    clientWs.send(JSON.stringify({ type: "proxy_patch_state", stale }));
+  } catch (err) {
+    // Kein Alarm bei einem Pruef-Fehler — sonst steht da eine Warnung, die
+    // gar nichts ueber die Patches aussagt.
+    clientWs.send(JSON.stringify({ type: "proxy_patch_state", stale: [], error: String((err && err.message) || err) }));
+  }
+}
+
+// ── Einstellungen: Datenschutz-Schalter von Claude Code ─────────────
+//
+// Drei Kanaele, ueber die Claude Code von sich aus Daten an Anthropic bzw. an
+// einen Fehler-Dienst schickt. Sie liegen als Umgebungsvariablen vor und lassen
+// sich in ~/.claude/settings.json unter "env" setzen — die Datei ist in den
+// Proxy-Container gemountet, also koennen wir sie von hier aus pflegen, ohne
+// die docker-compose.yml anzufassen.
+//
+// WICHTIG: gesetzt wird in settings.json. Steht dieselbe Variable ZUSAETZLICH
+// als echte Container-Umgebungsvariable (docker-compose), gewinnt die — darum
+// prueft "Pruefen" beides und sagt, was tatsaechlich im Prozess ankommt.
+const PRIVACY_FLAGS = [
+  { key: "DISABLE_ERROR_REPORTING",
+    label: "Fehlerberichte",
+    info: "Stacktraces an einen Fehler-Dienst. Bei Pro/Max ab CLI 2.1.198 standardmäßig AN." },
+  { key: "DISABLE_TELEMETRY",
+    label: "Nutzungs-Metriken",
+    info: "Latenz/Zuverlässigkeit. Enthält laut Anthropic nie Code, Prompts oder Pfade." },
+  { key: "DISABLE_FEEDBACK_COMMAND",
+    label: "/feedback-Versand",
+    info: "Sendet sonst auf Zuruf die ganze Unterhaltung inkl. Code — 5 Jahre Aufbewahrung." },
+];
+const CLAUDE_SETTINGS_PATH = "/root/.claude/settings.json";
+
+function _shq(s) { return "'" + String(s).replace(/'/g, "'\\''") + "'"; }
+
+async function handleGetPrivacyFlags(clientWs) {
+  try {
+    // 1) Was kommt im PROZESS wirklich an? Das ist die Wahrheit.
+    const envOut = await dockerExec("aria-proxy",
+      "env | grep -E '^(DISABLE_ERROR_REPORTING|DISABLE_TELEMETRY|DISABLE_FEEDBACK_COMMAND|CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC)=' || true");
+    const liveEnv = {};
+    for (const line of String(envOut || "").split("\n")) {
+      const i = line.indexOf("=");
+      if (i > 0) liveEnv[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+    }
+    // 2) Was steht in settings.json?
+    const settingsRaw = await dockerExec("aria-proxy",
+      `cat ${CLAUDE_SETTINGS_PATH} 2>/dev/null || echo '{}'`);
+    let settingsEnv = {};
+    try { settingsEnv = (JSON.parse(settingsRaw || "{}").env) || {}; } catch (_) {}
+
+    const isOn = (v) => v === "1" || String(v).toLowerCase() === "true";
+    const flags = PRIVACY_FLAGS.map(f => {
+      const fromEnv = liveEnv[f.key];
+      const fromSettings = settingsEnv[f.key];
+      // Container-Env gewinnt gegen settings.json.
+      const effective = fromEnv !== undefined ? isOn(fromEnv) : isOn(fromSettings);
+      return {
+        key: f.key, label: f.label, info: f.info,
+        disabled: effective,
+        source: fromEnv !== undefined ? "container" : (fromSettings !== undefined ? "settings" : "none"),
+      };
+    });
+    const bulk = isOn(liveEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC);
+    clientWs.send(JSON.stringify({ type: "privacy_flags", flags, bulkDisabled: bulk }));
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "privacy_flags", error: String((err && err.message) || err) }));
+  }
+}
+
+async function handleSetPrivacyFlags(clientWs, wanted) {
+  try {
+    const keys = PRIVACY_FLAGS.map(f => f.key);
+    const raw = await dockerExec("aria-proxy",
+      `cat ${CLAUDE_SETTINGS_PATH} 2>/dev/null || echo '{}'`);
+    let cfg = {};
+    try { cfg = JSON.parse(raw || "{}"); } catch (_) { cfg = {}; }
+    if (!cfg.env || typeof cfg.env !== "object") cfg.env = {};
+    for (const k of keys) {
+      if (wanted && wanted[k]) cfg.env[k] = "1";
+      else delete cfg.env[k];
+    }
+    if (Object.keys(cfg.env).length === 0) delete cfg.env;
+
+    // Atomar schreiben (temp + mv), damit eine laufende CLI nie eine halbe
+    // Datei liest.
+    const json = JSON.stringify(cfg, null, 2);
+    await dockerExec("aria-proxy",
+      `printf '%s' ${_shq(json)} > ${CLAUDE_SETTINGS_PATH}.tmp && mv ${CLAUDE_SETTINGS_PATH}.tmp ${CLAUDE_SETTINGS_PATH}`);
+    log("info", "server", `Datenschutz-Schalter gesetzt: ${JSON.stringify(wanted || {})}`);
+    clientWs.send(JSON.stringify({
+      type: "privacy_flags_saved",
+      info: "Gespeichert. Gilt für JEDE neue Anfrage — ein laufender Turn nutzt noch die alte Einstellung.",
+    }));
+    await handleGetPrivacyFlags(clientWs);
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "privacy_flags_saved", error: String((err && err.message) || err) }));
+  }
+}
+
+// ── Einstellungen: Model-Test ───────────────────────────────────────
+//
+// Schickt eine winzige ECHTE Anfrage durch den kompletten Weg
+// (Diagnostic -> Proxy -> extractModel -> claude CLI -> Anthropic) und meldet,
+// welches Modell tatsaechlich geantwortet hat.
+//
+// Wichtig: wir fragen NICHT das Modell selbst ("welche Version bist du?") —
+// darauf kann man sich nicht verlassen, Modelle kennen ihren eigenen
+// Versionsstring oft nicht und raten. Die Wahrheit kommt aus modelUsage der
+// CLI (Feld canonicalModel): das ist der Name, unter dem der Call wirklich
+// lief. Bei einem Alias sieht man damit die aufgeloeste Version
+// ("opus" -> "claude-opus-5-5"), bei einem ungueltigen Namen den Fehler.
+function handleTestModel(clientWs, model) {
+    const m = String(model || "").trim();
+    if (!m) {
+        clientWs.send(JSON.stringify({
+            type: "model_test_result", error: "Kein Modell angegeben" }));
+        return;
+    }
+    const started = Date.now();
+    (async () => {
+        try {
+            const r = await fetch(`${PROXY_URL}/v1/chat/completions`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    model: m,
+                    // Kurz halten: der Test soll Sekunden kosten, nicht Minuten.
+                    messages: [{ role: "user", content: "Antworte nur mit: OK" }],
+                    max_tokens: 16,
+                }),
+                signal: AbortSignal.timeout(180000),
+            });
+            const d = await r.json().catch(() => null);
+            if (!r.ok || !d) {
+                throw new Error(`Proxy antwortete HTTP ${r.status}`);
+            }
+            const tookMs = Date.now() - started;
+            const reply = (d.choices && d.choices[0] && d.choices[0].message
+                && d.choices[0].message.content) || "";
+            // Kein Modell in modelUsage ODER is_error => der Call kam nie
+            // zustande. Die CLI legt ihre Begruendung dann in den Text.
+            if (d.aria_error || !d.aria_model) {
+                clientWs.send(JSON.stringify({
+                    type: "model_test_result",
+                    requested: m,
+                    error: (reply || "Modell hat nicht geantwortet").slice(0, 400),
+                    tookMs,
+                }));
+                return;
+            }
+            clientWs.send(JSON.stringify({
+                type: "model_test_result",
+                requested: m,
+                actual: d.aria_model,
+                contextWindow: d.aria_context_window || 0,
+                maxOutput: d.aria_max_output || 0,
+                reply: reply.slice(0, 120),
+                tookMs,
+            }));
+            log("info", "server", `Model-Test: ${m} -> ${d.aria_model} (${tookMs}ms)`);
+        } catch (err) {
+            const msg = err && err.name === "TimeoutError"
+                ? "Zeitüberschreitung (3 min) — Proxy oder CLI antwortet nicht"
+                : String((err && err.message) || err);
+            clientWs.send(JSON.stringify({
+                type: "model_test_result", requested: m, error: msg,
+                tookMs: Date.now() - started,
+            }));
+        }
+    })();
+}
+
+// ── Einstellungen: Groessen-Limit fuer Memory-Anhaenge ──────────────
+// Steht in runtime.json als `memoryAttachmentMaxMb`. Das Brain liest es bei
+// JEDEM Upload neu (memory_attachments.max_bytes()) — eine Aenderung greift
+// also sofort, ohne aria-brain neu zu starten.
+//
+// Obergrenze mit Bedacht: der Anhang geht als base64-in-JSON zur App, die muss
+// ihn komplett in den Speicher nehmen. Ueber ~64 MB laedt das Handy ihn nicht
+// mehr (TAP_DL_MAX_BYTES in ChatScreen.tsx) — dann liegt er zwar sauber auf dem
+// Server, ist mobil aber nur noch per Dateimanager erreichbar. Darum warnen wir
+// darueber, verbieten es aber nicht.
+const ATTACHMENT_LIMIT_SOFT_MB = 64;
+const ATTACHMENT_LIMIT_MAX_MB = 1024;
+
+function handleGetAttachmentLimit(clientWs) {
+  // Das Brain ist die Wahrheit — es kennt auch den ENV-Fallback, den der
+  // Diagnostic-Container nicht sieht.
+  const brain = process.env.BRAIN_URL || "http://aria-brain:8080";
+  const req = http.get(`${brain}/attachments/limit`, { timeout: 5000 }, (r) => {
+    let body = "";
+    r.on("data", (c) => { body += c; });
+    r.on("end", () => {
+      let maxMb = null;
+      try { maxMb = JSON.parse(body).maxMb; } catch (_) {}
+      clientWs.send(JSON.stringify({
+        type: "attachment_limit_info",
+        maxMb,
+        softMb: ATTACHMENT_LIMIT_SOFT_MB,
+        hardMb: ATTACHMENT_LIMIT_MAX_MB,
+        error: maxMb == null ? "Brain antwortet nicht verwertbar" : undefined,
+      }));
+    });
+  });
+  req.on("error", (err) => {
+    clientWs.send(JSON.stringify({ type: "attachment_limit_info", error: err.message }));
+  });
+  req.on("timeout", () => { req.destroy(new Error("Brain antwortet nicht")); });
+}
+
+function handleSetAttachmentLimit(clientWs, maxMb) {
+  const n = Number(maxMb);
+  if (!isFinite(n) || n <= 0) {
+    clientWs.send(JSON.stringify({
+      type: "attachment_limit_info", error: "Bitte eine Zahl groesser 0 angeben (MB)" }));
+    return;
+  }
+  if (n > ATTACHMENT_LIMIT_MAX_MB) {
+    clientWs.send(JSON.stringify({
+      type: "attachment_limit_info",
+      error: `Maximal ${ATTACHMENT_LIMIT_MAX_MB} MB — darueber reisst der WebSocket-Transport` }));
+    return;
+  }
+  try {
+    writeRuntimeConfig({ memoryAttachmentMaxMb: n });
+    log("info", "server", `Anhang-Limit gesetzt: ${n} MB`);
+    clientWs.send(JSON.stringify({
+      type: "attachment_limit_info",
+      maxMb: n,
+      softMb: ATTACHMENT_LIMIT_SOFT_MB,
+      hardMb: ATTACHMENT_LIMIT_MAX_MB,
+      info: n > ATTACHMENT_LIMIT_SOFT_MB
+        ? `${n} MB gesetzt (greift sofort). Hinweis: ueber ${ATTACHMENT_LIMIT_SOFT_MB} MB `
+          + `laedt die Handy-App Anhaenge nicht mehr herunter — sie liegen dann nur `
+          + `noch auf dem Server.`
+        : `${n} MB gesetzt — greift sofort, kein Neustart noetig.`,
+    }));
+  } catch (err) {
+    clientWs.send(JSON.stringify({ type: "attachment_limit_info", error: err.message }));
+  }
+}
+
 // OpenClaw-Config-Handler entfernt — aria-core ist raus.

 // ── Start ───────────────────────────────────────────────
@@ -6,7 +6,14 @@
 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.
@@ -1,5 +1,6 @@
 .env
 build/
 dist/
+.buildenv/
 *.spec
 __pycache__/
@@ -4,6 +4,12 @@
 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
@@ -0,0 +1,36 @@
+# 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).
+RUN curl -fsSL https://nssm.cc/release/nssm-2.24.zip -o /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'"]
@@ -15,27 +15,162 @@ Geräte in einem LAN; der Host-Agent steuert *den Rechner, auf dem er läuft*.
 | `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 |
+| `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`.
+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).

-## Bauen (portable Binary)
+> **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          # braucht Docker; erzeugt dist/aria-host-agent (~15 MB)
+./build.sh          # -> dist/aria-host-agent  (~15 MB, läuft auf vielen Distros)
 ```

-Gebaut wird in einem bullseye-Container (altes glibc), damit die Binary auf
-möglichst vielen Distributionen läuft.
+**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`
-   — oder als Dienst: siehe `aria-host-agent.service`.
+
+### 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 0.2.0                 # Linux + Android + Windows (Wine)
+SKIP_WINDOWS=1 ./release_agent.sh 0.2.0  # ohne Windows (schneller)
+```
+
+Assets: `aria-host-agent-linux-x64`, `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

@@ -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
@@ -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'"]
@@ -0,0 +1,270 @@
+# 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 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).
@@ -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 105
+        versionName '0.0.1.5'
+    }
+
+    // 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)
+}
@@ -0,0 +1,89 @@
+<?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" />
+    <!-- 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" />
+
+        <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>
@@ -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" }
+    }
+}
@@ -0,0 +1,186 @@
+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
+
+        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))
+    }
+}
@@ -0,0 +1,298 @@
+package de.hackersoft.ariaagent
+
+import android.accessibilityservice.AccessibilityService
+import android.accessibilityservice.GestureDescription
+import android.graphics.Path
+import android.graphics.Rect
+import android.os.Bundle
+import android.view.View
+import android.view.accessibility.AccessibilityEvent
+import android.view.accessibility.AccessibilityNodeInfo
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Bedienungshilfe-Dienst (Meilenstein 2 — nur LESEND).
+ *
+ * Liefert einen strukturierten Baum der sichtbaren Bildschirm-Elemente: Text,
+ * Beschriftung (contentDescription), Klasse, Bildschirm-Position (Mittelpunkt +
+ * Rahmen) und Flags (klickbar/editierbar/ankreuzbar). ARIA nutzt das ergaenzend
+ * zum Screenshot, um Ziele exakt zu benennen. Tippen/Text folgt in M3.
+ *
+ * Der Nutzer schaltet den Dienst einmalig unter Einstellungen > Bedienungshilfen
+ * frei. Er fuehrt hier nichts autonom aus — reagiert nur auf `dump()`.
+ */
+class AriaAccessibilityService : AccessibilityService() {
+
+    override fun onServiceConnected() {
+        instance = this
+    }
+
+    override fun onUnbind(intent: android.content.Intent?): Boolean {
+        if (instance === this) instance = null
+        return super.onUnbind(intent)
+    }
+
+    override fun onDestroy() {
+        if (instance === this) instance = null
+        super.onDestroy()
+    }
+
+    override fun onAccessibilityEvent(event: AccessibilityEvent?) { /* passiv */ }
+    override fun onInterrupt() { /* passiv */ }
+
+    /**
+     * Steht eine Einblendung offen, raeumt sie der naechste Tastendruck weg.
+     *
+     * Der Trick: wir geben IMMER `false` zurueck. Damit laeuft die Taste ganz
+     * normal weiter an den Film/die App — die Einblendung schluckt nichts. Sie
+     * muss dafuer auch nicht fokussierbar sein, kann also weiterhin ueber einem
+     * laufenden Video stehen, ohne die Fernbedienung zu blockieren.
+     *
+     * Deshalb dieser Weg und nicht "Overlay faengt Tasten selbst ab": ein
+     * fokussierbares Fenster wuerde der App darunter JEDE Eingabe nehmen,
+     * solange es steht.
+     *
+     * Eine feste Anzeigedauer ist naemlich immer falsch — mal zu kurz zum
+     * Lesen, mal steht sie ewig im Bild.
+     */
+    override fun onKeyEvent(event: android.view.KeyEvent?): Boolean {
+        if (event != null && event.action == android.view.KeyEvent.ACTION_DOWN
+            && OverlayView.isShowing()) {
+            OverlayView.hide(applicationContext)
+        }
+        return false   // Taste NICHT verbrauchen
+    }
+
+    /** Strukturierter Baum des aktiven Fensters. Shape: {ok, result:{package,count,nodes[]}}. */
+    fun dump(): JSONObject {
+        val root = rootInActiveWindow
+            ?: return JSONObject().put("ok", false)
+                .put("error", "Kein aktives Fenster lesbar (Bildschirm evtl. aus oder gesperrt).")
+        val nodes = JSONArray()
+        try {
+            walk(root, nodes, 0)
+        } finally {
+            @Suppress("DEPRECATION") try { root.recycle() } catch (_: Exception) {}
+        }
+        val result = JSONObject()
+            .put("package", root.packageName?.toString() ?: "")
+            .put("count", nodes.length())
+            .put("nodes", nodes)
+        return JSONObject().put("ok", true).put("result", result)
+    }
+
+    private fun walk(node: AccessibilityNodeInfo?, out: JSONArray, depth: Int) {
+        if (node == null || depth > 40 || out.length() >= 400) return
+        val text = node.text?.toString()?.trim()
+        val desc = node.contentDescription?.toString()?.trim()
+        val cls = node.className?.toString()?.substringAfterLast('.')
+        val interesting = !text.isNullOrBlank() || !desc.isNullOrBlank() ||
+            node.isClickable || node.isEditable || node.isCheckable
+        if (interesting) {
+            val r = Rect()
+            node.getBoundsInScreen(r)
+            val o = JSONObject()
+            if (!text.isNullOrBlank()) o.put("text", text)
+            if (!desc.isNullOrBlank()) o.put("desc", desc)
+            if (cls != null) o.put("cls", cls)
+            if (node.isClickable) o.put("clickable", true)
+            if (node.isEditable) o.put("editable", true)
+            if (node.isCheckable) o.put("checked", node.isChecked)
+            o.put("x", r.centerX())
+            o.put("y", r.centerY())
+            o.put("bounds", "${r.left},${r.top},${r.right},${r.bottom}")
+            out.put(o)
+        }
+        for (i in 0 until node.childCount) {
+            walk(node.getChild(i), out, depth + 1)
+        }
+    }
+
+    // ─── Steuern (Meilenstein 3) ────────────────────────────────────
+
+    /** Tippt auf Bildschirm-Koordinaten (Pixel wie in ui_dump x/y). */
+    fun tap(x: Int, y: Int): JSONObject {
+        val path = Path().apply { moveTo(x.toFloat(), y.toFloat()) }
+        return gesture(path, 0, 60, "Tippen ($x,$y)")
+    }
+
+    /** Wischt von (x1,y1) nach (x2,y2) ueber dauerMs (Scrollen/Swipen). */
+    fun swipe(x1: Int, y1: Int, x2: Int, y2: Int, durationMs: Int): JSONObject {
+        val path = Path().apply {
+            moveTo(x1.toFloat(), y1.toFloat())
+            lineTo(x2.toFloat(), y2.toFloat())
+        }
+        return gesture(path, 0, durationMs.coerceIn(50, 5000).toLong(),
+            "Wischen ($x1,$y1 -> $x2,$y2)")
+    }
+
+    private fun gesture(path: Path, startMs: Long, durationMs: Long, desc: String): JSONObject {
+        val g = GestureDescription.Builder()
+            .addStroke(GestureDescription.StrokeDescription(path, startMs, durationMs))
+            .build()
+        val latch = CountDownLatch(1)
+        val ok = AtomicBoolean(false)
+        val dispatched = dispatchGesture(g, object : GestureResultCallback() {
+            override fun onCompleted(d: GestureDescription?) { ok.set(true); latch.countDown() }
+            override fun onCancelled(d: GestureDescription?) { latch.countDown() }
+        }, null)
+        if (!dispatched) return errMsg("Geste konnte nicht ausgeloest werden ($desc)")
+        try { latch.await(6, TimeUnit.SECONDS) } catch (_: InterruptedException) {}
+        return if (ok.get()) okMsg("$desc ausgefuehrt") else errMsg("$desc abgebrochen/timeout")
+    }
+
+    /** Schreibt Text in ein Eingabefeld an (x,y) — oder in das fokussierte Feld. */
+    fun setText(x: Int, y: Int, text: String): JSONObject {
+        val root = rootInActiveWindow ?: return errMsg("kein aktives Fenster")
+        val node = editableAt(root, x, y)
+            ?: root.findFocus(AccessibilityNodeInfo.FOCUS_INPUT)?.takeIf { it.isEditable }
+            ?: return errMsg("kein Textfeld an ($x,$y) gefunden — vorher ui_tap aufs Feld?")
+        node.performAction(AccessibilityNodeInfo.ACTION_FOCUS)
+        val args = Bundle().apply {
+            putCharSequence(AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE, text)
+        }
+        val done = node.performAction(AccessibilityNodeInfo.ACTION_SET_TEXT, args)
+        return if (done) okMsg("Text gesetzt (${text.length} Zeichen)")
+        else errMsg("Text setzen fehlgeschlagen (Feld nicht editierbar?)")
+    }
+
+    /** Tiefste editierbare Node, deren Rahmen (x,y) enthaelt. */
+    private fun editableAt(node: AccessibilityNodeInfo?, x: Int, y: Int): AccessibilityNodeInfo? {
+        if (node == null) return null
+        var found: AccessibilityNodeInfo? = null
+        for (i in 0 until node.childCount) {
+            editableAt(node.getChild(i), x, y)?.let { found = it }
+        }
+        if (found != null) return found
+        val r = Rect(); node.getBoundsInScreen(r)
+        return if (node.isEditable && r.contains(x, y)) node else null
+    }
+
+    /** Globale Taste: back/home/recents/notifications — plus D-Pad (Fire TV). */
+    fun globalKey(name: String): JSONObject {
+        val key = name.trim().lowercase()
+        // D-Pad/Medien: auf dem Fernseher wird damit navigiert (kein Touch).
+        DPAD_KEYS[key]?.let { return dpad(it, key) }
+        val action = when (key) {
+            "back", "zurueck", "zurück" -> GLOBAL_ACTION_BACK
+            "home", "start", "startseite" -> GLOBAL_ACTION_HOME
+            "recents", "letzte", "uebersicht", "übersicht" -> GLOBAL_ACTION_RECENTS
+            "notifications", "benachrichtigungen" -> GLOBAL_ACTION_NOTIFICATIONS
+            else -> return errMsg("Taste '$name' unbekannt. Verfuegbar: back, home, " +
+                "recents, notifications, up, down, left, right, ok/center, " +
+                "play_pause, next, prev, volume_up, volume_down, mute")
+        }
+        return if (performGlobalAction(action)) okMsg("Taste '$name' ausgefuehrt")
+        else errMsg("Taste '$name' fehlgeschlagen")
+    }
+
+    /** D-Pad/Medien-Taste — via Fokus-Navigation bzw. Medien-Session. */
+    private fun dpad(keyCode: Int, label: String): JSONObject {
+        // Lautstaerke/Stumm gehen ueber den AudioManager (zuverlaessiger als KeyEvent).
+        when (keyCode) {
+            android.view.KeyEvent.KEYCODE_VOLUME_UP,
+            android.view.KeyEvent.KEYCODE_VOLUME_DOWN,
+            android.view.KeyEvent.KEYCODE_VOLUME_MUTE -> {
+                val am = getSystemService(android.content.Context.AUDIO_SERVICE)
+                    as android.media.AudioManager
+                val dir = when (keyCode) {
+                    android.view.KeyEvent.KEYCODE_VOLUME_UP -> android.media.AudioManager.ADJUST_RAISE
+                    android.view.KeyEvent.KEYCODE_VOLUME_DOWN -> android.media.AudioManager.ADJUST_LOWER
+                    else -> android.media.AudioManager.ADJUST_TOGGLE_MUTE
+                }
+                am.adjustStreamVolume(android.media.AudioManager.STREAM_MUSIC, dir,
+                    android.media.AudioManager.FLAG_SHOW_UI)
+                return okMsg("Taste '$label' ausgefuehrt")
+            }
+        }
+        // Medientasten an die aktive Wiedergabe-Session.
+        if (keyCode in MEDIA_KEYS) {
+            val am = getSystemService(android.content.Context.AUDIO_SERVICE)
+                as android.media.AudioManager
+            val now = android.os.SystemClock.uptimeMillis()
+            am.dispatchMediaKeyEvent(android.view.KeyEvent(now, now,
+                android.view.KeyEvent.ACTION_DOWN, keyCode, 0))
+            am.dispatchMediaKeyEvent(android.view.KeyEvent(now, now,
+                android.view.KeyEvent.ACTION_UP, keyCode, 0))
+            return okMsg("Taste '$label' ausgefuehrt")
+        }
+        // Richtungen/OK: ueber die Bedienungshilfe-Fokus-Navigation.
+        val root = rootInActiveWindow ?: return errMsg("kein aktives Fenster")
+        val focus = root.findFocus(AccessibilityNodeInfo.FOCUS_INPUT)
+            ?: root.findFocus(AccessibilityNodeInfo.FOCUS_ACCESSIBILITY)
+        if (keyCode == android.view.KeyEvent.KEYCODE_DPAD_CENTER) {
+            val target = focus ?: return errMsg("nichts fokussiert — vorher navigieren")
+            return if (target.performAction(AccessibilityNodeInfo.ACTION_CLICK))
+                okMsg("OK/Auswahl ausgefuehrt") else errMsg("Auswahl fehlgeschlagen")
+        }
+        val dir = when (keyCode) {
+            android.view.KeyEvent.KEYCODE_DPAD_UP -> View.FOCUS_UP
+            android.view.KeyEvent.KEYCODE_DPAD_DOWN -> View.FOCUS_DOWN
+            android.view.KeyEvent.KEYCODE_DPAD_LEFT -> View.FOCUS_LEFT
+            else -> View.FOCUS_RIGHT
+        }
+        val from = focus ?: root
+        val next = from.focusSearch(dir)
+            ?: return errMsg("kein Element in Richtung '$label' gefunden")
+        return if (next.performAction(AccessibilityNodeInfo.ACTION_FOCUS))
+            okMsg("Taste '$label' ausgefuehrt") else errMsg("Taste '$label' fehlgeschlagen")
+    }
+
+    private fun okMsg(m: String): JSONObject =
+        JSONObject().put("ok", true).put("result", JSONObject().put("message", m))
+
+    private fun errMsg(m: String): JSONObject =
+        JSONObject().put("ok", false).put("error", m)
+
+    companion object {
+        @Volatile
+        var instance: AriaAccessibilityService? = null
+
+        val available: Boolean get() = instance != null
+
+        /** Fernseher-Navigation (Fire TV): D-Pad, Medien- und Lautstaerke-Tasten. */
+        private val DPAD_KEYS: Map<String, Int> = mapOf(
+            "up" to android.view.KeyEvent.KEYCODE_DPAD_UP,
+            "hoch" to android.view.KeyEvent.KEYCODE_DPAD_UP,
+            "down" to android.view.KeyEvent.KEYCODE_DPAD_DOWN,
+            "runter" to android.view.KeyEvent.KEYCODE_DPAD_DOWN,
+            "left" to android.view.KeyEvent.KEYCODE_DPAD_LEFT,
+            "links" to android.view.KeyEvent.KEYCODE_DPAD_LEFT,
+            "right" to android.view.KeyEvent.KEYCODE_DPAD_RIGHT,
+            "rechts" to android.view.KeyEvent.KEYCODE_DPAD_RIGHT,
+            "ok" to android.view.KeyEvent.KEYCODE_DPAD_CENTER,
+            "center" to android.view.KeyEvent.KEYCODE_DPAD_CENTER,
+            "select" to android.view.KeyEvent.KEYCODE_DPAD_CENTER,
+            "enter" to android.view.KeyEvent.KEYCODE_DPAD_CENTER,
+            "play_pause" to android.view.KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE,
+            "play" to android.view.KeyEvent.KEYCODE_MEDIA_PLAY,
+            "pause" to android.view.KeyEvent.KEYCODE_MEDIA_PAUSE,
+            "stop" to android.view.KeyEvent.KEYCODE_MEDIA_STOP,
+            "next" to android.view.KeyEvent.KEYCODE_MEDIA_NEXT,
+            "prev" to android.view.KeyEvent.KEYCODE_MEDIA_PREVIOUS,
+            "forward" to android.view.KeyEvent.KEYCODE_MEDIA_FAST_FORWARD,
+            "rewind" to android.view.KeyEvent.KEYCODE_MEDIA_REWIND,
+            "volume_up" to android.view.KeyEvent.KEYCODE_VOLUME_UP,
+            "lauter" to android.view.KeyEvent.KEYCODE_VOLUME_UP,
+            "volume_down" to android.view.KeyEvent.KEYCODE_VOLUME_DOWN,
+            "leiser" to android.view.KeyEvent.KEYCODE_VOLUME_DOWN,
+            "mute" to android.view.KeyEvent.KEYCODE_VOLUME_MUTE,
+            "stumm" to android.view.KeyEvent.KEYCODE_VOLUME_MUTE,
+        )
+
+        private val MEDIA_KEYS: Set<Int> = setOf(
+            android.view.KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE,
+            android.view.KeyEvent.KEYCODE_MEDIA_PLAY,
+            android.view.KeyEvent.KEYCODE_MEDIA_PAUSE,
+            android.view.KeyEvent.KEYCODE_MEDIA_STOP,
+            android.view.KeyEvent.KEYCODE_MEDIA_NEXT,
+            android.view.KeyEvent.KEYCODE_MEDIA_PREVIOUS,
+            android.view.KeyEvent.KEYCODE_MEDIA_FAST_FORWARD,
+            android.view.KeyEvent.KEYCODE_MEDIA_REWIND,
+        )
+    }
+}
@@ -0,0 +1,69 @@
+package de.hackersoft.ariaagent
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+
+/**
+ * Audio-Fokus — damit ARIA nicht einfach ueber den laufenden Film redet.
+ *
+ * Ohne Fokus mischt Android beide Tonspuren: Netflix/Jellyfin/Spotify laufen in
+ * voller Lautstaerke weiter und ARIA ist kaum zu verstehen. Mit Fokus verhaelt
+ * sie sich wie ein normaler Sprachassistent:
+ *
+ *   "duck"  (Standard)  laufende Medien werden LEISER, ARIA spricht darueber,
+ *                       danach geht die Lautstaerke von selbst wieder hoch.
+ *   "pause"             laufende Medien werden PAUSIERT (Player reagieren auf
+ *                       den Fokusverlust) — sinnvoll beim Zuhoeren, damit das
+ *                       Mikrofon nicht den Filmton aufnimmt.
+ *   "none"              kein Fokus (alte Mischung).
+ */
+object AudioFocusHelper {
+
+    private var request: AudioFocusRequest? = null
+    private var holder: String = ""
+
+    /** Fordert den Fokus an. [mode] = duck | pause | none. */
+    @Synchronized
+    fun request(ctx: Context, mode: String, who: String): Boolean {
+        if (mode == "none") return true
+        abandon(ctx)
+        val gain = if (mode == "pause") AudioManager.AUDIOFOCUS_GAIN_TRANSIENT
+                   else AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+        val usage = if (who == "listen") AudioAttributes.USAGE_ASSISTANCE_SONIFICATION
+                    else AudioAttributes.USAGE_ASSISTANT
+        return try {
+            val am = ctx.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+            val req = AudioFocusRequest.Builder(gain)
+                .setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(usage)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                        .build()
+                )
+                // Kurze Unterbrechungen nicht als "verloren" behandeln.
+                .setWillPauseWhenDucked(false)
+                .setOnAudioFocusChangeListener { }
+                .build()
+            request = req
+            holder = who
+            am.requestAudioFocus(req) == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+        } catch (_: Throwable) {
+            false
+        }
+    }
+
+    /** Gibt den Fokus zurueck — die Medien werden wieder lauter / laufen weiter. */
+    @Synchronized
+    fun abandon(ctx: Context) {
+        val req = request ?: return
+        request = null
+        holder = ""
+        try {
+            val am = ctx.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+            am.abandonAudioFocusRequest(req)
+        } catch (_: Throwable) {
+        }
+    }
+}
@@ -0,0 +1,16 @@
+package de.hackersoft.ariaagent
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+/** Startet den Agent-Service nach dem Booten wieder (wenn konfiguriert). */
+class BootReceiver : BroadcastReceiver() {
+    override fun onReceive(ctx: Context, intent: Intent) {
+        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
+            if (AgentConfig.load(ctx).isValid()) {
+                AgentService.start(ctx)
+            }
+        }
+    }
+}
@@ -0,0 +1,65 @@
+package de.hackersoft.ariaagent
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.media.projection.MediaProjectionManager
+import android.os.Bundle
+
+/**
+ * Unsichtbarer Helfer, der die Bildschirm-Aufnahme (neu) scharf schaltet.
+ *
+ * Hintergrund: Die Berechtigung (AppOp PROJECT_MEDIA) bleibt dauerhaft erhalten,
+ * die MediaProjection-SITZUNG aber nicht — Android laesst sie grundsaetzlich
+ * nicht speichern, sie stirbt mit dem Prozess. Nach einem Neustart des Geraets
+ * oder der App muesste man sonst jedes Mal von Hand "Bildschirm-Zugriff erlauben"
+ * druecken (auf einem Fire TV mit der Fernbedienung besonders laestig).
+ *
+ * Diese Activity loest die Anfrage automatisch aus und reicht das Ergebnis an den
+ * Dienst weiter. Ist PROJECT_MEDIA per ADB erlaubt, laeuft das OHNE Dialog durch —
+ * der Nutzer sieht nichts (durchsichtiges Theme, kein Fenster-Inhalt).
+ */
+class CaptureActivity : Activity() {
+
+    companion object {
+        private const val REQ = 4711
+
+        /** Startet die (Neu-)Scharfschaltung aus dem Dienst heraus. */
+        fun request(ctx: Context) {
+            val i = Intent(ctx, CaptureActivity::class.java)
+                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or
+                          Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS or
+                          Intent.FLAG_ACTIVITY_NO_ANIMATION)
+            ctx.startActivity(i)
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        try {
+            val mpm = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
+            startActivityForResult(mpm.createScreenCaptureIntent(), REQ)
+        } catch (e: Throwable) {
+            ScreenCapturer.lastError = "Anfrage fehlgeschlagen: ${e.message}"
+            finish()
+        }
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        if (requestCode == REQ && resultCode == RESULT_OK && data != null) {
+            val i = Intent(this, AgentService::class.java)
+                .setAction(AgentService.ACTION_PROJECTION)
+                .putExtra(AgentService.EXTRA_RESULT_CODE, resultCode)
+                .putExtra(AgentService.EXTRA_RESULT_DATA, data)
+            androidx.core.content.ContextCompat.startForegroundService(this, i)
+        } else {
+            // Abgelehnt oder (ohne AppOp) Dialog weggeklickt — kein Drama, der
+            // Nutzer kann es in der App jederzeit nachholen.
+            ScreenCapturer.lastError =
+                "Bildschirm-Zugriff nicht erteilt (in der Agent-App nachholen)"
+        }
+        finish()
+        overridePendingTransition(0, 0)
+    }
+}
@@ -0,0 +1,277 @@
+package de.hackersoft.ariaagent
+
+import android.Manifest
+import android.app.Activity
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.media.projection.MediaProjectionManager
+import android.os.Build
+import android.os.Bundle
+import android.provider.Settings
+import android.widget.Button
+import android.widget.EditText
+import android.widget.RadioButton
+import android.widget.TextView
+import android.widget.Toast
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.widget.SwitchCompat
+import androidx.core.content.ContextCompat
+import com.journeyapps.barcodescanner.ScanContract
+import com.journeyapps.barcodescanner.ScanOptions
+import org.json.JSONObject
+
+class MainActivity : AppCompatActivity() {
+
+    private lateinit var host: EditText
+    private lateinit var port: EditText
+    private lateinit var token: EditText
+    private lateinit var name: EditText
+    private lateinit var tls: SwitchCompat
+    private lateinit var control: SwitchCompat
+    private lateinit var statusView: TextView
+
+    private val scan = registerForActivityResult(ScanContract()) { res ->
+        res.contents?.let { applyQr(it) }
+    }
+    private val camPerm = registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+        if (granted) launchScan() else toast("Kamera-Berechtigung nötig für QR-Scan")
+    }
+    private val notifPerm = registerForActivityResult(ActivityResultContracts.RequestPermission()) { }
+
+    private val micPerm = registerForActivityResult(
+        ActivityResultContracts.RequestPermission()
+    ) { granted ->
+        if (granted) talkToAria() else toast("Ohne Mikrofon-Berechtigung kein Sprachdialog")
+    }
+
+    private val projection = registerForActivityResult(
+        ActivityResultContracts.StartActivityForResult()
+    ) { res ->
+        if (res.resultCode == Activity.RESULT_OK && res.data != null) {
+            val i = Intent(this, AgentService::class.java)
+                .setAction(AgentService.ACTION_PROJECTION)
+                .putExtra(AgentService.EXTRA_RESULT_CODE, res.resultCode)
+                .putExtra(AgentService.EXTRA_RESULT_DATA, res.data)
+            ContextCompat.startForegroundService(this, i)
+            toast("Bildschirm-Zugriff aktiv — ARIA kann jetzt Screenshots machen")
+        } else {
+            toast("Bildschirm-Zugriff abgelehnt")
+        }
+    }
+
+    private val statusReceiver = object : BroadcastReceiver() {
+        override fun onReceive(c: Context?, i: Intent?) = refreshStatus()
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+
+        host = findViewById(R.id.host)
+        port = findViewById(R.id.port)
+        token = findViewById(R.id.token)
+        name = findViewById(R.id.name)
+        tls = findViewById(R.id.tls)
+        control = findViewById(R.id.control)
+        statusView = findViewById(R.id.status)
+
+        findViewById<Button>(R.id.btnScan).setOnClickListener {
+            if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
+                == PackageManager.PERMISSION_GRANTED) launchScan()
+            else camPerm.launch(Manifest.permission.CAMERA)
+        }
+        findViewById<Button>(R.id.btnConnect).setOnClickListener { saveAndConnect() }
+        findViewById<Button>(R.id.btnStop).setOnClickListener {
+            AgentService.stop(this)
+            refreshStatus()
+        }
+        findViewById<Button>(R.id.btnScreen).setOnClickListener {
+            if (!AgentService.connected && !AgentConfig.load(this).isValid()) {
+                toast("Erst verbinden, dann Bildschirm-Zugriff erlauben")
+                return@setOnClickListener
+            }
+            val mpm = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
+            projection.launch(mpm.createScreenCaptureIntent())
+        }
+        findViewById<Button>(R.id.btnTalk).setOnClickListener {
+            if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO)
+                == PackageManager.PERMISSION_GRANTED) talkToAria()
+            else micPerm.launch(Manifest.permission.RECORD_AUDIO)
+        }
+        findViewById<Button>(R.id.btnOverlayPerm).setOnClickListener {
+            if (OverlayView.canDraw(this)) { toast("Einblendung ist bereits erlaubt"); return@setOnClickListener }
+            try {
+                startActivity(Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                    android.net.Uri.parse("package:$packageName")))
+                toast("'ARIA Host-Agent' erlauben")
+            } catch (_: Exception) {
+                try { startActivity(Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION)) }
+                catch (_: Exception) { toast("Einstellung nicht gefunden") }
+            }
+        }
+        findViewById<Button>(R.id.btnAccessibility).setOnClickListener {
+            try {
+                startActivity(Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS))
+                toast("'ARIA Host-Agent' in der Liste einschalten")
+            } catch (_: Exception) {
+                toast("Bedienungshilfe-Einstellungen nicht gefunden")
+            }
+        }
+
+        // Fern-Einrichtung (z.B. Fire TV, wo QR-Scan und Tippen wegfallen): der
+        // Satellit startet die App per ADB mit den Zugangsdaten als Extras.
+        // Hat das geklappt, ist die UI schon befuellt — sonst normal laden.
+        if (!applyProvisioning(intent)) loadIntoUi(AgentConfig.load(this))
+
+        // Fire TV: kein Touchscreen — der QR-Scan ist dort sinnlos (keine Kamera),
+        // und der erste Fokus muss gesetzt sein, damit die Fernbedienung greift.
+        if (isTvDevice()) {
+            findViewById<Button>(R.id.btnScan).visibility = android.view.View.GONE
+            host.requestFocus()
+        }
+
+        if (Build.VERSION.SDK_INT >= 33 &&
+            ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS)
+            != PackageManager.PERMISSION_GRANTED) {
+            notifPerm.launch(Manifest.permission.POST_NOTIFICATIONS)
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        val filter = IntentFilter(AgentService.ACTION_STATUS)
+        ContextCompat.registerReceiver(this, statusReceiver, filter,
+            ContextCompat.RECEIVER_NOT_EXPORTED)
+        refreshStatus()
+    }
+
+    override fun onPause() {
+        super.onPause()
+        try { unregisterReceiver(statusReceiver) } catch (_: Exception) {}
+    }
+
+    private fun launchScan() {
+        val o = ScanOptions()
+            .setBeepEnabled(false)
+            .setOrientationLocked(false)
+            .setPrompt("ARIA-Verbindungs-QR scannen")
+        scan.launch(o)
+    }
+
+    private fun applyQr(content: String) {
+        try {
+            val j = JSONObject(content)
+            host.setText(j.optString("host"))
+            port.setText((if (j.has("port")) j.optInt("port", 443) else 443).toString())
+            token.setText(j.optString("token"))
+            if (j.has("tls")) tls.isChecked = j.optBoolean("tls", true)
+            toast("QR übernommen — jetzt 'Speichern & Verbinden'")
+        } catch (_: Exception) {
+            toast("Das ist kein ARIA-Verbindungs-QR")
+        }
+    }
+
+    private fun loadIntoUi(c: AgentConfig) {
+        host.setText(c.host)
+        port.setText(c.port.toString())
+        token.setText(c.token)
+        name.setText(c.name)
+        tls.isChecked = c.tls
+        control.isChecked = c.controlEnabled
+        findViewById<RadioButton>(
+            if (c.replyMode == "speech") R.id.modeSpeech else R.id.modeOverlay
+        ).isChecked = true
+    }
+
+    private fun saveAndConnect() {
+        val c = AgentConfig(
+            host = host.text.toString().trim(),
+            port = port.text.toString().trim().toIntOrNull() ?: 443,
+            tls = tls.isChecked,
+            token = token.text.toString().trim(),
+            name = name.text.toString().trim(),
+            controlEnabled = control.isChecked,
+            replyMode = if (findViewById<RadioButton>(R.id.modeSpeech).isChecked) "speech" else "overlay",
+        )
+        if (!c.isValid()) {
+            toast("Host und Token sind Pflicht")
+            return
+        }
+        c.save(this)
+        AgentService.start(this)
+        toast("Agent gestartet")
+        refreshStatus()
+    }
+
+    private fun refreshStatus() {
+        val dot = if (AgentService.connected) "🟢" else "🔴"
+        statusView.text = "Status: ${AgentService.status}  $dot"
+    }
+
+    override fun onNewIntent(intent: Intent?) {
+        super.onNewIntent(intent)
+        if (intent == null) return
+        setIntent(intent)
+        applyProvisioning(intent)
+    }
+
+    /**
+     * Fern-Einrichtung per Intent-Extras (vom Satelliten via ADB gestartet).
+     *
+     * Auf einem Fire TV gibt es keine Kamera (kein QR) und Tippen mit der
+     * Fernbedienung ist muehsam — deshalb kann der Satellit die Zugangsdaten
+     * direkt mitgeben:
+     *   adb shell am start -n de.hackersoft.ariaagent/.MainActivity \
+     *     -a de.hackersoft.ariaagent.PROVISION \
+     *     -e host rvs.example.com --ei port 443 --ez tls true -e token XYZ
+     *
+     * Gibt true zurueck, wenn eingerichtet wurde (dann startet der Dienst gleich).
+     */
+    private fun applyProvisioning(intent: Intent): Boolean {
+        val host = intent.getStringExtra("host")?.trim().orEmpty()
+        val token = intent.getStringExtra("token")?.trim().orEmpty()
+        if (host.isEmpty() || token.isEmpty()) return false
+
+        val old = AgentConfig.load(this)
+        val cfg = AgentConfig(
+            host = host,
+            port = intent.getIntExtra("port", old.port.takeIf { it > 0 } ?: 443),
+            tls = intent.getBooleanExtra("tls", old.tls),
+            token = token,
+            name = intent.getStringExtra("name")?.trim().takeUnless { it.isNullOrEmpty() } ?: old.name,
+            controlEnabled = intent.getBooleanExtra("control", true),
+            replyMode = intent.getStringExtra("reply_mode")?.trim()
+                .takeUnless { it.isNullOrEmpty() } ?: old.replyMode,
+            // Der Satellit erteilt beim Einrichten PROJECT_MEDIA — dann darf sich
+            // die Bildschirm-Aufnahme nach jedem Neustart selbst scharf schalten.
+            captureEnabled = intent.getBooleanExtra("capture", old.captureEnabled),
+        )
+        cfg.save(this)
+        AgentService.start(this)
+        // Sichtbar machen, dass die Konfiguration von aussen kam (Transparenz).
+        toast("Von ARIA eingerichtet: ${cfg.host} — Agent gestartet")
+        loadIntoUi(cfg)
+        refreshStatus()
+        return true
+    }
+
+    /** Sprech-Taste: startet/stoppt die Aufnahme im laufenden Dienst. */
+    private fun talkToAria() {
+        if (!AgentConfig.load(this).isValid()) { toast("Erst verbinden"); return }
+        ContextCompat.startForegroundService(this,
+            Intent(this, AgentService::class.java).setAction(AgentService.ACTION_TALK))
+        toast("Sprich jetzt — nochmal drücken beendet die Aufnahme")
+    }
+
+    /** Fire TV / Android TV (kein Touchscreen, Bedienung per Fernbedienung). */
+    private fun isTvDevice(): Boolean = try {
+        packageManager.hasSystemFeature("android.software.leanback") ||
+            packageManager.hasSystemFeature("android.hardware.type.television")
+    } catch (_: Exception) { false }
+
+    private fun toast(m: String) = Toast.makeText(this, m, Toast.LENGTH_SHORT).show()
+}
@@ -0,0 +1,173 @@
+package de.hackersoft.ariaagent
+
+import android.content.Context
+import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+import android.util.Base64
+import android.view.Gravity
+import android.view.View
+import android.view.WindowManager
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+
+/**
+ * Einblendung ueber dem laufenden Bild (Fire TV / Android TV).
+ *
+ * ARIA kann Text (und optional ein Bild) UEBER Netflix & Co. anzeigen, ohne die
+ * Wiedergabe zu stoppen — fuer Antworten, Hinweise, Tuerklingel-Schnappschuesse.
+ * Technisch ein TYPE_APPLICATION_OVERLAY-Fenster; der Nutzer muss die
+ * Spezialberechtigung "Ueber anderen Apps anzeigen" einmalig erteilen.
+ *
+ * Nicht fokussierbar (FLAG_NOT_FOCUSABLE) — die Fernbedienung steuert weiter die
+ * App darunter, die Einblendung schluckt keine Tastendruecke.
+ *
+ * WEGBEKOMMEN ohne feste Anzeigedauer (seconds = 0):
+ *  - Fernbedienung: der Accessibility-Dienst sieht den naechsten Tastendruck und
+ *    raeumt die Einblendung weg — er gibt die Taste trotzdem an den Film weiter
+ *    (siehe AriaAccessibilityService.onKeyEvent).
+ *  - Touch: FLAG_WATCH_OUTSIDE_TOUCH meldet uns eine Beruehrung AUSSERHALB der
+ *    Einblendung. Die Beruehrung geht gleichzeitig an die App darunter — es
+ *    geht also kein Tipp verloren.
+ *  - Notbremse: nach HARD_CAP_SEC verschwindet sie in jedem Fall. Ohne das
+ *    koennte eine vergessene Einblendung dauerhaft im Bild stehen.
+ *
+ * Eine feste Dauer ist naemlich immer falsch geraten — mal zu kurz zum Lesen,
+ * mal steht sie laengst im Weg.
+ */
+object OverlayView {
+
+    /** Auch eine "bleibt stehen"-Einblendung geht spaetestens danach weg. */
+    private const val HARD_CAP_SEC = 600
+
+    private val main = Handler(Looper.getMainLooper())
+    private var root: LinearLayout? = null
+    private var hideRunnable: Runnable? = null
+
+    /** Steht gerade eine Einblendung? Der Accessibility-Dienst fragt das, bevor
+     *  er auf einen Tastendruck hin aufraeumt. */
+    fun isShowing(): Boolean = root != null
+
+    /** Hat der Nutzer "Ueber anderen Apps anzeigen" erlaubt? */
+    fun canDraw(ctx: Context): Boolean =
+        if (Build.VERSION.SDK_INT >= 23) Settings.canDrawOverlays(ctx) else true
+
+    /**
+     * Zeigt eine Einblendung. [seconds] = Anzeigedauer (0 = bis zum naechsten
+     * hide()). [imageB64] optional ein PNG/JPEG als Base64.
+     * Muss NICHT vom Main-Thread gerufen werden.
+     */
+    fun show(ctx: Context, title: String, text: String, seconds: Int, imageB64: String?) {
+        main.post {
+            try {
+                hideNow(ctx)
+                val wm = ctx.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+
+                val box = LinearLayout(ctx).apply {
+                    orientation = LinearLayout.VERTICAL
+                    setPadding(36, 28, 36, 28)
+                    background = GradientDrawable().apply {
+                        cornerRadius = 22f
+                        setColor(Color.parseColor("#E60D0D1A"))   // dunkel, leicht transparent
+                        setStroke(3, Color.parseColor("#3FFF9F"))
+                    }
+                }
+                if (title.isNotBlank()) {
+                    box.addView(TextView(ctx).apply {
+                        setText(title)
+                        setTextColor(Color.parseColor("#3FFF9F"))
+                        textSize = 22f
+                        setPadding(0, 0, 0, 10)
+                    })
+                }
+                if (text.isNotBlank()) {
+                    box.addView(TextView(ctx).apply {
+                        setText(text)
+                        setTextColor(Color.parseColor("#E0E0F0"))
+                        textSize = 19f
+                        maxLines = 8
+                    })
+                }
+                imageB64?.let { b64 ->
+                    try {
+                        val bytes = Base64.decode(b64, Base64.DEFAULT)
+                        val bmp = android.graphics.BitmapFactory
+                            .decodeByteArray(bytes, 0, bytes.size)
+                        if (bmp != null) {
+                            box.addView(ImageView(ctx).apply {
+                                setImageBitmap(bmp)
+                                adjustViewBounds = true
+                                maxHeight = 520
+                                setPadding(0, 14, 0, 0)
+                            })
+                        }
+                    } catch (_: Exception) { /* Bild optional */ }
+                }
+
+                val type = if (Build.VERSION.SDK_INT >= 26)
+                    WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
+                else
+                    @Suppress("DEPRECATION") WindowManager.LayoutParams.TYPE_SYSTEM_ALERT
+                val lp = WindowManager.LayoutParams(
+                    WindowManager.LayoutParams.WRAP_CONTENT,
+                    WindowManager.LayoutParams.WRAP_CONTENT,
+                    type,
+                    WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
+                        WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE or
+                        // Meldet uns Beruehrungen AUSSERHALB, ohne sie zu
+                        // schlucken — damit raeumt ein Tipp aufs Video die
+                        // Einblendung weg und steuert trotzdem den Player.
+                        WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH or
+                        WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN,
+                    android.graphics.PixelFormat.TRANSLUCENT,
+                ).apply {
+                    gravity = Gravity.TOP or Gravity.END
+                    x = 48
+                    y = 48
+                    width = (ctx.resources.displayMetrics.widthPixels * 0.42f).toInt()
+                }
+
+                // Beruehrung ausserhalb -> wegraeumen. Die Beruehrung selbst
+                // geht dank FLAG_NOT_TOUCHABLE weiter an die App darunter.
+                box.setOnTouchListener { _, ev ->
+                    if (ev.action == android.view.MotionEvent.ACTION_OUTSIDE) hideNow(ctx)
+                    false
+                }
+
+                wm.addView(box, lp)
+                root = box
+
+                // seconds > 0 : feste Dauer wie gehabt.
+                // seconds == 0: bleibt stehen, bis der Nutzer etwas tut
+                //               (Taste via Accessibility-Dienst / Tipp daneben)
+                //               — mit Notbremse, damit sie nie haengen bleibt.
+                val cap = if (seconds > 0) seconds else HARD_CAP_SEC
+                hideRunnable = Runnable { hideNow(ctx) }
+                main.postDelayed(hideRunnable!!, cap * 1000L)
+            } catch (_: Exception) {
+                root = null
+            }
+        }
+    }
+
+    /** Blendet eine laufende Einblendung aus. */
+    fun hide(ctx: Context) {
+        main.post { hideNow(ctx) }
+    }
+
+    private fun hideNow(ctx: Context) {
+        hideRunnable?.let { main.removeCallbacks(it) }
+        hideRunnable = null
+        val v: View? = root
+        root = null
+        if (v != null) {
+            try {
+                (ctx.getSystemService(Context.WINDOW_SERVICE) as WindowManager).removeView(v)
+            } catch (_: Exception) { /* schon weg */ }
+        }
+    }
+}
@@ -0,0 +1,447 @@
+package de.hackersoft.ariaagent
+
+import android.content.Context
+import android.os.BatteryManager
+import android.os.Build
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.TimeUnit
+
+/**
+ * RVS-WebSocket-Client (Meilenstein 1). Spricht dasselbe Protokoll wie der
+ * Desktop-Agent: meldet sich per host_hello, haelt sich per host_ping frisch,
+ * beantwortet host_command -> host_result.
+ *
+ * M1-Aktionen: nur `info`. screenshot/ui_* folgen in M2/M3.
+ */
+class RvsClient(
+    private val appCtx: Context,
+    private val config: AgentConfig,
+    private val onStatus: (connected: Boolean, msg: String) -> Unit,
+) {
+    private val client = OkHttpClient.Builder()
+        .pingInterval(20, TimeUnit.SECONDS)
+        .readTimeout(0, TimeUnit.MILLISECONDS)   // Server-Push: nie lesen-timeouten
+        .build()
+
+    private var ws: WebSocket? = null
+    @Volatile private var running = false
+    private var pingThread: Thread? = null
+
+    /** Sprachdialog mit ARIA (Mikro rein, Sprache/Einblendung raus). */
+    val voice: VoiceSession by lazy {
+        VoiceSession(appCtx, config,
+            send = { t, p -> ws?.let { send(it, t, p) } ?: false },
+            onEvent = { msg -> onStatus(true, msg) })
+    }
+
+    /** Fire TV / Android TV? Dann gibt es keinen Touchscreen, dafuer D-Pad. */
+    private val isTv: Boolean by lazy {
+        try {
+            val pm = appCtx.packageManager
+            pm.hasSystemFeature("android.software.leanback") ||
+                pm.hasSystemFeature("android.hardware.type.television") ||
+                (appCtx.getSystemService(Context.UI_MODE_SERVICE) as android.app.UiModeManager)
+                    .currentModeType == android.content.res.Configuration.UI_MODE_TYPE_TELEVISION
+        } catch (_: Exception) { false }
+    }
+
+    private val caps: List<String> by lazy {
+        val base = mutableListOf("info", "screenshot", "ui_dump",
+            "ui_tap", "ui_text", "ui_swipe", "ui_key", "app_launch",
+            // Ausgabe auf dem Geraet: Einblendung ueber dem Bild + Sprachausgabe.
+            "notify", "speak", "volume",
+            // Sprachdialog: Mikro oeffnen/schliessen (ARIA kann es auch anstossen).
+            "listen", "listen_stop")
+        if (isTv) base += "tv"   // Kennzeichen: dieses Geraet ist ein Fernseher/Stick
+        base
+    }
+
+    fun start() {
+        running = true
+        connect()
+    }
+
+    fun stop() {
+        running = false
+        pingThread?.interrupt()
+        try { ws?.close(1000, "bye") } catch (_: Exception) {}
+        ws = null
+    }
+
+    private fun url(): String {
+        val proto = if (config.tls) "wss" else "ws"
+        return "$proto://${config.host}:${config.port}?token=${config.token}"
+    }
+
+    private fun connect() {
+        if (!running) return
+        onStatus(false, "verbinde …")
+        val req = Request.Builder().url(url()).build()
+        ws = client.newWebSocket(req, object : WebSocketListener() {
+            override fun onOpen(webSocket: WebSocket, response: Response) {
+                onStatus(true, "verbunden")
+                sendHello(webSocket)
+                startPing(webSocket)
+            }
+            override fun onMessage(webSocket: WebSocket, text: String) {
+                handle(webSocket, text)
+            }
+            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+                onStatus(false, "getrennt: ${t.message ?: "?"}")
+                reconnectLater()
+            }
+            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+                onStatus(false, "geschlossen")
+                reconnectLater()
+            }
+        })
+    }
+
+    private fun reconnectLater() {
+        pingThread?.interrupt()
+        if (!running) return
+        Thread {
+            try { Thread.sleep(3000) } catch (_: InterruptedException) { return@Thread }
+            connect()
+        }.start()
+    }
+
+    /**
+     * Verschickt eine Nachricht. Gibt zurueck, ob der Socket sie ANGENOMMEN hat.
+     *
+     * Wichtig: OkHttps `send()` WIRFT NICHT, sondern gibt `false` zurueck, wenn
+     * die Verbindung zu ist oder der Ausgangspuffer voll ist. Dieser Rueckgabe-
+     * wert wurde vorher verworfen — ein Senden ins Leere sah damit aus wie ein
+     * Erfolg. Genau daran ist die Fire-TV-Sprachausgabe lautlos gescheitert und
+     * hat trotzdem "gesprochen" gemeldet.
+     */
+    private fun send(webSocket: WebSocket, type: String, payload: JSONObject): Boolean {
+        val o = JSONObject()
+        o.put("type", type)
+        o.put("payload", payload)
+        o.put("timestamp", System.currentTimeMillis())
+        return try { webSocket.send(o.toString()) } catch (_: Exception) { false }
+    }
+
+    private fun sendHello(webSocket: WebSocket) {
+        val p = JSONObject()
+        p.put("hostId", config.hostId())
+        p.put("name", config.displayName())
+        val kind = if (isTv) "Fire TV / Android TV" else "Android"
+        p.put("os", "$kind ${Build.VERSION.RELEASE} (${Build.MODEL})")
+        // Eigene LAN-IP mitmelden: so kann die Diagnostic diesen Agenten dem im
+        // Netz entdeckten Geraet zuordnen (z.B. um beim Ausrollen den bereits
+        // vergebenen Namen vorzuschlagen statt der technischen Kennung).
+        localIp()?.let { p.put("ip", it) }
+        p.put("caps", JSONArray(caps))
+        p.put("control", config.controlEnabled)
+        send(webSocket, "host_hello", p)
+    }
+
+    /** Erste echte IPv4 dieses Geraets im LAN (ohne Loopback). */
+    private fun localIp(): String? = try {
+        java.net.NetworkInterface.getNetworkInterfaces().toList()
+            .filter { it.isUp && !it.isLoopback }
+            .flatMap { it.inetAddresses.toList() }
+            .firstOrNull { !it.isLoopbackAddress && it is java.net.Inet4Address }
+            ?.hostAddress
+    } catch (_: Throwable) { null }
+
+    private fun startPing(webSocket: WebSocket) {
+        pingThread?.interrupt()
+        pingThread = Thread {
+            while (running && !Thread.currentThread().isInterrupted) {
+                try { Thread.sleep(25000) } catch (_: InterruptedException) { break }
+                val p = JSONObject().put("hostId", config.hostId())
+                send(webSocket, "host_ping", p)
+                sendHello(webSocket)   // Re-announce (RVS replayt hellos nicht)
+            }
+        }.also { it.start() }
+    }
+
+    private fun handle(webSocket: WebSocket, text: String) {
+        val msg = try { JSONObject(text) } catch (_: Exception) { return }
+        val type = msg.optString("type")
+        // Sprachdialog: chat/audio_pcm/stt_* laufen ueber dieselbe Verbindung.
+        // (Der RVS broadcastet alles im Raum — VoiceSession filtert auf den
+        // eigenen Turn, damit nicht auch Handy und Stick gleichzeitig antworten.)
+        if (type != "host_command") {
+            if (type in VOICE_TYPES) {
+                try { voice.handle(type, msg.optJSONObject("payload") ?: JSONObject()) }
+                catch (_: Throwable) {}
+            }
+            return
+        }
+        val payload = msg.optJSONObject("payload") ?: JSONObject()
+
+        val target = payload.optString("host").ifBlank { payload.optString("hostId") }
+        if (target.isNotBlank()
+            && !target.equals(config.hostId(), true)
+            && !target.equals(config.displayName(), true)) return
+
+        val action = payload.optString("action")
+        val params = payload.optJSONObject("params") ?: JSONObject()
+
+        fun reply(r: JSONObject) {
+            r.put("requestId", payload.optString("requestId"))
+            r.put("hostId", config.hostId())
+            r.put("action", action)
+            send(webSocket, "host_result", r)
+        }
+
+        // Alles, was SPRECHEN kann, laeuft in einem EIGENEN Thread. Es muss
+        // abwarten, bis wirklich Ton kommt — und dieses handle() laeuft auf dem
+        // Lese-Thread des WebSockets. Wuerden wir hier warten, kaeme das
+        // erwartete audio_pcm nie an (wir blockieren ja selbst das Lesen) und
+        // jede Sprachausgabe liefe garantiert in den Timeout.
+        if (action in SPEAKING_ACTIONS && config.controlEnabled) {
+            Thread {
+                val r = try {
+                    if (action == "speak") doSpeak(params) else doNotify(params)
+                } catch (t: Throwable) {
+                    err("Fehler bei '$action': ${t.javaClass.simpleName}: ${t.message}")
+                }
+                reply(r)
+            }.also { it.isDaemon = true }.start()
+            return
+        }
+
+        // WICHTIG: JEDE Aktion muss ein host_result liefern — auch bei Exception
+        // ODER OutOfMemoryError (Throwable!). Sonst bekommt ARIA statt einer
+        // Fehlermeldung nur einen Timeout (kein Result kommt zurueck).
+        val result: JSONObject = try {
+            when {
+                !config.controlEnabled ->
+                    err("Steuerung ist in der Agent-App deaktiviert (Schalter 'Steuerung erlauben').")
+                action == "info" -> doInfo()
+                action == "screenshot" -> doScreenshot()
+                action == "ui_dump" -> doUiDump()
+                // Steuern geht nur bei ENTSPERRTEM Gerät (Gesten/Tasten greifen sonst
+                // nicht — Android-Sicherheit). Sehen (screenshot/ui_dump) geht gesperrt.
+                action in CONTROL_ACTIONS && isLocked() ->
+                    err("Gerät ist gesperrt — zum Steuern bitte erst entsperren. " +
+                        "(Screenshot/Bildschirm lesen geht auch gesperrt.)")
+                action == "ui_tap" -> doUiTap(params)
+                action == "ui_text" -> doUiText(params)
+                action == "ui_swipe" -> doUiSwipe(params)
+                action == "ui_key" -> doUiKey(params)
+                action == "app_launch" -> doAppLaunch(params)
+                action == "notify" -> doNotify(params)
+                action == "speak" -> doSpeak(params)
+                action == "volume" -> doVolume(params)
+                action == "listen" -> voice.startListening()
+                action == "listen_stop" -> voice.stopListening("remote")
+                action == "app_list" ->
+                    err("Aktion '$action' kommt spaeter (noch nicht implementiert).")
+                else -> err("Aktion '$action' unbekannt.")
+            }
+        } catch (t: Throwable) {
+            err("Fehler bei '$action': ${t.javaClass.simpleName}: ${t.message}")
+        }
+        reply(result)
+    }
+
+    /** Steuer-Aktionen, die ein entsperrtes Gerät brauchen. */
+    private val CONTROL_ACTIONS = setOf("ui_tap", "ui_text", "ui_swipe", "ui_key", "app_launch")
+
+    /** Aktionen, die sprechen koennen — laufen abseits des WS-Lese-Threads,
+     *  weil sie auf das eintreffende audio_pcm warten (siehe handle()). */
+    private val SPEAKING_ACTIONS = setOf("speak", "notify")
+
+    /** Message-Typen des ARIA-Sprachdialogs (kein host_command). */
+    private val VOICE_TYPES = setOf(
+        "chat", "audio_pcm", "stt_endpoint", "stt_stream_done", "stt_partial")
+
+    private fun isLocked(): Boolean = try {
+        val km = appCtx.getSystemService(Context.KEYGUARD_SERVICE) as android.app.KeyguardManager
+        km.isKeyguardLocked
+    } catch (_: Exception) { false }
+
+    private fun err(m: String): JSONObject = JSONObject().put("ok", false).put("error", m)
+
+    /** Bildschirmfoto — selber Vertrag wie der Desktop-Agent: {format,bytes,base64}. */
+    private fun doScreenshot(): JSONObject {
+        if (!ScreenCapturer.active) {
+            val why = ScreenCapturer.lastError?.let { " (letzter Fehler: $it)" } ?: ""
+            return err("Bildschirm-Zugriff nicht erlaubt. In der Agent-App auf dem Handy " +
+                "einmalig 'Bildschirm-Zugriff erlauben' antippen.$why")
+        }
+        val png = ScreenCapturer.capture()
+            ?: return err("Screenshot fehlgeschlagen: ${ScreenCapturer.lastError ?: "unbekannt"}")
+        val b64 = android.util.Base64.encodeToString(png, android.util.Base64.NO_WRAP)
+        val res = JSONObject().put("format", "png").put("bytes", png.size).put("base64", b64)
+        return JSONObject().put("ok", true).put("result", res)
+    }
+
+    /** Sichtbare Bedienelemente als Baum (Bedienungshilfe). */
+    private fun doUiDump(): JSONObject {
+        val svc = a11y() ?: return a11yMissing()
+        return svc.dump()
+    }
+
+    private fun a11y(): AriaAccessibilityService? = AriaAccessibilityService.instance
+
+    private fun a11yMissing(): JSONObject =
+        err("Bedienungshilfe nicht aktiv. In der Agent-App 'Bedienungshilfe öffnen' " +
+            "antippen und 'ARIA Host-Agent' einschalten.")
+
+    /** Tippen auf Koordinaten (Pixel wie in ui_dump x/y). */
+    private fun doUiTap(p: JSONObject): JSONObject {
+        val svc = a11y() ?: return a11yMissing()
+        if (!p.has("x") || !p.has("y")) return err("ui_tap braucht x und y (aus ui_dump).")
+        return svc.tap(p.optInt("x"), p.optInt("y"))
+    }
+
+    /** Text in Feld an (x,y) schreiben. */
+    private fun doUiText(p: JSONObject): JSONObject {
+        val svc = a11y() ?: return a11yMissing()
+        val text = p.optString("text")
+        if (!p.has("x") || !p.has("y")) return err("ui_text braucht x, y und text.")
+        return svc.setText(p.optInt("x"), p.optInt("y"), text)
+    }
+
+    /** Wischen/Scrollen von (x1,y1) nach (x2,y2). */
+    private fun doUiSwipe(p: JSONObject): JSONObject {
+        val svc = a11y() ?: return a11yMissing()
+        if (!p.has("x1") || !p.has("y1") || !p.has("x2") || !p.has("y2"))
+            return err("ui_swipe braucht x1,y1,x2,y2 (optional duration_ms).")
+        return svc.swipe(p.optInt("x1"), p.optInt("y1"), p.optInt("x2"), p.optInt("y2"),
+            p.optInt("duration_ms", 300))
+    }
+
+    /** Globale Taste: back/home/recents/notifications. */
+    private fun doUiKey(p: JSONObject): JSONObject {
+        val svc = a11y() ?: return a11yMissing()
+        return svc.globalKey(p.optString("key"))
+    }
+
+    /** App starten (per Paketname oder Namens-Suche). */
+    private fun doAppLaunch(p: JSONObject): JSONObject {
+        val pm = appCtx.packageManager
+        var pkg = p.optString("package").trim()
+        val query = p.optString("query").trim()
+        if (pkg.isBlank() && query.isNotBlank()) {
+            pkg = resolvePackage(query) ?: return err("Keine App zu '$query' gefunden.")
+        }
+        if (pkg.isBlank()) return err("app_launch braucht 'package' ODER 'query' (App-Name).")
+        val intent = pm.getLaunchIntentForPackage(pkg)
+            ?: return err("App '$pkg' nicht installiert oder ohne Start-Symbol.")
+        intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
+        appCtx.startActivity(intent)
+        return JSONObject().put("ok", true)
+            .put("result", JSONObject().put("message", "App '$pkg' gestartet"))
+    }
+
+    /**
+     * ARIAs Antwort auf dem Geraet ausgeben: Einblendung (Overlay) und/oder Sprache.
+     * `mode` optional ("overlay" | "speech" | "both") — ohne Angabe gilt die
+     * Einstellung aus der App (config.replyMode). So kann ARIA pro Anfrage
+     * ueberschreiben ("...bitte als Sprache"), ohne die Voreinstellung zu aendern.
+     */
+    private fun doNotify(p: JSONObject): JSONObject {
+        val text = p.optString("text").ifBlank { p.optString("message") }
+        val title = p.optString("title", "ARIA")
+        if (text.isBlank() && !p.has("image_base64")) return err("notify braucht 'text'.")
+        val mode = p.optString("mode").ifBlank { config.replyMode }
+        val done = mutableListOf<String>()
+        val problems = mutableListOf<String>()
+
+        if (mode == "overlay" || mode == "both") {
+            if (!OverlayView.canDraw(appCtx)) {
+                problems += "Einblendung nicht erlaubt — in der Agent-App auf dem Gerät " +
+                    "'Einblendung erlauben' antippen (Berechtigung 'Über anderen Apps anzeigen')"
+            } else {
+                OverlayView.show(appCtx, title, text,
+                    p.optInt("seconds", 12),
+                    if (p.has("image_base64")) p.optString("image_base64") else null)
+                done += "eingeblendet"
+            }
+        }
+        if (mode == "speech" || mode == "both") {
+            val r = speakOut(p, text)
+            r.exceptionOrNull()?.let { problems += "Sprachausgabe: ${it.message}" }
+                ?: run { done += "gesprochen (ARIAs Stimme)" }
+        }
+        if (done.isEmpty()) return err(problems.joinToString("; ").ifBlank { "nichts ausgegeben" })
+        val msg = done.joinToString(" + ") + (if (problems.isEmpty()) "" else " (${problems.joinToString("; ")})")
+        return JSONObject().put("ok", true).put("result", JSONObject().put("message", msg))
+    }
+
+    /** Nur Sprachausgabe (ARIAs Audio, falls mitgeliefert — sonst Geraete-TTS). */
+    private fun doSpeak(p: JSONObject): JSONObject {
+        val text = p.optString("text")
+        if (text.isBlank() && !p.has("audio_base64")) return err("speak braucht 'text' oder 'audio_base64'.")
+        val how = if (p.optString("audio_base64").isNotBlank()) "Audio abgespielt"
+                  else if (p.optString("engine") == "device") "über die Geräte-Stimme gesprochen"
+                  else "wird mit ARIAs Stimme gesprochen (Audio kommt vom Server)"
+        val r = speakOut(p, text)
+        return r.fold(
+            { JSONObject().put("ok", true).put("result", JSONObject().put("message", how)) },
+            { err("Sprachausgabe fehlgeschlagen: ${it.message}") },
+        )
+    }
+
+    /**
+     * Sprachausgabe. Reihenfolge:
+     *  1. mitgeliefertes Audio abspielen,
+     *  2. ARIAs ECHTE Stimme ueber den Server anfordern (Standard) — Fire TV
+     *     Sticks haben oft gar keine (deutsche) TTS-Engine,
+     *  3. geraeteeigene Sprachausgabe nur auf ausdrueckliche Anforderung
+     *     (engine='device') oder wenn kein Server-Audio moeglich ist.
+     * focus: duck (Medien leiser, Standard) | pause (Medien anhalten) | none.
+     */
+    private fun speakOut(p: JSONObject, text: String): Result<Unit> {
+        val audio = p.optString("audio_base64")
+        val focus = p.optString("focus").ifBlank { "duck" }
+        if (audio.isNotBlank())
+            return Speaker.play(appCtx, audio, p.optString("audio_format", "wav"), focus)
+        if (p.optString("engine") == "device")
+            return Speaker.speak(appCtx, text, focus)
+        // Nicht nur abschicken, sondern abwarten bis wirklich Ton kommt —
+        // sonst meldet der Agent Erfolg und der Fernseher bleibt stumm.
+        return runCatching {
+            val mid = voice.requestTts(text)
+            voice.awaitSpeechStart(mid)
+        }
+    }
+
+    private fun doVolume(p: JSONObject): JSONObject {
+        if (!p.has("percent")) return err("volume braucht 'percent' (0-100).")
+        val v = p.optInt("percent")
+        Speaker.setVolume(appCtx, v)
+        return JSONObject().put("ok", true)
+            .put("result", JSONObject().put("message", "Lautstärke auf $v% gesetzt"))
+    }
+
+    /** Paketname per Label-Teilstring finden (case-insensitive). */
+    private fun resolvePackage(query: String): String? {
+        val pm = appCtx.packageManager
+        val q = query.lowercase()
+        val launch = android.content.Intent(android.content.Intent.ACTION_MAIN)
+            .addCategory(android.content.Intent.CATEGORY_LAUNCHER)
+        return pm.queryIntentActivities(launch, 0)
+            .mapNotNull { it.activityInfo }
+            .firstOrNull { pm.getApplicationLabel(it.applicationInfo).toString().lowercase().contains(q) }
+            ?.packageName
+    }
+
+    private fun doInfo(): JSONObject {
+        val res = JSONObject()
+        res.put("host", config.displayName())
+        res.put("model", Build.MODEL)
+        res.put("manufacturer", Build.MANUFACTURER)
+        res.put("android", Build.VERSION.RELEASE)
+        res.put("sdk", Build.VERSION.SDK_INT)
+        try {
+            val bm = appCtx.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
+            res.put("battery_percent", bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY))
+        } catch (_: Exception) {}
+        return JSONObject().put("ok", true).put("result", res)
+    }
+}
@@ -0,0 +1,149 @@
+package de.hackersoft.ariaagent
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.PixelFormat
+import android.hardware.display.DisplayManager
+import android.hardware.display.VirtualDisplay
+import android.media.Image
+import android.media.ImageReader
+import android.media.projection.MediaProjection
+import android.media.projection.MediaProjectionManager
+import android.os.Handler
+import android.os.HandlerThread
+import android.util.DisplayMetrics
+import android.view.WindowManager
+import java.io.ByteArrayOutputStream
+
+/**
+ * Bildschirm-Aufnahme via MediaProjection (Meilenstein 2 — "sehen").
+ *
+ * Der Nutzer erlaubt den Zugriff EINMALIG in der Agent-App (System-Dialog).
+ * Danach laeuft ein stiller VirtualDisplay -> ImageReader, aus dem `capture()`
+ * bei Bedarf das aktuelle Bild als PNG zieht. Kein Google-Dienst.
+ *
+ * Aufgenommen wird direkt in GEKAPPTER Aufloesung (max. 1280 lange Seite): die
+ * MediaProjection skaliert den Bildschirminhalt auf die VirtualDisplay-Groesse.
+ * Das haelt Speicher/Zeit klein (kein 10-MB-Vollbild-Bitmap -> kein OOM/Timeout).
+ *
+ * Der Zugriff geht bei App-Kill / Neustart verloren und muss neu erlaubt werden
+ * (Android-Sicherheit — Projection-Token ist nicht persistierbar).
+ */
+object ScreenCapturer {
+    private const val MAX_SIDE = 1280
+
+    private var projection: MediaProjection? = null
+    private var reader: ImageReader? = null
+    private var vdisplay: VirtualDisplay? = null
+    private var handlerThread: HandlerThread? = null
+    private var handler: Handler? = null
+    private var w = 0
+    private var h = 0
+    private var dpi = 0
+
+    /** Letzter Init-/Capture-Fehler (fuer die Fehlermeldung an ARIA). */
+    @Volatile
+    var lastError: String? = null
+
+    val active: Boolean
+        @Synchronized get() = projection != null
+
+    @Synchronized
+    fun start(ctx: Context, resultCode: Int, data: Intent) {
+        stop()
+        val mpm = ctx.getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
+        val mp = mpm.getMediaProjection(resultCode, data) ?: run {
+            lastError = "getMediaProjection lieferte null"
+            return
+        }
+
+        val metrics = DisplayMetrics()
+        val wm = ctx.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+        @Suppress("DEPRECATION")
+        wm.defaultDisplay.getRealMetrics(metrics)
+        dpi = metrics.densityDpi
+        // Direkt gekappt aufnehmen (lange Seite <= MAX_SIDE), Seitenverhaeltnis wahren.
+        val longSide = maxOf(metrics.widthPixels, metrics.heightPixels)
+        val scale = if (longSide > MAX_SIDE) MAX_SIDE.toFloat() / longSide else 1f
+        w = (metrics.widthPixels * scale).toInt().coerceAtLeast(1)
+        h = (metrics.heightPixels * scale).toInt().coerceAtLeast(1)
+
+        handlerThread = HandlerThread("aria-capture").also { it.start() }
+        handler = Handler(handlerThread!!.looper)
+
+        // Ab Android 14 Pflicht VOR createVirtualDisplay; frueher unschaedlich.
+        mp.registerCallback(object : MediaProjection.Callback() {
+            override fun onStop() { stop() }
+        }, handler)
+
+        val ir = ImageReader.newInstance(w, h, PixelFormat.RGBA_8888, 2)
+        reader = ir
+        // AUTO_MIRROR = Standard-Flag fuer MediaProjection-Capture (die Projection
+        // selbst autorisiert die Aufnahme, kein Sonderrecht noetig).
+        vdisplay = mp.createVirtualDisplay(
+            "aria-screen", w, h, dpi,
+            DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
+            ir.surface, null, handler,
+        )
+        projection = mp
+        lastError = null
+    }
+
+    @Synchronized
+    fun stop() {
+        try { vdisplay?.release() } catch (_: Exception) {}
+        try { reader?.close() } catch (_: Exception) {}
+        try { projection?.stop() } catch (_: Exception) {}
+        try { handlerThread?.quitSafely() } catch (_: Exception) {}
+        vdisplay = null
+        reader = null
+        projection = null
+        handlerThread = null
+        handler = null
+    }
+
+    /** PNG-Bytes des aktuellen Bildschirms, oder null (Grund in lastError). */
+    fun capture(): ByteArray? {
+        val r = reader ?: run { lastError = "kein aktiver Bildschirm-Reader"; return null }
+        var image: Image? = null
+        var tries = 0
+        // Bis ~3s auf den ersten Frame warten (frischer VirtualDisplay braucht evtl. kurz).
+        while (tries < 37) {
+            image = r.acquireLatestImage()
+            if (image != null) break
+            try { Thread.sleep(80) } catch (_: InterruptedException) {}
+            tries++
+        }
+        if (image == null) {
+            lastError = "kein Frame erhalten (Bildschirm an? evtl. DRM-geschuetzter Inhalt)"
+            return null
+        }
+        return try {
+            val plane = image.planes[0]
+            val buffer = plane.buffer
+            val pixelStride = plane.pixelStride
+            val rowStride = plane.rowStride
+            val rowPadding = rowStride - pixelStride * w
+            val bmpW = w + (if (pixelStride > 0) rowPadding / pixelStride else 0)
+            val bmp = Bitmap.createBitmap(bmpW, h, Bitmap.Config.ARGB_8888)
+            bmp.copyPixelsFromBuffer(buffer)
+            val out = ByteArrayOutputStream()
+            if (rowPadding == 0) {
+                bmp.compress(Bitmap.CompressFormat.PNG, 100, out)
+            } else {
+                val cropped = Bitmap.createBitmap(bmp, 0, 0, w, h)
+                cropped.compress(Bitmap.CompressFormat.PNG, 100, out)
+                cropped.recycle()
+            }
+            bmp.recycle()
+            lastError = null
+            out.toByteArray()
+        } catch (t: Throwable) {
+            lastError = "Encode-Fehler: ${t.javaClass.simpleName}: ${t.message}"
+            null
+        } finally {
+            try { image?.close() } catch (_: Exception) {}
+        }
+    }
+}
@@ -0,0 +1,105 @@
+package de.hackersoft.ariaagent
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.speech.tts.TextToSpeech
+import android.util.Base64
+import java.io.File
+import java.util.Locale
+
+/**
+ * Sprachausgabe auf dem Geraet (v.a. Fire TV: ARIA spricht ueber die TV-Lautsprecher).
+ *
+ * Zwei Wege:
+ *  1) `play(audioBase64)` — ARIAs ECHTE Stimme: fertiges Audio (WAV/MP3) aus dem
+ *     bestehenden TTS-Pfad (F5/XTTS) wird einfach abgespielt. Bevorzugt.
+ *  2) `speak(text)` — geraeteeigene TextToSpeech als Rueckfallebene, falls kein
+ *     Audio mitgeliefert wurde (klingt nach Standard-Stimme, nicht nach ARIA).
+ */
+object Speaker {
+
+    private var tts: TextToSpeech? = null
+    private var ttsReady = false
+    private var player: MediaPlayer? = null
+
+    /** Spielt fertiges Audio (Base64, z.B. WAV aus dem ARIA-TTS) ueber die Lautsprecher.
+     *  [focus] = duck (Medien leiser, Standard) | pause (Medien anhalten) | none. */
+    fun play(ctx: Context, audioB64: String, format: String = "wav",
+             focus: String = "duck"): Result<Unit> = runCatching {
+        stop()
+        val bytes = Base64.decode(audioB64, Base64.DEFAULT)
+        val f = File(ctx.cacheDir, "aria_speak.${format.ifBlank { "wav" }}")
+        f.writeBytes(bytes)
+        // Erst Fokus holen, damit Netflix & Co. leiser werden (sonst redet ARIA
+        // einfach mittendrin mit und man versteht beides nicht).
+        AudioFocusHelper.request(ctx, focus, "speak")
+        player = MediaPlayer().apply {
+            setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_ASSISTANT)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                    .build()
+            )
+            setDataSource(f.absolutePath)
+            setOnCompletionListener { mp ->
+                try { mp.release() } catch (_: Exception) {}
+                player = null
+                AudioFocusHelper.abandon(ctx)   // Medien wieder laut / weiterlaufen
+            }
+            setOnErrorListener { _, _, _ -> AudioFocusHelper.abandon(ctx); false }
+            prepare()
+            start()
+        }
+    }
+
+    /** Rueckfallebene: geraeteeigene Sprachausgabe. */
+    fun speak(ctx: Context, text: String, focus: String = "duck"): Result<Unit> = runCatching {
+        if (tts == null) {
+            tts = TextToSpeech(ctx.applicationContext) { status ->
+                ttsReady = status == TextToSpeech.SUCCESS
+                if (ttsReady) tts?.language = Locale.GERMAN
+            }
+            // Kurz auf die Initialisierung warten (TTS meldet sich asynchron).
+            var waited = 0
+            while (!ttsReady && waited < 3000) { Thread.sleep(100); waited += 100 }
+        }
+        if (!ttsReady) throw IllegalStateException(
+            "Geraet hat keine Sprachausgabe (TTS-Engine fehlt — auf Fire TV ueblich)")
+        // Sprache pruefen: eine Engine ohne deutsche Daten wuerde sonst STILL
+        // nichts sagen und wir wuerden faelschlich 'gesprochen' melden.
+        val lang = tts?.setLanguage(Locale.GERMAN) ?: TextToSpeech.LANG_NOT_SUPPORTED
+        if (lang == TextToSpeech.LANG_MISSING_DATA || lang == TextToSpeech.LANG_NOT_SUPPORTED)
+            throw IllegalStateException(
+                "Geraete-Sprachausgabe kann kein Deutsch (Sprachdaten fehlen)")
+        AudioFocusHelper.request(ctx, focus, "speak")
+        tts?.setOnUtteranceProgressListener(object : android.speech.tts.UtteranceProgressListener() {
+            override fun onStart(id: String?) {}
+            override fun onDone(id: String?) { AudioFocusHelper.abandon(ctx) }
+            @Deprecated("Deprecated in Java")
+            override fun onError(id: String?) { AudioFocusHelper.abandon(ctx) }
+        })
+        val rc = tts?.speak(text, TextToSpeech.QUEUE_FLUSH, null, "aria")
+        if (rc != TextToSpeech.SUCCESS) {
+            AudioFocusHelper.abandon(ctx)
+            throw IllegalStateException("Sprachausgabe abgelehnt (Code $rc)")
+        }
+        Unit
+    }
+
+    /** Lautstaerke 0..100 (Medien-Kanal). */
+    fun setVolume(ctx: Context, percent: Int) {
+        val am = ctx.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        val max = am.getStreamMaxVolume(AudioManager.STREAM_MUSIC)
+        val v = (max * percent.coerceIn(0, 100) / 100.0).toInt()
+        am.setStreamVolume(AudioManager.STREAM_MUSIC, v, AudioManager.FLAG_SHOW_UI)
+    }
+
+    fun stop(ctx: Context? = null) {
+        try { player?.stop(); player?.release() } catch (_: Exception) {}
+        player = null
+        try { tts?.stop() } catch (_: Exception) {}
+        ctx?.let { AudioFocusHelper.abandon(it) }
+    }
+}
@@ -0,0 +1,351 @@
+package de.hackersoft.ariaagent
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFormat
+import android.media.AudioManager
+import android.media.AudioRecord
+import android.media.AudioTrack
+import android.media.MediaRecorder
+import android.media.audiofx.AcousticEchoCanceler
+import android.media.audiofx.NoiseSuppressor
+import android.util.Base64
+import okhttp3.WebSocket
+import org.json.JSONObject
+import kotlin.random.Random
+
+/**
+ * Sprachdialog mit ARIA direkt auf dem Geraet (v.a. Fire TV: reden ueber die
+ * Fernbedienung, Antwort ueber die TV-Lautsprecher bzw. als Einblendung).
+ *
+ * Nutzt GENAU das Protokoll der ARIA-App, damit serverseitig nichts angepasst
+ * werden muss:
+ *   rein : stt_stream_start -> stt_audio_chunk (Feld 'pcm', 16 kHz mono s16le,
+ *          6400-Byte-Bloecke) -> stt_stream_end
+ *   raus : chat (sender=aria, messageId/speak/converse) + audio_pcm (Feld
+ *          'base64', 24 kHz mono s16le, chunkweise bis final=true)
+ *
+ * WICHTIG — Turn-Ownership: Der RVS ist ein Broadcast-Relay ohne Adressierung.
+ * Jeder Client im Raum bekommt JEDE Antwort. Ohne Filter wuerden Handy-App und
+ * Fire TV dieselbe Antwort gleichzeitig vorlesen. Deshalb gibt dieses Geraet nur
+ * aus, was aus SEINER eigenen Frage entstanden ist (audioRequestId -> messageId).
+ */
+class VoiceSession(
+    private val appCtx: Context,
+    private val config: AgentConfig,
+    /** Gibt zurueck, ob der Socket die Nachricht angenommen hat (false = ins Leere). */
+    private val send: (type: String, payload: JSONObject) -> Boolean,
+    private val onEvent: (String) -> Unit = {},
+) {
+    companion object {
+        // Aufnahme — muss exakt zur STT-Bridge passen.
+        private const val IN_RATE = 16000
+        private const val CHUNK_BYTES = 6400          // 3200 Samples = 200 ms
+        // Wiedergabe — F5-TTS liefert 24 kHz (sampleRate steht aber im Payload).
+        private const val OUT_RATE_DEFAULT = 24000
+        private const val MAX_RECORD_MS = 60000
+    }
+
+    @Volatile private var recording = false
+    @Volatile private var recordThread: Thread? = null
+    private var rec: AudioRecord? = null
+    private var aec: AcousticEchoCanceler? = null
+    private var ns: NoiseSuppressor? = null
+
+    private var track: AudioTrack? = null
+    @Volatile private var playingMessageId: String? = null
+
+    /** Eigener Turn: gesetzt beim Aufnehmen, wandert ueber stt_endpoint zur messageId. */
+    @Volatile private var myAudioRequestId: String? = null
+    @Volatile private var myMessageId: String? = null
+    @Volatile private var sessionId: String? = null
+    /** Text der letzten ARIA-Antwort auf UNSERE Frage (fuer die Einblendung). */
+    @Volatile private var lastReplyText: String = ""
+
+    /** Angeforderte TTS-Ausgaben (messageId) — deren Audio spielen wir ab, auch
+     *  wenn es nicht aus einem eigenen Sprach-Turn stammt. */
+    private val expectedAudio = java.util.Collections.synchronizedSet(mutableSetOf<String>())
+
+    val isRecording: Boolean get() = recording
+
+    // ── Aufnehmen + streamen ────────────────────────────────────────
+
+    /** Startet die Aufnahme und streamt live an die STT. */
+    fun startListening(): JSONObject {
+        if (recording) return JSONObject().put("ok", false).put("error", "Nimmt bereits auf.")
+        val stamp = System.currentTimeMillis()
+        val rnd = Random.nextInt(100000, 999999)
+        val sid = "sttstr_${stamp}_$rnd"
+        val aid = "audio_${stamp}_$rnd"
+        sessionId = sid
+        myAudioRequestId = aid
+        myMessageId = null
+
+        val minBuf = AudioRecord.getMinBufferSize(
+            IN_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT)
+        if (minBuf <= 0) return JSONObject().put("ok", false)
+            .put("error", "Kein Mikrofon verfuegbar (Fire-TV-Fernbedienung aktiv? USB-Mikro?)")
+
+        val r = try {
+            AudioRecord(MediaRecorder.AudioSource.VOICE_COMMUNICATION, IN_RATE,
+                AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT,
+                maxOf(minBuf, CHUNK_BYTES * 4))
+        } catch (e: Throwable) {
+            return JSONObject().put("ok", false)
+                .put("error", "Mikrofon-Zugriff fehlgeschlagen: ${e.message}")
+        }
+        if (r.state != AudioRecord.STATE_INITIALIZED) {
+            try { r.release() } catch (_: Exception) {}
+            return JSONObject().put("ok", false)
+                .put("error", "Mikrofon nicht initialisiert (Berechtigung erteilt? Mikro vorhanden?)")
+        }
+        // Echo/Rauschen daempfen, damit der Stick nicht seine eigene Ausgabe hoert.
+        try { if (AcousticEchoCanceler.isAvailable()) aec = AcousticEchoCanceler.create(r.audioSessionId)?.apply { enabled = true } } catch (_: Exception) {}
+        try { if (NoiseSuppressor.isAvailable()) ns = NoiseSuppressor.create(r.audioSessionId)?.apply { enabled = true } } catch (_: Exception) {}
+
+        rec = r
+        recording = true
+        // Beim Zuhoeren laufende Medien ANHALTEN — sonst nimmt das Mikrofon den
+        // Filmton mit auf und die Spracherkennung versteht nur Kauderwelsch.
+        AudioFocusHelper.request(appCtx, "pause", "listen")
+
+        send("stt_stream_start", JSONObject().apply {
+            put("requestId", sid)
+            put("audioRequestId", aid)
+            put("voice", "")
+            put("speed", 1.0)
+            put("interrupted", false)
+            put("endpointMs", 2400)
+            put("hardCapMs", MAX_RECORD_MS)
+            put("sampleRate", IN_RATE)
+            put("projectId", "")
+            put("targetInstance", "")
+            put("language", "de")
+        })
+        onEvent("hoert zu …")
+
+        recordThread = Thread {
+            val buf = ByteArray(CHUNK_BYTES)
+            var seq = 0
+            try {
+                r.startRecording()
+                val until = System.currentTimeMillis() + MAX_RECORD_MS
+                while (recording && System.currentTimeMillis() < until) {
+                    val n = r.read(buf, 0, buf.size)
+                    if (n <= 0) continue
+                    val slice = if (n == buf.size) buf else buf.copyOf(n)
+                    send("stt_audio_chunk", JSONObject().apply {
+                        put("requestId", sid)
+                        put("pcm", Base64.encodeToString(slice, Base64.NO_WRAP))
+                        put("seq", seq++)
+                        put("targetInstance", "")
+                    })
+                }
+            } catch (_: Throwable) {
+                // Aufnahme abgebrochen — stopListening raeumt auf.
+            } finally {
+                stopListening("auto")
+            }
+        }.also { it.isDaemon = true; it.start() }
+
+        return JSONObject().put("ok", true)
+            .put("result", JSONObject().put("message", "Hoere zu …"))
+    }
+
+    /** Beendet die Aufnahme (die STT antwortet dann per stt_endpoint). */
+    fun stopListening(reason: String = "user"): JSONObject {
+        if (!recording) return JSONObject().put("ok", true)
+            .put("result", JSONObject().put("message", "Nahm nicht auf"))
+        recording = false
+        try { rec?.stop() } catch (_: Exception) {}
+        try { rec?.release() } catch (_: Exception) {}
+        try { aec?.release() } catch (_: Exception) {}
+        try { ns?.release() } catch (_: Exception) {}
+        rec = null; aec = null; ns = null
+        // Aufnahme vorbei -> Medien laufen weiter (die Antwort holt sich gleich
+        // selbst wieder Fokus, sobald ARIAs Audio kommt).
+        AudioFocusHelper.abandon(appCtx)
+        sessionId?.let {
+            send("stt_stream_end", JSONObject().apply {
+                put("requestId", it); put("reason", reason); put("targetInstance", "")
+            })
+        }
+        onEvent("verarbeite …")
+        return JSONObject().put("ok", true)
+            .put("result", JSONObject().put("message", "Aufnahme beendet"))
+    }
+
+    /**
+     * Laesst ARIAs ECHTE Stimme etwas sagen: fordert das TTS-Audio ueber den
+     * bestehenden Server-Pfad an (tts_request -> Bridge -> F5/XTTS -> audio_pcm)
+     * und spielt es ab, sobald es hereinkommt.
+     *
+     * Besser als die geraeteeigene Sprachausgabe: Fire TV Sticks haben oft gar
+     * keine (deutsche) TTS-Engine — und es klingt nach ARIA, nicht nach Roboter.
+     */
+    fun requestTts(text: String): String {
+        val mid = "spk_${System.currentTimeMillis()}_${Random.nextInt(100000, 999999)}"
+        expectedAudio.add(mid)
+        // Nicht unbegrenzt wachsen lassen, falls mal keine Antwort kommt.
+        if (expectedAudio.size > 20) {
+            synchronized(expectedAudio) {
+                expectedAudio.iterator().let { if (it.hasNext()) { it.next(); it.remove() } }
+            }
+        }
+        val accepted = send("tts_request", JSONObject().apply {
+            put("text", text)
+            put("messageId", mid)
+            put("voice", "")
+            put("speed", 1.0)
+        })
+        if (!accepted) {
+            expectedAudio.remove(mid)
+            throw IllegalStateException(
+                "Keine Verbindung zum Server — TTS-Anfrage ging nicht raus")
+        }
+        return mid
+    }
+
+    /**
+     * Wartet, bis fuer [mid] wirklich der erste Ton kommt.
+     *
+     * Ohne das meldete `host_speak` Erfolg, sobald die Anfrage im Socket lag —
+     * ARIA sagte "erledigt", und der Fernseher blieb still. Hier wird erst
+     * geantwortet, wenn tatsaechlich Audio laeuft, sonst mit klarem Grund.
+     */
+    fun awaitSpeechStart(mid: String, timeoutMs: Long = 20000) {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            if (playingMessageId == mid) return            // Ton laeuft
+            if (!expectedAudio.contains(mid)) return        // schon fertig gesprochen
+            try { Thread.sleep(100) } catch (_: InterruptedException) { return }
+        }
+        expectedAudio.remove(mid)
+        throw IllegalStateException(
+            "Server hat kein Audio geliefert (TTS-Dienst erreichbar? Stimme gesetzt?)")
+    }
+
+    /** Text direkt an ARIA schicken (ohne Mikrofon) — Antwort landet hier genauso. */
+    fun ask(text: String): JSONObject {
+        if (text.isBlank()) return JSONObject().put("ok", false).put("error", "leerer Text")
+        val stamp = System.currentTimeMillis()
+        myAudioRequestId = "audio_${stamp}_${Random.nextInt(100000, 999999)}"
+        myMessageId = null
+        send("chat", JSONObject().apply {
+            put("text", text)
+            put("voice", ""); put("speed", 1.0); put("projectId", "")
+            put("clientMsgId", "cmsg_${stamp}_${Random.nextInt(100000, 999999)}")
+        })
+        return JSONObject().put("ok", true)
+            .put("result", JSONObject().put("message", "Frage gesendet"))
+    }
+
+    // ── Eingehende Nachrichten ──────────────────────────────────────
+
+    /** Verarbeitet Sprach-/Chat-Nachrichten. true = war fuer uns relevant. */
+    fun handle(type: String, p: JSONObject): Boolean = when (type) {
+        "stt_endpoint", "stt_stream_done" -> {
+            if (p.optString("requestId") == sessionId) {
+                val text = p.optString("text")
+                if (type == "stt_endpoint" && text.isNotBlank()) onEvent("verstanden: $text")
+                if (type == "stt_stream_done") { recording = false; sessionId = null }
+            }
+            true
+        }
+        "chat" -> {
+            if (p.optString("sender") == "aria" && isMyTurn(p)) {
+                myMessageId = p.optString("messageId")
+                lastReplyText = p.optString("text")
+                deliverReply(p)
+            }
+            true
+        }
+        "audio_pcm" -> {
+            // Abspielen, wenn (a) wir dieses Audio selbst angefordert haben
+            // (host_speak/notify) oder (b) es die Antwort auf UNSERE Frage ist und
+            // Sprachausgabe gewuenscht war. Sonst wuerde auch das Handy mitreden.
+            val mid = p.optString("messageId")
+            if (mid.isNotBlank() &&
+                (expectedAudio.contains(mid) || (mid == myMessageId && wantSpeech()))) {
+                feedAudio(p)
+                if (p.optBoolean("final", false)) expectedAudio.remove(mid)
+            }
+            true
+        }
+        else -> false
+    }
+
+    /** Gehoert diese Antwort zu unserer Frage? */
+    private fun isMyTurn(p: JSONObject): Boolean {
+        val aid = myAudioRequestId ?: return false
+        val pa = p.optString("audioRequestId")
+        // Sprach-Turn: audioRequestId wird durchgereicht. Text-Turn (ask): die
+        // naechste ARIA-Antwort nach unserer Frage gehoert uns.
+        return if (pa.isNotBlank()) pa == aid else myMessageId == null
+    }
+
+    private fun wantSpeech(): Boolean = config.replyMode == "speech"
+
+    /** Antwort ausgeben: Einblendung und/oder Sprache (je nach Einstellung). */
+    private fun deliverReply(p: JSONObject) {
+        val text = p.optString("text")
+        if (text.isBlank()) return
+        if (config.replyMode == "overlay" && OverlayView.canDraw(appCtx)) {
+            OverlayView.show(appCtx, "ARIA", text, 15, null)
+        } else if (config.replyMode == "overlay") {
+            onEvent("Antwort (Einblendung nicht erlaubt): $text")
+        }
+        // Bei "speech" kommt das Audio ueber audio_pcm; falls ARIA nicht spricht
+        // (speak=false), trotzdem einblenden, damit nichts verloren geht.
+        if (wantSpeech() && !p.optBoolean("speak", true) && OverlayView.canDraw(appCtx)) {
+            OverlayView.show(appCtx, "ARIA", text, 15, null)
+        }
+    }
+
+    // ── TTS-Wiedergabe (chunkweises PCM) ────────────────────────────
+
+    private fun feedAudio(p: JSONObject) {
+        val mid = p.optString("messageId")
+        val rate = p.optInt("sampleRate", OUT_RATE_DEFAULT)
+        if (p.optBoolean("final", false)) {
+            try { track?.stop() } catch (_: Exception) {}
+            try { track?.release() } catch (_: Exception) {}
+            track = null; playingMessageId = null
+            // Fertig gesprochen -> Medien wieder hochfahren/weiterlaufen lassen.
+            AudioFocusHelper.abandon(appCtx)
+            onEvent("bereit")
+            return
+        }
+        val b64 = p.optString("base64")
+        if (b64.isBlank()) return
+        val pcm = try { Base64.decode(b64, Base64.DEFAULT) } catch (_: Exception) { return }
+        if (track == null || playingMessageId != mid) {
+            try { track?.release() } catch (_: Exception) {}
+            // ARIA antwortet -> laufende Medien leiser (duck), bis sie fertig ist.
+            AudioFocusHelper.request(appCtx, "duck", "speak")
+            val min = AudioTrack.getMinBufferSize(rate, AudioFormat.CHANNEL_OUT_MONO,
+                AudioFormat.ENCODING_PCM_16BIT)
+            track = AudioTrack.Builder()
+                .setAudioAttributes(AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_ASSISTANT)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH).build())
+                .setAudioFormat(AudioFormat.Builder()
+                    .setSampleRate(rate)
+                    .setChannelMask(AudioFormat.CHANNEL_OUT_MONO)
+                    .setEncoding(AudioFormat.ENCODING_PCM_16BIT).build())
+                .setBufferSizeInBytes(maxOf(min, 16384))
+                .setTransferMode(AudioTrack.MODE_STREAM)
+                .build().also { it.play() }
+            playingMessageId = mid
+            onEvent("spricht …")
+        }
+        try { track?.write(pcm, 0, pcm.size) } catch (_: Exception) {}
+    }
+
+    fun shutdown() {
+        stopListening("shutdown")
+        try { track?.stop(); track?.release() } catch (_: Exception) {}
+        track = null
+        AudioFocusHelper.abandon(appCtx)
+    }
+}
@@ -0,0 +1,32 @@
+<!-- Banner-Kachel fuer den Fire-TV-/Android-TV-Launcher (320x180 dp).
+     TV-Launcher zeigen Banner statt Icons — ohne das fehlt die Kachel. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="320dp"
+    android:height="180dp"
+    android:viewportWidth="320"
+    android:viewportHeight="180">
+    <path
+        android:fillColor="#0D0D1A"
+        android:pathData="M0,0h320v180h-320z" />
+    <!-- Ring (ARIA-Auge) -->
+    <path
+        android:fillColor="#3FFF9F"
+        android:pathData="M74,90 m-34,0 a34,34 0 1,0 68,0 a34,34 0 1,0 -68,0 Z M74,90 m-17,0 a17,17 0 1,1 34,0 a17,17 0 1,1 -34,0 Z" />
+    <!-- Schriftzug "ARIA" als Pfade (keine Font-Abhaengigkeit im Vector) -->
+    <path
+        android:fillColor="#E0E0F0"
+        android:pathData="M140,110 L152,64 L162,64 L174,110 L164,110 L161,99 L153,99 L150,110 Z M155,91 L159,91 L157,82 Z" />
+    <path
+        android:fillColor="#E0E0F0"
+        android:pathData="M180,110 L180,64 L196,64 A13,13 0 0,1 196,90 L200,110 L190,110 L187,92 L189,92 L189,110 Z M189,72 L189,84 L195,84 A6,6 0 0,0 195,72 Z" />
+    <path
+        android:fillColor="#E0E0F0"
+        android:pathData="M208,64 L217,64 L217,110 L208,110 Z" />
+    <path
+        android:fillColor="#E0E0F0"
+        android:pathData="M224,110 L236,64 L246,64 L258,110 L248,110 L245,99 L237,99 L234,110 Z M239,91 L243,91 L241,82 Z" />
+    <!-- Untertitel-Balken -->
+    <path
+        android:fillColor="#3FFF9F"
+        android:pathData="M140,122 h118 v4 h-118 z" />
+</vector>
@@ -0,0 +1,15 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillColor="#0D0D1A"
+        android:pathData="M0,0h108v108h-108z" />
+    <path
+        android:fillColor="#3FFF9F"
+        android:pathData="M54,26 m-26,0 a26,26 0 1,0 52,0 a26,26 0 1,0 -52,0 Z M54,26 m-13,0 a13,13 0 1,1 26,0 a13,13 0 1,1 -26,0 Z" />
+    <path
+        android:fillColor="#3FFF9F"
+        android:pathData="M52,58 h4 v24 h-4 z" />
+</vector>
@@ -0,0 +1,181 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fillViewport="true">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:padding="20dp">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/app_name"
+            android:textSize="22sp"
+            android:textStyle="bold"
+            android:paddingBottom="4dp" />
+
+        <TextView
+            android:id="@+id/status"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Status: —"
+            android:paddingBottom="16dp" />
+
+        <Button
+            android:id="@+id/btnScan"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:focusable="true"
+            android:focusableInTouchMode="false"
+            android:text="QR-Code scannen" />
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="— oder manuell —"
+            android:paddingTop="12dp"
+            android:paddingBottom="4dp" />
+
+        <EditText
+            android:id="@+id/host"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="RVS-Host (z.B. rvs.example.com)"
+            android:inputType="textUri" />
+
+        <EditText
+            android:id="@+id/port"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="Port"
+            android:text="443"
+            android:inputType="number" />
+
+        <EditText
+            android:id="@+id/token"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="RVS-Token"
+            android:inputType="textNoSuggestions" />
+
+        <EditText
+            android:id="@+id/name"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="Anzeigename (optional, z.B. 'Stefans Handy')"
+            android:inputType="text" />
+
+        <androidx.appcompat.widget.SwitchCompat
+            android:id="@+id/tls"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="TLS (wss)"
+            android:checked="true"
+            android:paddingTop="12dp" />
+
+        <androidx.appcompat.widget.SwitchCompat
+            android:id="@+id/control"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Steuerung erlauben (Aktionen ausführen)"
+            android:paddingTop="8dp"
+            android:paddingBottom="16dp" />
+
+        <Button
+            android:id="@+id/btnConnect"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Speichern &amp; Verbinden" />
+
+        <Button
+            android:id="@+id/btnStop"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Agent stoppen"
+            android:paddingTop="8dp" />
+
+        <Button
+            android:id="@+id/btnTalk"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:focusable="true"
+            android:text="🎤 Mit ARIA sprechen"
+            android:paddingTop="16dp" />
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Sehen (Meilenstein 2)"
+            android:textStyle="bold"
+            android:paddingTop="24dp"
+            android:paddingBottom="4dp" />
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Damit ARIA Screenshots machen und die Oberfläche lesen kann. Beides einmalig freigeben."
+            android:textSize="13sp"
+            android:paddingBottom="8dp" />
+
+        <Button
+            android:id="@+id/btnScreen"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Bildschirm-Zugriff erlauben" />
+
+        <Button
+            android:id="@+id/btnAccessibility"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Bedienungshilfe öffnen"
+            android:paddingTop="8dp" />
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Antworten (Fernseher)"
+            android:textStyle="bold"
+            android:paddingTop="24dp"
+            android:paddingBottom="4dp" />
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Wie ARIA hier standardmäßig antwortet. Sie kann das pro Anfrage überschreiben (z.B. mit dem Zusatz: bitte als Sprache)."
+            android:textSize="13sp"
+            android:paddingBottom="8dp" />
+
+        <RadioGroup
+            android:id="@+id/replyMode"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical">
+
+            <RadioButton
+                android:id="@+id/modeOverlay"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:focusable="true"
+                android:text="Einblendung über dem Bild (Standard)" />
+
+            <RadioButton
+                android:id="@+id/modeSpeech"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:focusable="true"
+                android:text="Sprachausgabe über die Lautsprecher" />
+        </RadioGroup>
+
+        <Button
+            android:id="@+id/btnOverlayPerm"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Einblendung erlauben"
+            android:paddingTop="8dp" />
+
+    </LinearLayout>
+</ScrollView>
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">ARIA Host-Agent</string>
+    <string name="accessibility_desc">Erlaubt ARIA, die sichtbaren Bildschirm-Elemente zu lesen (Text und Position), um Dich fernzusteuern. Nur aktiv, wenn Du \'Steuerung erlauben\' eingeschaltet hast.</string>
+</resources>
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
+    android:accessibilityEventTypes="typeWindowStateChanged|typeWindowContentChanged"
+    android:accessibilityFeedbackType="feedbackGeneric"
+    android:accessibilityFlags="flagRetrieveInteractiveWindows|flagReportViewIds|flagRequestFilterKeyEvents"
+    android:canRetrieveWindowContent="true"
+    android:canPerformGestures="true"
+    android:canRequestFilterKeyEvents="true"
+    android:notificationTimeout="100"
+    android:description="@string/accessibility_desc" />
@@ -0,0 +1,5 @@
+// Root-Build. Plugin-Versionen zentral, in den Modulen nur angewandt.
+plugins {
+    id 'com.android.application' version '8.2.2' apply false
+    id 'org.jetbrains.kotlin.android' version '1.9.22' apply false
+}
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# Baut die Android-Agent-APK per Docker (Android-SDK + Gradle).
+#   ./build.sh
+# Ergebnis: dist/aria-android-agent.apk  -> aufs Handy kopieren + installieren
+# ("Unbekannte Quellen erlauben").
+set -euo pipefail
+cd "$(dirname "$0")"
+mkdir -p dist
+docker build -f Dockerfile.build -t aria-android-agent-build .
+docker run --rm -v "$(pwd)/dist:/out" aria-android-agent-build
+echo
+echo "Fertig: dist/aria-android-agent.apk"
@@ -0,0 +1,5 @@
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true
+org.gradle.caching=true
@@ -0,0 +1,16 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.PREFER_SETTINGS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+rootProject.name = "aria-android-agent"
+include(":app")
@@ -0,0 +1,28 @@
+@echo off
+REM ARIA Host-Agent — Windows-Build mit PyInstaller (kein Docker).
+REM Voraussetzung: Python 3 installiert und im PATH (python.org, "Add to PATH").
+REM
+REM   build-native.bat
+REM
+REM Ergebnis: dist\aria-host-agent.exe (Onefile). Danach .env danebenlegen
+REM (siehe .env.example) und starten. Fuer Admin-Rechte die .exe per Rechtsklick
+REM "Als Administrator ausfuehren".
+setlocal
+cd /d "%~dp0"
+
+python -m venv .buildenv || goto :err
+call .buildenv\Scripts\activate.bat
+python -m pip install --quiet --upgrade pip
+python -m pip install --quiet pyinstaller -r requirements.txt || goto :err
+pyinstaller --onefile --name aria-host-agent --collect-all psutil host_agent.py || goto :err
+call deactivate
+
+echo.
+echo Fertig: dist\aria-host-agent.exe
+echo .env danebenlegen (siehe .env.example), dann starten (ggf. als Administrator).
+goto :eof
+
+:err
+echo.
+echo FEHLER beim Bauen. Ist Python 3 installiert und im PATH? (python --version)
+exit /b 1
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Baut die Host-Agent-Binary OHNE Docker — direkt mit PyInstaller.
+# Nutze das, wenn Docker nicht geht (z.B. Live-ISO mit overlayfs-Root, wo
+# Dockers overlay2-Treiber kein Overlay-auf-Overlay stapeln kann).
+#
+#   sudo apt install -y python3-pip python3-venv    # falls noch nicht da
+#   ./build-native.sh
+#
+# WICHTIG: Nativ gebaut linkt die Binary gegen das glibc DIESER Maschine. Sie
+# laeuft dann nur auf Systemen mit glibc >= dem hier. Fuer breite Kompatibilitaet
+# lieber ./build.sh (Docker/bullseye) auf einem normalen Rechner nutzen.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+python3 -m venv .buildenv
+# shellcheck disable=SC1091
+. .buildenv/bin/activate
+pip install --quiet --upgrade pip
+pip install --quiet pyinstaller -r requirements.txt
+pyinstaller --onefile --name aria-host-agent --collect-all psutil host_agent.py
+deactivate
+
+echo
+echo "Fertig: dist/aria-host-agent"
+echo ".env danebenlegen (siehe .env.example), dann: chmod +x aria-host-agent && ./aria-host-agent"
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Baut die Windows-.exe + setup.exe des Host-Agents AUF LINUX (Wine im Docker).
+#   ./build-win.sh [version]
+# Ergebnis:
+#   dist/aria-host-agent.exe         (Konsolen-Binary)
+#   dist/aria-host-agent-setup.exe   (Installer: richtet Windows-Dienst ein)
+#
+# Hinweis: Der erste Lauf zieht das tobix/pywine-Image (~1-2 GB) + baut die
+# Wine-Umgebung — das dauert. Folge-Builds sind schnell.
+set -euo pipefail
+cd "$(dirname "$0")"
+VERSION="${1:-0.0.0}"
+mkdir -p dist
+docker build -f Dockerfile.win --build-arg VERSION="$VERSION" -t aria-host-agent-win .
+docker run --rm -v "$(pwd)/dist:/out" aria-host-agent-win
+echo
+echo "Fertig: dist/aria-host-agent.exe + dist/aria-host-agent-setup.exe"
@@ -31,11 +31,28 @@ import re
 import shutil
 import socket
 import subprocess
+import sys
 import time
 from pathlib import Path

 import websockets

+# ─── Plattform-Weichen (Linux / macOS / Windows) ────────────────────
+IS_WINDOWS = os.name == "nt"
+IS_MAC = sys.platform == "darwin"
+
+
+def _is_admin() -> bool:
+    """root (Unix) bzw. Administrator (Windows)."""
+    try:
+        return os.geteuid() == 0            # Unix (Linux/macOS)
+    except AttributeError:
+        try:
+            import ctypes
+            return ctypes.windll.shell32.IsUserAnAdmin() != 0   # Windows
+        except Exception:
+            return False
+
 logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [host-agent] %(levelname)s %(message)s",
@@ -47,7 +64,13 @@ def _load_dotenv() -> None:
    """Laedt eine .env neben der Binary/dem Script (oder im CWD) in os.environ.
    Bereits gesetzte Werte gewinnen. Kein python-dotenv noetig."""
    here = os.path.dirname(os.path.abspath(__file__))
-    for path in (os.path.join(here, ".env"), os.path.join(os.getcwd(), ".env")):
+    # PyInstaller-onefile: __file__ liegt im Temp-Extract-Dir, NICHT beim .exe/
+    # Binary — deshalb zusaetzlich sys.executable-Ordner (echter Binary-Ort) und
+    # das CWD (z.B. der ProgramData-Ordner, den der Windows-Dienst als AppDir nutzt).
+    exe_dir = os.path.dirname(os.path.abspath(sys.executable))
+    seen = set()
+    candidates = [os.path.join(d, ".env") for d in (exe_dir, here, os.getcwd())]
+    for path in [p for p in candidates if not (p in seen or seen.add(p))]:
        if not os.path.isfile(path):
            continue
        try:
@@ -98,7 +121,27 @@ def _default_id() -> str:
 RVS_HOST = os.environ.get("RVS_HOST", "")
 RVS_PORT = int(os.environ.get("RVS_PORT", "443") or "443")
 RVS_TLS = _env_bool("RVS_TLS", True)
+# Bei TLS-Fehlschlag einmal auf ws:// zurueckfallen (wie die Compute-Bridges).
+# Hilft nur, wenn der RVS plaintext erreichbar ist; gegen Caddy-TLS bleibt wss.
+RVS_TLS_FALLBACK = _env_bool("RVS_TLS_FALLBACK", True)
 RVS_TOKEN = os.environ.get("RVS_TOKEN", "")
+# TLS-Hostname (SNI + Zertifikatspruefung), falls RVS_HOST eine IP ist — z.B. der
+# Agent laeuft im selben Netz wie der RVS und verbindet direkt auf die interne IP,
+# das Caddy-Zertifikat gilt aber fuer den Namen. Dann: RVS_HOST=<interne-ip>,
+# RVS_SNI=<zert-name>. Leer = SNI = RVS_HOST (Normalfall).
+RVS_SNI = os.environ.get("RVS_SNI", "").strip()
+
+# In-Process-DNS-Override: wenn RVS_SNI gesetzt ist, verbindet die URI ueber den
+# HOSTNAMEN (Host-Header + SNI + Cert stimmen), waehrend getaddrinfo den Namen auf
+# die echte IP in RVS_HOST aufloest. Versionsunabhaengig — host=/port= kollidiert
+# in der Legacy-websockets-API mit dem aus der URI abgeleiteten Host.
+if RVS_TLS and RVS_SNI:
+    import socket as _socket
+    _orig_getaddrinfo = _socket.getaddrinfo
+    def _sni_getaddrinfo(host, *a, **k):
+        return _orig_getaddrinfo(RVS_HOST if host == RVS_SNI else host, *a, **k)
+    _socket.getaddrinfo = _sni_getaddrinfo
+

 HOST_ID = (os.environ.get("HOST_ID") or _default_id()).strip()
 HOST_NAME = (os.environ.get("HOST_NAME") or HOST_ID).strip()
@@ -118,8 +161,41 @@ OUT_MAX_CHARS_HARD = int(os.environ.get("OUT_MAX_CHARS_HARD", "200000") or "2000
 # Datei-Transfer-Limit (Base64 durchs RVS).
 FILE_MAX_BYTES = int(os.environ.get("FILE_MAX_BYTES", str(10 * 1024 * 1024)) or str(10 * 1024 * 1024))

+# Version (wird von release_agent.sh beim Release gesetzt).
+AGENT_VERSION = "0.0.1.5"
+
 HEARTBEAT_SEC = 25
+
+
+def _gui_input_method() -> str:
+    """Welche Methode zur GUI-Steuerung (Maus/Tastatur) ist verfuegbar?
+    '' = keine (z.B. Linux-Server ohne X/Wayland -> nur Terminal/exec).
+      windows  -> PowerShell (Bordmittel)
+      macos    -> osascript (Text/Tasten) + cliclick (Maus, falls installiert)
+      xdotool  -> Linux/X11
+      ydotool  -> Linux/Wayland (Daemon noetig)"""
+    if IS_WINDOWS:
+        return "windows"
+    if IS_MAC:
+        return "macos"
+    if os.environ.get("DISPLAY") and shutil.which("xdotool"):
+        return "xdotool"
+    if os.environ.get("WAYLAND_DISPLAY") and shutil.which("ydotool"):
+        return "ydotool"
+    return ""
+
+
+GUI_METHOD = _gui_input_method()
+# macOS: Maus braucht cliclick; Text/Tasten/App gehen per osascript (Bordmittel).
+_MAC_MOUSE = IS_MAC and shutil.which("cliclick") is not None
+
 CAPS = ["exec", "read", "write", "info", "screenshot"]
+if GUI_METHOD:
+    # Tastatur/Text/App gehen bei jeder GUI-Methode; Maus (tap/swipe) auf dem Mac
+    # nur mit cliclick.
+    CAPS += ["ui_text", "ui_key", "app_launch"]
+    if GUI_METHOD != "macos" or _MAC_MOUSE:
+        CAPS += ["ui_tap", "ui_swipe"]


 # ─── Text-/Zahl-Helfer ──────────────────────────────────────────────
@@ -160,8 +236,18 @@ def _window_text(text: str, params: dict) -> dict:
 # ─── Aktionen ───────────────────────────────────────────────────────

 def _wrap_sudo(cmd: str, use_sudo: bool):
-    """Gibt (argv, stdin_data) oder (None, fehlertext) wenn sudo nicht moeglich."""
-    if not use_sudo or os.geteuid() == 0:
+    """Baut die Argv (OS-abhaengige Shell) + optional Root/Admin-Rechte.
+    Gibt (argv, stdin_data) oder (None, fehlertext)."""
+    if IS_WINDOWS:
+        # PowerShell; kein sudo. Fuer Admin-Rechte muss der Agent SELBST als
+        # Administrator laufen (UAC) — dann hat 'sudo:true' bereits volle Rechte.
+        if use_sudo and not _is_admin():
+            return None, ("Windows kennt kein sudo. Starte den Agent als "
+                          "Administrator ('Als Administrator ausfuehren'), dann "
+                          "laufen Kommandos mit vollen Rechten.")
+        return ["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd], None
+    # Unix: Linux + macOS (bash vorhanden; macOS-sudo verhaelt sich wie Linux)
+    if not use_sudo or _is_admin():
        return ["bash", "-lc", cmd], None
    if SUDO_PASSWORD:
        return ["sudo", "-S", "-p", "", "bash", "-lc", cmd], SUDO_PASSWORD + "\n"
@@ -244,9 +330,12 @@ def _do_write(params: dict) -> dict:
 def _do_info(params: dict) -> dict:
    info = {
        "host": HOST_NAME, "hostname": socket.gethostname(),
+        "agent_version": AGENT_VERSION,
        "os": platform.platform(), "kernel": platform.release(),
        "arch": platform.machine(), "python": platform.python_version(),
-        "user": os.environ.get("USER") or "", "is_root": os.geteuid() == 0,
+        "user": os.environ.get("USER") or os.environ.get("USERNAME") or "",
+        "is_root": _is_admin(),
+        "gui": GUI_METHOD or "none",   # '' => nur Terminal, keine GUI-Steuerung
    }
    try:
        import psutil
@@ -286,24 +375,35 @@ def _do_info(params: dict) -> dict:


 def _do_screenshot(params: dict) -> dict:
-    """Bildschirmfoto via System-Tool (Wayland: grim; X11: scrot/maim/import/
-    gnome-screenshot). Braucht eine aktive grafische Session (DISPLAY/WAYLAND)."""
+    """Bildschirmfoto — OS-abhaengig. Windows: PowerShell/System.Drawing;
+    macOS: screencapture; Linux: grim (Wayland) / scrot/maim/import (X11).
+    Braucht eine aktive grafische Session."""
    import tempfile
    tmp = os.path.join(tempfile.gettempdir(), f"aria_shot_{int(time.time())}.png")
-    wayland = bool(os.environ.get("WAYLAND_DISPLAY"))
    candidates = []
-    if wayland and shutil.which("grim"):
-        candidates.append(["grim", tmp])
-    for tool, argv in (("scrot", ["scrot", "-o", tmp]),
-                       ("maim", ["maim", tmp]),
-                       ("gnome-screenshot", ["gnome-screenshot", "-f", tmp]),
-                       ("import", ["import", "-window", "root", tmp])):
-        if shutil.which(tool):
-            candidates.append(argv)
+    if IS_WINDOWS:
+        ps = ("Add-Type -AssemblyName System.Windows.Forms,System.Drawing;"
+              "$b=[System.Windows.Forms.SystemInformation]::VirtualScreen;"
+              "$bmp=New-Object System.Drawing.Bitmap $b.Width,$b.Height;"
+              "$g=[System.Drawing.Graphics]::FromImage($bmp);"
+              "$g.CopyFromScreen($b.Location,[System.Drawing.Point]::Empty,$b.Size);"
+              f"$bmp.Save('{tmp}');$g.Dispose();$bmp.Dispose()")
+        candidates.append(["powershell", "-NoProfile", "-NonInteractive", "-Command", ps])
+    elif IS_MAC:
+        candidates.append(["screencapture", "-x", tmp])   # -x = ohne Ton
+    else:
+        if os.environ.get("WAYLAND_DISPLAY") and shutil.which("grim"):
+            candidates.append(["grim", tmp])
+        for tool, argv in (("scrot", ["scrot", "-o", tmp]),
+                           ("maim", ["maim", tmp]),
+                           ("gnome-screenshot", ["gnome-screenshot", "-f", tmp]),
+                           ("import", ["import", "-window", "root", tmp])):
+            if shutil.which(tool):
+                candidates.append(argv)
    if not candidates:
        return {"ok": False, "error":
-                "Kein Screenshot-Tool gefunden. Installiere grim (Wayland) oder "
-                "scrot/maim (X11)."}
+                "Kein Screenshot-Tool gefunden. Linux: grim (Wayland) oder "
+                "scrot/maim (X11) installieren. (Windows/macOS nutzen Bordmittel.)"}
    last_err = ""
    for argv in candidates:
        try:
@@ -321,9 +421,191 @@ def _do_screenshot(params: dict) -> dict:
            "Laeuft der Agent in derselben grafischen Session?"}


+# ─── GUI-Steuerung (Maus/Tastatur/App) — nur mit grafischer Session ──
+
+def _gui_unavailable() -> dict:
+    return {"ok": False, "error":
+            "Keine grafische Session zum Steuern. Linux: X11 (DISPLAY + xdotool) "
+            "oder Wayland (WAYLAND_DISPLAY + ydotool-Daemon). macOS: cliclick fuer "
+            "Maus. Auf einem reinen Terminal-/Server-System gibt es keine GUI."}
+
+
+def _run_gui(argv: list, desc: str) -> dict:
+    try:
+        r = subprocess.run(argv, capture_output=True, text=True, timeout=15)
+        if r.returncode == 0:
+            return {"ok": True, "result": {"message": f"{desc} ausgefuehrt"}}
+        return {"ok": False, "error": f"{desc} fehlgeschlagen: "
+                + (r.stderr or r.stdout or f"exit {r.returncode}").strip()[:200]}
+    except Exception as exc:
+        return {"ok": False, "error": f"{desc}: {exc}"}
+
+
+def _ps(script: str, desc: str) -> dict:
+    return _run_gui(["powershell", "-NoProfile", "-NonInteractive", "-Command", script], desc)
+
+
+def _osa(script: str, desc: str) -> dict:
+    return _run_gui(["osascript", "-e", script], desc)
+
+
+_WIN_MOUSE_DECL = (
+    "Add-Type -Name U -Namespace W -MemberDefinition '"
+    "[DllImport(\"user32.dll\")] public static extern bool SetCursorPos(int x,int y);"
+    "[DllImport(\"user32.dll\")] public static extern void mouse_event("
+    "uint f,uint x,uint y,uint d,int e);';"
+)
+
+
+def _do_ui_tap(params: dict) -> dict:
+    if not GUI_METHOD:
+        return _gui_unavailable()
+    x = _to_int(params.get("x")); y = _to_int(params.get("y"))
+    if x is None or y is None:
+        return {"ok": False, "error": "ui_tap braucht x,y (Bildschirm-Pixel aus dem Screenshot)."}
+    button = str(params.get("button", "left")).lower()
+    double = bool(params.get("double"))
+    desc = f"Klick ({x},{y})"
+    if GUI_METHOD == "xdotool":
+        btn = {"left": "1", "middle": "2", "right": "3"}.get(button, "1")
+        argv = ["xdotool", "mousemove", "--sync", str(x), str(y), "click"]
+        if double:
+            argv += ["--repeat", "2", "--delay", "120"]
+        return _run_gui(argv + [btn], desc)
+    if GUI_METHOD == "ydotool":
+        code = {"left": "0xC0", "right": "0xC1", "middle": "0xC2"}.get(button, "0xC0")
+        _run_gui(["ydotool", "mousemove", "-a", str(x), str(y)], "move")
+        r = _run_gui(["ydotool", "click", code], desc)
+        if double and r.get("ok"):
+            _run_gui(["ydotool", "click", code], desc)
+        return r
+    if GUI_METHOD == "macos":
+        if not _MAC_MOUSE:
+            return {"ok": False, "error": "Maus-Steuerung braucht cliclick (brew install cliclick)."}
+        cmd = ("dc:" if double else ("rc:" if button == "right" else "c:")) + f"{x},{y}"
+        return _run_gui(["cliclick", cmd], desc)
+    if GUI_METHOD == "windows":
+        down, up = ("0x0002", "0x0004") if button != "right" else ("0x0008", "0x0010")
+        click = f"[W.U]::mouse_event({down},0,0,0,0);[W.U]::mouse_event({up},0,0,0,0);"
+        script = _WIN_MOUSE_DECL + f"[W.U]::SetCursorPos({x},{y});" + click + (click if double else "")
+        return _ps(script, desc)
+    return _gui_unavailable()
+
+
+def _do_ui_text(params: dict) -> dict:
+    if not GUI_METHOD:
+        return _gui_unavailable()
+    text = str(params.get("text", ""))
+    if not text:
+        return {"ok": False, "error": "ui_text braucht 'text'."}
+    desc = f"Text ({len(text)} Zeichen)"
+    if GUI_METHOD == "xdotool":
+        return _run_gui(["xdotool", "type", "--clearmodifiers", "--", text], desc)
+    if GUI_METHOD == "ydotool":
+        return _run_gui(["ydotool", "type", "--", text], desc)
+    if GUI_METHOD == "macos":
+        esc = text.replace("\\", "\\\\").replace('"', '\\"')
+        return _osa(f'tell application "System Events" to keystroke "{esc}"', desc)
+    if GUI_METHOD == "windows":
+        safe = re.sub(r"([+^%~(){}\[\]])", r"{\1}", text).replace('"', '`"')
+        return _ps("Add-Type -AssemblyName System.Windows.Forms;"
+                   f"[System.Windows.Forms.SendKeys]::SendWait(\"{safe}\")", desc)
+    return _gui_unavailable()
+
+
+def _do_ui_key(params: dict) -> dict:
+    if not GUI_METHOD:
+        return _gui_unavailable()
+    key = str(params.get("key", "")).strip()
+    if not key:
+        return {"ok": False, "error": "ui_key braucht 'key' (z.B. Return, Escape, ctrl+c)."}
+    desc = f"Taste '{key}'"
+    if GUI_METHOD == "xdotool":
+        return _run_gui(["xdotool", "key", "--clearmodifiers", key], desc)
+    if GUI_METHOD == "ydotool":
+        return _run_gui(["ydotool", "key", key], desc)   # best effort (Keycodes)
+    if GUI_METHOD == "macos":
+        codes = {"return": 36, "enter": 36, "tab": 48, "space": 49, "delete": 51,
+                 "escape": 53, "esc": 53, "left": 123, "right": 124, "down": 125, "up": 126,
+                 "home": 115, "end": 119, "pageup": 116, "pagedown": 121}
+        k = key.lower()
+        if k in codes:
+            return _osa(f'tell application "System Events" to key code {codes[k]}', desc)
+        return _osa(f'tell application "System Events" to keystroke "{key}"', desc)
+    if GUI_METHOD == "windows":
+        m = {"return": "{ENTER}", "enter": "{ENTER}", "escape": "{ESC}", "esc": "{ESC}",
+             "tab": "{TAB}", "backspace": "{BACKSPACE}", "delete": "{DEL}",
+             "up": "{UP}", "down": "{DOWN}", "left": "{LEFT}", "right": "{RIGHT}",
+             "home": "{HOME}", "end": "{END}", "pageup": "{PGUP}", "pagedown": "{PGDN}"}
+        send = m.get(key.lower(), key)
+        return _ps("Add-Type -AssemblyName System.Windows.Forms;"
+                   f"[System.Windows.Forms.SendKeys]::SendWait('{send}')", desc)
+    return _gui_unavailable()
+
+
+def _do_ui_swipe(params: dict) -> dict:
+    """Auf dem Desktop = Maus ziehen von (x1,y1) nach (x2,y2)."""
+    if not GUI_METHOD:
+        return _gui_unavailable()
+    x1 = _to_int(params.get("x1")); y1 = _to_int(params.get("y1"))
+    x2 = _to_int(params.get("x2")); y2 = _to_int(params.get("y2"))
+    if None in (x1, y1, x2, y2):
+        return {"ok": False, "error": "ui_swipe braucht x1,y1,x2,y2."}
+    desc = f"Ziehen ({x1},{y1} -> {x2},{y2})"
+    if GUI_METHOD == "xdotool":
+        return _run_gui(["xdotool", "mousemove", "--sync", str(x1), str(y1),
+                         "mousedown", "1", "mousemove", "--sync", str(x2), str(y2),
+                         "mouseup", "1"], desc)
+    if GUI_METHOD == "ydotool":
+        _run_gui(["ydotool", "mousemove", "-a", str(x1), str(y1)], "move")
+        _run_gui(["ydotool", "click", "0x40"], "down")
+        _run_gui(["ydotool", "mousemove", "-a", str(x2), str(y2)], "move")
+        return _run_gui(["ydotool", "click", "0x80"], desc)
+    if GUI_METHOD == "macos":
+        if not _MAC_MOUSE:
+            return {"ok": False, "error": "Ziehen braucht cliclick."}
+        return _run_gui(["cliclick", f"dd:{x1},{y1}", f"du:{x2},{y2}"], desc)
+    if GUI_METHOD == "windows":
+        script = (_WIN_MOUSE_DECL +
+                  f"[W.U]::SetCursorPos({x1},{y1});[W.U]::mouse_event(0x0002,0,0,0,0);"
+                  f"Start-Sleep -Milliseconds 80;[W.U]::SetCursorPos({x2},{y2});"
+                  "[W.U]::mouse_event(0x0004,0,0,0,0);")
+        return _ps(script, desc)
+    return _gui_unavailable()
+
+
+def _do_app_launch(params: dict) -> dict:
+    """Startet eine App/ein Programm (nicht-blockierend). 'app' = Name/Pfad,
+    'command' = beliebiger Startbefehl."""
+    app = str(params.get("app") or params.get("query") or "").strip()
+    command = str(params.get("command") or "").strip()
+    if not app and not command:
+        return {"ok": False, "error": "app_launch braucht 'app' (Name) oder 'command'."}
+    try:
+        if command:
+            argv = command if IS_WINDOWS else ["/bin/sh", "-c", command]
+            subprocess.Popen(argv, shell=bool(IS_WINDOWS),
+                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return {"ok": True, "result": {"message": f"Befehl gestartet: {command}"}}
+        if IS_MAC:
+            subprocess.Popen(["open", "-a", app])
+        elif IS_WINDOWS:
+            subprocess.Popen(["cmd", "/c", "start", "", app])
+        else:
+            launcher = shutil.which(app) or app
+            head = ["setsid"] if shutil.which("setsid") else []
+            subprocess.Popen(head + [launcher],
+                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return {"ok": True, "result": {"message": f"App gestartet: {app}"}}
+    except Exception as exc:
+        return {"ok": False, "error": f"Start fehlgeschlagen: {exc}"}
+
+
 ACTIONS = {
    "exec": _do_exec, "read": _do_read, "write": _do_write,
    "info": _do_info, "screenshot": _do_screenshot,
+    "ui_tap": _do_ui_tap, "ui_text": _do_ui_text, "ui_key": _do_ui_key,
+    "ui_swipe": _do_ui_swipe, "app_launch": _do_app_launch,
 }


@@ -355,7 +637,7 @@ class HostAgent:
                        HOST_ID, HOST_NAME, ",".join(CAPS), CONTROL_ENABLED)
        await self._send({"type": "host_hello", "payload": {
            "hostId": HOST_ID, "name": HOST_NAME, "os": platform.platform(),
-            "caps": CAPS, "control": CONTROL_ENABLED,
+            "version": AGENT_VERSION, "caps": CAPS, "control": CONTROL_ENABLED,
        }, "timestamp": int(time.time() * 1000)})

    async def _heartbeat(self) -> None:
@@ -400,15 +682,26 @@ class HostAgent:
            logger.error("RVS_HOST und RVS_TOKEN sind Pflicht (siehe .env.example).")
            return
        backoff = 1
+        # use_tls kann bei Fehlschlag einmal auf ws:// fallen (RVS_TLS_FALLBACK),
+        # danach wieder zurueck auf RVS_TLS (kein Sticky-Fallback).
+        use_tls = RVS_TLS
+        tls_fallback_tried = False
+        connect_kwargs = {"max_size": 16 * 1024 * 1024,
+                          "ping_interval": 20, "ping_timeout": 20}
        while True:
-            proto = "wss" if RVS_TLS else "ws"
-            url = f"{proto}://{RVS_HOST}:{RVS_PORT}?token={RVS_TOKEN}"
+            proto = "wss" if use_tls else "ws"
+            # Bei TLS + RVS_SNI: URI nutzt den HOSTNAMEN (Host-Header/SNI/Cert),
+            # getaddrinfo mappt ihn auf die IP in RVS_HOST. Bei ws:// direkt die IP.
+            uri_host = RVS_SNI if (use_tls and RVS_SNI) else RVS_HOST
+            url = f"{proto}://{uri_host}:{RVS_PORT}?token={RVS_TOKEN}"
+            fallback = False
            try:
-                logger.info("Verbinde mit RVS %s://%s:%s …", proto, RVS_HOST, RVS_PORT)
-                async with websockets.connect(url, max_size=16 * 1024 * 1024,
-                                              ping_interval=20, ping_timeout=20) as ws:
+                logger.info("Verbinde mit RVS %s://%s:%s%s …", proto, uri_host, RVS_PORT,
+                            f" (TCP {RVS_HOST})" if (use_tls and RVS_SNI) else "")
+                async with websockets.connect(url, **connect_kwargs) as ws:
                    self.ws = ws
                    backoff = 1
+                    tls_fallback_tried = False
                    await self._hello(log=True)
                    hb = asyncio.create_task(self._heartbeat())
                    try:
@@ -418,15 +711,24 @@ class HostAgent:
                        hb.cancel()
            except Exception as exc:
                logger.warning("RVS-Verbindung verloren: %s", exc)
+                if use_tls and RVS_TLS_FALLBACK and not tls_fallback_tried:
+                    logger.info("TLS fehlgeschlagen — Fallback auf ws://")
+                    use_tls = False
+                    tls_fallback_tried = True
+                    fallback = True
            finally:
                self.ws = None
+            if fallback:
+                continue                        # sofort erneut mit ws://
            await asyncio.sleep(backoff)
            backoff = min(backoff * 2, 30)
+            use_tls = RVS_TLS                    # kein Sticky-Fallback
+            tls_fallback_tried = False


 def main() -> None:
    logger.info("ARIA Host-Agent startet — id=%s name=%s control=%s root=%s",
-                HOST_ID, HOST_NAME, CONTROL_ENABLED, os.geteuid() == 0)
+                HOST_ID, HOST_NAME, CONTROL_ENABLED, _is_admin())
    try:
        asyncio.run(HostAgent().run())
    except KeyboardInterrupt:
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# ARIA Host-Agent — Service-Installer (systemd).
+#
+# Installiert die Binary nach /usr/local/bin, die .env nach /etc/aria-host-agent
+# und richtet den systemd-Dienst ein (enable + start).
+#
+# Nutzung:
+#   sudo ./install-service.sh /pfad/zur/.env      # .env-Pfad direkt uebergeben
+#   sudo ./install-service.sh                      # ncurses-Dateidialog (dialog)
+#
+# Die Binary wird unter ./dist/aria-host-agent oder ./aria-host-agent erwartet
+# (vorher ./build.sh oder ./build-native.sh ausfuehren), oder als 2. Argument.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+BIN_DST="/usr/local/bin/aria-host-agent"
+ETC_DIR="/etc/aria-host-agent"
+UNIT_DST="/etc/systemd/system/aria-host-agent.service"
+
+die() { echo "FEHLER: $*" >&2; exit 1; }
+
+[ "$(id -u)" -eq 0 ] || die "Bitte mit sudo/root ausfuehren:  sudo $0 $*"
+
+# ── Binary finden (Arg 2 > dist/ > ./) ──────────────────────────────
+BIN_SRC="${2:-}"
+if [ -z "$BIN_SRC" ]; then
+  if   [ -x "$SCRIPT_DIR/dist/aria-host-agent" ]; then BIN_SRC="$SCRIPT_DIR/dist/aria-host-agent"
+  elif [ -x "$SCRIPT_DIR/aria-host-agent" ];      then BIN_SRC="$SCRIPT_DIR/aria-host-agent"
+  fi
+fi
+[ -n "$BIN_SRC" ] && [ -f "$BIN_SRC" ] || die "Binary nicht gefunden. Erst bauen (./build.sh) oder als 2. Argument uebergeben."
+
+# ── .env bestimmen: Arg 1, sonst ncurses-Dateidialog ────────────────
+ENV_SRC="${1:-}"
+if [ -z "$ENV_SRC" ]; then
+  if ! command -v dialog >/dev/null 2>&1; then
+    echo "Kein .env-Pfad uebergeben und 'dialog' ist nicht installiert."
+    read -r -p "dialog jetzt installieren (apt)? [j/N] " a
+    case "$a" in
+      j|J|y|Y) (apt-get update && apt-get install -y dialog) || die "dialog-Installation fehlgeschlagen — .env-Pfad bitte als Argument uebergeben." ;;
+      *) die "Ohne dialog bitte den .env-Pfad als Argument uebergeben:  sudo $0 /pfad/zur/.env" ;;
+    esac
+  fi
+  # dialog --fselect: Dateibrowser; --stdout gibt die Auswahl auf stdout.
+  START_DIR="${SUDO_USER:+/home/$SUDO_USER/}"
+  [ -d "$START_DIR" ] || START_DIR="$SCRIPT_DIR/"
+  ENV_SRC="$(dialog --stdout --title 'ARIA Host-Agent — .env auswaehlen' \
+                    --fselect "$START_DIR" 14 72)" || true
+  clear
+  [ -n "$ENV_SRC" ] || die "Abgebrochen — keine .env ausgewaehlt."
+fi
+[ -f "$ENV_SRC" ] || die ".env nicht gefunden: $ENV_SRC"
+
+echo "Binary : $BIN_SRC"
+echo ".env   : $ENV_SRC"
+
+# ── Installieren ────────────────────────────────────────────────────
+install -m 0755 "$BIN_SRC" "$BIN_DST"
+install -d -m 0755 "$ETC_DIR"
+install -m 0600 "$ENV_SRC" "$ETC_DIR/.env"      # 0600: enthaelt Token/Passwoerter
+
+if [ -f "$SCRIPT_DIR/aria-host-agent.service" ]; then
+  install -m 0644 "$SCRIPT_DIR/aria-host-agent.service" "$UNIT_DST"
+else
+  die "aria-host-agent.service nicht gefunden neben dem Installer."
+fi
+
+systemctl daemon-reload
+systemctl enable --now aria-host-agent
+
+echo
+echo "✓ Installiert & gestartet."
+echo "  Status:  systemctl status aria-host-agent"
+echo "  Log:     journalctl -u aria-host-agent -f"
+echo "  .env:    $ETC_DIR/.env   (aendern -> systemctl restart aria-host-agent)"
@@ -0,0 +1,150 @@
+#!/bin/bash
+# ════════════════════════════════════════════════════════════════════
+#  ARIA Host-Agent — Release Script
+#  Baut die auf Linux+Docker moeglichen Artefakte und haengt sie als
+#  Gitea-Release-Assets an einen Tag. NICHTS wandert in den Git-Tree —
+#  Binaries leben nur unter "Releases" (blaeht clone/History nicht auf).
+#
+#  Verwendung:  ./release_agent.sh <version>     (z.B. ./release_agent.sh 0.2.0)
+#
+#  Artefakte:
+#    - Linux-x64-Binary      (Docker, PyInstaller)          -> immer
+#    - Android-APK           (Docker, Gradle)               -> immer
+#    - macOS / Windows       (falls in dist/ vorgebaut)     -> optional
+#      (mac/win koennen auf Linux nicht cross-gebaut werden -> build-native.*
+#       auf dem jeweiligen OS laufen lassen, Ergebnis nach host-agent/dist/ legen)
+#
+#  Eigener Tag-Namespace  agent-v<version>  (kollidiert NICHT mit den
+#  App-Tags v<version>).
+#
+#  Gitea-Zugang (GITEA_URL, GITEA_REPO, GITEA_USER) wird aus der Umgebung
+#  oder aus host-agent/.env bzw. der Repo-Wurzel-.env gelesen; das Kennwort
+#  wird interaktiv abgefragt.
+# ════════════════════════════════════════════════════════════════════
+
+set -e
+cd "$(dirname "$0")"          # host-agent/
+SCRIPT_DIR="$(pwd)"
+ROOT_DIR="$(cd .. && pwd)"
+
+# ── Farben ───────────────────────────────────────────────────────────
+RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; CYAN='\033[0;36m'; NC='\033[0m'
+
+# ── Parameter ────────────────────────────────────────────────────────
+VERSION=${1:?"Usage: ./release_agent.sh <version>  (z.B. 0.2.0)"}
+TAG="agent-v$VERSION"
+
+# ── Gitea-Konfiguration (env > host-agent/.env > Repo-Wurzel-.env) ────
+[ -f "$SCRIPT_DIR/.env" ] && source "$SCRIPT_DIR/.env"
+[ -f "$ROOT_DIR/.env" ] && source "$ROOT_DIR/.env"
+
+GITEA_URL="${GITEA_URL:?"GITEA_URL nicht gesetzt (in .env oder als Umgebungsvariable)"}"
+GITEA_REPO="${GITEA_REPO:?"GITEA_REPO nicht gesetzt (z.B. stefan/aria-agent)"}"
+GITEA_USER="${GITEA_USER:-$(echo "$GITEA_REPO" | cut -d'/' -f1)}"
+
+echo -e "${CYAN}╔═══════════════════════════════════════════╗${NC}"
+echo -e "${CYAN}║   ARIA Host-Agent Release — ${TAG}$(printf '%*s' $((14 - ${#TAG})) '')║${NC}"
+echo -e "${CYAN}╚═══════════════════════════════════════════╝${NC}\n"
+
+# ── Kennwort ─────────────────────────────────────────────────────────
+echo -e "${YELLOW}Gitea-Login: ${GITEA_USER}${NC}"
+read -s -p "Gitea-Kennwort: " GITEA_PASS; echo ""
+HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -u "${GITEA_USER}:${GITEA_PASS}" "$GITEA_URL/api/v1/user")
+if [ "$HTTP_CODE" != "200" ]; then
+    echo -e "${RED}Login fehlgeschlagen (HTTP $HTTP_CODE). Kennwort korrekt?${NC}"; exit 1
+fi
+echo -e "  ${GREEN}✓${NC} Login erfolgreich\n"
+
+# ── Versionsnummern setzen ───────────────────────────────────────────
+echo -e "${GREEN}[1/5] Version auf $VERSION setzen...${NC}"
+# Desktop-Agent
+sed -i "s/^AGENT_VERSION = \"[^\"]*\"/AGENT_VERSION = \"$VERSION\"/" host_agent.py
+echo -e "  ${GREEN}✓${NC} host_agent.py → AGENT_VERSION $VERSION"
+# Android: versionName + versionCode (aus Version berechnen; 3- oder 4-stellig)
+IFS='.' read -ra VP <<< "$VERSION"
+V1=${VP[0]:-0}; V2=${VP[1]:-0}; V3=${VP[2]:-0}; V4=${VP[3]:-0}
+VERSION_CODE=$((V1 * 1000000 + V2 * 10000 + V3 * 100 + V4)); [ "$VERSION_CODE" -lt 1 ] && VERSION_CODE=1
+sed -i "s/versionName '[^']*'/versionName '$VERSION'/" android/app/build.gradle
+sed -i "s/versionCode [0-9]*/versionCode $VERSION_CODE/" android/app/build.gradle
+echo -e "  ${GREEN}✓${NC} android/app/build.gradle → versionName $VERSION, versionCode $VERSION_CODE\n"
+
+# ── Bauen (Docker) ───────────────────────────────────────────────────
+echo -e "${GREEN}[2/5] Linux-Binary + Android-APK bauen (Docker)...${NC}"
+./build.sh >/dev/null
+LINUX_BIN="$SCRIPT_DIR/dist/aria-host-agent"
+[ -f "$LINUX_BIN" ] || { echo -e "${RED}Linux-Binary fehlt: $LINUX_BIN${NC}"; exit 1; }
+echo -e "  ${GREEN}✓${NC} Linux-Binary ($(du -h "$LINUX_BIN" | cut -f1))"
+
+( cd android && ./build.sh >/dev/null )
+APK="$SCRIPT_DIR/android/dist/aria-android-agent.apk"
+[ -f "$APK" ] || { echo -e "${RED}APK fehlt: $APK${NC}"; exit 1; }
+echo -e "  ${GREEN}✓${NC} Android-APK ($(du -h "$APK" | cut -f1))"
+
+# Windows (.exe + setup.exe) via Wine im Docker. Dauert (pywine-Image ~1-2 GB) —
+# mit  SKIP_WINDOWS=1 ./release_agent.sh <v>  ueberspringbar.
+if [ "${SKIP_WINDOWS:-0}" = "1" ]; then
+    echo -e "  ${YELLOW}Windows-Build uebersprungen (SKIP_WINDOWS=1)${NC}"
+else
+    echo -e "  ${CYAN}…${NC} Windows-.exe + setup.exe bauen (Wine, kann dauern)"
+    if ./build-win.sh "$VERSION" >/dev/null 2>&1; then
+        echo -e "  ${GREEN}✓${NC} Windows-.exe + setup.exe"
+    else
+        echo -e "  ${YELLOW}Windows-Build fehlgeschlagen — Release laeuft ohne Windows weiter.${NC}"
+        echo -e "  ${YELLOW}(Einzeln testen: ./build-win.sh $VERSION)${NC}"
+    fi
+fi
+echo ""
+
+# Asset-Liste aufbauen:  "lokaler_pfad::asset-name"
+ASSETS=(
+    "$LINUX_BIN::aria-host-agent-linux-x64"
+    "$APK::aria-host-agent-android-$TAG.apk"
+)
+# Native Artefakte (nur wenn vorhanden): Windows aus build-win.sh, macOS
+# vorgebaut (build-native.sh auf einem Mac -> dist/aria-host-agent-macos legen).
+[ -f "$SCRIPT_DIR/dist/aria-host-agent-macos" ]     && ASSETS+=("$SCRIPT_DIR/dist/aria-host-agent-macos::aria-host-agent-macos")
+[ -f "$SCRIPT_DIR/dist/aria-host-agent.exe" ]       && ASSETS+=("$SCRIPT_DIR/dist/aria-host-agent.exe::aria-host-agent-windows.exe")
+[ -f "$SCRIPT_DIR/dist/aria-host-agent-setup.exe" ] && ASSETS+=("$SCRIPT_DIR/dist/aria-host-agent-setup.exe::aria-host-agent-windows-setup.exe")
+
+# ── Git-Tag ──────────────────────────────────────────────────────────
+echo -e "${GREEN}[3/5] Git-Tag $TAG...${NC}"
+git add host_agent.py android/app/build.gradle
+git commit -m "release(agent): bump to $VERSION" 2>/dev/null || echo -e "  ${YELLOW}Keine Aenderungen zum Committen${NC}"
+if git rev-parse "$TAG" &>/dev/null; then
+    echo -e "  ${YELLOW}Tag $TAG existiert bereits — überspringe${NC}"
+else
+    git tag "$TAG"; echo -e "  ${GREEN}✓${NC} Tag $TAG erstellt"
+fi
+git push origin main "$TAG"
+echo -e "  ${GREEN}✓${NC} Tag gepusht\n"
+
+# ── Gitea-Release ────────────────────────────────────────────────────
+echo -e "${GREEN}[4/5] Gitea-Release anlegen...${NC}"
+BODY=$(printf 'ARIA Host-Agent %s\n\nDesktop (Linux) + Android-APK. Auf das Zielgeraet kopieren, siehe README.' "$TAG")
+BODY_JSON=$(printf '%s' "$BODY" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '"%s"' "$BODY")
+RESP=$(curl -s -X POST "$GITEA_URL/api/v1/repos/$GITEA_REPO/releases" \
+    -u "${GITEA_USER}:${GITEA_PASS}" -H "Content-Type: application/json" \
+    -d "{\"tag_name\":\"$TAG\",\"name\":\"Host-Agent $TAG\",\"body\":$BODY_JSON,\"draft\":false,\"prerelease\":false}")
+RELEASE_ID=$(echo "$RESP" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
+if [ -z "$RELEASE_ID" ]; then echo -e "${RED}Release fehlgeschlagen:${NC}\n$RESP"; exit 1; fi
+echo -e "  ${GREEN}✓${NC} Release #$RELEASE_ID erstellt\n"
+
+# ── Assets hochladen ─────────────────────────────────────────────────
+echo -e "${GREEN}[5/5] Assets hochladen (${#ASSETS[@]})...${NC}"
+for entry in "${ASSETS[@]}"; do
+    path="${entry%%::*}"; name="${entry##*::}"
+    UP=$(curl -s -X POST \
+        "$GITEA_URL/api/v1/repos/$GITEA_REPO/releases/$RELEASE_ID/assets?name=$name" \
+        -u "${GITEA_USER}:${GITEA_PASS}" -F "attachment=@${path}")
+    if echo "$UP" | grep -q '"name"'; then
+        echo -e "  ${GREEN}✓${NC} $name"
+    else
+        echo -e "  ${RED}✗ $name fehlgeschlagen:${NC} $UP"
+    fi
+done
+
+echo ""
+echo -e "${GREEN}╔═══════════════════════════════════════════════════╗${NC}"
+echo -e "${GREEN}║   Host-Agent $TAG ist live!${NC}"
+echo -e "${GREEN}║${NC}   $GITEA_URL/$GITEA_REPO/releases/tag/$TAG"
+echo -e "${GREEN}╚═══════════════════════════════════════════════════╝${NC}"
@@ -0,0 +1,83 @@
+; ARIA Host-Agent — Windows-Installer (NSIS, auf Linux mit makensis gebaut).
+;
+; Installiert die Agent-.exe nach %ProgramFiles%\ARIA Host-Agent, legt eine .env
+; in %ProgramData%\ARIA-Host-Agent an (nur falls noch keine da ist — User-Config
+; bleibt erhalten) und richtet einen automatisch startenden Windows-Dienst via
+; nssm ein. Der Dienst laeuft mit AppDirectory = ProgramData-Ordner, damit der
+; Agent die .env von dort (aus dem CWD) liest.
+
+!ifndef VERSION
+  !define VERSION "0.0.0"
+!endif
+!define SVC "ARIAHostAgent"
+
+Name "ARIA Host-Agent ${VERSION}"
+OutFile "aria-host-agent-setup.exe"
+InstallDir "$PROGRAMFILES64\ARIA Host-Agent"
+RequestExecutionLevel admin
+Unicode true
+ShowInstDetails show
+ShowUninstDetails show
+
+Var DataDir
+
+Page directory
+Page instfiles
+UninstPage uninstConfirm
+UninstPage instfiles
+
+Section "Install"
+  SetOutPath "$INSTDIR"
+  File "aria-host-agent.exe"
+  File "nssm.exe"
+
+  ; ProgramData-Ordner fuer die .env bestimmen
+  ReadEnvStr $0 "ProgramData"
+  StrCmp $0 "" 0 +2
+    StrCpy $0 "$PROFILE"            ; Fallback, falls %ProgramData% fehlt
+  StrCpy $DataDir "$0\ARIA-Host-Agent"
+  CreateDirectory "$DataDir"
+
+  ; .env nur schreiben, wenn noch keine existiert (User-Config nicht ueberschreiben)
+  IfFileExists "$DataDir\.env" env_done 0
+    FileOpen $1 "$DataDir\.env" w
+    FileWrite $1 "# ARIA Host-Agent — Konfiguration (dieser Windows-Dienst liest diese Datei).$\r$\n"
+    FileWrite $1 "# Nach dem Aendern den Dienst neu starten: services.msc -> ARIA Host-Agent.$\r$\n"
+    FileWrite $1 "RVS_HOST=rvs.example.de$\r$\n"
+    FileWrite $1 "RVS_PORT=443$\r$\n"
+    FileWrite $1 "RVS_TLS=true$\r$\n"
+    FileWrite $1 "RVS_TLS_FALLBACK=true$\r$\n"
+    FileWrite $1 "RVS_TOKEN=$\r$\n"
+    FileWrite $1 "RVS_SNI=$\r$\n"
+    FileWrite $1 "HOST_NAME=$\r$\n"
+    FileWrite $1 "CONTROL_ENABLED=true$\r$\n"
+    FileClose $1
+  env_done:
+
+  ; Dienst (neu) einrichten — evtl. alten sauber entfernen, dann installieren
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" stop ${SVC}'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" remove ${SVC} confirm'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" install ${SVC} "$INSTDIR\aria-host-agent.exe"'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" set ${SVC} AppDirectory "$DataDir"'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" set ${SVC} DisplayName "ARIA Host-Agent"'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" set ${SVC} Description "ARIA-Fernsteuerung dieses Rechners (RVS-Agent)."'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" set ${SVC} Start SERVICE_AUTO_START'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" start ${SVC}'
+
+  ; Uninstaller + Eintrag unter "Apps & Features"
+  WriteUninstaller "$INSTDIR\uninstall.exe"
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\ARIAHostAgent" "DisplayName" "ARIA Host-Agent"
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\ARIAHostAgent" "DisplayVersion" "${VERSION}"
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\ARIAHostAgent" "UninstallString" '"$INSTDIR\uninstall.exe"'
+SectionEnd
+
+Section "Uninstall"
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" stop ${SVC}'
+  nsExec::ExecToLog '"$INSTDIR\nssm.exe" remove ${SVC} confirm'
+  Delete "$INSTDIR\aria-host-agent.exe"
+  Delete "$INSTDIR\nssm.exe"
+  Delete "$INSTDIR\uninstall.exe"
+  RMDir "$INSTDIR"
+  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\ARIAHostAgent"
+  ; Die .env in %ProgramData%\ARIA-Host-Agent bleibt bewusst erhalten (User-Config).
+SectionEnd
@@ -100,9 +100,13 @@ function _parseToolCalls(text) {
 }

 export function cliResultToOpenai(result, requestId) {
-    const modelName = result.modelUsage
-        ? Object.keys(result.modelUsage)[0]
-        : "claude-sonnet-4";
+    // modelUsage ist die Wahrheit: die CLI tragt dort den Namen ein, unter dem
+    // der Request wirklich lief — bei einem Alias also die aufgeloeste Version
+    // ("opus" -> "claude-opus-5-5"). Leer bleibt es, wenn gar kein Call
+    // zustande kam (z.B. unbekanntes Modell).
+    const usage = result.modelUsage || {};
+    const usedKey = Object.keys(usage)[0];
+    const modelName = (usedKey && (usage[usedKey]?.canonicalModel || usedKey)) || "";

    const rawText = result.result || "";
    const { tool_calls, rest } = _parseToolCalls(rawText);
@@ -134,13 +138,32 @@ export function cliResultToOpenai(result, requestId) {
            total_tokens:
                (result.usage?.input_tokens || 0) + (result.usage?.output_tokens || 0),
        },
+        // ARIA-Zusatzfelder (ausserhalb des OpenAI-Schemas, Clients ignorieren
+        // sie). Damit kann die Diagnostic pruefen, ob ein Modell wirklich
+        // gelaufen ist: bei einem unbekannten Namen kommt die CLI gar nicht bis
+        // zum Call, dann ist modelUsage leer und is_error gesetzt. Ohne das
+        // koennte man einen Fehlschlag nicht von einer Antwort unterscheiden —
+        // die Fehlermeldung steht naemlich einfach im content.
+        aria_model: modelName,
+        aria_error: result.is_error === true,
+        aria_context_window: (usedKey && usage[usedKey]?.contextWindow) || 0,
+        aria_max_output: (usedKey && usage[usedKey]?.maxOutputTokens) || 0,
    };
 }

+/**
+ * Modellname fuer die Antwort.
+ *
+ * Hier wurde der Name FRUEHER umgeschrieben: alles mit "opus" drin wurde zu
+ * "claude-opus-4", Sonnet zu "claude-sonnet-4" usw. Damit log das Feld — die
+ * CLI liefert in modelUsage den tatsaechlich benutzten Namen (z.B.
+ * "claude-opus-5-5"), und genau der wurde weggeworfen. Im OpenAI-Protokoll
+ * soll `model` das Modell nennen, das geantwortet HAT; ein erfundener Name
+ * macht jede Ueberpruefung unmoeglich ("welches Modell lief gerade?").
+ *
+ * Jetzt bleibt der echte Name stehen; nur wenn gar keiner da ist, gibt es
+ * einen neutralen Platzhalter.
+ */
 function normalizeModelName(model) {
-    const m = model || "claude-sonnet-4";
-    if (m.includes("opus")) return "claude-opus-4";
-    if (m.includes("sonnet")) return "claude-sonnet-4";
-    if (m.includes("haiku")) return "claude-haiku-4";
-    return m;
+    return model || "unknown";
 }
@@ -18,6 +18,9 @@
 */
 import { spawn } from "child_process";
 import { EventEmitter } from "events";
+import fs from "fs";
+import os from "os";
+import path from "path";
 import { isAssistantMessage, isResultMessage, isContentDelta } from "../types/claude-cli.js";
 const DEFAULT_TIMEOUT = 86400000; // 24h — lange Agent-Loops (Pentests etc.)
 export class ClaudeSubprocess extends EventEmitter {
@@ -26,6 +29,8 @@ export class ClaudeSubprocess extends EventEmitter {
    timeoutId = null;
    isKilled = false;
    _stdinClosed = false;
+    _systemPromptFile = null;
+    _systemPromptDir = null;
    /**
     * Start the Claude CLI subprocess with the given prompt
     */
@@ -51,6 +56,7 @@ export class ClaudeSubprocess extends EventEmitter {
                // Handle spawn errors (e.g., claude not found)
                this.process.on("error", (err) => {
                    this.clearTimeout();
+                    this._cleanupSystemPrompt();
                    if (err.message.includes("ENOENT")) {
                        reject(new Error("Claude CLI not found. Install with: npm install -g @anthropic-ai/claude-code"));
                    }
@@ -85,6 +91,7 @@ export class ClaudeSubprocess extends EventEmitter {
                this.process.on("close", (code) => {
                    console.error(`[Subprocess] Process closed with code: ${code}`);
                    this.clearTimeout();
+                    this._cleanupSystemPrompt();
                    // Process any remaining buffer
                    if (this.buffer.trim()) {
                        this.processBuffer();
@@ -96,6 +103,7 @@ export class ClaudeSubprocess extends EventEmitter {
            }
            catch (err) {
                this.clearTimeout();
+                this._cleanupSystemPrompt();
                reject(err);
            }
        });
@@ -114,13 +122,47 @@ export class ClaudeSubprocess extends EventEmitter {
            "stream-json", // ARIA: User-Messages via stdin (Zwischenruf)
            "--model",
            options.model, // Model alias (opus/sonnet/haiku)
-            "--no-session-persistence", "--dangerously-skip-permissions", "--system-prompt", options.systemPrompt, "--safe-mode",
+            "--no-session-persistence", "--dangerously-skip-permissions", "--safe-mode",
        ];
+        // ARIA: System-Prompt ueber eine DATEI statt als Kommandozeilen-Argument.
+        // Grund: execve() begrenzt argv+envp zusammen auf ARG_MAX — im Container
+        // nur 128 KiB. Ein gewachsener System-Prompt (gepinnte Erinnerungen,
+        // Skills, Projektkontext; real gesehen ~77k Zeichen) sprengte das und der
+        // Start brach mit "spawn E2BIG" ab: der Turn ging verloren, die App bekam
+        // 502 und die Nachricht blieb unbeantwortet. Ueber die Datei gibt es
+        // praktisch keine Groessengrenze mehr.
+        this._systemPromptFile = null;
+        const sysPrompt = options.systemPrompt || "";
+        if (sysPrompt) {
+            try {
+                const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aria-sysprompt-"));
+                const file = path.join(dir, "system-prompt.txt");
+                fs.writeFileSync(file, sysPrompt, "utf-8");
+                this._systemPromptFile = file;
+                this._systemPromptDir = dir;
+                args.push("--system-prompt-file", file);
+            }
+            catch (err) {
+                // Notfalls wie bisher (kleine Prompts funktionieren so weiterhin).
+                console.error(`[Subprocess] System-Prompt-Datei fehlgeschlagen (${err.message}) — nutze Argument`);
+                args.push("--system-prompt", sysPrompt);
+            }
+        }
        if (options.sessionId) {
            args.push("--session-id", options.sessionId);
        }
        return args;
    }
+    /** Temporaere System-Prompt-Datei wieder entfernen. */
+    _cleanupSystemPrompt() {
+        try {
+            if (this._systemPromptFile)
+                fs.rmSync(this._systemPromptDir || this._systemPromptFile, { recursive: true, force: true });
+        }
+        catch (_) { }
+        this._systemPromptFile = null;
+        this._systemPromptDir = null;
+    }
    /**
     * Eine User-Message im stream-json-Input-Format an stdin schreiben.
     * Genutzt fuer den initialen Prompt UND fuer Zwischenrufe (sendMessage).
@@ -15,29 +15,47 @@
 * (siehe docker-compose.yml proxy-Block).
 */

+// NUR echte Tier-Aliase. Die CLI loest sie selbst auf die aktuelle Version des
+// Tiers auf.
+//
+// Hier standen frueher auch volle Versionen (claude-opus-5 → "opus",
+// claude-fable-5 → "fable", ...). Das war falsch: wer bewusst eine BESTIMMTE
+// Version waehlte, bekam still das Tier-Default — also unter Umstaenden ein
+// ganz anderes Modell als ausgewaehlt. Volle Namen gehen jetzt unveraendert an
+// die CLI (siehe extractModel), die versteht sie.
 const MODEL_MAP = {
-    "claude-opus-4": "opus",
-    "claude-sonnet-4": "sonnet",
-    "claude-haiku-4": "haiku",
-    "claude-code-cli/claude-opus-4": "opus",
-    "claude-code-cli/claude-sonnet-4": "sonnet",
-    "claude-code-cli/claude-haiku-4": "haiku",
    "opus": "opus",
    "sonnet": "sonnet",
    "haiku": "haiku",
    "fable": "fable",
-    "claude-fable-5": "fable",
+    "claude-code-cli/opus": "opus",
+    "claude-code-cli/sonnet": "sonnet",
+    "claude-code-cli/haiku": "haiku",
    "claude-code-cli/fable": "fable",
-    // Volle aktuelle IDs (falls die App/Diagnostic sie mal direkt setzt)
-    "claude-opus-5": "opus",
-    "claude-sonnet-5": "sonnet",
-    "claude-haiku-4-5": "haiku",
 };

+// Echte Claude-Modellnamen: claude-<familie>-<zahlen/suffixe>.
+// Die CLI nimmt laut `claude --help` "an alias for the latest model (e.g.
+// 'fable', 'opus', or 'sonnet') or a model's full name" — exakte Versionen
+// darf man also direkt durchreichen.
+const FULL_MODEL_RE = /^claude-[a-z]+-[0-9][0-9a-z.-]*$/;
+
 export function extractModel(model) {
    if (MODEL_MAP[model]) return MODEL_MAP[model];
    const stripped = (model || "").replace(/^claude-code-cli\//, "");
    if (MODEL_MAP[stripped]) return MODEL_MAP[stripped];
+    // Exakte Version durchreichen statt sie auf einen Tier einzuschmelzen.
+    //
+    // Vorher landete JEDER unbekannte Name still auf "opus". Damit war eine
+    // neuere Version faktisch nicht waehlbar: wer "claude-opus-5-5" setzte,
+    // bekam ohne jede Meldung das Tier-Default — die Einstellung sah gesetzt
+    // aus und tat nichts. Kennt die CLI den Namen nicht, sagt SIE das deutlich
+    // ("isn't described by this version's model catalog"), und das ist die
+    // ehrlichere Antwort als ein stilles Downgrade.
+    if (FULL_MODEL_RE.test(stripped)) return stripped;
+    if (stripped) {
+        console.error(`[aria-model] Unbekannter Modellname ${JSON.stringify(stripped)} — nutze 'opus'`);
+    }
    return "opus";
 }

@@ -552,19 +552,144 @@ function _loadModels() {
    return DEFAULT_MODELS;
 }

-export function handleModels(_req, res) {
+// ── Echte Modell-Liste von Anthropic ────────────────────────────────
+//
+// Anthropic veroeffentlicht einen signierten Modell-Katalog, aus dem auch
+// Claude Code selbst seinen Modell-Auswaehler fuellt. Oeffentlich erreichbar,
+// KEIN API-Key noetig (die Models-API /v1/models braucht einen; mit dem
+// Max-Abo gibt es keinen).
+//
+// Warum ueberhaupt: die handgepflegte Liste hier veraltete garantiert. Sie
+// kannte Opus 5 — waehrend im Katalog laengst Opus 5.5, Sonnet 5.5 und
+// Fable 5.1 standen. Ein "↻ Aktualisieren"-Knopf, der nur eine lokale Datei
+// neu liest, aktualisiert nichts.
+//
+// Struktur: surfaces.<surface>.model_selector_config[].models[]
+//           = { id, name, short_name, description, section }
+// 'cc' ist die Claude-Code-Oberflaeche — genau die, durch die ARIA laeuft.
+// section 'main' = die vorgeschlagenen, 'overflow' = aeltere/weitere.
+const CATALOG_URL = process.env.ARIA_MODEL_CATALOG_URL
+    || "https://downloads.claude.ai/model-catalog/v1/catalog.json";
+const CATALOG_CACHE_FILE = "/shared/config/model_catalog_cache.json";
+const CATALOG_TTL_MS = 6 * 60 * 60 * 1000;   // 6h — der Katalog gilt eine Woche
+const CATALOG_SURFACE = "cc";
+
+let _catalogMem = null;      // { at, models }
+
+function _parseCatalog(doc) {
+    const out = [];
+    const surfaces = (doc && doc.surfaces && doc.surfaces[CATALOG_SURFACE]) || null;
+    const configs = surfaces && surfaces.model_selector_config;
+    if (!Array.isArray(configs)) return out;
+    for (const cfg of configs) {
+        for (const m of (cfg.models || [])) {
+            if (!m || typeof m.id !== "string") continue;
+            out.push({
+                id: m.id,
+                tier: m.short_name ? String(m.short_name).toLowerCase() : m.id,
+                display_name: m.name || m.id,
+                description: m.description || "",
+                section: m.section || "main",
+            });
+        }
+    }
+    return out;
+}
+
+function _readCatalogCache() {
+    try {
+        const c = JSON.parse(fs.readFileSync(CATALOG_CACHE_FILE, "utf-8"));
+        if (Array.isArray(c.models) && c.models.length) return c;
+    } catch (_) { /* kein Cache */ }
+    return null;
+}
+
+/**
+ * Liefert die Katalog-Modelle. `force` umgeht den TTL (Diagnostic-Knopf).
+ * Schlaegt der Abruf fehl, gilt der Cache — auch ein abgelaufener, denn eine
+ * etwas alte echte Liste ist besser als gar keine.
+ */
+async function _catalogModels(force) {
+    const now = Date.now();
+    if (!force && _catalogMem && (now - _catalogMem.at) < CATALOG_TTL_MS) {
+        return _catalogMem.models;
+    }
+    if (!force) {
+        const cached = _readCatalogCache();
+        if (cached && (now - (cached.at || 0)) < CATALOG_TTL_MS) {
+            _catalogMem = { at: cached.at, models: cached.models };
+            return cached.models;
+        }
+    }
+    try {
+        const ctl = AbortSignal.timeout ? AbortSignal.timeout(10000) : undefined;
+        const r = await fetch(CATALOG_URL, { signal: ctl });
+        if (!r.ok) throw new Error(`HTTP ${r.status}`);
+        const doc = await r.json();
+        const models = _parseCatalog(doc);
+        if (!models.length) throw new Error("Katalog enthaelt keine Modelle fuer Surface " + CATALOG_SURFACE);
+        _catalogMem = { at: now, models };
+        try {
+            fs.mkdirSync("/shared/config", { recursive: true });
+            fs.writeFileSync(CATALOG_CACHE_FILE, JSON.stringify({
+                at: now, version: doc.version, expires_at: doc.expires_at, models,
+            }, null, 2));
+        } catch (e) {
+            console.error("[aria-models] Katalog-Cache schreiben fehlgeschlagen:", e && e.message);
+        }
+        console.error(`[aria-models] Katalog geladen: ${models.length} Modelle (Version ${doc.version})`);
+        return models;
+    } catch (e) {
+        console.error("[aria-models] Katalog-Abruf fehlgeschlagen:", e && e.message);
+        const cached = _readCatalogCache();
+        if (cached) {
+            console.error("[aria-models] nutze Cache vom " + new Date(cached.at || 0).toISOString());
+            _catalogMem = { at: cached.at, models: cached.models };
+            return cached.models;
+        }
+        return [];
+    }
+}
+
+export async function handleModels(req, res) {
    const created = Math.floor(Date.now() / 1000);
-    const models = _loadModels();
+    const force = !!(req && req.query && (req.query.refresh === "1" || req.query.refresh === "true"));
+
+    // 1) Tier-Aliase zuerst: sie zeigen IMMER auf die aktuelle Version ihres
+    //    Tiers, ganz ohne Pflege. Fuer den Alltag die richtige Wahl.
+    const tiers = _loadModels().map(m => ({
+        id: m.id,
+        tier: m.tier || m.id,
+        display_name: m.display_name || m.id,
+        description: m.description || "",
+        section: "tier",
+    }));
+
+    // 2) Danach die exakten Versionen aus dem Anthropic-Katalog.
+    const catalog = await _catalogModels(force);
+    const seen = new Set(tiers.map(t => t.id));
+    const exact = catalog.filter(m => !seen.has(m.id)).map(m => ({
+        id: m.id,
+        tier: m.tier,
+        display_name: m.display_name
+            + (m.section === "main" ? "" : " (ältere Version)"),
+        description: m.description
+            || (m.section === "main" ? "" : "Aeltere Version — nur waehlen wenn gewollt."),
+        section: m.section,
+    }));
+
    res.json({
        object: "list",
-        data: models.map(m => ({
+        catalog_ok: catalog.length > 0,
+        data: [...tiers, ...exact].map(m => ({
            id: m.id,
            object: "model",
            owned_by: "anthropic",
            created,
-            tier: m.tier || m.id,
-            display_name: m.display_name || m.id,
-            description: m.description || "",
+            tier: m.tier,
+            display_name: m.display_name,
+            description: m.description,
+            section: m.section,
        })),
    });
 }
@@ -88,6 +88,24 @@ const ALLOWED_TYPES = new Set([
  // host_hello/host_ping und fuehrt host_command aus (exec/read/write/info/
  // screenshot) -> host_result. ARIA steuert so Rechner auch hinter NAT.
  "host_hello", "host_ping", "host_command", "host_result",
+  // Agent-Historie: Brain schickt pro Host-Aktion ein agent_history-Event (via
+  // Bridge), Diagnostic fragt die gespeicherte Historie per agent_history_query
+  // ab, die Bridge antwortet mit agent_history_list. OHNE diese Typen verwirft
+  // der RVS sie still an der Allow-List und die Historie bleibt leer.
+  "agent_history", "agent_history_query", "agent_history_list",
+  // STT-Lease: die App fragt vor einer Aufnahme, WELCHE STT-Instanz sie nehmen
+  // soll (stt_lease_request -> stt_lease). Fehlten diese Typen hier, lief die
+  // Anfrage IMMER in den 250ms-Timeout: jede Aufnahme startete verspaetet (erste
+  // Silben weg) und ohne targetInstance nahmen ALLE STT-Worker dieselbe Session
+  // an -> doppelte stt_endpoint. chat_ack quittiert getippte Nachrichten; ohne
+  // ihn liefen sie in der App nach 3 Versuchen auf "fehlgeschlagen", obwohl sie
+  // laengst verarbeitet waren. stt_transcribe_* ist die Wake-Wort-Bestaetigung.
+  "stt_lease", "stt_lease_request", "stt_transcribe_blob", "stt_transcribe_result",
+  "chat_ack",
+  // Raum-Diagnose: Diagnostic fragt die aktuellen RVS-Raeume ab (rooms_query),
+  // RVS antwortet direkt mit rooms_info (Fingerprint + Laenge + Client-Zahl je
+  // Raum). Deckt Token-Prefix-Kollisionen auf (2 Raeume, gleicher 8-Zeichen-Log).
+  "rooms_query", "rooms_info",
  // Compute-Flotte (AI-Boxen): Worker (f5tts/whisper/voxtral/llm-adapter) melden
  // sich per worker_hello an und pingen per worker_ping; der Diagnostic-Server
  // aggregiert das und broadcastet worker_update/worker_list an die Browser-UI.
@@ -95,6 +113,9 @@ const ALLOWED_TYPES = new Set([
  // OHNE diese Typen verwirft der RVS die Meldungen an der Allow-List (Z. 312),
  // und die Box bleibt in der Flotte unsichtbar, obwohl sie sendet.
  "worker_hello", "worker_ping", "worker_update", "worker_list",
+  // OpenAI-Endpunkt einer LLM-Box: Diagnostic setzt den API-Key (der PORT kommt
+  // immer aus der .env der Box — er ist ein Docker-Port-Mapping).
+  "llm_openai_config", "llm_openai_config_result",
  "node_stats", "node_stats_stream_start", "node_stats_stream_stop",
  "node_stats_history_request", "node_stats_history",
  "node_stats_reset", "node_stats_reset_done",
@@ -103,6 +124,86 @@ const ALLOWED_TYPES = new Set([
 // Token-Raum: token -> { clients: Set<ws> }
 const rooms = new Map();

+// ── Punkt-zu-Punkt-Antworten ────────────────────────────────────────
+//
+// Der RVS ist ein Broadcast-Relay: normalerweise bekommt JEDER Client im Raum
+// jede Nachricht. Bei Datei-Antworten ist das fatal. Ein 150-MB-Video wird als
+// base64 ~200 MB gross und ging bisher an ALLE Clients im Raum — auch an die
+// STT/TTS-Worker, die daran mit Code 1009 (message too big) gestorben sind und
+// die gerade laufende Sprachaufnahme mitgerissen haben ("erste Sprachnachricht
+// kommt nicht durch"). Die Worker-max_size-Angleichung verhindert den Absturz,
+// aber 200 MB an zehn Clients zu schicken bleibt Unsinn: nur EINER hat gefragt.
+//
+// Darum: wer eine Anfrage mit requestId stellt, wird gemerkt — die Antwort mit
+// derselben requestId geht nur an ihn zurueck. Unbekannte requestId → wie
+// bisher broadcasten (nichts geht verloren, falls ein Client mithoeren muss,
+// dessen Anfrage der RVS nie gesehen hat).
+const TARGETED = new Map([
+  ["file_request", "file_response"],
+  ["file_zip_request", "file_zip_response"],
+  ["file_version_download_request", "file_version_download_response"],
+  ["brain_request", "brain_response"],
+]);
+const TARGETED_REPLIES = new Set(TARGETED.values());
+
+// `antwortTyp \0 requestId` -> { clients: Set<ws>, at }
+// Mehrere Clients koennen dieselbe requestId benutzen (die App nimmt die
+// Nachrichten-ID) — darum ein Set, sonst bekaeme nur der letzte die Antwort.
+const pendingReplies = new Map();
+const PENDING_TTL_MS = 180_000;
+
+function pendingKey(replyType, requestId) {
+  return `${replyType}${requestId}`;
+}
+
+/** Merkt sich den Fragenden, wenn die Nachricht eine gezielte Anfrage ist. */
+function rememberRequester(ws, msg) {
+  const replyType = TARGETED.get(msg.type);
+  if (!replyType) return;
+  const rid = msg.payload && msg.payload.requestId;
+  if (!rid || typeof rid !== "string") return;
+  const key = pendingKey(replyType, rid);
+  let entry = pendingReplies.get(key);
+  if (!entry) {
+    entry = { clients: new Set(), at: Date.now() };
+    pendingReplies.set(key, entry);
+  }
+  entry.clients.add(ws);
+  entry.at = Date.now();
+}
+
+/**
+ * Empfaenger fuer eine Antwort-Nachricht.
+ * null  = keine gezielte Antwort → normal broadcasten.
+ * []    = der Fragende ist weg → verwerfen (NICHT broadcasten, sonst waere
+ *         der ganze Sinn weg und die 200 MB gingen doch an alle).
+ */
+function targetedRecipients(msg) {
+  if (!TARGETED_REPLIES.has(msg.type)) return null;
+  const rid = msg.payload && msg.payload.requestId;
+  if (!rid || typeof rid !== "string") return null;
+  const key = pendingKey(msg.type, rid);
+  const entry = pendingReplies.get(key);
+  if (!entry) return null;
+  pendingReplies.delete(key);
+  return [...entry.clients].filter((c) => c.readyState === 1);
+}
+
+/** Abgelaufene/tote Eintraege wegwerfen (laeuft mit cleanupRooms). */
+function cleanupPendingReplies() {
+  const now = Date.now();
+  for (const [key, entry] of pendingReplies) {
+    if (now - entry.at > PENDING_TTL_MS) {
+      pendingReplies.delete(key);
+      continue;
+    }
+    for (const c of entry.clients) {
+      if (c.readyState > 1) entry.clients.delete(c);
+    }
+    if (entry.clients.size === 0) pendingReplies.delete(key);
+  }
+}
+
 // ── Hilfsfunktionen ─────────────────────────────────────────────────

 function timestamp() {
@@ -126,6 +227,7 @@ function cleanupRooms() {
      log(`Leerer Raum entfernt: ${token.slice(0, 8)}...`);
    }
  }
+  cleanupPendingReplies();
 }

 // ── HTTP + WebSocket Server (hybrid) ────────────────────────────────
@@ -349,6 +451,29 @@ function registerClient(ws, token) {
      return;
    }

+    // Raum-Diagnose: direkt an den anfragenden Client antworten (nicht relay'en).
+    // Zeigt ALLE Raeume mit token8 (wie im Log), einem laengeren Fingerprint und
+    // der Token-Laenge — so werden Prefix-Kollisionen (2 Raeume, gleicher 8-Zeichen-
+    // Log, aber verschiedene volle Tokens) sofort sichtbar. KEINE vollen Tokens.
+    if (msg.type === "rooms_query") {
+      const crypto = require("crypto");
+      const out = [];
+      for (const [tok, room] of rooms) {
+        let live = 0;
+        for (const c of room.clients) if (c.readyState === 1) live++;
+        out.push({
+          token8: tok.slice(0, 8),
+          fp: crypto.createHash("sha256").update(tok).digest("hex").slice(0, 12),
+          len: tok.length,
+          clients: live,
+          you: tok === ws._token,
+        });
+      }
+      out.sort((a, b) => b.clients - a.clients);
+      ws.send(JSON.stringify({ type: "rooms_info", payload: { rooms: out }, timestamp: Date.now() }));
+      return;
+    }
+
    // Update-Download: APK als Base64 ueber WebSocket senden
    if (msg.type === "update_download") {
      const apkInfo = getLatestAPK();
@@ -377,6 +502,28 @@ function registerClient(ws, token) {
      return;
    }

+    // Anfrage merken, damit die Antwort gleich gezielt zurueckgehen kann
+    rememberRequester(ws, msg);
+
+    // Gezielte Antwort? Dann NUR an den Fragenden — nicht an den ganzen Raum.
+    const targets = targetedRecipients(msg);
+    if (targets) {
+      const data = raw.toString();
+      let sent = 0;
+      for (const client of targets) {
+        if (client !== ws) { client.send(data); sent++; }
+      }
+      // Grosse Payloads mitloggen: hier spart der RVS am meisten ein, und
+      // wenn mal eine Antwort verschwindet will man genau das hier sehen.
+      if (raw.length > 4 * 1024 * 1024 || sent === 0) {
+        const mb = (raw.length / 1024 / 1024).toFixed(1);
+        log(sent === 0
+          ? `${msg.type}: Fragender nicht mehr verbunden — ${mb}MB verworfen`
+          : `${msg.type}: ${mb}MB gezielt an ${sent} Client(s) statt an ${room.clients.size - 1}`);
+      }
+      return;
+    }
+
    // An alle anderen Clients im Raum weiterleiten
    for (const client of room.clients) {
      if (client !== ws && client.readyState === 1) {
@@ -387,6 +534,9 @@ function registerClient(ws, token) {

  ws.on("close", () => {
    room.clients.delete(ws);
+    for (const [key, entry] of pendingReplies) {
+      if (entry.clients.delete(ws) && entry.clients.size === 0) pendingReplies.delete(key);
+    }
    log(`Client getrennt: ${token.slice(0, 8)}... (${room.clients.size} verbleibend)`);
    if (room.clients.size === 0) {
      rooms.delete(token);
@@ -6,7 +6,14 @@
 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 (Satellit 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 / Adresse dieses Satelliten ────────────────────────
 # SATELLITE_ID  = technisch eindeutig (a-z0-9-_), Default = Hostname-Slug.
@@ -34,7 +41,27 @@ CONTROL_ENABLED=true
 #   fritzbox.info  FritzBox: Verbindung/Datenrate/externe IP (TR-064, braucht Login)
 #   fritzbox.hosts FritzBox: verbundene Geraete (TR-064, braucht Login)
 #   ssh.exec     Kommando per SSH ausfuehren (params: ip, cmd; Auth aus Creds 'ssh')
-CONTROL_ALLOWLIST=dial.launch,wol,http.get,snmp.get,snmp.walk,snmp.printer,snmp.ports,snmp.info,fritzbox.info,fritzbox.hosts,ssh.exec
+#   adb.install  APK auf ein Android-Geraet/Fire TV ausrollen (params: ip, url)
+#   adb.connect  ADB-Verbindung aufbauen (params: ip)
+#   adb.devices  verbundene ADB-Geraete auflisten
+#   adb.shell    Shell-Kommando auf dem Android-Geraet (params: ip, cmd)
+#   adb.provision  Agent FERN einrichten: RVS-Zugang uebergeben, statt ihn mit der
+#                  Fernbedienung abzutippen (params: ip, rvs_host, rvs_token, ...)
+#   adb.status   laeuft/installiert der Agent auf dem Geraet? (params: ip)
+#   adb.permissions  Sonderrechte per ADB erteilen (Bildschirmaufnahme/Overlay/
+#                    Mikro) — spart das Zusammenklicken mit der Fernbedienung
+# ACHTUNG: Diese Liste ueberschreibt den Code-Default. Wird eine neue Aktion
+# ergaenzt, MUSS sie hier nachgetragen werden — sonst lehnt der Satellit sie ab.
+CONTROL_ALLOWLIST=dial.launch,wol,http.get,snmp.get,snmp.walk,snmp.printer,snmp.ports,snmp.info,fritzbox.info,fritzbox.hosts,ssh.exec,adb.devices,adb.connect,adb.install,adb.shell,adb.provision,adb.status,adb.permissions
+
+# ─── ADB / Android-Rollout (optional) ──────────────────────────────
+# Fire TV Sticks & Android-Geraete im LAN: APK ausrollen ohne Datei-Kopieren.
+# Voraussetzung am Geraet: ADB-Debugging AN (Fire TV: Einstellungen > Mein Fire TV
+# > Entwickleroptionen > ADB-Debugging) und den Dialog "USB-Debugging zulassen?"
+# einmalig bestaetigen (Haken "Immer erlauben").
+ADB_PORT=5555
+ADB_TIMEOUT_SEC=180          # install dauert 30-60s, grosszuegig lassen
+APK_CACHE_DIR=/data/apk      # heruntergeladene APKs (1x laden, N Geraete)

 # ─── Credential-Store (optional) ───────────────────────────────────
 # Pro Geraet koennen im Diagnostic Zugangsdaten hinterlegt werden (SNMP-Community/
@@ -7,8 +7,11 @@ WORKDIR /app

 # net-snmp-CLI (snmpget/snmpwalk) fuer die snmp.*-Aktionen — z.B. Drucker-
 # Tintenstaende zuverlaessig aus der Printer-MIB statt HTML zu scrapen.
+# adb: Android-Geraete im LAN (v.a. Fire TV Sticks) per Netzwerk-Debugging
+# erreichen und APKs ausrollen (adb.*-Aktionen). In Debian bookworm heisst das
+# Paket schlicht "adb" (nicht mehr android-tools-adb).
 RUN apt-get update \
-    && apt-get install -y --no-install-recommends snmp \
+    && apt-get install -y --no-install-recommends snmp adb \
    && rm -rf /var/lib/apt/lists/*

 COPY requirements.txt .
@@ -32,6 +32,18 @@ docker compose logs -f          # "Netz: primary_ip=192.168.0.x" + "[scan] N Ger
 ```
 `network_mode: host` (schon gesetzt) gibt hier echtes LAN + Multicast.

+> **Fehler `KeyError: 'ContainerConfig'` beim Neubauen?**
+> Das ist ein **Bug im alten `docker-compose` 1.29.2** (Python-Version), nicht im
+> Satelliten: Beim *Ersetzen* eines bestehenden Containers mit Volume liest es ein
+> Feld aus dem Image, das neuere Docker-Versionen nicht mehr schreiben. Zwei Fixes:
+> ```bash
+> docker compose up -d --build                 # v2 (mit LEERZEICHEN) — falls vorhanden
+> # oder mit der alten Version: alten Container erst weg, dann neu anlegen
+> docker-compose rm -sf satellite && docker-compose up -d --build
+> ```
+> Der `./data`-Ordner (Credentials, ADB-Schlüssel, APK-Cache) bleibt dabei erhalten —
+> er ist ein Bind-Mount, kein Container-Volume.
+
 **B) Nativ als Python-Prozess** (für Mac/Windows-Test oder ohne Docker) — läuft direkt
 auf einer Maschine im Ziel-LAN. Das Script lädt die `.env` **selbst** (muss im
 `satellite/`-Ordner liegen):
@@ -48,6 +60,11 @@ python satellite.py       # liest .env automatisch
 den Satelliten erreicht). `SATELLITE_LOCATION` ist der Name, über den ARIA das Netz
 anspricht („Büro").

+**Satellit im selben Netz wie der RVS** (z.B. Rechenzentrum, direkt auf die
+interne IP statt NAT-Hairpin): `RVS_HOST=<interne-ip>` + **`RVS_SNI=<zert-name>`**
+(der Name, für den das Caddy-Zertifikat gilt). Ohne das scheitert TLS an
+`tlsv1 alert internal error`. Zuhause / normal: `RVS_SNI` leer lassen.
+
 **Kontrolle:** im Log/Diagnostic muss `primary_ip` im Ziel-LAN liegen
 (`192.168.0.x`) — steht da `192.168.65.x` oder `172.x`, sitzt der Satellit im
 falschen (Docker-)Netz.
@@ -21,6 +21,12 @@ services:
    network_mode: host
    env_file: .env
    restart: unless-stopped
+    environment:
+      # ADB-Schluessel in /data persistieren: sonst erzeugt adb nach jedem
+      # Rebuild einen NEUEN Schluessel und das Fire TV fragt erneut
+      # "USB-Debugging zulassen?" (Autorisierung geht verloren).
+      - HOME=/data
+      - ANDROID_ADB_SERVER_PORT=5038   # 5037 kann auf dem Host belegt sein
    volumes:
      # Persistenter Credential-Store (verschluesselt) + Schluesseldatei.
      - ./data:/data
@@ -106,7 +106,25 @@ def _default_id() -> str:
 RVS_HOST = os.environ.get("RVS_HOST", "")
 RVS_PORT = int(os.environ.get("RVS_PORT", "443") or "443")
 RVS_TLS = _env_bool("RVS_TLS", True)
+# Bei TLS-Fehlschlag einmal auf ws:// zurueckfallen (wie die Compute-Bridges).
+RVS_TLS_FALLBACK = _env_bool("RVS_TLS_FALLBACK", True)
 RVS_TOKEN = os.environ.get("RVS_TOKEN", "")
+# TLS-Hostname (SNI + Zertifikatspruefung), falls RVS_HOST eine IP ist — z.B. ein
+# Satellit im selben Netz wie der RVS, der direkt auf die interne IP verbindet
+# (das Caddy-Zertifikat gilt aber fuer den Namen). Leer = SNI = RVS_HOST.
+RVS_SNI = os.environ.get("RVS_SNI", "").strip()
+
+# In-Process-DNS-Override: wenn RVS_SNI gesetzt ist, verbindet die URI ueber den
+# HOSTNAMEN (Host-Header + SNI + Cert stimmen), waehrend getaddrinfo den Namen auf
+# die echte IP in RVS_HOST aufloest. Versionsunabhaengig — host=/port= kollidiert
+# in der Legacy-websockets-API mit dem aus der URI abgeleiteten Host.
+if RVS_TLS and RVS_SNI:
+    import socket as _socket
+    _orig_getaddrinfo = _socket.getaddrinfo
+    def _sni_getaddrinfo(host, *a, **k):
+        return _orig_getaddrinfo(RVS_HOST if host == RVS_SNI else host, *a, **k)
+    _socket.getaddrinfo = _sni_getaddrinfo
+

 SATELLITE_ID = (os.environ.get("SATELLITE_ID") or _default_id()).strip()
 SATELLITE_LOCATION = (os.environ.get("SATELLITE_LOCATION") or SATELLITE_ID).strip()
@@ -116,10 +134,24 @@ CONTROL_ALLOWLIST = [
    a.strip() for a in
    os.environ.get("CONTROL_ALLOWLIST",
                   "dial.launch,wol,http.get,snmp.get,snmp.walk,snmp.printer,"
-                   "snmp.ports,snmp.info,fritzbox.info,fritzbox.hosts,ssh.exec").split(",")
+                   "snmp.ports,snmp.info,fritzbox.info,fritzbox.hosts,ssh.exec,"
+                   "adb.devices,adb.connect,adb.install,adb.shell,adb.provision,adb.status").split(",")
    if a.strip()
 ]

+# adb.*: Android-Geraete (v.a. Fire TV) im LAN per Netzwerk-Debugging erreichen.
+# install dauert lange (APK laden + uebertragen + installieren) -> grosszuegiger
+# Timeout. APK-Cache in /data (persistentes Volume), damit N Sticks nur EINEN
+# Download brauchen.
+ADB_PORT = int(os.environ.get("ADB_PORT", "5555") or "5555")
+ADB_TIMEOUT_SEC = float(os.environ.get("ADB_TIMEOUT_SEC", "180") or "180")
+# Beim ERSTEN Verbinden zeigt das Geraet "USB-Debugging zulassen?" auf dem
+# Bildschirm. Statt mit Fehler abzubrechen (und den Nutzer nochmal klicken zu
+# lassen) wartet der Satellit so lange auf die Bestaetigung.
+ADB_AUTH_WAIT_SEC = float(os.environ.get("ADB_AUTH_WAIT_SEC", "90") or "90")
+APK_CACHE_DIR = os.environ.get("APK_CACHE_DIR", "/data/apk")
+APK_MAX_BYTES = int(os.environ.get("APK_MAX_BYTES", str(64 * 1024 * 1024)) or str(64 * 1024 * 1024))
+
 SCAN_INTERVAL_SEC = int(os.environ.get("SCAN_INTERVAL_SEC", "300") or "300")
 DISCOVER_TIMEOUT_SEC = float(os.environ.get("DISCOVER_TIMEOUT_SEC", "6") or "6")
 DEVICE_CACHE_TTL_SEC = int(os.environ.get("DEVICE_CACHE_TTL_SEC", "120") or "120")
@@ -251,6 +283,9 @@ MDNS_TYPES = [
    "_smb._tcp.local.",             # NAS / Fileshares
    "_workstation._tcp.local.",     # generische Hosts
    "_http._tcp.local.",            # Web-UIs (Router, NAS, IoT)
+    "_amzn-wplay._tcp.local.",      # Amazon Whisperplay — zuverlaessigster Fire-TV-Marker
+    "_adb-tls-connect._tcp.local.",  # Android 11+ Wireless Debugging
+    "_androidtvremote2._tcp.local.",  # Android TV Remote
 ]

 CAPABILITIES = ["discover"]
@@ -298,7 +333,48 @@ def _net_context() -> dict:
                   "mDNS/SSDP erreichen die realen Geraete so nicht. Auf Docker Desktop "
                   "(Mac/Windows) geht LAN-Discovery nicht — den Satelliten NATIV (python "
                   "satellite.py) oder auf einem Linux-Host im Ziel-LAN betreiben.")
-    return {"primary_ip": p, "ips": ips, "warning": warning}
+    return {"primary_ip": p, "ips": ips, "mac": _own_mac(p), "warning": warning}
+
+
+def _own_mac(ip: str) -> str:
+    """MAC der eigenen (primaeren) Netzwerkkarte — identifiziert die Kiste
+    eindeutig (DHCP-Reservierung, WOL). Liest /sys/class/net (Linux); faellt auf
+    uuid.getnode() zurueck, wenn das Interface nicht zuzuordnen ist."""
+    import subprocess
+    try:
+        base = "/sys/class/net"
+        if os.path.isdir(base):
+            # Interface zur primaeren IP finden (ueber die Adressen im /proc-Netz).
+            want = ""
+            if ip:
+                try:
+                    out = subprocess.run(["ip", "-o", "-4", "addr", "show"],
+                                         capture_output=True, text=True, timeout=3).stdout
+                    for line in out.splitlines():
+                        parts = line.split()
+                        if len(parts) >= 4 and parts[3].split("/")[0] == ip:
+                            want = parts[1]
+                            break
+                except Exception:
+                    pass
+            names = [want] if want else []
+            names += [n for n in sorted(os.listdir(base)) if n != "lo" and n not in names]
+            for n in names:
+                try:
+                    with open(os.path.join(base, n, "address"), "r") as f:
+                        mac = f.read().strip()
+                    if mac and mac != "00:00:00:00:00:00":
+                        return mac.lower()
+                except Exception:
+                    continue
+    except Exception:
+        pass
+    try:
+        import uuid
+        node = uuid.getnode()
+        return ":".join(f"{(node >> e) & 0xFF:02x}" for e in range(40, -8, -8))
+    except Exception:
+        return ""


 NET = _net_context()
@@ -386,6 +462,8 @@ def _mdns_kind(service_type: str) -> str:
        "_spotify-connect": "spotify", "_sonos": "sonos", "_hap": "homekit",
        "_printer": "printer", "_ipp": "printer", "_smb": "fileshare",
        "_workstation": "host", "_http": "web",
+        "_amzn-wplay": "firetv", "_adb-tls-connect": "android-adb",
+        "_androidtvremote2": "androidtv",
    }
    for k, v in m.items():
        if service_type.startswith(k):
@@ -547,6 +625,20 @@ async def _control(action: str, params: dict, devices: list[dict]) -> dict:
            return await loop.run_in_executor(None, _do_fritzbox, action, params)
        if action == "ssh.exec":
            return await loop.run_in_executor(None, _do_ssh, params)
+        if action == "adb.devices":
+            return await loop.run_in_executor(None, _do_adb_devices, params)
+        if action == "adb.connect":
+            return await loop.run_in_executor(None, _do_adb_connect, params)
+        if action == "adb.install":
+            return await loop.run_in_executor(None, _do_adb_install, params)
+        if action == "adb.shell":
+            return await loop.run_in_executor(None, _do_adb_shell, params)
+        if action == "adb.provision":
+            return await loop.run_in_executor(None, _do_adb_provision, params)
+        if action == "adb.status":
+            return await loop.run_in_executor(None, _do_adb_status, params)
+        if action == "adb.permissions":
+            return await loop.run_in_executor(None, _do_adb_permissions, params)
        return {"ok": False, "error": f"Aktion '{action}' nicht implementiert."}
    except Exception as exc:
        return {"ok": False, "error": f"{action} fehlgeschlagen: {exc}"}
@@ -1028,6 +1120,429 @@ def _do_ssh(params: dict) -> dict:
                                   "stderr": err[:4000], **win}}


+# ─── ADB: Android-Geraete im LAN (Fire TV Sticks) ───────────────────
+
+def _adb_run(args: list, timeout: float = 0) -> tuple:
+    """Fuehrt adb aus. Gibt (rc, stdout, stderr). Muster wie _snmp_run."""
+    import subprocess
+    try:
+        r = subprocess.run(["adb"] + args, capture_output=True, text=True,
+                           timeout=timeout or ADB_TIMEOUT_SEC)
+        return r.returncode, (r.stdout or "").strip(), (r.stderr or "").strip()
+    except FileNotFoundError:
+        return 127, "", ("adb fehlt im Container — 'adb' ins satellite/Dockerfile "
+                         "aufnehmen und neu bauen.")
+    except subprocess.TimeoutExpired:
+        return 124, "", f"adb-Timeout nach {timeout or ADB_TIMEOUT_SEC:.0f}s."
+
+
+def _adb_target(params: dict) -> str:
+    """Ziel als ip:port (Port default 5555)."""
+    host = _snmp_target(params)
+    if not host:
+        return ""
+    return host if ":" in host else f"{host}:{int(params.get('port') or ADB_PORT)}"
+
+
+def _adb_connect(target: str) -> tuple:
+    """Verbindet zum Geraet. Gibt (ok, meldung)."""
+    rc, out, err = _adb_run(["connect", target], timeout=25)
+    txt = f"{out} {err}".strip()
+    low = txt.lower()
+    if "connected to" in low:                      # connected / already connected
+        return True, txt
+    if "unauthorized" in low:
+        return False, ("Geraet hat die Verbindung nicht autorisiert. Auf dem "
+                       "Bildschirm des Geraets den Dialog 'USB-Debugging zulassen?' "
+                       "bestaetigen (Haken bei 'Immer erlauben').")
+    if rc == 127 or "adb fehlt" in low:
+        return False, txt
+    return False, (txt or "Verbindung fehlgeschlagen") + \
+        " — ADB-Debugging aktiv? (Fire TV: Einstellungen > Mein Fire TV > " \
+        "Entwickleroptionen > ADB-Debugging)"
+
+
+def _adb_state(target: str) -> str:
+    """'device' | 'unauthorized' | 'offline' | '' (unbekannt)."""
+    rc, out, _ = _adb_run(["devices"], timeout=20)
+    for line in out.splitlines()[1:]:
+        parts = line.split()
+        if len(parts) >= 2 and parts[0] == target:
+            return parts[1]
+    return ""
+
+
+def _adb_wait_authorized(target: str, seconds: float) -> tuple:
+    """Wartet, bis das Geraet autorisiert ist ('device').
+
+    Beim ersten Kontakt erscheint auf dem Fernseher/Handy der Dialog
+    "USB-Debugging zulassen?". Frueher brach die Installation hier ab und man
+    musste nach dem Bestaetigen ein zweites Mal starten — jetzt wartet der
+    Satellit einfach, bis der Nutzer bestaetigt hat. Gibt (ok, zustand).
+    """
+    import time as _time
+    deadline = _time.time() + max(0.0, seconds)
+    last = _adb_state(target)
+    while _time.time() < deadline:
+        if last == "device":
+            return True, last
+        _time.sleep(2.0)
+        # Erneut verbinden: nach dem Bestaetigen wechselt der Zustand oft erst
+        # mit einem frischen connect von 'unauthorized'/'offline' auf 'device'.
+        _adb_run(["connect", target], timeout=15)
+        last = _adb_state(target)
+    return last == "device", last
+
+
+def _do_adb_devices(params: dict) -> dict:
+    """Listet die dem Satelliten bekannten ADB-Geraete."""
+    rc, out, err = _adb_run(["devices", "-l"], timeout=20)
+    if rc not in (0,):
+        return {"ok": False, "error": err or "adb devices fehlgeschlagen"}
+    devices = []
+    for line in out.splitlines()[1:]:
+        parts = line.split()
+        if len(parts) >= 2:
+            devices.append({"target": parts[0], "state": parts[1],
+                            "info": " ".join(parts[2:])})
+    return {"ok": True, "result": {"devices": devices, "count": len(devices)}}
+
+
+def _do_adb_connect(params: dict) -> dict:
+    target = _adb_target(params)
+    if not target:
+        return {"ok": False, "error": "ip/host erforderlich."}
+    ok, msg = _adb_connect(target)
+    state = _adb_state(target)
+    wait = float(params.get("auth_wait") or ADB_AUTH_WAIT_SEC)
+    if (not ok or state != "device") and wait > 0:
+        authed, state = _adb_wait_authorized(target, wait)
+        if not authed:
+            return {"ok": False, "error":
+                    "Nicht autorisiert — auf dem Bildschirm des Geraets "
+                    "'USB-Debugging zulassen?' bestaetigen. "
+                    f"(gewartet: {wait:.0f}s, Zustand: '{state or '?'}')"}
+        msg = f"verbunden (nach Bestaetigung am Geraet)"
+    elif not ok:
+        return {"ok": False, "error": msg}
+    return {"ok": True, "result": {"target": target, "state": state, "message": msg}}
+
+
+AGENT_PACKAGE = os.environ.get("AGENT_PACKAGE", "de.hackersoft.ariaagent")
+
+
+def _adb_app_installed(target: str, package: str) -> bool:
+    rc, out, _ = _adb_run(["-s", target, "shell", "pm", "list", "packages", package],
+                          timeout=30)
+    return rc == 0 and f"package:{package}" in out
+
+
+def _adb_app_running(target: str, package: str) -> bool:
+    """Laeuft der Vordergrund-Dienst des Agents? (Fire TV / Android)."""
+    rc, out, _ = _adb_run(["-s", target, "shell", "dumpsys", "activity", "services",
+                           package], timeout=30)
+    return rc == 0 and "ServiceRecord" in out
+
+
+def _do_adb_status(params: dict) -> dict:
+    """Ist der ARIA-Agent auf dem Geraet installiert und laeuft er?"""
+    target = _adb_target(params)
+    if not target:
+        return {"ok": False, "error": "ip/host erforderlich."}
+    package = (params.get("package") or AGENT_PACKAGE).strip()
+    ok, msg = _adb_connect(target)
+    if not ok:
+        return {"ok": False, "error": msg}
+    installed = _adb_app_installed(target, package)
+    running = _adb_app_running(target, package) if installed else False
+    ver = ""
+    if installed:
+        rc, out, _ = _adb_run(["-s", target, "shell", "dumpsys", "package", package],
+                              timeout=30)
+        m = re.search(r"versionName=(\S+)", out or "")
+        ver = m.group(1) if m else ""
+    return {"ok": True, "result": {
+        "target": target, "package": package, "installed": installed,
+        "running": running, "version": ver,
+        "message": ("Agent laeuft" if running else
+                    "installiert, laeuft aber nicht" if installed else
+                    "nicht installiert")}}
+
+
+def _adb_grant_permissions(target: str, package: str) -> dict:
+    """Erteilt dem Agenten die Sonderrechte per ADB — das spart das Antippen mit
+    der Fernbedienung (auf einem Fire TV besonders muehsam):
+      PROJECT_MEDIA       Bildschirmaufnahme ohne Nachfrage-Dialog (Screenshots)
+      SYSTEM_ALERT_WINDOW Einblendung ueber dem laufenden Bild (Overlay)
+      RECORD_AUDIO        Mikrofon (Sprachdialog)
+    Best effort: was nicht geht, wird gemeldet, bricht aber nichts ab."""
+    granted, failed = [], []
+    ops = [("appops", ["appops", "set", package, "PROJECT_MEDIA", "allow"], "Bildschirmaufnahme"),
+           ("appops", ["appops", "set", package, "SYSTEM_ALERT_WINDOW", "allow"], "Einblendung")]
+    perms = [("android.permission.RECORD_AUDIO", "Mikrofon")]
+    for _, cmd, label in ops:
+        rc, out, err = _adb_run(["-s", target, "shell"] + cmd, timeout=30)
+        (granted if rc == 0 and "error" not in f"{out}{err}".lower() else failed).append(label)
+    for perm, label in perms:
+        rc, out, err = _adb_run(["-s", target, "shell", "pm", "grant", package, perm], timeout=30)
+        (granted if rc == 0 and "error" not in f"{out}{err}".lower() else failed).append(label)
+    return {"granted": granted, "failed": failed}
+
+
+def _do_adb_permissions(params: dict) -> dict:
+    """Nur die Berechtigungen setzen (ohne Neuinstallation/Einrichtung)."""
+    target = _adb_target(params)
+    if not target:
+        return {"ok": False, "error": "ip/host erforderlich."}
+    package = (params.get("package") or AGENT_PACKAGE).strip()
+    ok, msg = _adb_connect(target)
+    if not ok:
+        return {"ok": False, "error": msg}
+    r = _adb_grant_permissions(target, package)
+    msg = "erteilt: " + (", ".join(r["granted"]) or "—")
+    if r["failed"]:
+        msg += " · nicht moeglich: " + ", ".join(r["failed"])
+    return {"ok": True, "result": {"target": target, "message": msg, **r}}
+
+
+def _do_adb_provision(params: dict) -> dict:
+    """Richtet den ARIA-Agent auf dem Geraet FERN ein (RVS-Zugang uebergeben).
+
+    Auf einem Fire TV gibt es keine Kamera (kein QR-Scan) und Tippen mit der
+    Fernbedienung ist muehsam. Der Satellit startet die App deshalb per ADB
+    direkt mit den Zugangsdaten als Intent-Extras.
+    params: {ip, rvs_host, rvs_token, rvs_port?, rvs_tls?, name?, control?,
+             reply_mode?, package?}
+    """
+    target = _adb_target(params)
+    if not target:
+        return {"ok": False, "error": "ip/host erforderlich."}
+    rvs_host = (params.get("rvs_host") or "").strip()
+    rvs_token = (params.get("rvs_token") or "").strip()
+    if not rvs_host or not rvs_token:
+        return {"ok": False, "error": "rvs_host und rvs_token erforderlich."}
+    package = (params.get("package") or AGENT_PACKAGE).strip()
+
+    ok, msg = _adb_connect(target)
+    state = _adb_state(target)
+    wait = float(params.get("auth_wait") or ADB_AUTH_WAIT_SEC)
+    if (not ok or state != "device") and wait > 0:
+        authed, state = _adb_wait_authorized(target, wait)
+        if not authed:
+            return {"ok": False, "error":
+                    "Nicht autorisiert — 'USB-Debugging zulassen?' auf dem "
+                    f"Bildschirm bestaetigen. (Zustand: '{state or '?'}')"}
+    elif not ok:
+        return {"ok": False, "error": msg}
+
+    if not _adb_app_installed(target, package):
+        return {"ok": False, "error": f"'{package}' ist nicht installiert — "
+                "erst adb.install ausfuehren."}
+
+    # Sonderrechte gleich mit erteilen (Bildschirm/Overlay/Mikro) — sonst muesste
+    # man sie am Fernseher mit der Fernbedienung zusammenklicken.
+    perms = ({"granted": [], "failed": []} if params.get("skip_permissions")
+             else _adb_grant_permissions(target, package))
+
+    # WICHTIG: 'adb shell' haengt die Argumente zu EINER Kommandozeile zusammen,
+    # die auf dem Geraet nochmal von der Shell zerlegt wird. Werte mit Leerzeichen
+    # ("Wohnzimmer Fire TV") wuerden dabei abgeschnitten -> jeden Wert quoten.
+    import shlex
+    q = shlex.quote
+    # Der Intent MUSS eindeutig sein: Android vergleicht beim Start Komponente,
+    # Action und Daten — NICHT die Extras. Ohne eigene Daten-URI gilt ein zweites
+    # Provisioning als "gleicher Intent", die Activity wird nur nach vorn geholt
+    # und onCreate/onNewIntent laufen nie -> der alte Name bliebe stehen.
+    stamp = str(int(time.time() * 1000))
+    args = ["-s", target, "shell", "am", "start",
+            "-n", f"{package}/.MainActivity",
+            "-a", f"{package}.PROVISION",
+            "-d", q(f"aria://provision/{stamp}"),
+            "-e", "host", q(rvs_host),
+            "-e", "token", q(rvs_token),
+            "--ei", "port", str(int(params.get("rvs_port") or 443)),
+            "--ez", "tls", "true" if _as_bool(params.get("rvs_tls"), True) else "false",
+            "--ez", "control", "true" if _as_bool(params.get("control"), True) else "false",
+            # Nur wenn die Bildschirm-Berechtigung wirklich sitzt: dann darf sich
+            # die Aufnahme nach jedem Neustart selbst scharf schalten (dialogfrei).
+            "--ez", "capture", "true" if "Bildschirmaufnahme" in perms.get("granted", []) else "false"]
+    if params.get("name"):
+        args += ["-e", "name", q(str(params["name"]))]
+    if params.get("reply_mode"):
+        args += ["-e", "reply_mode", q(str(params["reply_mode"]))]
+
+    rc, out, err = _adb_run(args, timeout=60)
+    txt = f"{out} {err}".strip()
+    if rc != 0 or "Error" in txt:
+        return {"ok": False, "error": (txt or f"exit {rc}")[:400]}
+    # Android meldet das, wenn es den Intent als "schon offen" abtut und die
+    # Activity nur nach vorn holt — dann kaeme die neue Konfiguration NICHT an.
+    if "brought to the front" in txt.lower() or "not started" in txt.lower():
+        return {"ok": False, "error":
+                "Android hat den Einrichtungs-Intent nicht ausgeliefert (Activity "
+                "war schon offen). Auf dem Geraet die Agent-App einmal schliessen "
+                "und erneut 'Nur einrichten' druecken. Details: " + txt[:200]}
+    msg = f"Agent eingerichtet (RVS {rvs_host}) und gestartet"
+    if perms.get("granted"):
+        msg += " · Rechte erteilt: " + ", ".join(perms["granted"])
+    if perms.get("failed"):
+        msg += " · manuell noetig: " + ", ".join(perms["failed"])
+    return {"ok": True, "result": {
+        "target": target, "package": package, "permissions": perms, "message": msg}}
+
+
+def _as_bool(v, default: bool) -> bool:
+    if v is None:
+        return default
+    if isinstance(v, bool):
+        return v
+    return str(v).strip().lower() in ("1", "true", "yes", "on", "ja")
+
+
+def _do_adb_shell(params: dict) -> dict:
+    """Shell-Kommando auf dem Android-Geraet (Diagnose, z.B. 'pm list packages')."""
+    target = _adb_target(params)
+    cmd = (params.get("cmd") or params.get("command") or "").strip()
+    if not target:
+        return {"ok": False, "error": "ip/host erforderlich."}
+    if not cmd:
+        return {"ok": False, "error": "cmd erforderlich."}
+    ok, msg = _adb_connect(target)
+    if not ok:
+        return {"ok": False, "error": msg}
+    rc, out, err = _adb_run(["-s", target, "shell", cmd], timeout=60)
+    win = _window_text(out, params)
+    return {"ok": rc == 0, "result": {"target": target, "exit_code": rc,
+                                      "stderr": err[:2000], **win},
+            **({} if rc == 0 else {"error": err[:500] or f"exit {rc}"})}
+
+
+def _apk_fetch(params: dict) -> tuple:
+    """Besorgt die APK lokal. Gibt (pfad, fehler).
+    Quelle: 'url' (HTTP-Pull, gecached in APK_CACHE_DIR) ODER 'apk_base64'.
+    HTTP-Pull ist der Normalweg — der RVS ist ein Broadcast-Relay, eine APK
+    als base64 ginge an JEDEN Client im Raum."""
+    import base64
+    import hashlib
+    import requests
+    os.makedirs(APK_CACHE_DIR, exist_ok=True)
+    url = (params.get("url") or "").strip()
+    b64 = params.get("apk_base64")
+    want_sha = (params.get("sha256") or "").strip().lower()
+
+    if b64:
+        try:
+            data = base64.b64decode(b64)
+        except Exception as exc:
+            return "", f"apk_base64 ungueltig: {exc}"
+    elif url:
+        digest = hashlib.sha256(url.encode()).hexdigest()[:16]
+        cached = os.path.join(APK_CACHE_DIR, f"{digest}.apk")
+        if os.path.isfile(cached) and os.path.getsize(cached) > 0:
+            return cached, ""
+        try:
+            headers = {}
+            if params.get("token"):
+                headers["Authorization"] = f"token {params['token']}"
+            with requests.get(url, stream=True, timeout=60, headers=headers,
+                              verify=not params.get("insecure")) as r:
+                r.raise_for_status()
+                total = 0
+                tmp = cached + ".part"
+                with open(tmp, "wb") as f:
+                    for chunk in r.iter_content(65536):
+                        total += len(chunk)
+                        if total > APK_MAX_BYTES:
+                            f.close(); os.remove(tmp)
+                            return "", f"APK groesser als {APK_MAX_BYTES // 1024 // 1024} MB."
+                        f.write(chunk)
+                os.replace(tmp, cached)
+        except Exception as exc:
+            return "", f"APK-Download fehlgeschlagen: {exc}"
+        data = None
+    else:
+        return "", "url ODER apk_base64 erforderlich."
+
+    if data is not None:
+        if len(data) > APK_MAX_BYTES:
+            return "", f"APK groesser als {APK_MAX_BYTES // 1024 // 1024} MB."
+        path = os.path.join(APK_CACHE_DIR,
+                            hashlib.sha256(data).hexdigest()[:16] + ".apk")
+        with open(path, "wb") as f:
+            f.write(data)
+        cached = path
+
+    if want_sha:
+        h = hashlib.sha256()
+        with open(cached, "rb") as f:
+            for blk in iter(lambda: f.read(65536), b""):
+                h.update(blk)
+        if h.hexdigest().lower() != want_sha:
+            return "", "sha256 stimmt nicht — Download verworfen."
+    return cached, ""
+
+
+def _do_adb_install(params: dict) -> dict:
+    """Rollt eine APK auf ein Android-Geraet aus (Fire TV & Co.).
+    params: {ip|host|device, url|apk_base64, sha256?, port?, downgrade?, timeout?}
+    Selbstheilend: verbindet, installiert, gibt den Status zurueck."""
+    target = _adb_target(params)
+    if not target:
+        return {"ok": False, "error": "ip/host erforderlich."}
+    apk, err = _apk_fetch(params)
+    if err:
+        return {"ok": False, "error": err}
+
+    ok, msg = _adb_connect(target)
+    state = _adb_state(target)
+    # Erstkontakt: Das Geraet zeigt jetzt "USB-Debugging zulassen?" auf dem
+    # Bildschirm. Statt abzubrechen warten wir auf die Bestaetigung — ein Klick
+    # im Diagnostic genuegt, kein zweiter Anlauf noetig.
+    wait = float(params.get("auth_wait") or ADB_AUTH_WAIT_SEC)
+    if (not ok or state != "device") and wait > 0:
+        logger.info("[adb] %s: warte bis zu %.0fs auf Autorisierung (Zustand '%s')",
+                    target, wait, state or "?")
+        authed, state = _adb_wait_authorized(target, wait)
+        if not authed:
+            hint = ("Das Geraet hat die Verbindung nicht autorisiert. Auf dem "
+                    "Bildschirm erscheint 'USB-Debugging zulassen?' — bitte "
+                    "bestaetigen (Haken bei 'Immer erlauben'). "
+                    f"Ich habe {wait:.0f}s gewartet, Zustand: '{state or 'nicht erreichbar'}'.")
+            return {"ok": False, "error": hint if (state or ok) else msg}
+    elif not ok:
+        return {"ok": False, "error": msg}
+
+    args = ["-s", target, "install", "-r"]          # -r = Update statt Neuinstallation
+    if params.get("downgrade"):
+        args.append("-d")
+    args.append(apk)
+    rc, out, err2 = _adb_run(args, timeout=float(params.get("timeout") or ADB_TIMEOUT_SEC))
+    txt = f"{out} {err2}".strip()
+    size_mb = round(os.path.getsize(apk) / 1024 / 1024, 1)
+    if rc == 0 and "success" in txt.lower():
+        res = {"target": target, "apk_mb": size_mb,
+               "message": f"APK installiert ({size_mb} MB)"}
+        # Direkt einrichten, wenn die RVS-Daten mitkamen — auf einem Fire TV
+        # spart das der Fernbedienung das Abtippen von Host und Token.
+        if params.get("rvs_host") and params.get("rvs_token"):
+            prov = _do_adb_provision(params)
+            res["provisioned"] = bool(prov.get("ok"))
+            if prov.get("ok"):
+                res["message"] += " und eingerichtet — der Agent sollte gleich online sein"
+            else:
+                res["message"] += (f". Einrichtung fehlgeschlagen: "
+                                   f"{prov.get('error', '?')}")
+        return {"ok": True, "result": res}
+    low = txt.lower()
+    if "signatures do not match" in low or "update_incompatible" in low:
+        return {"ok": False, "error": "Signatur passt nicht zur installierten Version — "
+                "die alte App muss zuerst deinstalliert werden (adb.shell "
+                "'pm uninstall <paket>')."}
+    if "insufficient" in low or "no space" in low:
+        return {"ok": False, "error": "Nicht genug Speicher auf dem Geraet."}
+    return {"ok": False, "error": (txt or f"Installation fehlgeschlagen (exit {rc})")[:500]}
+
+
 def _to_int(s: str):
    try:
        return int(str(s).strip())
@@ -1095,6 +1610,13 @@ def _parse_http_headers(text: str) -> dict:
    return headers


+def _looks_amazon(dev: dict) -> bool:
+    """Fire TV? Amazon-Hersteller oder Modell-Praefix AFT (AFTMM, AFTKA, ...)."""
+    blob = f"{dev.get('manufacturer', '')} {dev.get('name', '')}".lower()
+    model = str(dev.get("model", "")).upper()
+    return "amazon" in blob or "fire tv" in blob or model.startswith("AFT")
+
+
 def _xml_tag(xml: str, tag: str) -> str:
    m = re.search(rf"<{tag}>(.*?)</{tag}>", xml, re.IGNORECASE | re.DOTALL)
    return m.group(1).strip() if m else ""
@@ -1129,10 +1651,12 @@ class Satellite:
            self._devices = _merge_devices(mdns, ssdp, arp)
            if SNMP_DISCOVERY:
                await self._enrich_snmp(self._devices)
+            await self._enrich_adb(self._devices)
            self._devices_ts = time.time()
            n_snmp = sum(1 for d in self._devices if d.get("snmpCapable"))
-            logger.info("[scan] %d Geraete (mdns=%d ssdp=%d arp=%d, snmp=%d)",
-                        len(self._devices), len(mdns), len(ssdp), len(arp), n_snmp)
+            n_adb = sum(1 for d in self._devices if d.get("adbCapable"))
+            logger.info("[scan] %d Geraete (mdns=%d ssdp=%d arp=%d, snmp=%d, adb=%d)",
+                        len(self._devices), len(mdns), len(ssdp), len(arp), n_snmp, n_adb)
        finally:
            self._scanning = False
        return self._devices
@@ -1163,6 +1687,34 @@ class Satellite:

        await asyncio.gather(*(_one(d) for d in devices))

+    async def _enrich_adb(self, devices: list) -> None:
+        """Prueft parallel, welche Geraete ADB-Netzwerk-Debugging offen haben
+        (TCP 5555). Damit sieht ARIA/die Diagnostic sofort, auf welche Geraete
+        (v.a. Fire TV Sticks) sich eine APK ausrollen laesst."""
+        sem = asyncio.Semaphore(16)
+
+        async def _one(dev: dict) -> None:
+            ip = dev.get("ip") or ""
+            if not ip:
+                return
+            async with sem:
+                try:
+                    fut = asyncio.open_connection(ip, ADB_PORT)
+                    reader, writer = await asyncio.wait_for(fut, timeout=1.5)
+                    writer.close()
+                    try:
+                        await writer.wait_closed()
+                    except Exception:
+                        pass
+                except Exception:
+                    return
+            dev["adbCapable"] = True
+            dev["adbPort"] = ADB_PORT
+            if dev.get("type", "") in ("", "host", "unknown", "dial"):
+                dev["type"] = "firetv" if _looks_amazon(dev) else "android"
+
+        await asyncio.gather(*(_one(d) for d in devices))
+
    async def _send(self, message: dict) -> None:
        if self.ws is None:
            return
@@ -1316,15 +1868,26 @@ class Satellite:
        _creds_load()
        asyncio.create_task(self._periodic_scan())
        backoff = 1
+        # use_tls kann bei Fehlschlag einmal auf ws:// fallen (RVS_TLS_FALLBACK),
+        # danach wieder zurueck auf RVS_TLS (kein Sticky-Fallback). Bei TLS+RVS_SNI
+        # nutzt die URI den HOSTNAMEN (Host-Header/SNI/Cert), getaddrinfo mappt ihn
+        # auf die IP in RVS_HOST.
+        use_tls = RVS_TLS
+        tls_fallback_tried = False
+        connect_kwargs = {"max_size": 8 * 1024 * 1024,
+                          "ping_interval": 20, "ping_timeout": 20}
        while True:
-            proto = "wss" if RVS_TLS else "ws"
-            url = f"{proto}://{RVS_HOST}:{RVS_PORT}?token={RVS_TOKEN}"
+            proto = "wss" if use_tls else "ws"
+            uri_host = RVS_SNI if (use_tls and RVS_SNI) else RVS_HOST
+            url = f"{proto}://{uri_host}:{RVS_PORT}?token={RVS_TOKEN}"
+            fallback = False
            try:
-                logger.info("Verbinde mit RVS %s://%s:%s …", proto, RVS_HOST, RVS_PORT)
-                async with websockets.connect(url, max_size=8 * 1024 * 1024,
-                                              ping_interval=20, ping_timeout=20) as ws:
+                logger.info("Verbinde mit RVS %s://%s:%s%s …", proto, uri_host, RVS_PORT,
+                            f" (TCP {RVS_HOST})" if (use_tls and RVS_SNI) else "")
+                async with websockets.connect(url, **connect_kwargs) as ws:
                    self.ws = ws
                    backoff = 1
+                    tls_fallback_tried = False
                    await self._hello(log=True)
                    hb = asyncio.create_task(self._heartbeat())
                    try:
@@ -1334,16 +1897,26 @@ class Satellite:
                        hb.cancel()
            except Exception as exc:
                logger.warning("RVS-Verbindung verloren: %s", exc)
+                if use_tls and RVS_TLS_FALLBACK and not tls_fallback_tried:
+                    logger.info("TLS fehlgeschlagen — Fallback auf ws://")
+                    use_tls = False
+                    tls_fallback_tried = True
+                    fallback = True
            finally:
                self.ws = None
+            if fallback:
+                continue
            await asyncio.sleep(backoff)
            backoff = min(backoff * 2, 30)
+            use_tls = RVS_TLS
+            tls_fallback_tried = False


 def main() -> None:
    logger.info("ARIA Satellit startet — id=%s location=%s control=%s",
                SATELLITE_ID, SATELLITE_LOCATION, CONTROL_ENABLED)
-    logger.info("Netz: primary_ip=%s alle=%s", NET.get("primary_ip"), NET.get("ips"))
+    logger.info("Netz: primary_ip=%s mac=%s alle=%s",
+                NET.get("primary_ip"), NET.get("mac") or "?", NET.get("ips"))
    if NET.get("warning"):
        logger.warning("⚠ %s", NET["warning"])
    try:
@@ -4,7 +4,7 @@
 # ════════════════════════════════════════════════

 # ─── Welche Dienste startet DIESER Node? ──────────
-# Komma-getrennt aus: voxtral, whisper, f5tts, llm
+# Komma-getrennt aus: voxtral, whisper, f5tts, llm, openhands
 # Nur die aufgefuehrten Dienste starten bei `docker compose up -d`.
 #   nur STT-Box (Voxtral) → COMPOSE_PROFILES=voxtral
 #   nur STT-Box (Whisper) → COMPOSE_PROFILES=whisper
@@ -13,6 +13,12 @@
 #   Kleine Karte (wenig VRAM): Whisper + F5-TTS auf EINER GPU
 #                         → COMPOSE_PROFILES=whisper,f5tts
 #   All-in-One, grosse Karte  → COMPOSE_PROFILES=voxtral,f5tts,llm
+#   LLM + OpenHands-Oberflaeche → COMPOSE_PROFILES=llm,openhands
+# 'openhands' ist REIN OPTIONAL (Standalone-Entwickler-Agent, s.u.). Wer es nicht
+# auffuehrt, bei dem wird der Container gar nicht erst angelegt — das Image wird
+# nicht einmal geladen. Fuer den normalen ARIA-Betrieb also einfach weglassen.
+# ACHTUNG: Profile brauchen compose v2 (`docker compose`, mit Leerzeichen). Das
+# alte `docker-compose` 1.x behandelt sie unzuverlaessig.
 # Hinweis: voxtral UND whisper zusammen NICHT sinnvoll — beide sind STT und
 # wuerden dieselbe Anfrage doppelt beantworten. Pro Node genau EINEN STT waehlen:
 # Voxtral-3B (~9 GB, beste Qualitaet) ODER Whisper (klein, passt neben F5-TTS).
@@ -43,9 +49,47 @@ RVS_PORT=444
 RVS_TLS=true
 RVS_TLS_FALLBACK=true
 RVS_TOKEN=dein_token_hier
+# RVS_SNI: nur noetig, wenn die Box im SELBEN Netz wie der RVS steht und direkt
+# auf dessen interne IP verbinden soll (kein NAT-Hairpin ueber den externen
+# Hostnamen). Dann RVS_HOST=<interne-ip> und hier den Zertifikats-/Hostnamen, fuer
+# den Caddy sein Cert hat. Zuhause / normal: leer lassen.
+#   RVS_HOST=10.0.0.2
+#   RVS_SNI=example.com
+RVS_SNI=

 # ─── Optional ─────────────────────────────────────
 # HF_TOKEN=            # nur falls ein HF-gated Modell (z.B. Voxtral) geladen wird
 # WHISPER_MODEL=small  # tiny|base|small|medium|large-v3 (Hot-Swap via Diagnostic)
 # WHISPER_LANGUAGE=de
 # LLM_MODEL=qwen3-8b   # Key aus llama-swap/config.yaml
+
+# ─── OpenAI-Endpunkt des lokalen LLM (optional) ───
+# llama-swap ist OpenAI-kompatibel (/v1/chat/completions, /v1/models). Damit
+# koennen Fremd-Tools direkt auf das lokale Modell: OpenHands, Continue,
+# Open WebUI, Aider ...  Base-URL dann:  http://<box>:<LLM_OPENAI_PORT>/v1
+#
+# LLM_OPENAI_BIND steuert, WER drankommt:
+#   127.0.0.1  nur diese Maschine (Default, sicher)
+#   0.0.0.0    das ganze LAN  →  dann UNBEDINGT LLM_OPENAI_KEY setzen!
+LLM_OPENAI_BIND=127.0.0.1
+LLM_OPENAI_PORT=8081
+# API-Key. Leer = Endpunkt ohne Authentifizierung (nur mit BIND=127.0.0.1 ok).
+# WICHTIG: Steht hier ein Wert, hat er VORRANG — das Feld ist dann in der ARIA-
+# Diagnostic schreibgeschuetzt. Leer lassen, wenn Du den Key lieber dort pro Box
+# setzen willst (er wird dann auf der Box unter /models/openai_key.json abgelegt).
+# Der Key wirkt, sobald ein Modell das naechste Mal geladen wird.
+LLM_OPENAI_KEY=
+
+# ─── OpenHands (optional, eigenes Profil) ─────────
+# Standalone-Entwickler-Agent, der das lokale LLM nutzt. Start:
+#   COMPOSE_PROFILES=llm,openhands docker compose up -d
+# Dann http://<box>:<OPENHANDS_PORT> aufrufen.
+# ACHTUNG: OpenHands startet eigene Arbeits-Container und bekommt dafuer den
+# Docker-Socket — das ist faktisch Root-Zugriff auf diese Maschine. Deshalb
+# BIND auf 127.0.0.1 lassen und von aussen per SSH-Tunnel zugreifen:
+#   ssh -L 3000:127.0.0.1:3000 user@box   ->  lokal http://localhost:3000
+OPENHANDS_BIND=127.0.0.1
+OPENHANDS_PORT=3000
+# Wie OpenHands das lokale Modell anspricht (Container-intern, daher :8080):
+OPENHANDS_LLM_BASE_URL=http://llama-swap:8080/v1
+OPENHANDS_LLM_MODEL=openai/qwen3-8b
@@ -58,6 +58,10 @@ GPU-Test + Stack-Start.
  24-GB-Karte: `docker compose stop whisper-bridge && docker compose --profile voxtral up -d --build`.
 - **Erster Start lädt Modelle** (mehrere GB via HuggingFace nach `xtts/hf-cache`
  + `xtts/models`) — genug Platz (1 TB NVMe ✓) und etwas Geduld.
+- **Box im selben Netz wie der RVS** (z.B. Rechenzentrum, direkt auf die interne
+  IP statt NAT-Hairpin): in `xtts/.env` `RVS_HOST=<interne-ip>` + **`RVS_SNI=<zert-name>`**
+  (Name, für den das Caddy-Zert gilt). Ohne das scheitert TLS an `tlsv1 alert
+  internal error`. Zuhause / normal: `RVS_SNI` leer lassen.

 ## Verifizieren

@@ -66,3 +70,83 @@ nvidia-smi                                   # Host sieht die GPU
 docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu22.04 nvidia-smi   # Container auch
 docker logs -f aria-whisper-bridge           # "RVS verbunden" + service_status ready
 ```
+
+## Lokales LLM von außen nutzen (OpenAI-Endpunkt)
+
+`llama-swap` spricht **OpenAI-kompatibel** (`/v1/chat/completions`, `/v1/models`).
+Damit können Fremd-Tools direkt auf das lokale Modell: **OpenHands**, Continue,
+Open WebUI, Aider …
+
+```
+Base-URL:  http://<box>:<LLM_OPENAI_PORT>/v1
+Modell:    qwen3-8b   (oder ein anderer Key aus llama-swap/config.yaml)
+API-Key:   LLM_OPENAI_KEY  (falls gesetzt)
+```
+
+In der `.env`:
+
+| Variable | Bedeutung |
+|---|---|
+| `LLM_OPENAI_BIND` | `127.0.0.1` = nur diese Maschine (**Default, sicher**) · `0.0.0.0` = ganzes LAN |
+| `LLM_OPENAI_PORT` | Host-Port (Default `8081`) |
+| `LLM_OPENAI_KEY`  | API-Key; leer = **ohne Authentifizierung** |
+
+> ⚠️ `LLM_OPENAI_BIND=0.0.0.0` **ohne** `LLM_OPENAI_KEY` heißt: jeder im Netz kann
+> das Modell benutzen. Entweder Key setzen oder auf localhost gebunden lassen.
+
+**Wo wird was konfiguriert?**
+
+- **Port und Erreichbarkeit** immer in der `.env`. Beides ist ein Docker-Port-Mapping
+  und steht beim Container-Start fest — es lässt sich nicht aus der Ferne ändern.
+- **API-Key**: entweder in der `.env` **oder** — wenn dort leer — in der ARIA-Diagnostic
+  unter *Compute-Flotte* bei der jeweiligen Box. Dort abgelegt landet er auf der Box
+  unter `/models/openai_key.json` (Rechte 0600).
+- **Die `.env` hat immer Vorrang.** Steht `LLM_OPENAI_KEY` dort, ist das Feld in der
+  Diagnostic **schreibgeschützt** (🔒-Hinweis).
+- Ein geänderter Key greift, sobald ein Modell das **nächste Mal geladen** wird
+  (llama-server bekommt ihn per `--api-key`). Laufendes Modell also einmal entladen
+  lassen (TTL) oder ein anderes Modell anfragen.
+
+Prüfen:
+```bash
+curl -s http://localhost:8081/v1/models                       # ohne Key
+curl -s -H "Authorization: Bearer $LLM_OPENAI_KEY" \
+     http://localhost:8081/v1/models                          # mit Key
+```
+
+## OpenHands (optionales Profil)
+
+OpenHands ist **rein optional** und liegt in einem eigenen Profil. Wer es nicht in
+`COMPOSE_PROFILES` aufführt, bei dem wird der Container **gar nicht erst angelegt** —
+das Image wird nicht einmal geladen. Für den normalen ARIA-Betrieb also einfach weglassen:
+
+```bash
+COMPOSE_PROFILES=voxtral,f5tts,llm docker compose up -d   # ohne OpenHands
+COMPOSE_PROFILES=llm,openhands     docker compose up -d   # mit OpenHands
+```
+
+Dann `http://<box>:<OPENHANDS_PORT>` (Default `3000`) öffnen. Das lokale Modell ist
+schon vorbelegt (`OPENHANDS_LLM_BASE_URL`, `OPENHANDS_LLM_MODEL`) und in der
+Oberfläche änderbar.
+
+| Variable | Bedeutung |
+|---|---|
+| `OPENHANDS_BIND` | `127.0.0.1` (Default) oder `0.0.0.0` fürs LAN |
+| `OPENHANDS_PORT` | Host-Port (Default `3000`) |
+| `OPENHANDS_LLM_BASE_URL` | Default `http://llama-swap:8080/v1` (Container-intern — **nicht** der Host-Port) |
+| `OPENHANDS_LLM_MODEL` | Default `openai/qwen3-8b` |
+
+> ⚠️ OpenHands startet eigene Arbeits-Container und bekommt dafür den **Docker-Socket**.
+> Das ist faktisch Root-Zugriff auf diese Maschine — wer die Oberfläche erreicht,
+> kann im Zweifel alles auf der Box.
+>
+> **Deshalb bleibt `OPENHANDS_BIND` auf `127.0.0.1`.** Von einem anderen Rechner
+> greifst Du per SSH-Tunnel zu, statt den Port ins LAN zu öffnen:
+> ```bash
+> ssh -L 3000:127.0.0.1:3000 user@box     # dann lokal http://localhost:3000
+> ```
+> Das kostet nichts und ist die wirksamste Absicherung, solange der Socket
+> durchgereicht wird. Wer echte Isolation braucht: OpenHands in eine eigene VM,
+> oder einen rootless Docker-Daemon als Beiwagen statt des Host-Sockets.
+
+Ohne das Profil ändert sich nichts: Wer nur ARIAs Box fahren will, startet OpenHands gar nicht.
@@ -139,6 +139,13 @@ services:
    # Liest die vom llm-adapter generierte Config. Beim allerersten Boot faengt
    # restart: unless-stopped die Reihenfolge ab, bis der Adapter sie geschrieben hat.
    command: ["--config", "/models/llama-swap.config.yaml", "--listen", "0.0.0.0:8080"]
+    # OpenAI-kompatibler Endpunkt (/v1/chat/completions, /v1/models) — damit
+    # koennen Fremd-Tools wie OpenHands, Continue oder Open WebUI direkt auf das
+    # lokale LLM. Standardmaessig NUR auf localhost gebunden (sicher); fuer
+    # Zugriff aus dem LAN LLM_OPENAI_BIND=0.0.0.0 setzen — dann aber unbedingt
+    # LLM_OPENAI_KEY vergeben, sonst kann jeder im Netz das Modell nutzen.
+    ports:
+      - "${LLM_OPENAI_BIND:-127.0.0.1}:${LLM_OPENAI_PORT:-8081}:8080"
    restart: unless-stopped

  # ─── Local-LLM-Adapter — RVS <-> llama.cpp ────
@@ -172,3 +179,33 @@ services:
      # Erster Load eines Modells kann ein GGUF ziehen (mehrere GB) — grosszuegig.
      - LLM_TIMEOUT_SEC=${LLM_TIMEOUT_SEC:-600}
    restart: unless-stopped
+
+  # ─── OpenHands (optional, Standalone) ────────────────
+  # Eigenstaendige Entwickler-Agenten-Oberflaeche, die das LOKALE LLM ueber den
+  # OpenAI-Endpunkt von llama-swap nutzt. Bewusst ein eigenes Profil: wer nur
+  # ARIAs Box fahren will, startet es gar nicht erst.
+  #   COMPOSE_PROFILES=llm,openhands docker compose up -d
+  # Danach http://<box>:${OPENHANDS_PORT:-3000} und dort als Provider
+  # "OpenAI-kompatibel" mit Base-URL http://llama-swap:8080/v1 eintragen
+  # (aus dem Container heraus erreichbar), Modell z.B. qwen3-8b.
+  openhands:
+    image: docker.all-hands.dev/all-hands-ai/openhands:latest
+    container_name: aria-openhands
+    profiles: ["openhands"]
+    environment:
+      - SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:latest
+      - LOG_ALL_EVENTS=true
+      # Vorbelegung fuer das lokale Modell — in der Oberflaeche aenderbar.
+      - LLM_BASE_URL=${OPENHANDS_LLM_BASE_URL:-http://llama-swap:8080/v1}
+      - LLM_API_KEY=${LLM_OPENAI_KEY:-local}
+      - LLM_MODEL=${OPENHANDS_LLM_MODEL:-openai/qwen3-8b}
+    volumes:
+      # OpenHands startet seine Arbeits-Container selbst -> braucht den Socket.
+      # ACHTUNG: das gibt dem Container Kontrolle ueber den Docker-Host.
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ./openhands-state:/.openhands
+    ports:
+      - "${OPENHANDS_BIND:-127.0.0.1}:${OPENHANDS_PORT:-3000}:3000"
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    restart: unless-stopped
@@ -51,6 +51,21 @@ RVS_PORT = int(os.getenv("RVS_PORT", "443"))
 RVS_TLS = os.getenv("RVS_TLS", "true").lower() == "true"
 RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true").lower() == "true"
 RVS_TOKEN = os.getenv("RVS_TOKEN", "").strip()
+# TLS-Hostname (SNI + Cert), falls RVS_HOST eine IP ist (Box im selben Netz wie
+# der RVS, direkt auf die interne IP). Leer = SNI = RVS_HOST.
+RVS_SNI = os.getenv("RVS_SNI", "").strip()
+
+# In-Process-DNS-Override: wenn RVS_SNI gesetzt ist, verbindet die URI ueber den
+# HOSTNAMEN (Host-Header + SNI + Cert stimmen), waehrend getaddrinfo den Namen auf
+# die echte IP in RVS_HOST aufloest. Versionsunabhaengig — host=/port= kollidiert
+# in der Legacy-websockets-API mit dem aus der URI abgeleiteten Host.
+if RVS_TLS and RVS_SNI:
+    import socket as _socket
+    _orig_getaddrinfo = _socket.getaddrinfo
+    def _sni_getaddrinfo(host, *a, **k):
+        return _orig_getaddrinfo(RVS_HOST if host == RVS_SNI else host, *a, **k)
+    _socket.getaddrinfo = _sni_getaddrinfo
+

 # F5-TTS Konfiguration
 # ─────────────────────────────────────────────────────────────────
@@ -877,12 +892,21 @@ async def run_loop(runner: F5Runner) -> None:

    while True:
        scheme = "wss" if use_tls else "ws"
-        url = f"{scheme}://{RVS_HOST}:{RVS_PORT}?token={RVS_TOKEN}"
+        uri_host = RVS_SNI if (use_tls and RVS_SNI) else RVS_HOST
+        url = f"{scheme}://{uri_host}:{RVS_PORT}?token={RVS_TOKEN}"
        masked = url.replace(RVS_TOKEN, "***") if RVS_TOKEN else url

+        # max_size MUSS zum RVS/zur Bridge passen (1500 MB). Der RVS ist ein
+        # BROADCAST-Relay: eine grosse Nachricht (Datei-Transfer, Voice-Upload,
+        # APK-Update) geht an JEDEN Client im Raum. Wer ein kleineres Limit hat,
+        # schliesst die Verbindung mit Code 1009 ("message too big") und landet in
+        # einer Reconnect-Schleife — real gesehen mit einem 209-MB-Frame, der
+        # whisper und f5tts im Minutentakt neu starten liess.
+        _MAX_WS_BYTES = int(os.getenv("RVS_MAX_SIZE_MB", "1500")) * 1024 * 1024
+        connect_kwargs = {"ping_interval": 20, "ping_timeout": 10, "max_size": _MAX_WS_BYTES}
        try:
-            logger.info("Verbinde zu RVS: %s", masked)
-            async with websockets.connect(url, ping_interval=20, ping_timeout=10, max_size=50 * 1024 * 1024) as ws:
+            logger.info("Verbinde zu RVS: %s%s", masked, f" (TCP {RVS_HOST})" if (use_tls and RVS_SNI) else "")
+            async with websockets.connect(url, **connect_kwargs) as ws:
                logger.info("RVS verbunden")
                retry_s = 2
                tls_fallback_tried = False
@@ -27,6 +27,8 @@ import asyncio
 import json
 import logging
 import os
+import re
+import shlex
 import time

 import httpx
@@ -43,6 +45,21 @@ RVS_PORT = os.getenv("RVS_PORT", "443").strip()
 RVS_TLS = os.getenv("RVS_TLS", "true").lower() == "true"
 RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true").lower() == "true"
 RVS_TOKEN = os.getenv("RVS_TOKEN", "").strip()
+# TLS-Hostname (SNI + Cert), falls RVS_HOST eine IP ist (Box im selben Netz wie
+# der RVS, direkt auf die interne IP). Leer = SNI = RVS_HOST.
+RVS_SNI = os.getenv("RVS_SNI", "").strip()
+
+# In-Process-DNS-Override: wenn RVS_SNI gesetzt ist, verbindet die URI ueber den
+# HOSTNAMEN (Host-Header + SNI + Cert stimmen), waehrend getaddrinfo den Namen auf
+# die echte IP in RVS_HOST aufloest. Versionsunabhaengig — host=/port= kollidiert
+# in der Legacy-websockets-API mit dem aus der URI abgeleiteten Host.
+if RVS_TLS and RVS_SNI:
+    import socket as _socket
+    _orig_getaddrinfo = _socket.getaddrinfo
+    def _sni_getaddrinfo(host, *a, **k):
+        return _orig_getaddrinfo(RVS_HOST if host == RVS_SNI else host, *a, **k)
+    _socket.getaddrinfo = _sni_getaddrinfo
+

 LLAMA_URL = os.getenv("LLAMA_URL", "http://llama:8081").rstrip("/")
 LLM_MODEL = os.getenv("LLM_MODEL", "qwen3-8b")
@@ -79,6 +96,44 @@ BASE_CONFIG_PATH = os.getenv("LLAMA_BASE_CONFIG", "/llamaswap/config.yaml")
 GEN_CONFIG_PATH = os.getenv("LLAMA_GEN_CONFIG", "/models/llama-swap.config.yaml")
 REGISTRY_PATH = os.getenv("LLM_REGISTRY", "/models/aria_models.json")

+# ── OpenAI-kompatibler Endpunkt (fuer OpenHands & Co.) ─────
+# Der Port ist ein Docker-Port-Mapping und steht beim Container-Start fest —
+# er kommt IMMER aus der .env. Der API-Key kann zusaetzlich zur Laufzeit aus der
+# Diagnostic gesetzt werden, ABER: steht er in der .env, hat die .env Vorrang
+# und das Feld ist in der Diagnostic schreibgeschuetzt.
+OPENAI_PORT = os.getenv("LLM_OPENAI_PORT", "8081").strip() or "8081"
+OPENAI_BIND = os.getenv("LLM_OPENAI_BIND", "127.0.0.1").strip() or "127.0.0.1"
+_OPENAI_KEY_ENV = os.getenv("LLM_OPENAI_KEY", "").strip()
+OPENAI_KEY_FILE = os.getenv("LLM_OPENAI_KEY_FILE", "/models/openai_key.json")
+
+
+def _openai_key() -> str:
+    """Gueltiger API-Key: .env gewinnt, sonst der in der Diagnostic gesetzte."""
+    if _OPENAI_KEY_ENV:
+        return _OPENAI_KEY_ENV
+    try:
+        with open(OPENAI_KEY_FILE) as f:
+            return str((json.load(f) or {}).get("key") or "").strip()
+    except Exception:
+        return ""
+
+
+def _openai_key_save(key: str) -> bool:
+    """Speichert den in der Diagnostic gesetzten Key. Bei .env-Vorrang: nein."""
+    if _OPENAI_KEY_ENV:
+        return False
+    try:
+        os.makedirs(os.path.dirname(OPENAI_KEY_FILE), exist_ok=True)
+        tmp = OPENAI_KEY_FILE + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump({"key": key.strip()}, f)
+        os.replace(tmp, OPENAI_KEY_FILE)
+        os.chmod(OPENAI_KEY_FILE, 0o600)
+        return True
+    except Exception as exc:
+        logger.error("OpenAI-Key speichern fehlgeschlagen: %s", exc)
+        return False
+
 # ── Auslastungs-Monitor (Stage E) ──────────────────────────
 import node_stats
 STATS_PATH = os.getenv("STATS_PATH", "/models/aria_stats.json")
@@ -129,6 +184,19 @@ def _generate_config() -> int:
                    f"-hf {repo}:{quant}\n-ngl {ngl} -c {ctx} --jinja"),
            "ttl": 3600,
        }
+    # API-Key auf JEDES Modell anwenden (auch die aus dem Basis-Template) —
+    # llama-server prueft dann den Authorization-Header. Ohne Key bleibt der
+    # Endpunkt offen; deshalb ist er per Default nur an localhost gebunden.
+    key = _openai_key()
+    for k, spec in list(models.items()):
+        cmd = str((spec or {}).get("cmd") or "")
+        if not cmd:
+            continue
+        cmd = re.sub(r"\s*--api-key\s+\S+", "", cmd)     # alten Key entfernen
+        if key:
+            cmd = cmd.rstrip() + f" --api-key {shlex.quote(key)}"
+        models[k] = dict(spec, cmd=cmd)
+
    out = dict(base)
    out["models"] = models
    try:
@@ -255,6 +323,13 @@ async def _announce(ws) -> None:
        "instanceId": INSTANCE_ID, "service": WORKER_SERVICE,
        "node": NODE_NAME, "gpus": GPU_IDS, "model": LLM_MODEL,
        "models": models,   # welche Modelle diese Box fahren kann (llama-swap-Keys)
+        # OpenAI-Endpunkt fuer Fremd-Tools (OpenHands & Co.). Der Key selbst wird
+        # NICHT gesendet (Broadcast!) — nur ob einer gesetzt ist und ob die .env
+        # ihn vorgibt (dann ist das Feld in der Diagnostic schreibgeschuetzt).
+        "openaiPort": OPENAI_PORT,
+        "openaiBind": OPENAI_BIND,
+        "openaiKeySet": bool(_openai_key()),
+        "openaiEnvLocked": bool(_OPENAI_KEY_ENV),
    })
    logger.info("worker_hello: models=%s", models)

@@ -340,6 +415,45 @@ async def _do_llm_request(ws, payload: dict) -> None:
    })


+async def _handle_openai_config(ws, payload: dict) -> None:
+    """Setzt den API-Key des OpenAI-Endpunkts (aus der Diagnostic).
+
+    Der PORT wird hier bewusst NICHT geaendert: er ist ein Docker-Port-Mapping
+    und steht beim Container-Start fest — dafuer ist die .env zustaendig.
+    Steht der Key in der .env, gewinnt sie und wir lehnen ab.
+    """
+    if (payload.get("instanceId") or INSTANCE_ID) != INSTANCE_ID:
+        return
+    req_id = payload.get("requestId", "")
+    key = str(payload.get("apiKey") or "").strip()
+    if _OPENAI_KEY_ENV:
+        await _send(ws, "llm_openai_config_result", {
+            "requestId": req_id, "instanceId": INSTANCE_ID, "ok": False,
+            "error": "Der API-Key steht in der .env dieser Box — die hat Vorrang. "
+                     "Zum Aendern dort anpassen und die Box neu starten.",
+        })
+        return
+    if not _openai_key_save(key):
+        await _send(ws, "llm_openai_config_result", {
+            "requestId": req_id, "instanceId": INSTANCE_ID, "ok": False,
+            "error": "Key konnte nicht gespeichert werden (Schreibrechte auf /models?)",
+        })
+        return
+    # Config neu schreiben, damit llama-server den Key beim naechsten Laden nutzt.
+    _generate_config()
+    logger.info("OpenAI-API-Key %s (wirkt beim naechsten Modell-Laden)",
+                "gesetzt" if key else "entfernt")
+    await _send(ws, "llm_openai_config_result", {
+        "requestId": req_id, "instanceId": INSTANCE_ID, "ok": True,
+        "keySet": bool(key),
+        "message": ("API-Key gesetzt. Er greift, sobald das Modell das naechste Mal "
+                    "geladen wird — bereits laufende Modelle einmal entladen lassen "
+                    "(TTL) oder ein anderes Modell anfragen."
+                    if key else "API-Key entfernt — der Endpunkt ist jetzt offen."),
+    })
+    await _announce(ws)
+
+
 async def _handle_provision(ws, payload: dict) -> None:
    """Fuegt ein Modell hinzu: Registry+Config schreiben, reload, dann Warmup
    (zieht das GGUF via -hf beim ersten Load). Meldet die neue Modell-Liste."""
@@ -417,13 +531,21 @@ async def _run() -> None:

    while True:
        scheme = "wss" if use_tls else "ws"
-        url = f"{scheme}://{RVS_HOST}:{RVS_PORT}?token={RVS_TOKEN}"
+        uri_host = RVS_SNI if (use_tls and RVS_SNI) else RVS_HOST
+        url = f"{scheme}://{uri_host}:{RVS_PORT}?token={RVS_TOKEN}"
        masked = url.replace(RVS_TOKEN, "***") if RVS_TOKEN else url
+        # max_size MUSS zum RVS/zur Bridge passen (1500 MB). Der RVS ist ein
+        # BROADCAST-Relay: eine grosse Nachricht (Datei-Transfer, Voice-Upload,
+        # APK-Update) geht an JEDEN Client im Raum. Wer ein kleineres Limit hat,
+        # schliesst die Verbindung mit Code 1009 ("message too big") und landet in
+        # einer Reconnect-Schleife — real gesehen mit einem 209-MB-Frame, der
+        # whisper und f5tts im Minutentakt neu starten liess.
+        _MAX_WS_BYTES = int(os.getenv("RVS_MAX_SIZE_MB", "1500")) * 1024 * 1024
+        connect_kwargs = {"ping_interval": 20, "ping_timeout": 10, "max_size": _MAX_WS_BYTES}
        try:
-            logger.info("Verbinde zu RVS: %s (llama=%s)", masked, LLAMA_URL)
-            async with websockets.connect(
-                url, ping_interval=20, ping_timeout=10, max_size=16 * 1024 * 1024
-            ) as ws:
+            logger.info("Verbinde zu RVS: %s%s (llama=%s)", masked,
+                        f" (TCP {RVS_HOST})" if (use_tls and RVS_SNI) else "", LLAMA_URL)
+            async with websockets.connect(url, **connect_kwargs) as ws:
                logger.info("RVS verbunden — llm-adapter online")
                retry_s = 2
                tls_fallback_tried = False
@@ -448,6 +570,9 @@ async def _run() -> None:
                    # Auslastungs-Monitor (node_stats_*) abfangen.
                    if await _stats.handle(ws, mtype, payload, _send):
                        continue
+                    if mtype == "llm_openai_config":
+                        asyncio.create_task(_handle_openai_config(ws, payload))
+                        continue
                    if mtype not in ("llm_request", "llm_provision_model", "llm_remove_model"):
                        continue
                    if mtype == "llm_provision_model":
@@ -53,6 +53,21 @@ RVS_PORT = int(os.getenv("RVS_PORT", "443"))
 RVS_TLS = os.getenv("RVS_TLS", "true").lower() == "true"
 RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true").lower() == "true"
 RVS_TOKEN = os.getenv("RVS_TOKEN", "").strip()
+# TLS-Hostname (SNI + Cert), falls RVS_HOST eine IP ist (Box im selben Netz wie
+# der RVS, direkt auf die interne IP). Leer = SNI = RVS_HOST.
+RVS_SNI = os.getenv("RVS_SNI", "").strip()
+
+# In-Process-DNS-Override: wenn RVS_SNI gesetzt ist, verbindet die URI ueber den
+# HOSTNAMEN (Host-Header + SNI + Cert stimmen), waehrend getaddrinfo den Namen auf
+# die echte IP in RVS_HOST aufloest. Versionsunabhaengig — host=/port= kollidiert
+# in der Legacy-websockets-API mit dem aus der URI abgeleiteten Host.
+if RVS_TLS and RVS_SNI:
+    import socket as _socket
+    _orig_getaddrinfo = _socket.getaddrinfo
+    def _sni_getaddrinfo(host, *a, **k):
+        return _orig_getaddrinfo(RVS_HOST if host == RVS_SNI else host, *a, **k)
+    _socket.getaddrinfo = _sni_getaddrinfo
+

 VOXTRAL_MODEL = os.getenv("VOXTRAL_MODEL", "mistralai/Voxtral-Mini-3B-2507")
 VOXTRAL_LANGUAGE = os.getenv("VOXTRAL_LANGUAGE", "de")
@@ -742,12 +757,20 @@ async def run_loop(sessions: SessionManager) -> None:
    tls_fallback_tried = False
    while True:
        scheme = "wss" if use_tls else "ws"
-        url = f"{scheme}://{RVS_HOST}:{RVS_PORT}?token={RVS_TOKEN}"
+        uri_host = RVS_SNI if (use_tls and RVS_SNI) else RVS_HOST
+        url = f"{scheme}://{uri_host}:{RVS_PORT}?token={RVS_TOKEN}"
        masked = url.replace(RVS_TOKEN, "***") if RVS_TOKEN else url
+        # max_size MUSS zum RVS/zur Bridge passen (1500 MB). Der RVS ist ein
+        # BROADCAST-Relay: eine grosse Nachricht (Datei-Transfer, Voice-Upload,
+        # APK-Update) geht an JEDEN Client im Raum. Wer ein kleineres Limit hat,
+        # schliesst die Verbindung mit Code 1009 ("message too big") und landet in
+        # einer Reconnect-Schleife — real gesehen mit einem 209-MB-Frame, der
+        # whisper und f5tts im Minutentakt neu starten liess.
+        _MAX_WS_BYTES = int(os.getenv("RVS_MAX_SIZE_MB", "1500")) * 1024 * 1024
+        connect_kwargs = {"ping_interval": 20, "ping_timeout": 10, "max_size": _MAX_WS_BYTES}
        try:
-            logger.info("Verbinde zu RVS: %s", masked)
-            async with websockets.connect(url, ping_interval=20, ping_timeout=10,
-                                           max_size=50 * 1024 * 1024) as ws:
+            logger.info("Verbinde zu RVS: %s%s", masked, f" (TCP {RVS_HOST})" if (use_tls and RVS_SNI) else "")
+            async with websockets.connect(url, **connect_kwargs) as ws:
                logger.info("RVS verbunden")
                retry_s = 2
                tls_fallback_tried = False
@@ -53,6 +53,21 @@ RVS_PORT = int(os.getenv("RVS_PORT", "443"))
 RVS_TLS = os.getenv("RVS_TLS", "true").lower() == "true"
 RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true").lower() == "true"
 RVS_TOKEN = os.getenv("RVS_TOKEN", "").strip()
+# TLS-Hostname (SNI + Cert), falls RVS_HOST eine IP ist (Box im selben Netz wie
+# der RVS, direkt auf die interne IP). Leer = SNI = RVS_HOST.
+RVS_SNI = os.getenv("RVS_SNI", "").strip()
+
+# In-Process-DNS-Override: wenn RVS_SNI gesetzt ist, verbindet die URI ueber den
+# HOSTNAMEN (Host-Header + SNI + Cert stimmen), waehrend getaddrinfo den Namen auf
+# die echte IP in RVS_HOST aufloest. Versionsunabhaengig — host=/port= kollidiert
+# in der Legacy-websockets-API mit dem aus der URI abgeleiteten Host.
+if RVS_TLS and RVS_SNI:
+    import socket as _socket
+    _orig_getaddrinfo = _socket.getaddrinfo
+    def _sni_getaddrinfo(host, *a, **k):
+        return _orig_getaddrinfo(RVS_HOST if host == RVS_SNI else host, *a, **k)
+    _socket.getaddrinfo = _sni_getaddrinfo
+

 WHISPER_MODEL = os.getenv("WHISPER_MODEL", "small")
 WHISPER_DEVICE = os.getenv("WHISPER_DEVICE", "cuda")
@@ -84,6 +99,12 @@ STREAM_SPEAKER_CHECK_MS = 1500        # Mindest-Audio fuer Speaker-ID-Pruefung
 STREAM_DEFAULT_ENDPOINT_MS = 1500     # nach 1.5s ohne neuen Text → Endpoint
 STREAM_DEFAULT_HARD_CAP_MS = 60000    # nach 60s Audio: harter Cut egal was
 STREAM_MIN_AUDIO_MS = 600             # erst transkribieren wenn min 600ms Audio da
+# Zwischen-Transkriptionen sehen nur die letzten N Sekunden an. Sonst waechst
+# ihre Rechenzeit mit der Aufnahmelaenge (jedes Mal der ganze Buffer): bei 2min
+# Sprechen dauerte eine Zwischen-Transkription mehrere Sekunden, blockierte die
+# GPU und machte die Live-Anzeige traege. Der FINALE Text entsteht weiterhin aus
+# dem gesamten Buffer (beam_size=5) — es geht also kein Wort verloren.
+STREAM_PARTIAL_WINDOW_MS = 30000
 STREAM_SESSION_TTL_S = 120            # tote Sessions nach 2 min aufraeumen

 # Akustisches Endpointing (ergaenzt die rein-semantische Stagnation).
@@ -372,6 +393,10 @@ class StreamSession:
    speaker_checked: bool = False
    speaker_match: Optional[bool] = None
    speaker_similarity: float = 0.0
+    # Laufende Zwischen-Transkription. Die laeuft NEBENHER, nicht im Tick —
+    # sonst stand der Endpointer waehrend des Transkribierens, und die
+    # Rechenzeit wurde als Stille gezaehlt (siehe _tick_session).
+    partial_task: Optional[asyncio.Task] = None


 class SessionManager:
@@ -464,7 +489,11 @@ class SessionManager:
        return session

    def drop(self, request_id: str) -> None:
-        self._sessions.pop(request_id, None)
+        sess = self._sessions.pop(request_id, None)
+        # Nicht als Waise weiterlaufen lassen — sie haelt sonst den GPU-Lock
+        # fuer eine Sitzung, die es nicht mehr gibt.
+        if sess is not None and sess.partial_task is not None and not sess.partial_task.done():
+            sess.partial_task.cancel()

    async def run_endpointer(self) -> None:
        """Background-Loop: alle ~200ms ueber alle Sessions iterieren."""
@@ -569,6 +598,12 @@ class SessionManager:
        if ws is None:
            return  # disconnected — Endpointer pausiert bis Reconnect

+        # Modell laedt noch (Kaltstart): Audio weiter sammeln, aber NICHT
+        # transkribieren/finalisieren — sonst kaeme leerer Text heraus und die
+        # Aufnahme waere verloren. Sobald es geladen ist, laeuft es normal weiter.
+        if self.runner.model is None:
+            return
+
        audio_ms = self._buffer_duration_ms(sess)

        # Hard-Cap erreicht → wie Endpoint behandeln (egal ob neuer Text)
@@ -639,38 +674,78 @@ class SessionManager:
        if since_last < STREAM_TRANSCRIBE_INTERVAL_MS:
            return

+        # Zwischen-Transkription NEBENHER starten, nicht hier abwarten.
+        #
+        # WARUM: dieser Tick laeuft alle 200ms und ist die einzige Stelle, die
+        # akustische Sprach-Energie misst (last_voice_at). Wurde hier auf das
+        # Transkribieren gewartet, stand der Endpointer solange — und beim
+        # naechsten Tick war `now - last_voice_at` um die gesamte Rechenzeit
+        # groesser. Die Rechenzeit zaehlte also als STILLE.
+        #
+        # Das skaliert mit der Aufnahmelaenge, weil jede Zwischen-Transkription
+        # den KOMPLETTEN Buffer neu durchlaeuft: bei 10s Audio harmlos, bei 2min
+        # dauert sie mehrere Sekunden und reisst damit die endpoint_ms-Grenze —
+        # mitten im Satz. Genau das war "lange Texte hoeren irgendwann auf,
+        # obwohl ich weiterrede".
+        if sess.partial_task is not None and not sess.partial_task.done():
+            return   # vorige laeuft noch — Tick bleibt frei fuers Messen
        sess.last_transcribe_at = now
-        try:
-            audio = pcm_s16le_to_float32(bytes(sess.pcm_buffer))
-        except Exception:
-            logger.exception("Stream %s: PCM-Decode fehlgeschlagen", sess.request_id[:8])
-            return
+        sess.partial_task = asyncio.create_task(self._partial_transcribe(sess, ws))

+    async def _partial_transcribe(self, sess: StreamSession, ws) -> None:
+        """Zwischen-Transkription fuer Live-Text + Wachstums-Erkennung.
+
+        Laeuft als eigener Task (siehe _tick_session). Der finale Text entsteht
+        in _finalize aus dem GESAMTEN Buffer mit beam_size=5 — hier darf also
+        gekuerzt und ungenau gearbeitet werden, ohne dass Text verloren geht.
+        """
        try:
+            # Nur das Ende des Buffers ansehen. Sonst waechst die Rechenzeit mit
+            # der Aufnahmelaenge, bindet die GPU und die Live-Anzeige wird immer
+            # traeger. Fuer "waechst der Text noch?" reicht der Schluss.
+            tail_bytes = int(STREAM_PARTIAL_WINDOW_MS / 1000.0 * sess.sample_rate) * 2
+            buf = bytes(sess.pcm_buffer)
+            windowed = len(buf) > tail_bytes
+            try:
+                audio = pcm_s16le_to_float32(buf[-tail_bytes:] if windowed else buf)
+            except Exception:
+                logger.exception("Stream %s: PCM-Decode fehlgeschlagen", sess.request_id[:8])
+                return
+
            # Kleinere beam_size fuer Streaming-Partials — wir wollen Latenz,
            # nicht maximale Genauigkeit. Final-Transcribe (in _finalize) faehrt
            # dann mit beam_size=5.
-            text, _dur = await self.runner.transcribe(audio, sess.language, beam_size=1, vad_filter=True)
-        except Exception:
-            logger.exception("Stream %s: Partial-Transcribe crashed", sess.request_id[:8])
-            return
+            try:
+                text, _dur = await self.runner.transcribe(
+                    audio, sess.language, beam_size=1, vad_filter=True)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Stream %s: Partial-Transcribe crashed", sess.request_id[:8])
+                return

-        text = text.strip()
-        grew = bool(text) and text != sess.last_partial
-        if grew:
-            sess.last_partial = text
-            sess.last_growth_at = now
-            # Optional: stt_partial broadcasten fuer UI-Feedback. Wir schicken's
-            # mit damit Diagnostic / ChatScreen Live-Text zeigen kann.
-            await _send(ws, "stt_partial", {
-                "requestId": sess.request_id,
-                "audioRequestId": sess.audio_request_id,
-                "text": text,
-            })
-            await _debug_log(ws, "stream.partial",
-                f"id={sess.request_id[:12]} text={text[:80]!r}")
-        # else: kein neuer Text — die Endpoint-Entscheidung (akustisch +
-        # semantischer Backstop) laeuft oben pro Tick, hier nichts mehr zu tun.
+            if sess.endpoint_sent or sess.closed:
+                return   # Session ist durch — Partial nicht mehr nachschicken
+            text = text.strip()
+            grew = bool(text) and text != sess.last_partial
+            if grew:
+                sess.last_partial = text
+                sess.last_growth_at = time.time()
+                # Optional: stt_partial broadcasten fuer UI-Feedback. Wir schicken's
+                # mit damit Diagnostic / ChatScreen Live-Text zeigen kann.
+                await _send(ws, "stt_partial", {
+                    "requestId": sess.request_id,
+                    "audioRequestId": sess.audio_request_id,
+                    "text": text,
+                    # Nur der Schluss der Aufnahme — der volle Text kommt final.
+                    "windowed": windowed,
+                })
+                await _debug_log(ws, "stream.partial",
+                    f"id={sess.request_id[:12]}{' [tail]' if windowed else ''} text={text[:80]!r}")
+            # else: kein neuer Text — die Endpoint-Entscheidung (akustisch +
+            # semantischer Backstop) laeuft im Tick, hier nichts mehr zu tun.
+        except asyncio.CancelledError:
+            pass

    def _buffer_duration_ms(self, sess: StreamSession) -> float:
        # 16-bit s16le mono → 2 bytes pro Sample
@@ -722,6 +797,11 @@ class SessionManager:
        if sess.endpoint_sent:
            return
        sess.endpoint_sent = True
+        # Laufende Zwischen-Transkription abbrechen: sie haelt den GPU-Lock und
+        # der finale Text muesste sonst hinter ihr warten — bei langen Aufnahmen
+        # mehrere Sekunden zusaetzliche Verzoegerung fuer nichts.
+        if sess.partial_task is not None and not sess.partial_task.done():
+            sess.partial_task.cancel()
        audio = pcm_s16le_to_float32(bytes(sess.pcm_buffer))
        if audio.size == 0:
            logger.info("Stream %s: leere Audio-Daten — final text leer", sess.request_id[:8])
@@ -874,11 +954,20 @@ async def run_loop(runner: WhisperRunner, sessions: SessionManager) -> None:

    while True:
        scheme = "wss" if use_tls else "ws"
-        url = f"{scheme}://{RVS_HOST}:{RVS_PORT}?token={RVS_TOKEN}"
+        uri_host = RVS_SNI if (use_tls and RVS_SNI) else RVS_HOST
+        url = f"{scheme}://{uri_host}:{RVS_PORT}?token={RVS_TOKEN}"
        masked = url.replace(RVS_TOKEN, "***") if RVS_TOKEN else url
+        # max_size MUSS zum RVS/zur Bridge passen (1500 MB). Der RVS ist ein
+        # BROADCAST-Relay: eine grosse Nachricht (Datei-Transfer, Voice-Upload,
+        # APK-Update) geht an JEDEN Client im Raum. Wer ein kleineres Limit hat,
+        # schliesst die Verbindung mit Code 1009 ("message too big") und landet in
+        # einer Reconnect-Schleife — real gesehen mit einem 209-MB-Frame, der
+        # whisper und f5tts im Minutentakt neu starten liess.
+        _MAX_WS_BYTES = int(os.getenv("RVS_MAX_SIZE_MB", "1500")) * 1024 * 1024
+        connect_kwargs = {"ping_interval": 20, "ping_timeout": 10, "max_size": _MAX_WS_BYTES}
        try:
-            logger.info("Verbinde zu RVS: %s", masked)
-            async with websockets.connect(url, ping_interval=20, ping_timeout=10, max_size=50 * 1024 * 1024) as ws:
+            logger.info("Verbinde zu RVS: %s%s", masked, f" (TCP {RVS_HOST})" if (use_tls and RVS_SNI) else "")
+            async with websockets.connect(url, **connect_kwargs) as ws:
                logger.info("RVS verbunden")
                retry_s = 2
                tls_fallback_tried = False
@@ -945,19 +1034,22 @@ async def run_loop(runner: WhisperRunner, sessions: SessionManager) -> None:
                        # transcribe-Call mit Leerstring weil Model None.
                        target_model = payload.get("model") or runner.model_size or WHISPER_MODEL
                        needs_load = (runner.model is None) or (target_model != runner.model_size)
+                        # WICHTIG: Session SOFORT anlegen — auch wenn das Modell
+                        # noch laedt. Sonst laufen alle stt_audio_chunk der ersten
+                        # Aufnahme ins Leere (feed_chunk findet keine Session) und
+                        # der Take ist verloren; erst die zweite Aufnahme klappt,
+                        # weil das Modell dann warm ist. Der Buffer fuellt sich
+                        # jetzt waehrend des Ladens, das Transkribieren wartet.
+                        sessions.start_session(payload)
                        if needs_load:
-                            async def _load_then_start(p, target):
+                            async def _load_only(target):
                                await _broadcast_status(ws, "loading", model=target)
                                try:
                                    await runner.ensure_loaded(target)
                                    await _broadcast_status(ws, "ready", model=runner.model_size)
                                except Exception as e:
                                    await _broadcast_status(ws, "error", error=str(e)[:200])
-                                    return
-                                sessions.start_session(p)
-                            asyncio.create_task(_load_then_start(payload, target_model))
-                        else:
-                            sessions.start_session(payload)
+                            asyncio.create_task(_load_only(target_model))

                    elif mtype == "stt_audio_chunk":
                        ok = sessions.feed_chunk(payload)