release: bump version to 0.2.2.5

fix(vm): Screenshot ohne /root-Rechte + VNC-Tastatur robuster
Screenshot: aria-vm lief als User 'aria', SHOT_DIR war aber /root/... → "mkdir: cannot create directory /root". Jetzt schreibt aria-vm das PNG ins VM-Verzeichnis (aria-schreibbar) und der Brain holt es per SSH (base64, _ssh_host) — unabhaengig von Volume-Rechten. End-to-end validiert (gueltiges PNG). Wird weiter ins Projekt (screenshots/) kopiert. VNC-Tastatur: verstecktes Input-Feld war off-screen (opacity:0, left:-1000px) → Android oeffnete die Tastatur oft nicht / lieferte keine Events. Jetzt on-screen (bottom, 1px, opacity:0, pointer-events:none) + beforeinput als primaerer Handler (Android-robust) mit input-Fallback. Strg+Alt+Entf ging schon. py/bash/tsc clean. aria-vm bereits live. Deploy: brain rebuild + APK. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-21 00:47:46 +02:00 · 2026-07-21 00:45:41 +02:00 · 2026-07-21 00:35:26 +02:00 · 2026-07-21 00:25:19 +02:00 · 2026-07-21 00:23:23 +02:00 · 2026-07-21 00:20:21 +02:00
51 changed files with 4849 additions and 61 deletions
@@ -10,6 +10,141 @@ Alle Änderungen am Projekt. Format: [Keep a Changelog](https://keepachangelog.c

 ---

+## [0.2.3.0] — 2026-07-19 — Satelliten: ARIAs Augen & Hände in fremden Netzen 🛰️
+
+### Hinzugefügt
+
+**Neuer eigenständiger Container `satellite/`** — ein Außenposten, den du in einem beliebigen Netz (Büro, Werkstatt …) deployst. Er verbindet sich als RVS-Client in deinen Raum und gibt ARIA Zugriff auf **genau dieses Netz**, ohne dass der Haupt-Stack dort steht.
+- **Entdeckung (Info):** mDNS/Zeroconf (Chromecast, AirPlay, Sonos, Drucker, NAS …), SSDP/UPnP + **DIAL** (Smart-TVs, Fire TV), ARP-Tabelle (rohe Hosts) → Live-Inventar.
+- **Steuerung (mit Guards):** **DIAL-App-Launch** (z.B. „ARIA, spiel YouTube-Video X auf dem Büro-Stick" → Fire TV), **Wake-on-LAN**, generisches **HTTP**. Nur wenn `CONTROL_ENABLED=true`, nur Aktionen aus der `CONTROL_ALLOWLIST`, alles geloggt, read-only per `.env` abschaltbar. Reagiert nur auf den eigenen RVS-Raum (Token). Keine offenen Ports.
+- **Adressierung** über `SATELLITE_LOCATION` (z.B. „Büro") — mehrere Satelliten im selben Raum, jeder mit eigenem Namen.
+
+**End-to-end verdrahtet:**
+- `satellite/`: eigener Stack (`docker compose` mit `network_mode: host`), `.env.example`, README.
+- RVS: neue Message-Typen `sat_hello / sat_discover / sat_devices / sat_command / sat_result`.
+- Bridge: Satelliten-Registry (`sat_hello`) + Future-Relay (`/internal/satellite`, `/internal/satellite-list`) analog zum flux-Muster.
+- Brain: Tools `satellite_list`, `satellite_devices`, `satellite_command` + Seed-Regel, die ARIA den Ablauf beibringt (erst list, dann devices, dann command).
+- **Diagnostic: neuer Tab „Satelliten"** — zeigt live welche Satelliten verbunden sind (online/offline, Standort, Capabilities, read-only vs. steuerbar) und pro Satellit ein „Geräte scannen" (löst `sat_discover` aus → erkannte Geräte mit Typ/IP/Modell/DIAL/MAC).
+
+### Deploy
+Satellit im Ziel-Netz: `cd satellite && cp .env.example .env && docker compose up -d --build`. Haupt-Stack: `git pull && docker compose up -d --build brain bridge` + RVS-Stack `up -d --build`. Kein APK-Rebuild.
+
+---
+
+## [0.2.2.3] — 2026-07-17 — ARIA liest andere Projekt-Chats wirklich (volle Historie)
+
+### Behoben
+
+- **`project_summary` fand fast nie Inhalte.** Es las nur ARIAs rollendes Kontextfenster (~50 Turns über ALLE Projekte) — ältere/andere Projekt-Chats sind da längst rausdistilliert. „Hol dir die Infos aus Projekt X" lieferte deshalb leere Ergebnisse, und ARIA wusste nicht, wie sie an die Historie kommt. Jetzt liest das Tool die **echte, volle Historie aus `chat_backup.jsonl`** (im Brain gemountet) — die letzten ~20 Turns des Zielprojekts, unabhängig davon wie lange man da nicht war. Standort-Hints in User-Turns werden rausgefiltert. Fallback aufs Fenster, falls das Backup fehlt. Tool-Beschreibung geschärft, damit ARIA es direkt aufruft.
+- Nebenbei bereinigt: `mac_os_update_fehler` war durch den alten `set_project_kind`-Bug (0.2.2.1) fälschlich `kind=code` — auf `chat` zurückgesetzt.
+
+### Deploy
+`git pull && docker compose up -d --build brain` (kein APK-Rebuild nötig).
+
+---
+
+## [0.2.2.2] — 2026-07-17 — Voice-Projektwechsel zurück — aber gerätelokal
+
+### Hinzugefügt
+
+- **„ARIA, geh in Projekt X" per Sprache wechselt wieder das Projekt** — aber **nur auf dem Gerät, das den Befehl gab**. Andere App-Instanzen und das Diagnostic bleiben in ihrem Projekt.
+- Umsetzung: Jedes Gerät merkt sich die IDs seiner eigenen Anfragen (Text-`clientMsgId` + Voice-`audioRequestId`). Der Brain/Voice-Router hängt an jedes `project_changed`-Event die auslösende `clientMsgId` an; die App folgt dem Wechsel nur, wenn die ID eine **eigene** ist. Deckt beide Voice-Pfade ab (ARIAs `project_enter`/`exit` via `send_to_core` **und** den Bridge-Voice-Router „für Projekt X: …" / „zurück zum Hauptchat").
+- Manuelles Umschalten bleibt wie gehabt gerätelokal über den Drawer.
+
+### Deploy
+`git pull && docker compose up -d --build bridge` + APK 0.2.2.2 (kein Brain-Rebuild nötig).
+
+---
+
+## [0.2.2.1] — 2026-07-17 — Projekt-Fokus wirklich pro Gerät unabhängig
+
+### Behoben
+
+- **`set_project_kind` markierte das falsche Projekt.** Es nutzte den **globalen** `active_project` (geräteübergreifend) statt des Projekts, in dem der aktuelle Request läuft. Folge: Obwohl auf der App „Basic os" aktiv war, bekam das global-aktive „Mac OS Update Fehler" `kind=code`. Jetzt wirkt das Tool auf die pro Request mitgesendete `project_id` (in `_dispatch_tool` durchgereicht) — jede App-/Diagnostic-Instanz markiert ihr eigenes Projekt.
+- **App wurde von fremden `project_changed`-Broadcasts ins andere Projekt gezogen.** Ein Projektwechsel/‑anlegen durch ARIA, das Diagnostic oder eine andere App-Instanz erzwang auf **allen** Geräten einen Fokuswechsel. Der Projekt-Fokus ist jetzt **rein gerätelokal**: Broadcasts aktualisieren nur Namen + Typ, wechseln aber nicht mehr das Projekt. Umschalten geht ausschließlich lokal über den Projekt-Drawer. So arbeitet jedes Gerät unabhängig in seinem eigenen Projekt (auch mehrere App-Instanzen).
+- Hinweis: „ARIA, geh in Projekt X" per Sprache wechselt das App-Projekt dadurch **nicht mehr** automatisch — bewusst, damit Geräte unabhängig bleiben. Wechseln über den Drawer.
+
+### Deploy
+`git pull && docker compose up -d --build brain` + APK 0.2.2.1 neu bauen.
+
+---
+
+## [0.2.2.0] — 2026-07-17 — Workbench: Taskleisten-Dock statt Zoom-Landkarte + bedienbare VNC-Konsole
+
+### Geändert
+
+**Cockpit-Navigation neu gedacht — Dock statt Pinch-Canvas**
+- Die Zoom-Landkarte (mit 2 Fingern rauszoomen, Kachel finden, reintippen) fühlte sich auf 5 Zoll fummelig an. Ersetzt durch eine **Taskleiste unten im Daumenbereich** (Chat · Code · Desktop): **ein Tap wechselt sofort** das Panel, ein animierter Indikator gleitet unter das aktive Icon. Desktop-*Umfang*, Handy-*Ergonomie*.
+- Jedes Panel ist **bildschirmfüllend** und Handy-optimiert; alle bleiben gemountet (nur das aktive ist sichtbar) → kein Remount, Chat behält RVS/Audio/Queue, WebViews ihren Zustand.
+- Das Dock **blendet bei offener Tastatur aus** (mehr Platz zum Tippen) und respektiert die Gesten-Navigationsleiste (Safe-Area).
+- **Aktivitäts-Punkte** am Dock: Code blau, sobald Dateien da sind; Desktop grün, wenn die VM verbunden ist.
+- Entfällt: Pinch/Pan-Canvas, Übersichts-Button im Header, die „Landkarten"-Thumbnails.
+
+**noVNC-Konsole endlich bedienbar**
+- Steuerungs-Leiste im Desktop-Panel: **⌨ Tastatur** (blendet die Handy-Tastatur ein, tippt direkt in die VM — inkl. Enter/Backspace/Pfeiltasten), **Strg+Alt+Entf**, und **⤢ Fit ↔ 1:1**. Tippen/Ziehen steuert weiterhin die Maus.
+
+### Deploy
+Nur **App neu bauen** (kein Backend). APK 0.2.2.0.
+
+---
+
+## [0.2.1.9] — 2026-07-17 — Kompakt ↔ Cockpit: Umschalter für den Kachel-Desktop
+
+### Hinzugefügt
+
+- **Ansichts-Umschalter im Header** („⧉ Kompakt" / „⧉ Cockpit"): Die App startet in **Kompakt** — der klassische Vollbild-Chat, **exakt wie vor dem Umbau** (Default, Mama-tauglich). Ein Tap auf den Button oben rechts schaltet auf **Cockpit** — den zoom-/verschiebbaren Kachel-Desktop. Persistiert über Neustart (`aria_view_mode`).
+- **Warum:** Nach dem 0.2.1.8-Deploy sah die App „unverändert" aus — korrekt, denn im normalen Chat gibt es nur eine Kachel (= Vollbild-Chat). Der Umschalter macht den Cockpit-Modus jetzt **explizit sichtbar/steuerbar**, statt nur bei Code-Projekten aufzutauchen.
+- Im Cockpit ist die **Übersicht jetzt immer erreichbar** (auch im Hauptchat): „⤢ Übersicht" sitzt **im Header links** (kollidiert nicht mehr mit dem Abbrechen-Button der „ARIA denkt"-Leiste), dazu 2-Finger-Pinch/Pan und Hardware-Back.
+- Im Cockpit werden **immer alle vier Kacheln** gezeigt (Chat/Editor/Desktop/Vorschau) — Editor/Desktop/Vorschau als Platzhalter mit Status-Untertitel („kein Code-Projekt" / „kein Desktop"), bis ARIA ein Code-Projekt startet bzw. eine VM läuft. Vorher wirkten sie „verschwunden", weil sie erst bei Code-Projekten auftauchten.
+
+---
+
+## [0.2.1.8] — 2026-07-17 — Desktop-Workspace: zoombarer Canvas, Live-Code-Editor, QEMU/VNC
+
+### Hinzugefügt
+
+**Zoom-/verschiebbarer Workspace-Canvas (App)**
+- Die App ist jetzt eine desktop-artige Arbeitsfläche: rausgezoomt sieht man eine **Landkarte aus Kacheln** (Chat, Editor, Desktop, Vorschau), die man mit **2 Fingern zoomt und verschiebt**. Tippt man eine Kachel an, zoomt sie voll auf und wird **echt bedienbar** („Übersicht + Fokus"). „⤢ Übersicht" bzw. der Hardware-Back führen zurück zur Landkarte.
+- Technisch: `react-native-gesture-handler` + `react-native-reanimated` (60 fps auf dem UI-Thread). Zwei Ebenen — eine skalierte Thumbnail-Welt und eine **Identity-Content-Ebene** (Scale 1), in der die schweren Inhalte (ChatScreen + WebViews) immer gemountet sind und nur die fokussierte sichtbar ist. Dadurch bleiben Touch-Koordinaten/Keyboard korrekt und nichts remountet beim Fokuswechsel. **Reiner Chat verhält sich exakt wie bisher** (eine Kachel, dauerhaft fokussiert).
+
+**Live-Code-Editor für Code-Projekte (App + Bridge + Proxy)**
+- Wird ein Projekt zum Code-Projekt (ARIA ruft `set_project_kind('code')`), erscheinen Editor- und Desktop-Kachel. Der Editor (WebView, selbstenthaltener Highlight-Editor, offline) **zeigt live, was ARIA schreibt** — und Stefan kann selbst editieren; Änderungen gehen zurück an ARIA.
+- Fluss: ARIAs `Write`/`Edit` unter `/shared/projects/<projekt-id>/` werden im Proxy abgefangen und als `code_file` über die Bridge/RVS an die App gespiegelt; Stefans Edits kommen als `code_file_edit` pfad-sicher zurück ins selbe Verzeichnis.
+
+**QEMU für alle Architekturen + Live-Desktop per VNC (Host + Bridge + App)**
+- ARIA kann jetzt VMs für **jede Architektur** bauen/testen (x86, ARM, MIPS, PPC, RISC-V, SPARC) — Host-Helper `aria-vm` (`create/boot/screenshot/list/stop`), installiert via `host-provisioning/qemu-setup.sh`. KVM für x86-Gäste, sonst TCG. Beispiel: ein Win-3.11-System bauen und in QEMU testen.
+- Der **VNC-Live-Desktop wird durch den RVS-Server getunnelt**: die Bridge brückt rohes RFB-TCP (QEMU `127.0.0.1:5901`) ↔ RVS (`vnc_data`/`vnc_input`, Base64-in-JSON), der noVNC-Client läuft in der App-WebView (`window.WebSocket`-Shim). Stefan bedient die VM **live mit Maus/Tastatur** in der Desktop-Kachel — NAT-sicher, kein offener Port am Host, kein websockify/noVNC auf dem Host nötig.
+
+**Kleineres**
+- Pro-Projekt-Layout: die zuletzt fokussierte Kachel wird pro Projekt gemerkt (`aria_workspace_layout`).
+- Projekt-Modell bekommt `kind` ('chat'|'code'); Seed-Regel lehrt ARIA den Code-Projekt-Workflow (Arbeitsverzeichnis `/shared/projects/<id>/`, `aria-vm`, VNC landet automatisch in der App).
+
+### Deploy
+`git pull && docker compose up -d --build brain bridge proxy` · RVS-Stack `up -d --build` · Host: `bash host-provisioning/qemu-setup.sh` (einmalig, als root) · APK neu bauen (nach `npm install` einmalig `npm start --reset-cache` + `gradlew clean`, wegen der neuen nativen Module).
+
+---
+
+## [0.2.1.5] — 2026-07-12 — Pro-Projekt-Queue mit Rückfrage-Loop
+
+### Hinzugefügt
+
+**Nachrichten-Queue pro Projekt (App + Diagnostic)**
+- Eine zweite Nachricht, während ARIA am aktuellen Task arbeitet, wird jetzt **angestellt** statt den laufenden Task abzubrechen (vorher: Barge-In-Cancel). Sie läuft der Reihe nach, **pro Projekt unabhängig** (paralleles Arbeiten in mehreren Projekten bleibt). Wartende Nachrichten zeigen als ⏸-Bubble — tippen entfernt sie aus der Warteschlange.
+- **Rückfrage-Loop:** Stellt ARIA eine echte, blockierende Rückfrage, **pausiert** die Queue und deine nächste Eingabe beantwortet sie — bis eine finale Antwort kommt, dann läuft der nächste Queue-Eintrag (gleiches Muster). Banner „❓ ARIA fragt nach — deine Eingabe beantwortet das". Der Stop-Button bricht den aktuellen Task ab und schaltet zum nächsten.
+- ARIA signalisiert eine Rückfrage über einen **unsichtbaren `[[AWAIT]]`-Marker** — wie speak/converse deklariert das Modell den Zustand selbst (kein „endet-mit-?"-Raten). Brain strippt ihn, gibt `awaiting_reply` durch `chat()` → `ChatOut` → Bridge-Chat-Payload. Local (tool-los) und Fast-Path markieren nie.
+
+**Pro-Projekt-Textfeld-Entwürfe (App + Diagnostic)**
+- Der Feldinhalt bleibt beim Projektwechsel erhalten: in Projekt X tippen, zu Y wechseln (leeres Feld), zurück zu X → dein Entwurf steht wieder da. In Storage persistiert.
+
+**TTS-Abspiel-Queue (App)**
+- Zwei fast gleichzeitig fertige Antworten sprechen jetzt garantiert **nacheinander** statt sich gegenseitig abzuschneiden. Vorher war das Timing-Glück (`PcmStreamPlayer.start()` ruft `stopInternal()` = flush/release, hätte die laufende gecuttet). Jetzt: „spielt hörbar" gilt bis zum echten `PcmPlaybackFinished` (nicht nur bis Stream-Ende); eine neue hörbare Antwort, die währenddessen ankommt, wird gepuffert und danach nachgespielt (Kette für 3, 4, …). Harter Stop/Barge-In/Mund-Button verwirft die Queue.
+
+### Geändert
+
+- **Voice bricht nicht mehr ab:** eine neue Sprachnachricht während ARIA arbeitet stoppt nur akustisch das TTS (sauberes Mikro) und wird über den Brain-Projekt-Lock serialisiert, statt den laufenden Task abzubrechen (passend zu „immer anstellen + Stop-Button"). Text-Senden erkennt Brain-busy als Fallback, damit auch nach einem voice-gestarteten Turn korrekt angestellt wird. Grenze: eine per Sprache gestartete Aufgabe erscheint nicht als löschbare ⏸-Bubble (Aufnahme wird live gestreamt, nicht app-seitig gepuffert).
+
+---
+
 ## [0.2.1.4] — 2026-07-12 — Lokales LLM: der ehrliche Rückbau

 ### Geändert
@@ -96,6 +96,7 @@ ARIA hat zwei Rollen:
 | RVS | Rechenzentrum | `cd rvs && docker compose up -d` |
 | ARIA Brain/Bridge/Diagnostic | Debian 13 VM | `./init.sh && ./aria-setup.sh && docker compose up -d` |
 | Gamebox-Stack (F5-TTS + Whisper) | Gamebox (GPU) | `cd xtts && docker compose up -d` |
+| Satellit(en) 🛰️ (optional) | Fremdes Netz (Büro …) | `cd satellite && cp .env.example .env && docker compose up -d --build` |
 | Android App | Stefans Handy | APK installieren (Auto-Update via RVS) |

 > Der Gamebox-Stack ist optional: ohne ihn faellt STT auf lokales Whisper (CPU,
@@ -204,6 +205,37 @@ Die Diagnostic-UI hat sechs Top-Tabs:
 - **Dateien** — alle Dateien aus `/shared/uploads/` mit Multi-Select, Bulk-Download (ZIP) + Bulk-Delete
 - **Einstellungen** — Reparatur (Container-Restart), Wipe, Sprachausgabe, Whisper, Sprachmodell, Runtime-Config, App-Onboarding (QR), Komplett-Reset

+### 6. (Optional) Desktop-Workspace: QEMU auf dem Host
+
+Nur noetig, wenn ARIA VMs bauen/testen und du sie live in der Desktop-Kachel der
+App bedienen koennen sollst (Code-Projekte, z. B. ein Win-3.11-System). **Wird
+NICHT von `docker compose` mitinstalliert** — QEMU laeuft direkt auf dem Host
+(172.0.2.33), nicht in einem Container, weil dort KVM sitzt und die VNC binden
+kann. Einmalig als root:
+
+```bash
+sudo bash host-provisioning/qemu-setup.sh
+```
+
+Installiert `qemu-system-*` fuer **alle Architekturen** (x86/ARM/MIPS/PPC/SPARC/
+RISC-V), `qemu-utils`, Firmware, `socat`, `imagemagick` und den Helper
+`/usr/local/bin/aria-vm`. KVM-Beschleunigung gibt es nur fuer x86-Gaeste; andere
+Architekturen laufen emuliert (TCG). Danach testen:
+
+```bash
+aria-vm list
+```
+
+ARIA steuert VMs dann per `ssh aria-wohnung aria-vm ...` (create/boot/screenshot/
+list/stop). Der VNC-Desktop wird automatisch als RFB-Bytes durch die Bridge/RVS
+in die App getunnelt — **kein** Port am Host oeffnen, **kein** websockify/noVNC
+auf dem Host noetig (der noVNC-Client liegt in der App). Ohne diesen Schritt
+funktioniert alles andere normal; nur die Desktop-Kachel bleibt leer.
+
+> **App-Rebuild noetig** fuer den Workspace: die neuen nativen Module
+> (gesture-handler, reanimated, webview) brauchen nach `npm install` einmalig
+> `npm start --reset-cache` + `./gradlew clean`, dann APK neu bauen.
+
 ---

 ## Proxy — Wie funktioniert das?
@@ -469,12 +501,17 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.

 ### Features

+- **Desktop-Workbench (Kompakt ↔ Cockpit)**: Umschalter oben rechts im Header. **Kompakt** = klassischer Vollbild-Chat (Default). **Cockpit** = Workbench mit **Taskleiste unten** (Chat · Code · Desktop) — ein Daumen-Tap wechselt sofort das Panel, animierter Indikator, Aktivitäts-Punkte (Code blau / Desktop grün). Jedes Panel bildschirmfüllend und Handy-optimiert; Dock blendet bei offener Tastatur aus. Desktop-Umfang, aber auf 5 Zoll bedienbar
+- **Live-Code-Editor** (Code-Projekte): Wird ein Projekt zum Code-Projekt (`set_project_kind('code')`), zeigt eine Editor-Kachel **live, was ARIA schreibt** (Syntax-Highlighting, offline) und du kannst selbst editieren → zurück an ARIA. ARIAs `Write`/`Edit` unter `/shared/projects/<id>/` werden im Proxy abgefangen und als `code_file` gespiegelt; deine Edits kommen als `code_file_edit` pfad-sicher zurück
+- **Live-Desktop per VNC (durch RVS getunnelt)**: ARIA baut/testet VMs mit **QEMU für jede Architektur** (x86/ARM/MIPS/PPC/RISC-V/SPARC, Host-Helper `aria-vm`, KVM für x86). Der QEMU-Desktop erscheint **live in der Desktop-Kachel** — noVNC in der WebView, RFB-Bytes werden als Base64 über RVS gebrückt (Bridge ↔ QEMU `127.0.0.1:5901`). Du bedienst die VM **live mit Maus/Tastatur**, NAT-sicher, kein offener Port am Host
 - Text-Chat mit ARIA
 - **Sprachaufnahme**: Tap-to-Talk (tippen startet, tippen stoppt, Auto-Stop bei Stille via VAD)
 - **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
 - **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
 - **VAD (Voice Activity Detection)**: Adaptive Schwelle (Baseline aus ersten 500ms Mic-Pegel + 6dB Offset). Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme einstellbar (1–30 min, Default 5 min)
- **Barge-In**: Wenn du waehrend ARIAs Antwort eine neue Sprach-/Text-Nachricht reinschickst, wird sie unterbrochen + bekommt den Hint "das ist eine Korrektur"
+- **Nachricht anstellen statt abbrechen** (Queue pro Projekt): Schickst du eine zweite Nachricht waehrend ARIA noch am aktuellen Task arbeitet, wird sie **angestellt** statt den laufenden abzubrechen — laeuft der Reihe nach, pro Projekt unabhaengig. Wartende zeigen als `⏸`-Bubble (tippen entfernt sie aus der Warteschlange). Explizites Abbrechen laeuft ueber den Stop-Button am „ARIA denkt". Eine neue Sprachnachricht stoppt nur akustisch das TTS (sauberes Mikro), bricht die laufende Arbeit aber nicht mehr ab
+- **Rueckfrage-Loop**: Stellt ARIA eine echte, blockierende Rueckfrage, **pausiert** die Queue und deine naechste Eingabe beantwortet sie — bis eine finale Antwort kommt, dann laeuft der naechste Queue-Eintrag (gleiches Muster). Banner „❓ ARIA fragt nach — deine Eingabe beantwortet das". ARIA signalisiert das ueber einen unsichtbaren `[[AWAIT]]`-Marker im Antworttext (das Modell deklariert den Zustand selbst, kein „endet-mit-?"-Raten; Brain strippt ihn und gibt `awaiting_reply` an App + Diagnostic durch)
+- **Pro-Projekt-Textfeld-Entwuerfe**: Der Feldinhalt bleibt beim Projektwechsel erhalten — in Projekt X tippen, zu Y wechseln (leeres Feld), zurueck zu X → dein Entwurf steht wieder da. Persistiert ueber Neustart. Gleiches Verhalten im Diagnostic
 - **Wake-Word waehrend TTS**: Du kannst "Computer" sagen waehrend ARIA noch redet — AcousticEchoCanceler verhindert dass ARIAs eigene Stimme das Wake-Word triggert
 - **Anruf-Pause + Auto-Resume**: TTS verstummt bei klassischem Anruf oder VoIP-Call (WhatsApp/Signal/Discord). Nach dem Auflegen geht ARIA von der **genauen Stelle** weiter wo sie unterbrochen wurde — die App misst die Position vom Wiedergabe-Anfang und nutzt den WAV-Cache der Antwort
 - **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
@@ -482,6 +519,7 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 - **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
 - **TTS-Wiedergabe**: F5-TTS PCM-Streaming direkt in AudioTrack mit konfigurierbarem Pre-Roll-Buffer (1.0–6.0s, Default 3.5s) gegen Gaps bei Render-Pausen
 - **Audio-Pause**: Andere Apps (Spotify, YouTube etc.) pausieren komplett waehrend ARIA spricht und kommen erst wieder nach echtem Wiedergabe-Ende
+- **TTS-Abspiel-Queue**: Zwei fast gleichzeitig fertige Antworten sprechen garantiert **nacheinander** statt sich abzuschneiden — eine neue hoerbare Antwort, die waehrend der Wiedergabe einer anderen ankommt, wird gepuffert und erst nach deren echtem Wiedergabe-Ende (`PcmPlaybackFinished`, nicht nur Stream-Ende) nachgespielt. Harter Stop / Barge-In / Mund-Button verwirft die Queue
 - **Lokale Voice-Wahl**: Pro Geraet eigene Stimme moeglich (in Settings). Diagnostic-Wechsel ueberschreibt alle App-Wahlen.
 - **Voice-Ready Toast**: Beim Wechsel zeigt die App "Stimme X bereit (X.Ys)" sobald der Preload durch ist
 - **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden (aus Cache wenn vorhanden, sonst neu rendern)
@@ -994,6 +1032,9 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] Anruf-Pause + Auto-Resume: TTS verstummt bei Anruf, faehrt nach Auflegen ab der gemerkten Position fort (Date.now()-Tracking + WAV-Cache der Antwort)
 - [x] PcmPlaybackFinished-Event: AudioFocus wird erst released wenn AudioTrack wirklich durch ist — kein Spotify-mid-TTS mehr
 - [x] Edge-Case: neue Frage waehrend Telefonat verwirft pending Auto-Resume, neueste Antwort gewinnt
+- [x] **Pro-Projekt-Nachrichten-Queue** (loest das alte Barge-In-Cancel ab): zweite Nachricht wird **angestellt** statt den laufenden Task abzubrechen; **Rueckfrage-Loop** via unsichtbarem `[[AWAIT]]`-Marker (Queue pausiert, naechste Eingabe beantwortet die Rueckfrage); Stop-Button schaltet zum naechsten; sichtbare `⏸`-Bubbles (loeschbar). Pro Projekt unabhaengig, App + Diagnostic
+- [x] Pro-Projekt-Textfeld-Entwuerfe (Feldinhalt bleibt beim Projektwechsel erhalten, persistiert; App + Diagnostic)
+- [x] **TTS-Abspiel-Queue**: zwei fast gleichzeitig fertige Antworten sprechen garantiert nacheinander statt sich abzuschneiden (Puffern bis `PcmPlaybackFinished` der laufenden)
 - [x] Settings-Sub-Screens: 8 Kategorien statt langer Liste
 - [x] APK ABI-Split arm64-v8a: 35 MB statt 136 MB
 - [x] Sprachnachrichten-Bubble: audioRequestId statt Substring-Match — keine vertauschten Bubbles mehr bei parallelen Aufnahmen
@@ -1004,6 +1045,11 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] Background Audio Service: TTS, Wake-Word-Lauschen + Aufnahme laufen auch bei minimierter App weiter (Foreground-Service mit mediaPlayback|microphone, dynamische Notification)
 - [x] Disk-Voll Banner in Diagnostic mit copy-baren Cleanup-Befehlen
 - [x] Wake-Word on-device via openWakeWord (ONNX Runtime, kein API-Key) + State-Icon
+- [x] **Desktop-Workbench**: Taskleisten-Dock (Chat · Code · Desktop), Ein-Tap-Panelwechsel im Daumenbereich, Aktivitäts-Badges, keyboard-aware; Kompakt↔Cockpit-Umschalter. (Ersetzte den anfänglichen Pinch-Zoom-Kachel-Canvas — auf 5 Zoll zu fummelig)
+- [x] **noVNC-Konsole bedienbar**: Tastatur-Einblendung (tippt in die VM), Strg+Alt+Entf, Fit↔1:1
+- [x] **Live-Code-Editor** für Code-Projekte (WebView, offline, bidirektional) — ARIAs Write/Edit unter `/shared/projects/<id>/` live gespiegelt (`code_file`), eigene Edits zurück (`code_file_edit`)
+- [x] **QEMU für alle Architekturen** (Host-Helper `aria-vm`, `qemu-setup.sh`) + `set_project_kind`-Tool + Seed-Regel
+- [x] **VNC-Live-Desktop durch RVS getunnelt** (Bridge RFB-TCP ↔ RVS, noVNC-WebView mit WebSocket-Shim) — VM live mit Maus/Tastatur bedienbar

 ### Phase A — Refactor: OpenClaw raus, eigenes Brain rein

@@ -8,11 +8,13 @@
 import React, { useEffect } from 'react';
 import { AppState, AppStateStatus, PermissionsAndroid, Platform, StatusBar, StyleSheet } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { GestureHandlerRootView } from 'react-native-gesture-handler';
 import { NavigationContainer, DefaultTheme } from '@react-navigation/native';
 import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';

-import ChatScreen from './src/screens/ChatScreen';
+import WorkspaceScreen from './src/workspace/WorkspaceScreen';
 import SettingsScreen from './src/screens/SettingsScreen';
+import ViewModeToggle from './src/components/ViewModeToggle';
 import rvs from './src/services/rvs';
 import { initLogger, installGlobalCrashReporter } from './src/services/logger';
 import { acquireBackgroundAudio } from './src/services/backgroundAudio';
@@ -132,7 +134,7 @@ const App: React.FC = () => {
  }, []);

  return (
-    <>
+    <GestureHandlerRootView style={styles.root}>
      <StatusBar barStyle="light-content" backgroundColor="#0D0D1A" />
      <NavigationContainer theme={DarkTheme}>
        <Tab.Navigator
@@ -165,10 +167,11 @@ const App: React.FC = () => {
        >
          <Tab.Screen
            name="Chat"
-            component={ChatScreen}
+            component={WorkspaceScreen}
            options={{
              title: 'ARIA Chat',
              headerTitle: 'ARIA Cockpit',
+              headerRight: () => <ViewModeToggle />,
            }}
          />
          <Tab.Screen
@@ -180,13 +183,16 @@ const App: React.FC = () => {
          />
        </Tab.Navigator>
      </NavigationContainer>
-    </>
+    </GestureHandlerRootView>
  );
 };

 // --- Styles ---

 const styles = StyleSheet.create({
+  root: {
+    flex: 1,
+  },
  header: {
    backgroundColor: '#12122A',
    elevation: 0,
@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 20105
-        versionName "0.2.1.5"
+        versionCode 20205
+        versionName "0.2.2.5"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -1,3 +1,6 @@
 module.exports = {
  presets: ['module:metro-react-native-babel-preset'],
+  // react-native-reanimated/plugin MUSS das LETZTE Plugin sein (Worklet-Transform).
+  // Nach dem Hinzufuegen einmalig Metro-Cache leeren: `npm start --reset-cache`.
+  plugins: ['react-native-reanimated/plugin'],
 };
@@ -1,3 +1,6 @@
+// react-native-gesture-handler MUSS als allererstes importiert werden
+// (vor allem anderen), sonst crasht die Gesten-Erkennung auf Android.
+import 'react-native-gesture-handler';
 import { AppRegistry } from 'react-native';
 import App from './App';
 import { name as appName } from './app.json';
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.2.1.5",
+  "version": "0.2.2.5",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -20,12 +20,15 @@
    "react-native-camera-kit": "^13.0.0",
    "react-native-document-picker": "^9.1.1",
    "react-native-fs": "^2.20.0",
+    "react-native-gesture-handler": "2.14.1",
    "react-native-image-picker": "^7.1.0",
    "react-native-permissions": "^4.1.4",
+    "react-native-reanimated": "3.6.2",
    "react-native-safe-area-context": "^4.8.2",
    "react-native-screens": "3.27.0",
    "react-native-sound": "^0.11.2",
-    "react-native-svg": "^14.1.0"
+    "react-native-svg": "^14.1.0",
+    "react-native-webview": "13.6.4"
  },
  "devDependencies": {
    "@react-native/eslint-config": "^0.73.2",
@@ -28,6 +28,7 @@ import {

 import brainApi, { Project } from '../services/brainApi';
 import rvs from '../services/rvs';
+import projectFocus from '../services/projectFocus';

 interface Props {
  /** Optional — wenn als Modal genutzt, sonst inline */
@@ -75,6 +76,7 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
  const [editing, setEditing] = useState<Project | null>(null);
  const [editName, setEditName] = useState('');
  const [editDesc, setEditDesc] = useState('');
+  const [editKind, setEditKind] = useState<'code' | 'chat'>('chat');
  // Versteckte Projekte standardmaessig ausblenden; Toggle blendet sie
  // temporaer (gedimmt) ein — zum Ansehen/Auswaehlen oder Wieder-Sichtbarmachen.
  const [showHidden, setShowHidden] = useState(false);
@@ -148,18 +150,25 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
    setEditing(p);
    setEditName(p.name);
    setEditDesc(p.description || '');
+    setEditKind(p.kind === 'code' ? 'code' : 'chat');
  }, []);

  const saveEdit = useCallback(() => {
    if (!editing) return;
-    const patch: Partial<Pick<Project, 'name' | 'description'>> = {};
+    const patch: Partial<Pick<Project, 'name' | 'description' | 'kind'>> = {};
    if (editName.trim() && editName.trim() !== editing.name) patch.name = editName.trim();
    if (editDesc.trim() !== (editing.description || '')) patch.description = editDesc.trim();
+    const curKind = editing.kind === 'code' ? 'code' : 'chat';
+    if (editKind !== curKind) patch.kind = editKind;
    if (Object.keys(patch).length === 0) { setEditing(null); return; }
    brainApi.updateProject(editing.id, patch)
-      .then(() => { setEditing(null); load(); })
+      .then(() => {
+        // Kind sofort in den Workspace spiegeln (Editor/Desktop-Panels).
+        if (patch.kind) projectFocus.setKind(editing.id, patch.kind);
+        setEditing(null); load();
+      })
      .catch(e => Alert.alert('Fehler', String(e?.message || e)));
-  }, [editing, editName, editDesc, load]);
+  }, [editing, editName, editDesc, editKind, load]);

  const endProject = useCallback((p: Project) => {
    Alert.alert(`"${p.name}" beenden?`,
@@ -216,6 +225,9 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
              <View style={{ width: 8, height: 8, borderRadius: 4, backgroundColor: dot.color }} />
            )}
            <Text style={[s.rowName, isActive && { color: '#34C759' }]}>{item.name}</Text>
+            {item.has_files && (
+              <Text style={{ fontSize: 12 }} accessibilityLabel="hat Dateien">📄{item.file_count ? ` ${item.file_count}` : ''}</Text>
+            )}
            {hidden && <Text style={s.hiddenBadge}>versteckt</Text>}
            {item.status === 'ended' && <Text style={s.statusBadge}>beendet</Text>}
            {isActive && <Text style={s.activeBadge}>✓ FOCUS</Text>}
@@ -375,6 +387,21 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
              style={[s.input, { height: 70 }]}
              multiline
            />
+            <TouchableOpacity
+              onPress={() => setEditKind(k => (k === 'code' ? 'chat' : 'code'))}
+              style={{ flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', paddingVertical: 8 }}
+            >
+              <Text style={{ color: '#E0E0F0', fontSize: 14 }}>💻 Code-Projekt{'\n'}
+                <Text style={{ color: '#8888AA', fontSize: 11 }}>zeigt Editor + Desktop im Cockpit</Text>
+              </Text>
+              <View style={{
+                width: 46, height: 26, borderRadius: 13, padding: 3,
+                backgroundColor: editKind === 'code' ? '#0096FF' : '#2A2A3E',
+                alignItems: editKind === 'code' ? 'flex-end' : 'flex-start',
+              }}>
+                <View style={{ width: 20, height: 20, borderRadius: 10, backgroundColor: '#FFFFFF' }} />
+              </View>
+            </TouchableOpacity>
            <View style={{ flexDirection: 'row', gap: 8, marginTop: 12 }}>
              <TouchableOpacity onPress={() => setEditing(null)} style={[s.modalBtn, { backgroundColor: '#2A2A3E' }]}>
                <Text style={s.modalBtnText}>Abbrechen</Text>
@@ -0,0 +1,47 @@
+/**
+ * ViewModeToggle — kleiner Header-Button zum Umschalten zwischen Kompakt-
+ * Ansicht (klassischer Chat) und Cockpit (Kachel-Desktop).
+ *
+ * Sitzt rechts im Navigations-Header ("ARIA Cockpit"), kollidiert also mit
+ * nichts in der Chat-Ansicht. Zeigt das Ziel des naechsten Taps.
+ */
+
+import React, { useEffect, useState } from 'react';
+import { StyleSheet, Text, TouchableOpacity } from 'react-native';
+import viewMode, { ViewModeValue } from '../services/viewMode';
+
+const ViewModeToggle: React.FC = () => {
+  const [mode, setMode] = useState<ViewModeValue>(viewMode.get());
+  useEffect(() => viewMode.subscribe(setMode), []);
+
+  const isCockpit = mode === 'cockpit';
+  return (
+    <TouchableOpacity
+      onPress={() => viewMode.toggle()}
+      style={[styles.pill, isCockpit && styles.pillActive]}
+      hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+      activeOpacity={0.75}
+    >
+      <Text style={[styles.text, isCockpit && styles.textActive]}>
+        {isCockpit ? '⧉ Cockpit' : '⧉ Kompakt'}
+      </Text>
+    </TouchableOpacity>
+  );
+};
+
+const styles = StyleSheet.create({
+  pill: {
+    marginRight: 12,
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderRadius: 16,
+    borderWidth: 1,
+    borderColor: '#1E1E2E',
+    backgroundColor: '#12122A',
+  },
+  pillActive: { borderColor: '#0096FF', backgroundColor: '#0A1F33' },
+  text: { color: '#9090B0', fontSize: 13, fontWeight: '700' },
+  textActive: { color: '#0096FF' },
+});
+
+export default ViewModeToggle;
@@ -38,6 +38,7 @@ import audioService from '../services/audio';
 import wakeWordService, { loadPassiveListenMs } from '../services/wakeword';
 import ProjectsBrowser from '../components/ProjectsBrowser';
 import brainApi, { Project as BrainProject } from '../services/brainApi';
+import projectFocus from '../services/projectFocus';
 import phoneCallService from '../services/phoneCall';
 import { playWakeReadySound } from '../services/wakeReadySound';
 import {
@@ -318,6 +319,9 @@ const ChatScreen: React.FC = () => {
  const [projectQueues, setProjectQueues] = useState<Record<string, QueuedItem[]>>({});
  const projectStatesRef = useRef<Record<string, CtxState>>({});
  const projectQueuesRef = useRef<Record<string, QueuedItem[]>>({});
+  // Wann ist ein Kontext in 'running' gegangen? Fuer den Watchdog, der eine
+  // haengende Queue (z.B. Antwort waehrend Verbindungsabbruch verloren) loest.
+  const ctxRunningSinceRef = useRef<Record<string, number>>({});
  // Pro-Projekt-Textfeld-Entwuerfe (noch nicht gesendeter Feldinhalt). Key = pid.
  const projectDraftsRef = useRef<Record<string, string>>({});
  const prevFocusedPidRef = useRef<string>('');
@@ -403,6 +407,22 @@ const ChatScreen: React.FC = () => {
  const nextClientMsgId = (): string =>
    `cmsg_${Date.now()}_${Math.floor(Math.random() * 1_000_000)}`;

+  // IDs (clientMsgId + audioRequestId), die DIESES Geraet ausgeloest hat.
+  // Fuer den geraete-lokalen Voice-Projektwechsel: ein project_changed vom Brain
+  // traegt die ausloesende ID; nur wenn sie zu einer unserer IDs gehoert, folgt
+  // dieses Geraet dem Wechsel. So wechselt „ARIA, geh in Projekt X" nur das
+  // Geraet, das den Befehl gab — nicht andere App-/Diagnostic-Instanzen.
+  const myRequestIdsRef = useRef<Set<string>>(new Set());
+  const rememberMyRequest = (id: string): void => {
+    if (!id) return;
+    const s = myRequestIdsRef.current;
+    s.add(id);
+    if (s.size > 80) {
+      const oldest = s.values().next().value;
+      if (oldest !== undefined) s.delete(oldest);
+    }
+  };
+
  // Wie lange wir auf das ACK warten bevor wir retryen. Bridge sollte
  // unmittelbar zurueckmelden — 30s ist grosszuegig fuer schlechte Netze.
  // 60s — grosszuegiger als 30s, weil langsame Brain-Calls (Multi-Tool) sonst
@@ -458,6 +478,7 @@ const ChatScreen: React.FC = () => {
        return;
      }
      pendingPayloads.current.set(cmid, { type, payload });
+      rememberMyRequest(cmid);
      const online = connectionStateRef.current === 'connected';
      if (!online) {
        updateMessageStatus(cmid, { deliveryStatus: 'queued', sendAttempts: attempt });
@@ -522,8 +543,13 @@ const ChatScreen: React.FC = () => {
      brainApi.listProjects(true)
        .then(list => {
          const map: Record<string, string> = {};
-          for (const p of list) map[p.id] = p.name;
+          const kinds: Record<string, 'code' | 'chat'> = {};
+          for (const p of list) {
+            map[p.id] = p.name;
+            kinds[p.id] = p.kind === 'code' ? 'code' : 'chat';
+          }
          setProjectNameById(prev => ({ ...prev, ...map }));
+          projectFocus.setKinds(kinds);
        })
        .catch(() => {});
    };
@@ -551,6 +577,12 @@ const ChatScreen: React.FC = () => {
    }
  }, [focusedProjectId]);

+  // Focus + Projekt-Namen EINWEG in den projectFocus-Spiegel publizieren,
+  // damit der Workspace-Canvas den aktiven Kontext + Code-Projekt-Status
+  // kennt. Rein additiv — aendert ChatScreens eigenes Verhalten nicht.
+  useEffect(() => { projectFocus.setFocus(focusedProjectId); }, [focusedProjectId]);
+  useEffect(() => { projectFocus.setNames(projectNameById); }, [projectNameById]);
+
  // inputText-Spiegel (damit der Draft-Wechsel oben inputText nicht als Dep braucht).
  useEffect(() => { inputTextRef.current = inputText; }, [inputText]);

@@ -583,8 +615,24 @@ const ChatScreen: React.FC = () => {
      try {
        const s = await brainApi.getProjectQueueStatus();
        if (cancelled) return;
-        setQueueStatus(s.contexts || {});
-        queueStatusRef.current = s.contexts || {};
+        const ctxs = s.contexts || {};
+        setQueueStatus(ctxs);
+        queueStatusRef.current = ctxs;
+        // Watchdog: haengt ein Kontext seit >15s auf 'running', obwohl der Brain
+        // ihn NICHT als busy meldet, ist die Antwort verloren gegangen (z.B.
+        // Verbindungsabbruch) — sonst friert die Queue ein. Dann weiterschalten.
+        const api = queueApiRef.current;
+        if (api) {
+          const now = Date.now();
+          for (const [pid, since] of Object.entries(ctxRunningSinceRef.current)) {
+            if (api.getCtxState(pid) !== 'running') continue;
+            const busy = !!ctxs[pid || '__main__']?.busy;
+            if (!busy && now - since > 15000) {
+              console.log('[Chat] Queue-Watchdog: Kontext %s haengt (running, brain idle) → weiterschalten', pid || '(main)');
+              api.advanceQueue(pid);
+            }
+          }
+        }
      } catch {}
    };
    poll();
@@ -918,6 +966,11 @@ const ChatScreen: React.FC = () => {
          const localOnly = prev.filter(m => {
            if (m.skillCreated || m.triggerCreated || m.memorySaved) return true;
            if (m.audioRequestId && (!m.text || m.text === '🎙 Aufnahme...' || m.text === 'Aufnahme...')) return true;
+            // Wartende Queue-Bubbles (noch nicht gesendet → kein clientMsgId, nicht
+            // auf dem Server) MUESSEN erhalten bleiben — sonst verschwindet die
+            // Bubble beim Reconnect-Sync, waehrend projectQueues den Eintrag behaelt
+            // → "N in Warteschlange" friert ein ohne sichtbare Nachricht.
+            if (m.sender === 'user' && m.deliveryStatus === 'pending_queue') return true;
            if (m.sender === 'user' && m.clientMsgId && !serverCmids.has(m.clientMsgId)) {
              // Text-Match-Fallback: wenn der Server irgendwo eine textgleiche
              // User-Bubble hat, ist es dieselbe Nachricht (vor cmid-Aera, ts
@@ -951,10 +1004,23 @@ const ChatScreen: React.FC = () => {
        if (p.id && p.name) {
          setProjectNameById(prev => ({ ...prev, [p.id]: p.name }));
        }
-        if (action === 'entered' || action === 'created') {
-          if (p.id) setFocusedProjectId(p.id);
-        } else if (action === 'exited') {
-          setFocusedProjectId('');
+        // Projekt-Typ sofort spiegeln → Editor/Desktop-Kacheln erscheinen live
+        // (z.B. nach set_project_kind), nicht erst beim naechsten Reconnect.
+        if (p.id && (p.kind === 'code' || p.kind === 'chat')) {
+          projectFocus.setKind(p.id, p.kind);
+        }
+        // Projekt-Fokus ist GERAETE-LOKAL. Ein Broadcast wechselt dieses Geraet
+        // NUR, wenn er durch EINEN EIGENEN Befehl ausgeloest wurde — erkennbar an
+        // der mitgelieferten clientMsgId (unsere gesendete Text-cmid oder Voice-
+        // audioRequestId). So folgt „ARIA, geh in Projekt X" nur dem Geraet, das
+        // den Befehl gab; Diagnostic / andere App-Instanzen bleiben unberuehrt.
+        const trigCmid = typeof p.clientMsgId === 'string' ? p.clientMsgId : '';
+        if (trigCmid && myRequestIdsRef.current.has(trigCmid)) {
+          if (action === 'entered' || action === 'created') {
+            if (p.id) setFocusedProjectId(p.id);
+          } else if (action === 'exited') {
+            setFocusedProjectId('');
+          }
        }
        return;
      }
@@ -1579,6 +1645,7 @@ const ChatScreen: React.FC = () => {
      // dem finalen Text, dann wird die Bubble ueber audioRequestId-Match
      // aktualisiert (siehe chat-Handler oben).
      const audioRequestId = `audio_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+      rememberMyRequest(audioRequestId);
      const wasInterrupted = interruptAriaIfBusy();
      const location = await getCurrentLocation();
      const windowMs = await loadConvWindowMs();
@@ -1682,6 +1749,7 @@ const ChatScreen: React.FC = () => {
      // Kurze Pause damit halt durchgreift, dann neue Aufnahme starten
      await new Promise(r => setTimeout(r, 150));
      const audioRequestId = `audio_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+      rememberMyRequest(audioRequestId);
      const location = await getCurrentLocation();
      const windowMs = await loadConvWindowMs();

@@ -1731,6 +1799,13 @@ const ChatScreen: React.FC = () => {
      // das Mikro greifen kann.
      wakeWordService.stopBargeListening().catch(() => {});
    });
+    // Aus der TTS-Queue nachgespielte (zweite) Antwort: ihren WAV-Cache-Pfad an
+    // die Bubble haengen, damit der Mund-Button/Play sie auch abspielen kann.
+    const unsubPcmCached = audioService.onPcmCached((messageId, audioPath) => {
+      if (!messageId || !audioPath) return;
+      setMessages(prev => prev.map(m =>
+        m.messageId === messageId ? { ...m, audioPath } : m));
+    });

    return () => {
      unsubWake();
@@ -1739,6 +1814,7 @@ const ChatScreen: React.FC = () => {
      unsubPassive();
      unsubTtsStart();
      unsubTtsEnd();
+      unsubPcmCached();
    };
  }, [wakeWordActive]);

@@ -1750,6 +1826,7 @@ const ChatScreen: React.FC = () => {
  // useCallback damit der useEffect oben die Funktion stabil capturen kann.
  const startPassiveStreamingRecording = useCallback(async () => {
    const audioRequestId = `audio_passive_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+    rememberMyRequest(audioRequestId);
    const location = await getCurrentLocation();
    const passiveMs = await loadPassiveListenMs();
    const { ok } = await audioService.startStreamingRecording({
@@ -2042,6 +2119,9 @@ const ChatScreen: React.FC = () => {

  const setCtxState = useCallback((pid: string, s: CtxState) => {
    projectStatesRef.current = { ...projectStatesRef.current, [pid]: s };
+    // Watchdog-Zeitstempel: nur 'running' bekommt einen Start, sonst raus.
+    if (s === 'running') ctxRunningSinceRef.current[pid] = Date.now();
+    else delete ctxRunningSinceRef.current[pid];
    setProjectStates(prev => ({ ...prev, [pid]: s }));
  }, []);

@@ -2150,6 +2230,7 @@ const ChatScreen: React.FC = () => {
  // ueber audioRequestId-Match nachgereicht wenn whisper das Endpoint feuert.
  const handleVoiceButtonStart = useCallback(async (): Promise<boolean> => {
    const audioRequestId = `audio_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+    rememberMyRequest(audioRequestId);
    const wasInterrupted = interruptAriaIfBusy();
    const location = await getCurrentLocation();

@@ -284,6 +284,13 @@ class AudioService {
  private pcmSampleRate: number = 24000;
  private pcmChannels: number = 1;
  private pcmBuffer: string[] = []; // base64-chunks zum spaeteren WAV-Build
+  // ── TTS-Abspiel-Queue: zwei back-to-back-Antworten sollen sich NICHT
+  // gegenseitig abschneiden. Eine neue hoerbare Antwort, die reinkommt waehrend
+  // eine andere noch HOERBAR spielt, wird gepuffert und nach PcmPlaybackFinished
+  // nachgespielt (statt via start()→stopInternal() die laufende zu cutten). ──
+  private pcmAudiblePlaying: boolean = false;  // eine hoerbare Antwort spielt (bis PcmPlaybackFinished)
+  private pcmPlayingMsgId: string = '';         // deren messageId
+  private pcmPendingStreams: Array<{ messageId: string; sampleRate: number; channels: number; chunks: string[]; final: boolean }> = [];
  private pcmBytesCollected: number = 0;
  private readonly PCM_MAX_CACHE_BYTES = 30 * 1024 * 1024; // 30MB

@@ -374,6 +381,16 @@ class AudioService {
        const emitter = new NativeEventEmitter(NativeModules.PcmStreamPlayer as any);
        emitter.addListener('PcmPlaybackFinished', () => {
          console.log('[Audio] PcmPlaybackFinished — AudioTrack drained');
+          this.pcmAudiblePlaying = false;
+          this.pcmPlayingMsgId = '';
+          // TTS-Abspiel-Queue: steht eine naechste Antwort bereit? Dann NICHT
+          // "fertig" melden (kein Wake-Word-Re-Arm / Conversation-Ende) — ARIA
+          // spricht gleich weiter. Die naechste gepufferte Antwort direkt spielen.
+          if (this.pcmPendingStreams.length > 0) {
+            this._promoteNextPendingStream().catch(err =>
+              console.warn('[Audio] promote next pending stream err:', err));
+            return;
+          }
          this._releaseFocusDeferred();
          // Erst HIER playbackFinished-Listener feuern — nicht schon beim
          // Empfang des letzten PCM-Chunks (siehe handlePcmChunk). AudioTrack
@@ -1401,6 +1418,23 @@ class AudioService {
    const base64 = payload.base64 || '';
    const isFinal = !!payload.final;

+    // ── TTS-Abspiel-Queue ──
+    // Kommt eine NEUE hoerbare Antwort rein, waehrend eine andere noch hoerbar
+    // spielt? Dann NICHT starten (start()→stopInternal() wuerde die laufende
+    // abschneiden) — puffern und nach deren PcmPlaybackFinished nachspielen.
+    if (!silent && this.pcmAudiblePlaying && messageId && messageId !== this.pcmPlayingMsgId) {
+      let entry = this.pcmPendingStreams.find(e => e.messageId === messageId);
+      if (!entry) {
+        entry = { messageId, sampleRate, channels, chunks: [], final: false };
+        this.pcmPendingStreams.push(entry);
+        console.log('[Audio] TTS-Queue: Antwort %s wird gepuffert (spielt gerade %s)',
+                    messageId, this.pcmPlayingMsgId);
+      }
+      if (base64) entry.chunks.push(base64);
+      if (isFinal) entry.final = true;
+      return '';  // Live-Player nicht anfassen
+    }
+
    // Neuer Stream? (messageId Wechsel oder nicht aktiv)
    if (!this.pcmStreamActive || this.pcmMessageId !== messageId) {
      if (this.pcmStreamActive && !silent) {
@@ -1448,6 +1482,8 @@ class AudioService {
        this._cancelDeferredFocusRelease();
        AudioFocus?.requestDuck().catch(() => {});
        this._firePlaybackStarted();
+        this.pcmAudiblePlaying = true;
+        this.pcmPlayingMsgId = messageId;
      }
    }

@@ -1490,6 +1526,73 @@ class AudioService {
    return '';
  }

+  /** Naechste gepufferte TTS-Antwort abspielen (TTS-Abspiel-Queue). Wird nach
+   *  PcmPlaybackFinished der vorherigen aufgerufen — so sprechen zwei
+   *  back-to-back-Antworten NACHEINANDER statt sich abzuschneiden. */
+  private async _promoteNextPendingStream(): Promise<void> {
+    const entry = this.pcmPendingStreams.shift();
+    if (!entry) return;
+    // Inzwischen global gemutet / im Anruf / vom User gestoppt? Dann NICHT
+    // hoerbar abspielen — nur cachen und die naechste promoten.
+    const mutedNow = this._muted || this._pausedForCall ||
+                     (!!this._stoppedMessageId && this._stoppedMessageId === entry.messageId);
+    console.log('[Audio] TTS-Queue: spiele gepufferte Antwort %s (%d chunks, final=%s, muted=%s)',
+                entry.messageId, entry.chunks.length, entry.final, mutedNow);
+    // SOFORT als "spielt" markieren (vor jedem await) — sonst koennte ein
+    // gleichzeitig eintreffender Chunk einer DRITTEN Antwort in der await-Luecke
+    // einen konkurrierenden Stream starten statt zu puffern.
+    this.pcmPlayingMsgId = entry.messageId;
+    this.pcmAudiblePlaying = !mutedNow;
+    // Cache-State fuer den WAV-Build (Mund-Button-Replay) setzen.
+    this.pcmMessageId = entry.messageId;
+    this.pcmSampleRate = entry.sampleRate;
+    this.pcmChannels = entry.channels;
+    this.pcmBuffer = entry.chunks.slice();
+    this.pcmBytesCollected = entry.chunks.reduce((n, c) => n + Math.floor(c.length * 0.75), 0);
+    this.pcmStreamActive = true;
+    if (!mutedNow && PcmStreamPlayer) {
+      try {
+        const prerollSec = await loadPrerollSec();
+        await PcmStreamPlayer.start(entry.sampleRate, entry.channels, prerollSec);
+        this._cancelDeferredFocusRelease();
+        AudioFocus?.requestDuck().catch(() => {});
+        this._firePlaybackStarted();
+        this.pcmAudiblePlaying = true;
+        this.pcmPlayingMsgId = entry.messageId;
+        for (const c of entry.chunks) {
+          try { await PcmStreamPlayer.writeChunk(c); } catch (err) { console.warn('[Audio] promote writeChunk', err); }
+        }
+        if (entry.final) { try { await PcmStreamPlayer.end(); } catch {} }
+      } catch (err) {
+        console.error('[Audio] TTS-Queue promote start fehlgeschlagen:', err);
+        this.pcmAudiblePlaying = false;
+        this.pcmPlayingMsgId = '';
+      }
+    }
+    // War die Antwort schon komplett (final) da: WAV cachen + State wie im
+    // Normalpfad zuruecksetzen. Bei NICHT-final laeuft der Rest live ueber
+    // _handlePcmChunkImpl (messageId == pcmPlayingMsgId → Normalpfad).
+    if (entry.final) {
+      this.pcmStreamActive = false;
+      if (this.pcmBuffer.length > 0) {
+        const audioPath = await this._savePcmBufferAsWav(entry.messageId).catch(() => '');
+        if (audioPath) {
+          this.pcmCachedListeners.forEach(cb => {
+            try { cb(entry.messageId, audioPath); } catch (e) { console.warn('[Audio] pcmCached cb err:', e); }
+          });
+        }
+      }
+      this.pcmBuffer = [];
+      this.pcmBytesCollected = 0;
+      this.pcmMessageId = '';
+      // Nicht hoerbar abgespielt (gemutet)? Dann feuert PcmPlaybackFinished nicht
+      // → die naechste gepufferte Antwort selbst nachziehen (Kette).
+      if (!this.pcmAudiblePlaying) {
+        await this._promoteNextPendingStream();
+      }
+    }
+  }
+
  /** Gesammelte PCM-Chunks als WAV speichern. Gibt file:// Pfad zurueck. */
  private async _savePcmBufferAsWav(messageId: string): Promise<string> {
    try {
@@ -1578,6 +1681,19 @@ class AudioService {
  // Callback wenn alle Audio-Teile abgespielt sind
  private playbackFinishedListeners: (() => void)[] = [];
  private playbackStartedListeners: (() => void)[] = [];
+  // Feuert wenn eine aus der TTS-Queue NACHgespielte Antwort ihren WAV-Cache
+  // geschrieben hat — der Normalpfad meldet den Pfad ueber den handlePcmChunk-
+  // Rueckgabewert, gepufferte (zweite) Antworten koennen das aber nicht (ihre
+  // Chunks returnen '' waehrend sie warten). Damit setzt die App auch fuer die
+  // nachgespielte Antwort m.audioPath (Mund-Button-Replay).
+  private pcmCachedListeners: Array<(messageId: string, audioPath: string) => void> = [];
+
+  onPcmCached(callback: (messageId: string, audioPath: string) => void): () => void {
+    this.pcmCachedListeners.push(callback);
+    return () => {
+      this.pcmCachedListeners = this.pcmCachedListeners.filter(cb => cb !== callback);
+    };
+  }

  onPlaybackFinished(callback: () => void): () => void {
    this.playbackFinishedListeners.push(callback);
@@ -1759,6 +1875,10 @@ class AudioService {
    }
    // AudioTrack IMMER hart stoppen (idempotent) — auch im Drain-Fall.
    PcmStreamPlayer?.stop().catch(() => {});
+    // Wartende TTS-Antworten verwerfen (Mund-Button = still sein).
+    this.pcmPendingStreams = [];
+    this.pcmAudiblePlaying = false;
+    this.pcmPlayingMsgId = '';
    stopBackgroundAudio().catch(() => {});
    this._cancelDeferredFocusRelease();
    AudioFocus?.release().catch(() => {});
@@ -1770,7 +1890,8 @@ class AudioService {
    // Kick-Cycle anstossen — Re-Renders triggern setMuted oft mehrfach hinter-
    // einander, und jeder weitere Kick lässt Spotify nochmal kurz pausieren.
    const hasAnything = !!(this.currentSound || this.resumeSound || this.preloadedSound
-                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying);
+                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying
+                           || this.pcmPendingStreams.length);
    if (!hasAnything) return;
    console.log('[Audio] stopPlayback: currentSound=%s queue=%d pcm=%s',
                this.currentSound ? 'aktiv' : 'null', this.audioQueue.length, this.pcmStreamActive);
@@ -1804,6 +1925,11 @@ class AudioService {
    this.pcmBuffer = [];
    this.pcmBytesCollected = 0;
    this.pcmMessageId = '';
+    // TTS-Abspiel-Queue verwerfen — harter Stop/Abbruch/Barge-In soll auch
+    // wartende Antworten fallenlassen (sonst sprechen sie nach dem Stop weiter).
+    this.pcmPendingStreams = [];
+    this.pcmAudiblePlaying = false;
+    this.pcmPlayingMsgId = '';
    // Audio-Focus sofort freigeben — User hat explizit abgebrochen.
    // Unser Focus war TRANSIENT, Spotify resumed darum automatisch beim
    // Abandon. Den frueheren kickReleaseMedia haben wir entfernt: er
@@ -162,6 +162,15 @@ export interface Project {
  updated_at: number;
  last_activity_at: number;
  turn_count: number;
+  // Workspace: 'code' blendet Editor-/VNC-Kacheln ein. ARIA setzt das selbst
+  // via set_project_kind; fehlt/undefined = 'chat' (nur Chat-Kachel).
+  kind?: 'code' | 'chat';
+  // Optionale absolute noVNC-URL (falls der Desktop direkt erreichbar ist,
+  // sonst laeuft der VNC-Stream als RFB-Bytes durch RVS).
+  desktop_url?: string;
+  // Automatisch: hat das Projekt Dateien in /shared/projects/<id>/? → Datei-Symbol.
+  has_files?: boolean;
+  file_count?: number;
 }

 export interface ProjectStatus {
@@ -170,6 +179,19 @@ export interface ProjectStatus {
  projects: Project[];
 }

+/** QEMU-VM eines Projekts (Registry + Live-Status). */
+export interface ProjectVm {
+  name: string;
+  arch: string;
+  iso?: string;
+  vnc_display: number;
+  mem: number;
+  running?: boolean;
+  vnc_port?: number;
+  boot_cmd?: string;
+  created_at?: number;
+}
+
 /** Queue-Status pro Kontext — was gerade arbeitet, was wartet.
 *  Key "__main__" = Hauptchat, sonst project_id. */
 export interface QueueContextStatus {
@@ -594,14 +616,58 @@ export const brainApi = {
    });
  },

-  /** Projekt-Metadaten patchen (name / description / hidden). */
-  updateProject(projectId: string, patch: Partial<Pick<Project, 'name' | 'description' | 'hidden'>>): Promise<Project> {
+  /** Projekt-Metadaten patchen (name / description / hidden / kind). */
+  updateProject(projectId: string, patch: Partial<Pick<Project, 'name' | 'description' | 'hidden' | 'kind'>>): Promise<Project> {
    return _send(`/projects/${encodeURIComponent(projectId)}`, {
      method: 'PATCH',
      body: patch,
    });
  },

+  /** Projekt manuell als Code-Projekt / normalen Chat markieren. */
+  setProjectKind(projectId: string, kind: 'code' | 'chat'): Promise<Project> {
+    return _send(`/projects/${encodeURIComponent(projectId)}`, {
+      method: 'PATCH',
+      body: { kind },
+    });
+  },
+
+  /** Vorhandene Code-Dateien eines Projekts auflisten (/shared/projects/<id>/). */
+  listProjectFiles(projectId: string): Promise<{ projectId: string; files: { path: string; size: number }[] }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/files`);
+  },
+
+  /** Inhalt einer Projekt-Datei laden (Text). */
+  readProjectFile(projectId: string, path: string): Promise<{ projectId: string; path: string; content: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/file?path=${encodeURIComponent(path)}`);
+  },
+
+  /** Binaere Projekt-Datei (z.B. Bild) als Base64 + MIME laden. */
+  readProjectFileBinary(projectId: string, path: string): Promise<{ path: string; mime: string; base64: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/file?binary=1&path=${encodeURIComponent(path)}`, { timeoutMs: 30000 });
+  },
+
+  // ── QEMU-VMs pro Projekt ─────────────────────────────────────────
+  listProjectVms(projectId: string): Promise<{ projectId: string; vms: ProjectVm[] }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms`, { timeoutMs: 20000 });
+  },
+  addProjectVm(projectId: string, body: { name: string; arch?: string; iso?: string; vnc_display?: number; mem?: number; create_disk?: boolean; size?: string }): Promise<ProjectVm> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms`, { method: 'POST', body, timeoutMs: 30000 });
+  },
+  removeProjectVm(projectId: string, name: string, purge = false): Promise<{ ok: boolean }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}?purge=${purge ? 'true' : 'false'}`, { method: 'DELETE' });
+  },
+  bootProjectVm(projectId: string, name: string): Promise<{ ok: boolean; vnc_port: number; output: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}/boot`, { method: 'POST', timeoutMs: 45000 });
+  },
+  stopProjectVm(projectId: string, name: string): Promise<{ ok: boolean; output: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}/stop`, { method: 'POST', timeoutMs: 30000 });
+  },
+  /** Screenshot der laufenden VM (Base64-PNG) — VM-Bildschirm ohne Live-VNC. */
+  screenshotProjectVm(projectId: string, name: string): Promise<{ ok: boolean; filename: string; base64: string }> {
+    return _send(`/projects/${encodeURIComponent(projectId)}/vms/${encodeURIComponent(name)}/screenshot`, { method: 'POST', timeoutMs: 30000 });
+  },
+
  /** Projekt verstecken / wieder sichtbar machen (bleibt voll nutzbar). */
  setProjectHidden(projectId: string, hidden: boolean): Promise<Project> {
    return _send(`/projects/${encodeURIComponent(projectId)}`, {
@@ -0,0 +1,102 @@
+/**
+ * desktop — Desktop-/VNC-Anbindung fuer Code-Projekte.
+ *
+ * Zwei Aufgaben:
+ *  1. Verfuegbarkeit: `check_desktop` triggert die Bridge, `desktop_status`
+ *     meldet zurueck ob eine QEMU-VNC laeuft (und ggf. eine direkte URL).
+ *  2. VNC-Tunnel: der noVNC-Client in der App-WebView spricht kein eigenes
+ *     WebSocket, sondern schickt RFB-Bytes als `vnc_input` (Base64) ueber RVS;
+ *     die Bridge oeffnet die TCP-Verbindung zu QEMU (host:5901) und streamt die
+ *     Antwort als `vnc_data` zurueck. Base64-in-JSON wie audio_pcm.
+ *
+ * Eine Session = ein Desktop; wir nutzen die Projekt-ID als Session-Key (leer =
+ * 'main'). Muster wie services/rvs.ts (Singleton mit Listener-Listen).
+ */
+
+import rvs, { RVSMessage } from './rvs';
+
+export interface DesktopStatus {
+  available: boolean;
+  session: string;
+  /** optionale direkte noVNC-URL (falls Host direkt erreichbar) */
+  url?: string;
+  message?: string;
+}
+
+type StatusSub = (s: DesktopStatus) => void;
+type VncDataSub = (b64: string) => void;
+
+const DEFAULT_VNC_PORT = 5901;
+const sessionOf = (projectId: string) => projectId || 'main';
+
+class DesktopService {
+  private status: DesktopStatus = { available: false, session: '' };
+  private statusSubs: StatusSub[] = [];
+  private vncDataSubs: VncDataSub[] = [];
+  private currentSession = '';
+
+  constructor() {
+    rvs.onMessage((m) => this.onMessage(m));
+  }
+
+  private onMessage(m: RVSMessage): void {
+    const p = (m.payload || {}) as any;
+    if (m.type === 'desktop_status') {
+      this.status = {
+        available: !!p.available,
+        session: p.session || '',
+        url: typeof p.url === 'string' ? p.url : undefined,
+        message: p.message,
+      };
+      const s = this.status;
+      this.statusSubs.forEach((cb) => cb(s));
+    } else if (m.type === 'vnc_data') {
+      if (this.currentSession && p.session && p.session !== this.currentSession) return;
+      const b64 = typeof p.b64 === 'string' ? p.b64 : '';
+      if (b64) this.vncDataSubs.forEach((cb) => cb(b64));
+    }
+  }
+
+  getStatus(): DesktopStatus {
+    return this.status;
+  }
+
+  subscribeStatus(cb: StatusSub): () => void {
+    this.statusSubs.push(cb);
+    cb(this.status);
+    return () => { this.statusSubs = this.statusSubs.filter((s) => s !== cb); };
+  }
+
+  /** Bridge fragen, ob fuer dieses Projekt ein QEMU-Desktop laeuft. */
+  requestCheck(projectId: string, port: number = DEFAULT_VNC_PORT): void {
+    rvs.send('check_desktop', { projectId: projectId || '', session: sessionOf(projectId), port });
+  }
+
+  /** VNC-Tunnel oeffnen — Bridge verbindet TCP zu QEMU. */
+  openVnc(projectId: string, port: number = DEFAULT_VNC_PORT): string {
+    const session = sessionOf(projectId);
+    this.currentSession = session;
+    rvs.send('vnc_open', { session, port });
+    return session;
+  }
+
+  closeVnc(): void {
+    if (this.currentSession) rvs.send('vnc_close', { session: this.currentSession });
+    this.currentSession = '';
+  }
+
+  /** RFB-Bytes (Base64) aus der noVNC-WebView an die Bridge weiterreichen. */
+  sendInput(b64: string): void {
+    if (!this.currentSession) return;
+    rvs.send('vnc_input', { session: this.currentSession, b64 });
+  }
+
+  /** Listener fuer eingehende RFB-Bytes (Base64) — die noVNC-WebView. */
+  onVncData(cb: VncDataSub): () => void {
+    this.vncDataSubs.push(cb);
+    return () => { this.vncDataSubs = this.vncDataSubs.filter((s) => s !== cb); };
+  }
+}
+
+const desktop = new DesktopService();
+export default desktop;
@@ -0,0 +1,105 @@
+/**
+ * projectFocus — leichter Publish/Subscribe-Spiegel des aktuell fokussierten
+ * Projekt-Kontexts.
+ *
+ * ChatScreen bleibt die Quelle der Wahrheit fuer sein eigenes Rendering und
+ * publiziert hier bei jedem Focus-/Namens-/Kind-Wechsel EINWEG hinein. Der
+ * Workspace-Canvas liest/abonniert das Singleton, um zu wissen welches Projekt
+ * gerade aktiv ist und ob es ein Code-Projekt ist — ohne dass ChatScreen den
+ * Workspace kennen oder umgebaut werden muss.
+ *
+ * Muster wie services/rvs.ts (Singleton mit Listener-Liste + Unsubscribe).
+ */
+
+export type ProjectKind = 'code' | 'chat';
+
+export interface FocusSnapshot {
+  /** '' = Hauptchat, sonst Projekt-ID */
+  focusedProjectId: string;
+  projectNameById: Record<string, string>;
+  projectKindById: Record<string, ProjectKind>;
+}
+
+type Sub = (snap: FocusSnapshot) => void;
+
+class ProjectFocus {
+  private snap: FocusSnapshot = {
+    focusedProjectId: '',
+    projectNameById: {},
+    projectKindById: {},
+  };
+  private subs: Sub[] = [];
+
+  // --- Getter (synchron, fuer Nicht-Reaktive Leser) ---
+
+  get(): FocusSnapshot {
+    return this.snap;
+  }
+
+  getFocusedProjectId(): string {
+    return this.snap.focusedProjectId;
+  }
+
+  getProjectName(id: string): string {
+    return this.snap.projectNameById[id] || id;
+  }
+
+  /** Default 'chat' — ein Projekt ist erst 'code' wenn es explizit so
+   *  markiert wurde (set_project_kind) oder ein Code-/Desktop-Signal kam. */
+  getProjectKind(id: string): ProjectKind {
+    return this.snap.projectKindById[id] || 'chat';
+  }
+
+  // --- Publisher (von ChatScreen aufgerufen) ---
+
+  setFocus(id: string): void {
+    if (this.snap.focusedProjectId === id) return;
+    this.snap = { ...this.snap, focusedProjectId: id };
+    this.emit();
+  }
+
+  setNames(map: Record<string, string>): void {
+    // Flacher Merge — behaelt bereits bekannte Namen, ueberschreibt neue.
+    this.snap = {
+      ...this.snap,
+      projectNameById: { ...this.snap.projectNameById, ...map },
+    };
+    this.emit();
+  }
+
+  setKind(id: string, kind: ProjectKind): void {
+    if (this.snap.projectKindById[id] === kind) return;
+    this.snap = {
+      ...this.snap,
+      projectKindById: { ...this.snap.projectKindById, [id]: kind },
+    };
+    this.emit();
+  }
+
+  setKinds(map: Record<string, ProjectKind>): void {
+    this.snap = {
+      ...this.snap,
+      projectKindById: { ...this.snap.projectKindById, ...map },
+    };
+    this.emit();
+  }
+
+  // --- Abo ---
+
+  /** Registriert einen Listener und liefert sofort den aktuellen Snapshot. */
+  subscribe(cb: Sub): () => void {
+    this.subs.push(cb);
+    cb(this.snap);
+    return () => {
+      this.subs = this.subs.filter(s => s !== cb);
+    };
+  }
+
+  private emit(): void {
+    const s = this.snap;
+    this.subs.forEach(cb => cb(s));
+  }
+}
+
+const projectFocus = new ProjectFocus();
+export default projectFocus;
@@ -0,0 +1,57 @@
+/**
+ * viewMode — App-Ansicht: 'compact' (klassischer Vollbild-Chat wie vor 0.2.2.0)
+ * oder 'cockpit' (zoombarer Kachel-Desktop).
+ *
+ * Default 'compact' → fuer normale Nutzung aendert sich nichts (Mama-tauglich).
+ * Umschaltbar ueber den Header-Button; persistiert in AsyncStorage. Muster wie
+ * services/rvs.ts (Singleton mit Listener-Liste).
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export type ViewModeValue = 'compact' | 'cockpit';
+
+const KEY = 'aria_view_mode';
+type Sub = (mode: ViewModeValue) => void;
+
+class ViewMode {
+  private mode: ViewModeValue = 'compact';
+  private subs: Sub[] = [];
+  private loaded = false;
+
+  constructor() {
+    AsyncStorage.getItem(KEY).then((v) => {
+      if (v === 'cockpit' || v === 'compact') this.mode = v;
+      this.loaded = true;
+      this.emit();
+    }).catch(() => { this.loaded = true; });
+  }
+
+  get(): ViewModeValue { return this.mode; }
+  isLoaded(): boolean { return this.loaded; }
+
+  set(mode: ViewModeValue): void {
+    if (this.mode === mode) return;
+    this.mode = mode;
+    AsyncStorage.setItem(KEY, mode).catch(() => {});
+    this.emit();
+  }
+
+  toggle(): void {
+    this.set(this.mode === 'compact' ? 'cockpit' : 'compact');
+  }
+
+  subscribe(cb: Sub): () => void {
+    this.subs.push(cb);
+    cb(this.mode);
+    return () => { this.subs = this.subs.filter((s) => s !== cb); };
+  }
+
+  private emit(): void {
+    const m = this.mode;
+    this.subs.forEach((cb) => cb(m));
+  }
+}
+
+const viewMode = new ViewMode();
+export default viewMode;
@@ -0,0 +1,92 @@
+/**
+ * WorkspaceDeck — die Workbench: Vollbild-Panels + Taskleisten-Dock unten.
+ *
+ * Statt einer Zoom-Landkarte: jedes Panel ist bildschirmfuellend und Handy-
+ * optimiert, das Dock wechselt per Daumen-Tap sofort. Alle Panels sind IMMER
+ * gemountet (nur das aktive ist via display sichtbar) → kein Remount, Chat
+ * behaelt RVS/Audio/Queue, WebViews behalten ihren Zustand.
+ *
+ * Bei offener Tastatur blendet das Dock aus (mehr Platz zum Tippen).
+ */
+
+import React, { useEffect, useState } from 'react';
+import { Keyboard, StyleSheet, View } from 'react-native';
+import { TileId } from './layout';
+import { useWorkspaceLayout } from './useWorkspaceLayout';
+import WorkspaceDock from './WorkspaceDock';
+import ChatTile from './tiles/ChatTile';
+import FilesTile from './tiles/FilesTile';
+import CodeEditorTile from './tiles/CodeEditorTile';
+import DesktopTile from './tiles/DesktopTile';
+
+interface Props {
+  projectId: string;
+  panels: TileId[];
+  badges?: Partial<Record<TileId, string>>;
+}
+
+const WorkspaceDeck: React.FC<Props> = ({ projectId, panels, badges }) => {
+  const [active, setActive] = useState<TileId>('chat');
+  const [kbVisible, setKbVisible] = useState(false);
+  const { loaded, getFocus, saveFocus } = useWorkspaceLayout(projectId);
+
+  // Aktives Panel pro Projekt wiederherstellen.
+  useEffect(() => {
+    if (!loaded) return;
+    const stored = getFocus();
+    if (stored && panels.includes(stored)) setActive(stored);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [projectId, loaded]);
+
+  // Falls das aktive Panel wegfaellt → erstes nehmen.
+  useEffect(() => {
+    if (!panels.includes(active)) setActive(panels[0] || 'chat');
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [panels.join(',')]);
+
+  useEffect(() => {
+    if (loaded) saveFocus(active);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [active, loaded]);
+
+  useEffect(() => {
+    const s1 = Keyboard.addListener('keyboardDidShow', () => setKbVisible(true));
+    const s2 = Keyboard.addListener('keyboardDidHide', () => setKbVisible(false));
+    return () => { s1.remove(); s2.remove(); };
+  }, []);
+
+  const render = (id: TileId) => {
+    switch (id) {
+      case 'chat': return <ChatTile />;
+      case 'files': return <FilesTile projectId={projectId} focused={active === 'files'} />;
+      case 'editor': return <CodeEditorTile projectId={projectId} />;
+      case 'vnc': return <DesktopTile projectId={projectId} focused={active === 'vnc'} />;
+      default: return null;
+    }
+  };
+
+  return (
+    <View style={styles.root}>
+      <View style={styles.stack}>
+        {panels.map((id) => (
+          <View
+            key={id}
+            style={[StyleSheet.absoluteFill, { display: active === id ? 'flex' : 'none' }]}
+          >
+            {render(id)}
+          </View>
+        ))}
+      </View>
+      {!kbVisible && (
+        <WorkspaceDock panels={panels} active={active} badges={badges} onSelect={setActive} />
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  root: { flex: 1, backgroundColor: '#0D0D1A' },
+  stack: { flex: 1, position: 'relative' },
+});
+
+export default WorkspaceDeck;
@@ -0,0 +1,108 @@
+/**
+ * WorkspaceDock — die Taskleiste unten (Daumenzone). Ein Tap wechselt sofort
+ * das Panel; ein animierter Indikator gleitet unter das aktive Icon. Kleine
+ * Aktivitaets-Punkte (Badges) zeigen z.B. „Desktop verbunden" / „Code da".
+ *
+ * Das ist der Kern des Workbench-Gefuehls: Desktop-Umfang, aber Handy-schnell
+ * per Daumen erreichbar — statt einer Zoom-Landkarte.
+ */
+
+import React, { useState } from 'react';
+import { LayoutChangeEvent, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import Animated, { useAnimatedStyle, withTiming } from 'react-native-reanimated';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { TileId, TILE_META } from './layout';
+
+interface Props {
+  panels: TileId[];
+  active: TileId;
+  badges?: Partial<Record<TileId, string>>; // TileId → Punkt-Farbe (undefined = kein Punkt)
+  onSelect: (id: TileId) => void;
+}
+
+const WorkspaceDock: React.FC<Props> = ({ panels, active, badges, onSelect }) => {
+  const insets = useSafeAreaInsets();
+  const [rowW, setRowW] = useState(0);
+  const n = Math.max(1, panels.length);
+  const idx = Math.max(0, panels.indexOf(active));
+  const slot = rowW / n;
+
+  const onLayout = (e: LayoutChangeEvent) => setRowW(e.nativeEvent.layout.width);
+
+  const indicatorStyle = useAnimatedStyle(() => ({
+    width: slot,
+    transform: [{ translateX: withTiming(slot * idx, { duration: 200 }) }],
+  }));
+
+  return (
+    <View style={[styles.dock, { paddingBottom: Math.max(insets.bottom, 6) }]}>
+      <View style={styles.row} onLayout={onLayout}>
+        {rowW > 0 && <Animated.View style={[styles.indicator, indicatorStyle]} pointerEvents="none" />}
+        {panels.map((id) => {
+          const meta = TILE_META[id];
+          const isActive = id === active;
+          const badge = badges?.[id];
+          return (
+            <TouchableOpacity
+              key={id}
+              style={styles.item}
+              onPress={() => onSelect(id)}
+              activeOpacity={0.7}
+            >
+              <View>
+                <Text style={[styles.icon, isActive && styles.iconActive]}>{meta.icon}</Text>
+                {!!badge && <View style={[styles.badge, { backgroundColor: badge }]} />}
+              </View>
+              <Text style={[styles.label, isActive && styles.labelActive]} numberOfLines={1}>
+                {meta.title}
+              </Text>
+            </TouchableOpacity>
+          );
+        })}
+      </View>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  dock: {
+    backgroundColor: '#0B0B18',
+    borderTopWidth: 1,
+    borderTopColor: '#1E1E2E',
+  },
+  row: {
+    flexDirection: 'row',
+    height: 58,
+    position: 'relative',
+  },
+  indicator: {
+    position: 'absolute',
+    top: 0,
+    height: 3,
+    backgroundColor: '#0096FF',
+    borderBottomLeftRadius: 3,
+    borderBottomRightRadius: 3,
+  },
+  item: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: 2,
+  },
+  icon: { fontSize: 22, opacity: 0.55 },
+  iconActive: { opacity: 1 },
+  label: { color: '#6A6A85', fontSize: 10, fontWeight: '600' },
+  labelActive: { color: '#0096FF' },
+  badge: {
+    position: 'absolute',
+    top: -2,
+    right: -6,
+    width: 8,
+    height: 8,
+    borderRadius: 4,
+    borderWidth: 1,
+    borderColor: '#0B0B18',
+  },
+});
+
+export default WorkspaceDock;
@@ -0,0 +1,64 @@
+/**
+ * WorkspaceScreen — Screen-Wrapper fuer die Workbench.
+ *
+ * Kompakt-Modus → klassischer Vollbild-Chat (wie vor dem Umbau).
+ * Cockpit-Modus  → Workbench mit Taskleisten-Dock: Chat · Code · Desktop.
+ *
+ * Aktivitaets-Badges am Dock: Editor blau, wenn schon Code-Dateien da sind;
+ * Desktop gruen, wenn eine VM verbunden ist.
+ */
+
+import React, { useEffect, useMemo, useState } from 'react';
+import projectFocus, { FocusSnapshot } from '../services/projectFocus';
+import codeFile from '../services/codeFile';
+import desktop from '../services/desktop';
+import viewMode, { ViewModeValue } from '../services/viewMode';
+import ChatScreen from '../screens/ChatScreen';
+import { TileId } from './layout';
+import WorkspaceDeck from './WorkspaceDeck';
+
+const COCKPIT_PANELS: TileId[] = ['chat', 'files', 'editor', 'vnc'];
+
+const WorkspaceScreen: React.FC = () => {
+  const [mode, setMode] = useState<ViewModeValue>(viewMode.get());
+  const [focus, setFocus] = useState<FocusSnapshot>(projectFocus.get());
+  const [hasCode, setHasCode] = useState(false);
+  const [hasDesktop, setHasDesktop] = useState(false);
+
+  useEffect(() => viewMode.subscribe(setMode), []);
+  useEffect(() => projectFocus.subscribe(setFocus), []);
+
+  const pid = focus.focusedProjectId;
+  const kind = projectFocus.getProjectKind(pid);
+
+  // Code-Signal: hat der Spiegel schon Dateien fuer dieses Projekt?
+  useEffect(() => {
+    setHasCode(codeFile.getFiles(pid).length > 0);
+    return codeFile.subscribe((u) => {
+      if ((u.projectId || '') === (pid || '')) setHasCode(true);
+    });
+  }, [pid]);
+
+  // Desktop-Signal + einmaliger Check beim Betreten eines Code-Projekts.
+  useEffect(() => {
+    setHasDesktop(desktop.getStatus().available);
+    const unsub = desktop.subscribeStatus((s) => setHasDesktop(s.available));
+    if (kind === 'code') desktop.requestCheck(pid);
+    return unsub;
+  }, [pid, kind]);
+
+  const badges = useMemo(() => ({
+    editor: hasCode ? '#0096FF' : undefined,
+    vnc: hasDesktop ? '#34C759' : undefined,
+  } as Partial<Record<TileId, string>>), [hasCode, hasDesktop]);
+
+  // Kompakt-Ansicht: klassischer Vollbild-Chat, exakt wie vor dem Umbau.
+  if (mode === 'compact') {
+    return <ChatScreen />;
+  }
+
+  // Cockpit: Workbench mit Dock.
+  return <WorkspaceDeck projectId={pid} panels={COCKPIT_PANELS} badges={badges} />;
+};
+
+export default WorkspaceScreen;
@@ -0,0 +1,167 @@
+/**
+ * editorHtml — selbstenthaltener Live-Code-Editor fuer die WebView (offline,
+ * kein CDN/Bundler). Eine transparente <textarea> ueber einer <pre>-Highlight-
+ * Ebene: man sieht Syntax-Highlighting UND kann tippen. Bewusst leichtgewichtig
+ * (Regex-Highlighter fuer C-artige/JS/Python/Shell), damit es ohne Build-Schritt
+ * inline passt.
+ *
+ * Bridge-Protokoll:
+ *   RN -> WebView  window.ariaBridge.onMessage(jsonString):
+ *     {cmd:'setContent', content, language, version}
+ *     {cmd:'applyPatch', from, to, insert, version}
+ *     {cmd:'setLanguage', language}
+ *     {cmd:'setReadOnly', value}
+ *   WebView -> RN  window.ReactNativeWebView.postMessage(jsonString):
+ *     {event:'ready'}
+ *     {event:'onEditFromUser', from, to, insert, fullText, version}
+ */
+
+export const EDITOR_HTML = `<!doctype html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  html, body { height: 100%; background: #0D0D1A; }
+  #wrap { position: relative; height: 100%; width: 100%; }
+  #hl, #ed {
+    position: absolute; top: 0; left: 0; width: 100%; height: 100%;
+    margin: 0; border: 0; padding: 10px 12px;
+    font-family: 'Courier New', monospace; font-size: 13px; line-height: 1.45;
+    white-space: pre; word-wrap: normal; overflow: auto; tab-size: 2;
+  }
+  #hl { color: #C8C8E0; z-index: 1; pointer-events: none; }
+  #ed {
+    z-index: 2; color: transparent; background: transparent; caret-color: #0096FF;
+    resize: none; outline: none;
+    -webkit-text-fill-color: transparent;
+  }
+  #ed::selection { background: rgba(0,150,255,0.3); }
+  .tok-cmt { color: #6A7A6A; font-style: italic; }
+  .tok-str { color: #C6A972; }
+  .tok-num { color: #B58BE0; }
+  .tok-kw  { color: #4F9CE8; font-weight: bold; }
+</style></head><body>
+<div id="wrap">
+  <pre id="hl"></pre>
+  <textarea id="ed" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"></textarea>
+</div>
+<script>
+(function(){
+  var ed = document.getElementById('ed');
+  var hl = document.getElementById('hl');
+  var lang = 'text';
+  var version = 0;
+  var lastValue = '';
+  var applyingProgrammatic = false;
+
+  var KW = {
+    common: ['if','else','for','while','do','return','break','continue','switch','case','default','function','var','let','const','class','new','this','import','from','export','try','catch','finally','throw','typeof','instanceof','void','delete','in','of','yield','async','await','def','elif','end','then','fi','esac','local','echo','extends','implements','interface','public','private','protected','static','struct','enum','include','define','null','true','false','undefined','None','True','False','print','with','as','pass','lambda','not','and','or','is']
+  };
+
+  function esc(s){ return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
+
+  function highlight(code){
+    // Token-Scan: Kommentare, Strings, Zahlen, Keywords. Bewusst simpel.
+    var out = '';
+    var i = 0, n = code.length;
+    var kwRe = /[A-Za-z_][A-Za-z0-9_]*/;
+    while(i < n){
+      var c = code[i];
+      var two = code.substr(i,2);
+      // Zeilenkommentar // oder #
+      if(two === '//' || (c === '#')){
+        var j = code.indexOf('\\n', i); if(j<0) j=n;
+        out += '<span class="tok-cmt">'+esc(code.slice(i,j))+'</span>'; i=j; continue;
+      }
+      // Blockkommentar
+      if(two === '/*'){
+        var k = code.indexOf('*/', i+2); k = (k<0)? n : k+2;
+        out += '<span class="tok-cmt">'+esc(code.slice(i,k))+'</span>'; i=k; continue;
+      }
+      // Strings
+      if(c === '"' || c === "'" || c === '\`'){
+        var q=c, m=i+1;
+        while(m<n){ if(code[m]==='\\\\'){m+=2;continue;} if(code[m]===q){m++;break;} m++; }
+        out += '<span class="tok-str">'+esc(code.slice(i,m))+'</span>'; i=m; continue;
+      }
+      // Zahl
+      if(c>='0' && c<='9'){
+        var p=i+1; while(p<n && /[0-9a-fA-F.xX_]/.test(code[p])) p++;
+        out += '<span class="tok-num">'+esc(code.slice(i,p))+'</span>'; i=p; continue;
+      }
+      // Wort / Keyword
+      if(/[A-Za-z_]/.test(c)){
+        var rest = code.slice(i);
+        var mm = rest.match(kwRe);
+        var w = mm[0];
+        if(KW.common.indexOf(w) >= 0){ out += '<span class="tok-kw">'+esc(w)+'</span>'; }
+        else { out += esc(w); }
+        i += w.length; continue;
+      }
+      out += esc(c); i++;
+    }
+    return out;
+  }
+
+  function render(){
+    hl.innerHTML = highlight(ed.value) + '\\n';
+    hl.scrollTop = ed.scrollTop; hl.scrollLeft = ed.scrollLeft;
+  }
+
+  function post(obj){ if(window.ReactNativeWebView) window.ReactNativeWebView.postMessage(JSON.stringify(obj)); }
+
+  // Minimalen Diff (gemeinsamer Prefix/Suffix) zwischen alt und neu.
+  function diff(a, b){
+    var s = 0; var maxS = Math.min(a.length, b.length);
+    while(s < maxS && a[s] === b[s]) s++;
+    var e = 0;
+    while(e < (maxS - s) && a[a.length-1-e] === b[b.length-1-e]) e++;
+    return { from: s, to: a.length - e, insert: b.slice(s, b.length - e) };
+  }
+
+  var editTimer = null;
+  ed.addEventListener('input', function(){
+    render();
+    if(applyingProgrammatic) return;
+    if(editTimer) clearTimeout(editTimer);
+    editTimer = setTimeout(function(){
+      var nv = ed.value;
+      var d = diff(lastValue, nv);
+      lastValue = nv; version++;
+      post({ event:'onEditFromUser', from:d.from, to:d.to, insert:d.insert, fullText:nv, version:version });
+    }, 160);
+  });
+  ed.addEventListener('scroll', function(){ hl.scrollTop=ed.scrollTop; hl.scrollLeft=ed.scrollLeft; });
+
+  window.ariaBridge = {
+    onMessage: function(json){
+      var m; try { m = JSON.parse(json); } catch(e){ return; }
+      if(m.cmd === 'setContent'){
+        applyingProgrammatic = true;
+        ed.value = m.content || '';
+        lastValue = ed.value;
+        if(typeof m.version === 'number') version = m.version;
+        if(m.language) lang = m.language;
+        render();
+        applyingProgrammatic = false;
+      } else if(m.cmd === 'applyPatch'){
+        applyingProgrammatic = true;
+        var v = ed.value;
+        var from = Math.max(0, Math.min(m.from, v.length));
+        var to = Math.max(from, Math.min(m.to, v.length));
+        ed.value = v.slice(0, from) + (m.insert||'') + v.slice(to);
+        lastValue = ed.value;
+        if(typeof m.version === 'number') version = m.version;
+        render();
+        applyingProgrammatic = false;
+      } else if(m.cmd === 'setLanguage'){
+        lang = m.language || 'text'; render();
+      } else if(m.cmd === 'setReadOnly'){
+        ed.readOnly = !!m.value;
+      }
+    }
+  };
+
+  render();
+  post({ event:'ready' });
+})();
+</script></body></html>`;
@@ -0,0 +1,142 @@
+/**
+ * novncHtml — noVNC-Client fuer die WebView, dessen WebSocket durch den
+ * RVS-Tunnel gebrueckt wird.
+ *
+ * Trick: window.WebSocket wird VOR dem Laden von noVNC durch einen Shim
+ * ersetzt. noVNC (RFB) glaubt, ein echtes WebSocket zu benutzen; tatsaechlich
+ * gehen die RFB-Bytes als Base64 per postMessage an RN → RVS → Bridge → QEMU
+ * (und zurueck). Da RFB "server-speaks-first" ist, ist die Reihenfolge robust.
+ *
+ * noVNC wird vom CDN geladen (das Telefon hat Internet, da es ohnehin am RVS
+ * haengt). Voll-offline-Bundling waere ein spaeterer Schritt.
+ *
+ * Protokoll:
+ *   RN -> WebView  window.ariaVnc.onData(b64)   RFB-Bytes vom Server
+ *   WebView -> RN  {event:'ready'}              RFB initialisiert → Tunnel oeffnen
+ *                  {event:'vnc_send', b64}      RFB-Bytes an den Server
+ *                  {event:'vnc_close'}          RFB hat geschlossen
+ *                  {event:'vnc_state', state}   connected|disconnected
+ */
+
+export const NOVNC_HTML = `<!doctype html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+<style>
+  * { margin:0; padding:0; }
+  html, body { height:100%; background:#000; overflow:hidden; }
+  #screen { width:100%; height:100%; }
+  #msg { position:absolute; top:8px; left:0; right:0; text-align:center;
+         color:#9090B0; font-family:sans-serif; font-size:12px; pointer-events:none; }
+</style></head><body>
+<div id="screen"></div>
+<div id="msg">Verbinde mit Desktop …</div>
+<script>
+(function(){
+  function post(o){ if(window.ReactNativeWebView) window.ReactNativeWebView.postMessage(JSON.stringify(o)); }
+  function b64FromBytes(bytes){
+    var CHUNK=0x8000, parts=[];
+    for(var i=0;i<bytes.length;i+=CHUNK){ parts.push(String.fromCharCode.apply(null, bytes.subarray(i,i+CHUNK))); }
+    return btoa(parts.join(''));
+  }
+  function bytesFromB64(b64){
+    var s=atob(b64), a=new Uint8Array(s.length);
+    for(var i=0;i<s.length;i++) a[i]=s.charCodeAt(i);
+    return a;
+  }
+
+  // --- WebSocket-Shim ---
+  function BridgeSocket(url, protocols){
+    this.url=url; this.protocol=''; this.readyState=0; this.binaryType='arraybuffer';
+    this.onopen=null; this.onclose=null; this.onerror=null; this.onmessage=null;
+    var self=this; window.__vncSocket=self;
+    setTimeout(function(){ self.readyState=1; if(self.onopen) self.onopen({type:'open'}); }, 0);
+  }
+  BridgeSocket.CONNECTING=0; BridgeSocket.OPEN=1; BridgeSocket.CLOSING=2; BridgeSocket.CLOSED=3;
+  BridgeSocket.prototype.send=function(data){
+    var bytes;
+    if(data instanceof ArrayBuffer) bytes=new Uint8Array(data);
+    else if(ArrayBuffer.isView(data)) bytes=new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    else bytes=new Uint8Array(0);
+    post({event:'vnc_send', b64:b64FromBytes(bytes)});
+  };
+  BridgeSocket.prototype.close=function(){
+    if(this.readyState===3) return;
+    this.readyState=3; if(this.onclose) this.onclose({type:'close'}); post({event:'vnc_close'});
+  };
+  BridgeSocket.prototype.addEventListener=function(t,fn){ this['on'+t]=fn; };
+  BridgeSocket.prototype.removeEventListener=function(t){ this['on'+t]=null; };
+  window.WebSocket = BridgeSocket;
+
+  // Eingehende Server-Bytes → in den Shim einspeisen.
+  window.ariaVnc = {
+    onData:function(b64){
+      var sock=window.__vncSocket;
+      if(!sock || !sock.onmessage) return;
+      sock.onmessage({ type:'message', data: bytesFromB64(b64).buffer });
+    }
+  };
+
+  var msg=document.getElementById('msg');
+
+  // (Fast) unsichtbares Eingabefeld → Software-Tastatur des Handys tippt in die
+  // VM. WICHTIG: on-screen (nicht off-screen), sonst oeffnet Android die Tastatur
+  // oft nicht bzw. liefert keine Events. opacity:0 + pointer-events:none = sichtbar
+  // fuer den Fokus, aber unsichtbar und klaut keine VM-Touches. font-size:16px
+  // verhindert Auto-Zoom.
+  var kbd=document.createElement('input');
+  kbd.setAttribute('autocomplete','off'); kbd.setAttribute('autocorrect','off');
+  kbd.setAttribute('autocapitalize','off'); kbd.spellcheck=false;
+  kbd.style.cssText='position:fixed;bottom:0;left:0;width:100%;height:1px;opacity:0;'
+    +'border:0;padding:0;margin:0;background:transparent;color:transparent;'
+    +'caret-color:transparent;font-size:16px;pointer-events:none;';
+  document.body.appendChild(kbd);
+  var SPECIAL={Enter:0xff0d,Backspace:0xff08,Tab:0xff09,Escape:0xff1b,Delete:0xffff,
+    ArrowLeft:0xff51,ArrowUp:0xff52,ArrowRight:0xff53,ArrowDown:0xff54,Home:0xff50,End:0xff57};
+
+  import('https://cdn.jsdelivr.net/npm/@novnc/novnc@1.4.0/core/rfb.js').then(function(mod){
+    var RFB = mod.default;
+    var rfb = new RFB(document.getElementById('screen'), 'ws://aria-vnc/', {});
+    var fit=true;
+    rfb.scaleViewport = true;
+    rfb.clipViewport = false;
+    rfb.addEventListener('connect', function(){ msg.style.display='none'; post({event:'vnc_state', state:'connected'}); });
+    rfb.addEventListener('disconnect', function(e){
+      msg.style.display='block'; msg.textContent='Desktop getrennt';
+      post({event:'vnc_state', state:'disconnected'});
+    });
+    window.__rfb = rfb;
+
+    // Tasten aus dem versteckten Feld an die VM schicken.
+    function tap(keysym, code){ try{ rfb.sendKey(keysym, code||null, true); rfb.sendKey(keysym, code||null, false); }catch(_){} }
+    // Sondertasten (feuern zuverlaessig als keydown).
+    kbd.addEventListener('keydown', function(e){
+      if(SPECIAL[e.key]!==undefined){ tap(SPECIAL[e.key], e.code); e.preventDefault(); }
+    });
+    // Druckbare Zeichen + Editieren: beforeinput ist auf Android robuster als
+    // ein input-Diff. preventDefault haelt das Feld leer → kein Doppel-Senden.
+    kbd.addEventListener('beforeinput', function(e){
+      var t=e.inputType||'';
+      if(t==='insertText' && e.data){ for(var i=0;i<e.data.length;i++) tap(e.data.charCodeAt(i)); e.preventDefault(); }
+      else if(t.indexOf('insertLineBreak')>=0 || t.indexOf('insertParagraph')>=0){ tap(0xff0d); e.preventDefault(); }
+      else if(t.indexOf('deleteContentBackward')>=0){ tap(0xff08); e.preventDefault(); }
+      kbd.value='';
+    });
+    // Fallback, falls beforeinput nicht unterstuetzt wird.
+    kbd.addEventListener('input', function(){
+      if(kbd.value){ for(var i=0;i<kbd.value.length;i++){ tap(kbd.value.charCodeAt(i)); } kbd.value=''; }
+    });
+
+    // Steuerungs-API fuer die App (per injectJavaScript).
+    window.ariaVncCtl = {
+      focusKeyboard: function(){ try{ kbd.value=''; kbd.focus(); }catch(_){} },
+      blurKeyboard: function(){ try{ kbd.blur(); }catch(_){} },
+      cad: function(){ try{ rfb.sendCtrlAltDel(); }catch(_){} },
+      toggleFit: function(){ fit=!fit; rfb.scaleViewport=fit; rfb.clipViewport=!fit; post({event:'vnc_fit', fit:fit}); }
+    };
+
+    post({event:'ready'});
+  }).catch(function(err){
+    msg.textContent='noVNC konnte nicht geladen werden (Internet?)';
+    post({event:'vnc_state', state:'error', error:String(err)});
+  });
+})();
+</script></body></html>`;
@@ -0,0 +1,15 @@
+/**
+ * layout — Panel-Definitionen der Workbench (Metadaten fuer das Dock).
+ */
+
+export type TileId = 'chat' | 'files' | 'editor' | 'vnc' | 'preview';
+
+export interface TileDef { id: TileId; title: string; icon: string }
+
+export const TILE_META: Record<TileId, TileDef> = {
+  chat: { id: 'chat', title: 'Chat', icon: '💬' },
+  files: { id: 'files', title: 'Dateien', icon: '📁' },
+  editor: { id: 'editor', title: 'Code', icon: '📝' },
+  vnc: { id: 'vnc', title: 'Desktop', icon: '🖥️' },
+  preview: { id: 'preview', title: 'Vorschau', icon: '🖼️' },
+};
@@ -0,0 +1,15 @@
+/**
+ * ChatTile — hostet die bestehende ChatScreen unveraendert als Workspace-Kachel.
+ *
+ * ChatScreen bleibt genau EINE Instanz (der Workspace-Tab ersetzt den alten
+ * Chat-Tab) und wird nie beim Fokuswechsel remountet — sie liegt in der
+ * Identity-Content-Ebene und wird nur per display ein-/ausgeblendet. So
+ * behaelt sie RVS-Abos, Audio, Queue-State und Keyboard-Verhalten wie bisher.
+ */
+
+import React from 'react';
+import ChatScreen from '../../screens/ChatScreen';
+
+const ChatTile: React.FC = () => <ChatScreen />;
+
+export default React.memo(ChatTile);
@@ -0,0 +1,168 @@
+/**
+ * CodeEditorTile — Live-Code-Editor (WebView, editorHtml.ts).
+ *
+ * Zeigt die Dateien eines Code-Projekts aus /shared/projects/<id>/:
+ *  - beim Oeffnen werden die BEREITS vorhandenen Dateien vom Brain geladen
+ *    (listProjectFiles/readProjectFile) — sonst waere der Editor leer, obwohl
+ *    ARIA schon Dateien geschrieben hat.
+ *  - live schreibt ARIA weiter → code_file-Stream aktualisiert die offene Datei.
+ * Stefan kann selbst editieren → code_file_edit zurueck an die Bridge.
+ */
+
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import { WebView, WebViewMessageEvent } from 'react-native-webview';
+import codeFile from '../../services/codeFile';
+import brainApi from '../../services/brainApi';
+import { EDITOR_HTML } from '../assets/editorHtml';
+
+interface Props {
+  projectId: string;
+}
+
+function guessLang(path: string): string {
+  const ext = (path.split('.').pop() || '').toLowerCase();
+  const map: Record<string, string> = {
+    js: 'javascript', ts: 'typescript', tsx: 'typescript', py: 'python',
+    c: 'c', h: 'c', cpp: 'cpp', asm: 'asm', s: 'asm', sh: 'shell', bash: 'shell',
+    html: 'html', css: 'css', json: 'json', yaml: 'yaml', yml: 'yaml', md: 'markdown',
+    go: 'go', rs: 'rust', java: 'java', kt: 'kotlin', txt: 'text',
+  };
+  return map[ext] || 'text';
+}
+
+const CodeEditorTile: React.FC<Props> = ({ projectId }) => {
+  const webRef = useRef<WebView>(null);
+  // Pfade aus dem Brain (vorhandene Dateien) — mit Live-Dateien gemergt.
+  const [serverPaths, setServerPaths] = useState<string[]>([]);
+  const [currentPath, setCurrentPath] = useState<string | null>(null);
+  const [loadErr, setLoadErr] = useState<string>('');
+
+  const readyRef = useRef(false);
+  const currentPathRef = useRef<string | null>(currentPath);
+  currentPathRef.current = currentPath;
+
+  // Vereinigte, sortierte Dateiliste (Live-Spiegel + Server-Dateien).
+  const files = useMemo(() => {
+    const set = new Set<string>(serverPaths);
+    for (const f of codeFile.getFiles(projectId)) set.add(f.path);
+    return Array.from(set).sort((a, b) => a.localeCompare(b));
+  }, [serverPaths, projectId]);
+
+  const sendToWeb = useCallback((payload: Record<string, unknown>) => {
+    const js = `window.ariaBridge && window.ariaBridge.onMessage(${JSON.stringify(JSON.stringify(payload))}); true;`;
+    webRef.current?.injectJavaScript(js);
+  }, []);
+
+  const loadFileIntoEditor = useCallback(async (path: string | null) => {
+    if (!path) { sendToWeb({ cmd: 'setContent', content: '', language: 'text', version: 0 }); return; }
+    // Live-Version bevorzugen (falls ARIA gerade schreibt), sonst vom Brain holen.
+    const live = codeFile.getFile(projectId, path);
+    if (live) {
+      sendToWeb({ cmd: 'setContent', content: live.content, language: live.language, version: live.version });
+      return;
+    }
+    try {
+      const res = await brainApi.readProjectFile(projectId, path);
+      sendToWeb({ cmd: 'setContent', content: res.content ?? '', language: guessLang(path), version: 0 });
+    } catch (e: any) {
+      sendToWeb({ cmd: 'setContent', content: `// Konnte ${path} nicht laden: ${e?.message || e}`, language: 'text', version: 0 });
+    }
+  }, [projectId, sendToWeb]);
+
+  // Projektwechsel: vorhandene Dateien vom Brain laden.
+  useEffect(() => {
+    let cancelled = false;
+    setLoadErr('');
+    brainApi.listProjectFiles(projectId)
+      .then(res => {
+        if (cancelled) return;
+        const paths = (res.files || []).map(f => f.path);
+        setServerPaths(paths);
+        setCurrentPath(prev => (prev && paths.includes(prev)) ? prev : (paths[0] ?? codeFile.getFiles(projectId)[0]?.path ?? null));
+      })
+      .catch(e => { if (!cancelled) setLoadErr(String(e?.message || e)); });
+    return () => { cancelled = true; };
+  }, [projectId]);
+
+  // Live-Updates aus dem Spiegel.
+  useEffect(() => {
+    return codeFile.subscribe((u) => {
+      if ((u.projectId || '') !== (projectId || '')) return;
+      setServerPaths(prev => prev.includes(u.path) ? prev : [...prev, u.path]);
+      if (!currentPathRef.current) { setCurrentPath(u.path); return; }
+      if (u.path !== currentPathRef.current || !readyRef.current) return;
+      if (u.patch) {
+        sendToWeb({ cmd: 'applyPatch', from: u.patch.from, to: u.patch.to, insert: u.patch.insert, version: u.version });
+      } else {
+        sendToWeb({ cmd: 'setContent', content: u.content ?? '', language: u.language, version: u.version });
+      }
+    });
+  }, [projectId, sendToWeb]);
+
+  // Datei-Auswahl gewechselt → laden (falls WebView bereit).
+  useEffect(() => {
+    if (readyRef.current) loadFileIntoEditor(currentPath);
+  }, [currentPath, loadFileIntoEditor]);
+
+  const onMessage = useCallback((e: WebViewMessageEvent) => {
+    let m: any;
+    try { m = JSON.parse(e.nativeEvent.data); } catch { return; }
+    if (m.event === 'ready') {
+      readyRef.current = true;
+      loadFileIntoEditor(currentPathRef.current);
+    } else if (m.event === 'onEditFromUser') {
+      const path = currentPathRef.current;
+      if (!path) return;
+      codeFile.sendEdit(projectId, path, { from: m.from, to: m.to, insert: m.insert }, m.fullText, m.version);
+    }
+  }, [projectId, loadFileIntoEditor]);
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.tabsRow}>
+        {files.length === 0 ? (
+          <Text style={styles.noFiles}>{loadErr ? `Fehler: ${loadErr}` : 'Noch keine Datei in diesem Projekt'}</Text>
+        ) : (
+          <ScrollView horizontal showsHorizontalScrollIndicator={false} contentContainerStyle={styles.tabs}>
+            {files.map((path) => {
+              const active = path === currentPath;
+              const name = path.split('/').pop() || path;
+              return (
+                <TouchableOpacity key={path} onPress={() => setCurrentPath(path)} style={[styles.tab, active && styles.tabActive]}>
+                  <Text style={[styles.tabText, active && styles.tabTextActive]} numberOfLines={1}>{name}</Text>
+                </TouchableOpacity>
+              );
+            })}
+          </ScrollView>
+        )}
+      </View>
+      <WebView
+        ref={webRef}
+        style={styles.web}
+        originWhitelist={['*']}
+        source={{ html: EDITOR_HTML, baseUrl: '' }}
+        onMessage={onMessage}
+        javaScriptEnabled
+        domStorageEnabled
+        keyboardDisplayRequiresUserAction={false}
+        androidLayerType="hardware"
+        setBuiltInZoomControls={false}
+      />
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#0D0D1A' },
+  tabsRow: { height: 40, backgroundColor: '#12122A', borderBottomColor: '#1E1E2E', borderBottomWidth: 1, justifyContent: 'center' },
+  tabs: { alignItems: 'center', paddingHorizontal: 6 },
+  noFiles: { color: '#9090B0', fontSize: 13, paddingHorizontal: 12 },
+  tab: { paddingHorizontal: 12, paddingVertical: 6, marginHorizontal: 3, borderRadius: 12, backgroundColor: '#0D0D1A', maxWidth: 180 },
+  tabActive: { backgroundColor: '#0096FF' },
+  tabText: { color: '#9090B0', fontSize: 12, fontWeight: '600' },
+  tabTextActive: { color: '#FFFFFF' },
+  web: { flex: 1, backgroundColor: '#0D0D1A' },
+});
+
+export default CodeEditorTile;
@@ -0,0 +1,189 @@
+/**
+ * DesktopTile — das Desktop-Panel eines Code-Projekts.
+ *
+ * Zeigt die (pro Projekt gefuehrte) QEMU-VM-Liste: leer, bis ARIA per
+ * vm_register eine VM eintraegt. Pro VM: Start / Stop / Verbinden. „Verbinden"
+ * oeffnet die noVNC-Ansicht (VncTile) fuer den VNC-Port dieser VM.
+ */
+
+import React, { useCallback, useEffect, useState } from 'react';
+import { ActivityIndicator, Image, Modal, ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import brainApi, { ProjectVm } from '../../services/brainApi';
+import VncTile from './VncTile';
+
+interface Props {
+  projectId: string;
+  focused: boolean;
+}
+
+const DesktopTile: React.FC<Props> = ({ projectId, focused }) => {
+  const [vms, setVms] = useState<ProjectVm[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [err, setErr] = useState('');
+  const [busy, setBusy] = useState('');           // VM-Name, der gerade bootet/stoppt
+  const [connected, setConnected] = useState<ProjectVm | null>(null);
+  const [shotBusy, setShotBusy] = useState('');
+  const [shot, setShot] = useState<{ name: string; b64: string } | null>(null);
+
+  const load = useCallback(() => {
+    setLoading(true); setErr('');
+    brainApi.listProjectVms(projectId)
+      .then(r => setVms(r.vms || []))
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setLoading(false));
+  }, [projectId]);
+
+  useEffect(() => {
+    if (focused && !connected) load();
+  }, [focused, projectId, connected, load]);
+
+  const boot = useCallback((vm: ProjectVm) => {
+    setBusy(vm.name);
+    brainApi.bootProjectVm(projectId, vm.name)
+      .then(() => load())
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setBusy(''));
+  }, [projectId, load]);
+
+  const stop = useCallback((vm: ProjectVm) => {
+    setBusy(vm.name);
+    brainApi.stopProjectVm(projectId, vm.name)
+      .then(() => load())
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setBusy(''));
+  }, [projectId, load]);
+
+  const screenshot = useCallback((vm: ProjectVm) => {
+    setShotBusy(vm.name); setErr('');
+    brainApi.screenshotProjectVm(projectId, vm.name)
+      .then(r => setShot({ name: vm.name, b64: r.base64 }))
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setShotBusy(''));
+  }, [projectId]);
+
+  if (!focused) {
+    return (
+      <View style={styles.placeholder}>
+        <Text style={styles.icon}>🖥️</Text>
+        <Text style={styles.text}>Desktop</Text>
+        <Text style={styles.sub}>Panel öffnen für VM-Liste</Text>
+      </View>
+    );
+  }
+
+  // Verbunden → noVNC-Ansicht der VM + Zurück-Leiste.
+  if (connected) {
+    return (
+      <View style={styles.container}>
+        <View style={styles.bar}>
+          <TouchableOpacity onPress={() => setConnected(null)} style={styles.barBtn}>
+            <Text style={styles.barBtnText}>‹ VMs</Text>
+          </TouchableOpacity>
+          <Text style={styles.barTitle} numberOfLines={1}>{connected.name} · :{connected.vnc_display}</Text>
+        </View>
+        <VncTile projectId={projectId} focused port={connected.vnc_port || (5900 + (connected.vnc_display || 1))} />
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.bar}>
+        <Text style={styles.barTitle}>Virtuelle Maschinen</Text>
+        <TouchableOpacity onPress={load} style={styles.barBtn}><Text style={styles.barBtnText}>↻</Text></TouchableOpacity>
+      </View>
+      <ScrollView contentContainerStyle={{ padding: 12 }}>
+        {loading && vms.length === 0 ? (
+          <ActivityIndicator color="#0096FF" style={{ marginTop: 20 }} />
+        ) : err ? (
+          <Text style={styles.err}>{err}</Text>
+        ) : vms.length === 0 ? (
+          <Text style={styles.empty}>
+            Noch keine VM in diesem Projekt.{'\n'}
+            Sag ARIA z.B. „bau eine QEMU-VM zum Testen" — sie registriert sie hier,
+            dann kannst du sie starten und verbinden.
+          </Text>
+        ) : (
+          vms.map(vm => {
+            const isBusy = busy === vm.name;
+            return (
+              <View key={vm.name} style={styles.vmRow}>
+                <View style={{ flex: 1 }}>
+                  <Text style={styles.vmName}>
+                    <Text style={{ color: vm.running ? '#34C759' : '#555570' }}>●</Text> {vm.name}
+                    <Text style={styles.vmMeta}>  {vm.arch} · {vm.running ? 'läuft' : 'gestoppt'}</Text>
+                  </Text>
+                  <Text style={styles.vmCmd} numberOfLines={2}>{vm.boot_cmd || `aria-vm boot ${vm.name} --vnc-display ${vm.vnc_display}`}</Text>
+                </View>
+                <View style={styles.vmBtns}>
+                  {isBusy ? (
+                    <ActivityIndicator color="#0096FF" />
+                  ) : vm.running ? (
+                    <>
+                      <TouchableOpacity onPress={() => screenshot(vm)} style={[styles.vmBtn, { borderColor: '#8888AA' }]} disabled={shotBusy === vm.name}>
+                        {shotBusy === vm.name
+                          ? <ActivityIndicator color="#8888AA" size="small" />
+                          : <Text style={[styles.vmBtnText, { color: '#C8C8E0' }]}>📷</Text>}
+                      </TouchableOpacity>
+                      <TouchableOpacity onPress={() => setConnected(vm)} style={[styles.vmBtn, { borderColor: '#0096FF' }]}>
+                        <Text style={[styles.vmBtnText, { color: '#0096FF' }]}>Verbinden</Text>
+                      </TouchableOpacity>
+                      <TouchableOpacity onPress={() => stop(vm)} style={[styles.vmBtn, { borderColor: '#E55C5C' }]}>
+                        <Text style={[styles.vmBtnText, { color: '#E55C5C' }]}>Stop</Text>
+                      </TouchableOpacity>
+                    </>
+                  ) : (
+                    <TouchableOpacity onPress={() => boot(vm)} style={[styles.vmBtn, { borderColor: '#34C759' }]}>
+                      <Text style={[styles.vmBtnText, { color: '#34C759' }]}>Start</Text>
+                    </TouchableOpacity>
+                  )}
+                </View>
+              </View>
+            );
+          })
+        )}
+      </ScrollView>
+
+      <Modal visible={!!shot} transparent animationType="fade" onRequestClose={() => setShot(null)}>
+        <TouchableOpacity style={styles.shotOverlay} activeOpacity={1} onPress={() => setShot(null)}>
+          <Text style={styles.shotTitle}>{shot?.name} — Screenshot</Text>
+          {shot && (
+            <Image
+              source={{ uri: `data:image/png;base64,${shot.b64}` }}
+              style={styles.shotImg}
+              resizeMode="contain"
+            />
+          )}
+          <Text style={styles.shotHint}>Tippen zum Schließen</Text>
+        </TouchableOpacity>
+      </Modal>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#0D0D1A' },
+  placeholder: { flex: 1, backgroundColor: '#000', alignItems: 'center', justifyContent: 'center' },
+  icon: { fontSize: 64, marginBottom: 16 },
+  text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
+  sub: { color: '#9090B0', fontSize: 14, marginTop: 8 },
+  bar: { height: 40, flexDirection: 'row', alignItems: 'center', paddingHorizontal: 12, backgroundColor: '#12122A', borderBottomColor: '#1E1E2E', borderBottomWidth: 1 },
+  barTitle: { color: '#E0E0F0', fontSize: 14, fontWeight: '700', flex: 1 },
+  barBtn: { paddingHorizontal: 10, paddingVertical: 4 },
+  barBtnText: { color: '#0096FF', fontSize: 14, fontWeight: '700' },
+  empty: { color: '#8888AA', fontSize: 13, lineHeight: 20, textAlign: 'center', marginTop: 24 },
+  err: { color: '#FF6E6E', fontSize: 13, marginTop: 16 },
+  vmRow: { flexDirection: 'row', alignItems: 'center', backgroundColor: '#12122A', borderRadius: 10, padding: 12, marginBottom: 8 },
+  vmName: { color: '#E0E0F0', fontSize: 15, fontWeight: '700' },
+  vmMeta: { color: '#8888AA', fontSize: 12, fontWeight: '400' },
+  vmCmd: { color: '#6A9BD0', fontSize: 11, fontFamily: 'monospace', marginTop: 4 },
+  vmBtns: { flexDirection: 'row', gap: 6, alignItems: 'center' },
+  vmBtn: { borderWidth: 1, borderRadius: 8, paddingHorizontal: 10, paddingVertical: 6, minWidth: 34, alignItems: 'center' },
+  vmBtnText: { fontSize: 12, fontWeight: '700' },
+  shotOverlay: { flex: 1, backgroundColor: 'rgba(0,0,0,0.92)', alignItems: 'center', justifyContent: 'center', padding: 12 },
+  shotTitle: { color: '#E0E0F0', fontSize: 14, fontWeight: '700', marginBottom: 10 },
+  shotImg: { width: '100%', height: '78%', backgroundColor: '#000' },
+  shotHint: { color: '#8888AA', fontSize: 12, marginTop: 12 },
+});
+
+export default DesktopTile;
@@ -0,0 +1,148 @@
+/**
+ * FilesTile — Datei-Browser eines Projekts (/shared/projects/<id>/).
+ *
+ * Listet ALLE Dateien (nicht nur Code): erzeugte Bilder, Logs, Assets … — die
+ * gleichen, die in der Projektliste als 📄 gezaehlt werden. Tippen auf ein Bild
+ * zeigt es; tippen auf eine Textdatei zeigt eine Vorschau.
+ */
+
+import React, { useCallback, useEffect, useState } from 'react';
+import { ActivityIndicator, Image, Modal, ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import brainApi from '../../services/brainApi';
+
+interface Props {
+  projectId: string;
+  focused: boolean;
+}
+
+interface FileEntry { path: string; size: number }
+
+const IMG_EXT = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp'];
+
+function ext(path: string): string { return (path.split('.').pop() || '').toLowerCase(); }
+function isImage(path: string): boolean { return IMG_EXT.includes(ext(path)); }
+function iconFor(path: string): string {
+  const e = ext(path);
+  if (isImage(path)) return '🖼️';
+  if (['md', 'txt', 'readme'].includes(e)) return '📄';
+  if (['asm', 's', 'c', 'h', 'cpp', 'py', 'js', 'ts', 'sh', 'go', 'rs'].includes(e)) return '📝';
+  if (['zip', 'tar', 'gz', 'img', 'iso', 'qcow2'].includes(e)) return '📦';
+  return '📄';
+}
+function humanSize(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+const FilesTile: React.FC<Props> = ({ projectId, focused }) => {
+  const [files, setFiles] = useState<FileEntry[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [err, setErr] = useState('');
+  const [preview, setPreview] = useState<{ path: string; kind: 'image' | 'text'; data: string } | null>(null);
+  const [previewBusy, setPreviewBusy] = useState('');
+
+  const load = useCallback(() => {
+    setLoading(true); setErr('');
+    brainApi.listProjectFiles(projectId)
+      .then(r => setFiles((r.files || []).slice().sort((a, b) => a.path.localeCompare(b.path))))
+      .catch(e => setErr(String(e?.message || e)))
+      .finally(() => setLoading(false));
+  }, [projectId]);
+
+  useEffect(() => { if (focused) load(); }, [focused, projectId, load]);
+
+  const open = useCallback((f: FileEntry) => {
+    setPreviewBusy(f.path); setErr('');
+    if (isImage(f.path)) {
+      brainApi.readProjectFileBinary(projectId, f.path)
+        .then(r => setPreview({ path: f.path, kind: 'image', data: `data:${r.mime};base64,${r.base64}` }))
+        .catch(e => setErr(String(e?.message || e)))
+        .finally(() => setPreviewBusy(''));
+    } else {
+      brainApi.readProjectFile(projectId, f.path)
+        .then(r => setPreview({ path: f.path, kind: 'text', data: r.content ?? '' }))
+        .catch(e => setErr(String(e?.message || e)))
+        .finally(() => setPreviewBusy(''));
+    }
+  }, [projectId]);
+
+  if (!focused) {
+    return (
+      <View style={styles.placeholder}>
+        <Text style={styles.icon}>📁</Text>
+        <Text style={styles.text}>Dateien</Text>
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.bar}>
+        <Text style={styles.barTitle}>Dateien{files.length ? ` (${files.length})` : ''}</Text>
+        <TouchableOpacity onPress={load} style={styles.barBtn}><Text style={styles.barBtnText}>↻</Text></TouchableOpacity>
+      </View>
+      <ScrollView contentContainerStyle={{ padding: 8 }}>
+        {loading && files.length === 0 ? (
+          <ActivityIndicator color="#0096FF" style={{ marginTop: 20 }} />
+        ) : err ? (
+          <Text style={styles.err}>{err}</Text>
+        ) : files.length === 0 ? (
+          <Text style={styles.empty}>Noch keine Dateien in diesem Projekt.</Text>
+        ) : (
+          files.map(f => (
+            <TouchableOpacity key={f.path} onPress={() => open(f)} style={styles.row} disabled={previewBusy === f.path}>
+              <Text style={styles.rowIcon}>{iconFor(f.path)}</Text>
+              <Text style={styles.rowName} numberOfLines={1}>{f.path}</Text>
+              {previewBusy === f.path
+                ? <ActivityIndicator color="#8888AA" size="small" />
+                : <Text style={styles.rowSize}>{humanSize(f.size)}</Text>}
+            </TouchableOpacity>
+          ))
+        )}
+      </ScrollView>
+
+      <Modal visible={!!preview} transparent animationType="fade" onRequestClose={() => setPreview(null)}>
+        <View style={styles.pvOverlay}>
+          <View style={styles.pvBar}>
+            <Text style={styles.pvTitle} numberOfLines={1}>{preview?.path}</Text>
+            <TouchableOpacity onPress={() => setPreview(null)}><Text style={styles.pvClose}>✕</Text></TouchableOpacity>
+          </View>
+          {preview?.kind === 'image' ? (
+            <Image source={{ uri: preview.data }} style={styles.pvImg} resizeMode="contain" />
+          ) : (
+            <ScrollView style={styles.pvTextWrap} horizontal>
+              <ScrollView><Text style={styles.pvText}>{preview?.data}</Text></ScrollView>
+            </ScrollView>
+          )}
+        </View>
+      </Modal>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#0D0D1A' },
+  placeholder: { flex: 1, backgroundColor: '#0D0D1A', alignItems: 'center', justifyContent: 'center' },
+  icon: { fontSize: 56, marginBottom: 10 },
+  text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
+  bar: { height: 40, flexDirection: 'row', alignItems: 'center', paddingHorizontal: 12, backgroundColor: '#12122A', borderBottomColor: '#1E1E2E', borderBottomWidth: 1 },
+  barTitle: { color: '#E0E0F0', fontSize: 14, fontWeight: '700', flex: 1 },
+  barBtn: { paddingHorizontal: 10, paddingVertical: 4 },
+  barBtnText: { color: '#0096FF', fontSize: 14, fontWeight: '700' },
+  empty: { color: '#8888AA', fontSize: 13, textAlign: 'center', marginTop: 24 },
+  err: { color: '#FF6E6E', fontSize: 13, marginTop: 16, paddingHorizontal: 8 },
+  row: { flexDirection: 'row', alignItems: 'center', paddingVertical: 10, paddingHorizontal: 8, borderBottomColor: '#161628', borderBottomWidth: 1, gap: 10 },
+  rowIcon: { fontSize: 18 },
+  rowName: { color: '#E0E0F0', fontSize: 13, flex: 1 },
+  rowSize: { color: '#555570', fontSize: 11 },
+  pvOverlay: { flex: 1, backgroundColor: 'rgba(0,0,0,0.94)' },
+  pvBar: { flexDirection: 'row', alignItems: 'center', padding: 12, gap: 10 },
+  pvTitle: { color: '#E0E0F0', fontSize: 13, fontWeight: '700', flex: 1 },
+  pvClose: { color: '#E0E0F0', fontSize: 20, paddingHorizontal: 6 },
+  pvImg: { flex: 1, width: '100%' },
+  pvTextWrap: { flex: 1, padding: 12 },
+  pvText: { color: '#C8C8E0', fontSize: 12, fontFamily: 'monospace' },
+});
+
+export default FilesTile;
@@ -0,0 +1,144 @@
+/**
+ * VncTile — Live-Desktop der QEMU-VM (noVNC in einer WebView, RFB durch RVS).
+ *
+ * Nur aktiv, wenn das Desktop-Panel offen ist (focused): dann WebView mounten,
+ * bei 'ready' den RVS-VNC-Tunnel oeffnen. Eine kleine Steuerungs-Leiste macht
+ * die VM auf dem Handy bedienbar: Tastatur einblenden (tippt in die VM),
+ * Strg-Alt-Entf, und Fit ↔ 1:1 umschalten.
+ */
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import { WebView, WebViewMessageEvent } from 'react-native-webview';
+import desktop from '../../services/desktop';
+import { NOVNC_HTML } from '../assets/novncHtml';
+
+interface Props {
+  projectId: string;
+  focused: boolean;
+  port?: number; // VNC-Port der zu verbindenden VM (Default 5901 = Display :1)
+}
+
+const VncTile: React.FC<Props> = ({ projectId, focused, port = 5901 }) => {
+  const webRef = useRef<WebView>(null);
+  const [status, setStatus] = useState<'idle' | 'connecting' | 'connected' | 'disconnected'>('idle');
+  const unsubDataRef = useRef<null | (() => void)>(null);
+
+  const teardown = useCallback(() => {
+    if (unsubDataRef.current) { unsubDataRef.current(); unsubDataRef.current = null; }
+    desktop.closeVnc();
+  }, []);
+
+  useEffect(() => {
+    if (!focused) { teardown(); setStatus('idle'); }
+    return () => teardown();
+  }, [focused, teardown]);
+
+  const ctl = useCallback((fn: string) => {
+    webRef.current?.injectJavaScript(`window.ariaVncCtl && window.ariaVncCtl.${fn}(); true;`);
+  }, []);
+
+  const onMessage = useCallback((e: WebViewMessageEvent) => {
+    let m: any;
+    try { m = JSON.parse(e.nativeEvent.data); } catch { return; }
+    if (m.event === 'ready') {
+      setStatus('connecting');
+      unsubDataRef.current = desktop.onVncData((b64) => {
+        const js = `window.ariaVnc && window.ariaVnc.onData(${JSON.stringify(b64)}); true;`;
+        webRef.current?.injectJavaScript(js);
+      });
+      desktop.openVnc(projectId, port);
+    } else if (m.event === 'vnc_send') {
+      desktop.sendInput(m.b64);
+    } else if (m.event === 'vnc_close') {
+      desktop.closeVnc();
+    } else if (m.event === 'vnc_state') {
+      if (m.state === 'connected') setStatus('connected');
+      else if (m.state === 'disconnected') setStatus('disconnected');
+    }
+  }, [projectId, port]);
+
+  if (!focused) {
+    return (
+      <View style={styles.placeholder}>
+        <Text style={styles.icon}>🖥️</Text>
+        <Text style={styles.text}>Desktop</Text>
+        <Text style={styles.sub}>Panel öffnen zum Verbinden</Text>
+      </View>
+    );
+  }
+
+  const connected = status === 'connected';
+  return (
+    <View style={styles.container}>
+      <WebView
+        ref={webRef}
+        style={styles.web}
+        originWhitelist={['*']}
+        source={{ html: NOVNC_HTML, baseUrl: 'https://aria-vnc.local/' }}
+        onMessage={onMessage}
+        javaScriptEnabled
+        domStorageEnabled
+        mixedContentMode="always"
+        androidLayerType="hardware"
+        keyboardDisplayRequiresUserAction={false}
+      />
+
+      {/* Steuerungs-Leiste — nur wenn verbunden */}
+      {connected && (
+        <View style={styles.ctlBar}>
+          <TouchableOpacity style={styles.ctlBtn} onPress={() => ctl('focusKeyboard')} activeOpacity={0.7}>
+            <Text style={styles.ctlText}>⌨</Text>
+          </TouchableOpacity>
+          <TouchableOpacity style={styles.ctlBtn} onPress={() => ctl('cad')} activeOpacity={0.7}>
+            <Text style={styles.ctlTextSmall}>Strg+Alt+Entf</Text>
+          </TouchableOpacity>
+          <TouchableOpacity style={styles.ctlBtn} onPress={() => ctl('toggleFit')} activeOpacity={0.7}>
+            <Text style={styles.ctlText}>⤢</Text>
+          </TouchableOpacity>
+        </View>
+      )}
+
+      {!connected && (
+        <View style={styles.overlay} pointerEvents="none">
+          <Text style={styles.overlayText}>
+            {status === 'connecting' ? 'Verbinde …' : status === 'disconnected' ? 'Getrennt' : ''}
+          </Text>
+        </View>
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#000000' },
+  web: { flex: 1, backgroundColor: '#000000' },
+  placeholder: { flex: 1, backgroundColor: '#000000', alignItems: 'center', justifyContent: 'center' },
+  icon: { fontSize: 64, marginBottom: 16 },
+  text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
+  sub: { color: '#9090B0', fontSize: 14, marginTop: 8 },
+  ctlBar: {
+    position: 'absolute',
+    top: 8,
+    right: 8,
+    flexDirection: 'row',
+    gap: 6,
+  },
+  ctlBtn: {
+    backgroundColor: 'rgba(18,18,42,0.9)',
+    borderColor: '#2A2A3E',
+    borderWidth: 1,
+    borderRadius: 10,
+    paddingHorizontal: 10,
+    paddingVertical: 7,
+    minWidth: 38,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  ctlText: { color: '#E0E0F0', fontSize: 16, fontWeight: '700' },
+  ctlTextSmall: { color: '#E0E0F0', fontSize: 11, fontWeight: '700' },
+  overlay: { position: 'absolute', top: 12, left: 0, right: 0, alignItems: 'center' },
+  overlayText: { color: '#9090B0', fontSize: 12, backgroundColor: 'rgba(0,0,0,0.6)', paddingHorizontal: 10, paddingVertical: 4, borderRadius: 10, overflow: 'hidden' },
+});
+
+export default VncTile;
@@ -0,0 +1,40 @@
+/**
+ * useWorkspaceLayout — merkt sich pro Projekt die zuletzt fokussierte Kachel,
+ * damit man beim Zurueckkehren in ein Code-Projekt wieder dort landet (Editor/
+ * Desktop) statt immer im Chat. Persistiert nach AsyncStorage (Muster wie
+ * aria_project_drafts).
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { TileId } from './layout';
+
+const KEY = 'aria_workspace_layout';
+
+interface Entry { focus: TileId | null }
+type LayoutMap = Record<string, Entry>;
+
+const keyOf = (projectId: string) => projectId || '__main__';
+
+export function useWorkspaceLayout(projectId: string) {
+  const mapRef = useRef<LayoutMap>({});
+  const [loaded, setLoaded] = useState(false);
+
+  useEffect(() => {
+    AsyncStorage.getItem(KEY).then((v) => {
+      if (v) { try { mapRef.current = JSON.parse(v) || {}; } catch { /* ignore */ } }
+      setLoaded(true);
+    }).catch(() => setLoaded(true));
+  }, []);
+
+  const getFocus = useCallback((): TileId | null | undefined => {
+    return mapRef.current[keyOf(projectId)]?.focus;
+  }, [projectId]);
+
+  const saveFocus = useCallback((focus: TileId | null) => {
+    mapRef.current = { ...mapRef.current, [keyOf(projectId)]: { focus } };
+    AsyncStorage.setItem(KEY, JSON.stringify(mapRef.current)).catch(() => {});
+  }, [projectId]);
+
+  return { loaded, getFocus, saveFocus };
+}
@@ -37,6 +37,7 @@ import triggers as triggers_mod
 import watcher as watcher_mod
 import oauth as oauth_mod
 import projects as projects_mod
+import project_vms as project_vms_mod

 BRIDGE_URL = os.environ.get("BRIDGE_URL", "http://aria-bridge:8090")
 # SearXNG (self-hosted Meta-Suche) — Backend fuers web_search-Tool (B1b).
@@ -540,10 +541,13 @@ META_TOOLS = [
                    "fires_at": {
                        "type": "string",
                        "description": (
-                            "Absoluter ISO-Timestamp UTC fuer feste Termine, z.B. "
-                            "'2026-05-12T14:30:00Z'. Die aktuelle Zeit findest du im "
-                            "System-Prompt unter '## Aktuelle Zeit'. Fuer relative Angaben "
-                            "lieber `in_seconds` nutzen."
+                            "Fester Termin als ISO-Timestamp. Schreib einfach die LOKALE "
+                            "Wanduhrzeit, die Stefan meint, OHNE Zeitzone — z.B. 'um 14:30' "
+                            "→ '2026-05-12T14:30:00'. Der Server rechnet sie selbst in UTC "
+                            "um (naiv = Ortszeit Europe/Berlin). Nur wenn du explizit UTC "
+                            "willst, haeng Z an ('...T12:30:00Z'). Die aktuelle Lokal-/UTC-"
+                            "Zeit steht im System-Prompt unter '## Aktuelle Zeit'. Fuer "
+                            "relative Angaben ('in 2 Stunden') lieber `in_seconds`."
                        ),
                    },
                    "message": {"type": "string", "description": "Was soll bei der Erinnerung gesagt werden"},
@@ -1042,15 +1046,20 @@ META_TOOLS = [
        "function": {
            "name": "project_summary",
            "description": (
-                "Fasst zusammen was zuletzt in einem Projekt passiert ist (letzte ~10 Turns). "
-                "Nutze zwingend wenn Stefan in ein altes Projekt einsteigt mit "
-                "'hol mich ab' / 'was war zuletzt' / 'erinner mich dran' — sonst "
-                "halluzinierst Du Inhalte die nicht da sind."
+                "Liest die ECHTE gespeicherte Chat-Historie eines ANDEREN Projekts "
+                "(letzte ~20 Turns aus dem persistierten Verlauf — nicht nur Deinem "
+                "aktuellen Kontextfenster) und fasst sie zusammen. Funktioniert fuer "
+                "JEDES Projekt (per Name, Fuzzy-Match) UND fuer den Hauptchat "
+                "(name='Hauptchat'). Rufe es DIREKT auf, sobald Stefan sagt 'hol dir "
+                "die Infos aus Projekt X', 'schau mal in Projekt Y / den Hauptchat "
+                "rein', 'was war zuletzt bei ...', 'hol mich ab' — antworte NICHT aus "
+                "dem Gedaechtnis, sonst halluzinierst Du. Der Verlauf des Projekts steht "
+                "sicher zur Verfuegung, auch wenn Ihr da lange nicht wart."
            ),
            "parameters": {
                "type": "object",
                "properties": {
-                    "name": {"type": "string", "description": "Projekt-Name (Fuzzy-Match)."},
+                    "name": {"type": "string", "description": "Projekt-Name (Fuzzy-Match) oder 'Hauptchat' fuer den Hauptthread."},
                },
                "required": ["name"],
            },
@@ -1075,6 +1084,121 @@ META_TOOLS = [
            },
        },
    },
+    {
+        "type": "function",
+        "function": {
+            "name": "set_project_kind",
+            "description": (
+                "Markiert das AKTUELLE Projekt als Code-Projekt ('code') oder "
+                "normalen Chat ('chat'). Bei 'code' blendet die App zusaetzlich "
+                "einen Live-Code-Editor und den QEMU-Desktop (VNC) ein. Rufe es auf, "
+                "sobald aus einem Gespraech ein Programmier-/Bau-Projekt wird (Du "
+                "faengst an Code zu schreiben, eine VM zu bauen, etc.). Dein "
+                "Arbeitsverzeichnis fuer Code-Dateien ist dann /shared/projects/"
+                "<projekt-id>/ — nur was Du DORT schreibst erscheint im Editor."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "kind": {"type": "string", "enum": ["code", "chat"], "description": "'code' oder 'chat'."},
+                },
+                "required": ["kind"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "satellite_list",
+            "description": (
+                "Zeigt welche ARIA-Satelliten (Aussenposten-Container in FREMDEN Netzen, "
+                "z.B. 'Buero') gerade ONLINE sind und was sie koennen (discover / "
+                "dial.launch / wol / http). Nutze das ZUERST, wenn Stefan etwas 'im "
+                "Buero' / 'im Netz X' / 'auf dem <Geraet> dort' machen will — so weisst "
+                "Du welche Netze erreichbar sind."
+            ),
+            "parameters": {"type": "object", "properties": {}},
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "satellite_devices",
+            "description": (
+                "Listet die Geraete im Netz eines Satelliten (Fire TV, Chromecast, "
+                "Smart-TVs, Drucker, NAS, Hosts ...). Nutze es um herauszufinden welches "
+                "Geraet gemeint ist, BEVOR Du satellite_command aufrufst."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "satellite": {"type": "string", "description": "Satelliten-Name/Location/ID (z.B. 'Buero')."},
+                },
+                "required": ["satellite"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "satellite_command",
+            "description": (
+                "Fuehrt eine Aktion auf einem Geraet im Netz eines Satelliten aus. "
+                "Beispiel YouTube-Video auf Fire TV: action='dial.launch', "
+                "device='Fire TV', params={'app':'YouTube','v':'<videoId>'}. Weitere "
+                "Aktionen: 'wol' (params={'mac':'...'}) zum Aufwecken, "
+                "'http.get'/'http.post' (params={'url':'...'}) fuer lokale Webhooks. "
+                "Geht nur, wenn der Satellit Steuerung erlaubt (siehe satellite_list)."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "satellite": {"type": "string", "description": "Satelliten-Name/Location/ID."},
+                    "device": {"type": "string", "description": "Geraet (Name/ID/IP) aus satellite_devices."},
+                    "action": {"type": "string", "description": "z.B. 'dial.launch', 'wol', 'http.get'."},
+                    "params": {"type": "object", "description": "Aktions-Parameter, z.B. {'app':'YouTube','v':'<id>'}."},
+                },
+                "required": ["satellite", "action"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "vm_register",
+            "description": (
+                "Traegt eine QEMU-VM in die VM-Liste des AKTUELLEN Projekts ein, "
+                "damit sie in Stefans Desktop-Panel (Cockpit) erscheint und er sie "
+                "starten/stoppen/verbinden kann. Rufe das auf, NACHDEM Du mit aria-vm "
+                "eine VM gebaut/gebootet hast — mit den Medien, die zum Task passen: "
+                "disk (Festplatte, z.B. DOS-Spiele), floppy (Diskette, OS-Dev), iso "
+                "(Installer). Leer lassen = aria-vm erkennt disk.qcow2/floppy.img/"
+                "cdrom.iso im VM-Ordner selbst. vnc_display → Port 5900+display "
+                "(mehrere VMs = verschiedene Displays)."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "VM-Name wie bei aria-vm (a-z0-9_-)."},
+                    "arch": {"type": "string", "description": "z.B. i386, x86_64, aarch64, mips (Architektur zum Task waehlen)."},
+                    "disk": {"type": "string", "description": "optional: qcow2-Pfad (Festplatte)."},
+                    "floppy": {"type": "string", "description": "optional: Disketten-Image-Pfad (-fda)."},
+                    "iso": {"type": "string", "description": "optional: Boot-ISO-Pfad."},
+                    "vnc_display": {"type": "integer", "description": "meist WEGLASSEN — das VNC-Display wird global eindeutig auto-vergeben (kein Port-Konflikt bei mehreren VMs). Nur setzen wenn Du ein bestimmtes willst."},
+                    "mem": {"type": "integer", "description": "RAM in MB (Default 1024)."},
+                },
+                "required": ["name", "arch"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "vm_list",
+            "description": "Listet die registrierten QEMU-VMs des aktuellen Projekts (mit Lauf-Status).",
+            "parameters": {"type": "object", "properties": {}},
+        },
+    },
 ]


@@ -1488,7 +1612,7 @@ class Agent:
                        targs = {}
                    logger.info("[router] lokal Tool-Call: %s(%s)", tname,
                                ", ".join(targs.keys()))
-                    tresult = self._dispatch_tool(tname, targs)
+                    tresult = self._dispatch_tool(tname, targs, active_project_id)
                    # Echter Skill (run_*) erfolgreich? Dann uebernimmt dieser
                    # Turn das speak-Flag des Skills (Steuerbefehl=stumm,
                    # Antwort-Skill=vorlesen). Letzter Skill gewinnt.
@@ -1780,7 +1904,7 @@ class Agent:
                    ))
                    # Tools ausfuehren + Ergebnis als role=tool zurueck
                    for tc in result.tool_calls:
-                        tool_result = self._dispatch_tool(tc["name"], tc["arguments"])
+                        tool_result = self._dispatch_tool(tc["name"], tc["arguments"], active_project_id)
                        # Steuerbefehl-Skill (run_*, speak=false) erfolgreich
                        # ausgefuehrt → Antwort nicht vorlesen (letzter Skill gewinnt).
                        _tn = tc.get("name") or ""
@@ -1868,10 +1992,116 @@ class Agent:

    # ── Tool-Dispatcher ───────────────────────────────────────

-    def _dispatch_tool(self, name: str, arguments: dict) -> str:
+    def _read_project_history(self, project_id: str, limit: int = 20) -> list:
+        """Liest die VOLLE Chat-Historie eines Projekts aus dem geteilten
+        chat_backup.jsonl (/shared/config, auch im Brain gemountet).
+
+        Noetig, weil das rollende Conversation-Window nur die letzten ~50 Turns
+        ueber ALLE Projekte haelt — aeltere/andere Projekt-Chats sind da laengst
+        rausdistilliert. Gibt die letzten `limit` (role, text)-Paare zurueck,
+        gefiltert auf project_id ('' = Hauptthread). Fuehrende Hint-Bloecke
+        ([Standort: ...]) in User-Turns werden entfernt."""
+        path = "/shared/config/chat_backup.jsonl"
+        out: list = []
+        try:
+            if not os.path.exists(path):
+                return []
+            with open(path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        o = json.loads(line)
+                    except Exception:
+                        continue
+                    role = o.get("role")
+                    text = o.get("text")
+                    if not role or text is None:
+                        continue
+                    # nur echte Gespraechs-Turns (keine skill/memory/system-Eintraege)
+                    if role not in ("user", "assistant", "aria"):
+                        continue
+                    if (o.get("project_id") or "") != (project_id or ""):
+                        continue
+                    if role == "user":
+                        text = _strip_leading_hint_blocks(text)
+                    out.append((role, text))
+        except Exception as exc:
+            logger.warning("project_summary: chat_backup lesen fehlgeschlagen: %s", exc)
+            return []
+        return out[-limit:]
+
+    def _dispatch_satellite(self, name: str, arguments: dict) -> str:
+        """satellite_list / satellite_devices / satellite_command — geht via
+        Bridge (/internal/satellite*) → RVS → Satellit. Muster wie flux_generate."""
+        def _post(path: str, body: dict, timeout: float) -> dict:
+            data = json.dumps(body).encode("utf-8")
+            req = urllib.request.Request(f"{BRIDGE_URL}{path}", data=data, method="POST",
+                                         headers={"Content-Type": "application/json"})
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                return json.loads(resp.read().decode("utf-8", "ignore"))
+        try:
+            if name == "satellite_list":
+                result = _post("/internal/satellite-list", {}, 10)
+                sats = result.get("satellites") or []
+                if not sats:
+                    return ("Gerade ist kein Satellit online. (Ein Satellit ist ein "
+                            "Aussenposten-Container in einem fremden Netz, der sich mit "
+                            "RVS verbindet und Dir dort Geraete zeigt + steuerbar macht.)")
+                lines = []
+                for s in sats:
+                    status = "online" if s.get("online") else "offline"
+                    caps = ", ".join(s.get("caps") or []) or "nur beobachten"
+                    lines.append(f"- {s.get('location')} (id={s.get('id')}, {status}; kann: {caps})")
+                return "Satelliten / erreichbare Netze:\n" + "\n".join(lines)
+
+            if name == "satellite_devices":
+                sat = (arguments.get("satellite") or "").strip()
+                if not sat:
+                    return "FEHLER: satellite ist Pflicht."
+                result = _post("/internal/satellite", {"op": "discover", "satellite": sat}, 30)
+                if result.get("error"):
+                    return f"FEHLER: {result['error']}"
+                devices = result.get("devices") or []
+                if not devices:
+                    return f"Im Netz von '{sat}' wurden keine Geraete gefunden (oder der Satellit ist offline)."
+                lines = []
+                for d in devices[:40]:
+                    tags = []
+                    if d.get("model"):
+                        tags.append(d["model"])
+                    if d.get("dialAppUrl"):
+                        tags.append("DIAL/App-Launch")
+                    if d.get("mac"):
+                        tags.append(d["mac"])
+                    extra = f" ({'; '.join(tags)})" if tags else ""
+                    lines.append(f"- {d.get('name')} [{d.get('type')}] {d.get('ip', '')}{extra}  id={d.get('id')}")
+                return f"Geraete im Netz '{result.get('location', sat)}':\n" + "\n".join(lines)
+
+            # satellite_command
+            sat = (arguments.get("satellite") or "").strip()
+            action = (arguments.get("action") or "").strip()
+            if not sat or not action:
+                return "FEHLER: satellite und action sind Pflicht."
+            params = arguments.get("params") if isinstance(arguments.get("params"), dict) else {}
+            result = _post("/internal/satellite", {
+                "op": "command", "satellite": sat,
+                "device": arguments.get("device") or "", "action": action, "params": params,
+            }, 30)
+            if result.get("ok"):
+                r = result.get("result")
+                return f"OK — {r}" if r else "OK — Aktion ausgefuehrt."
+            return f"FEHLER: {result.get('error') or 'Aktion fehlgeschlagen'}"
+        except Exception as exc:
+            return f"FEHLER: Satellit/Bridge nicht erreichbar: {exc}"
+
+    def _dispatch_tool(self, name: str, arguments: dict, project_id: str = "") -> str:
        """Fuehrt einen Tool-Call aus und gibt ein kurzes Text-Resultat zurueck.
        Niemals werfen — Fehler werden als Text-Resultat reportet damit Claude
-        weitermachen kann."""
+        weitermachen kann. project_id = Projekt DIESES Requests (fuer Tools die
+        aufs aktuelle Projekt wirken, z.B. set_project_kind) — NICHT der globale
+        active_project (geraeteuebergreifend)."""
        try:
            if name == "skill_create":
                # ARIA-Skills sind immer Python — execution ist nicht mehr im Schema
@@ -2535,22 +2765,33 @@ class Agent:
                pname = (arguments.get("name") or "").strip()
                if not pname:
                    return "FEHLER: name ist Pflicht."
-                p = projects_mod.find_project(pname)
-                if not p:
-                    return f"Kein Projekt '{pname}' gefunden."
-                # Letzte ~10 Turns des Projekts aus dem Conversation-Log
-                turns = [t for t in self.conversation.turns if t.project_id == p["id"]]
+                # Hauptchat (project_id="") explizit unterstuetzen — damit ARIA auch
+                # aus einem Projekt heraus in den Hauptthread reinschauen kann.
+                if pname.lower() in {"hauptchat", "hauptthread", "haupt", "main",
+                                     "mainchat", "haupt-chat", "hauptchat-thread"}:
+                    target_pid = ""
+                    label, desc = "Hauptchat", "der Hauptthread (kein Projekt)"
+                else:
+                    p = projects_mod.find_project(pname)
+                    if not p:
+                        return f"Kein Chat/Projekt '{pname}' gefunden (fuer den Hauptthread: name='Hauptchat')."
+                    target_pid = p["id"]
+                    label, desc = p["name"], p.get("description", "(keine Beschreibung)")
+                # VOLLE Historie aus chat_backup.jsonl (nicht nur das rollende
+                # Window — sonst fehlen aeltere/andere Projekt-Chats komplett).
+                turns = self._read_project_history(target_pid, limit=20)
                if not turns:
-                    return (f"Projekt '{p['name']}' existiert (id={p['id']}), aber im "
-                            f"aktuellen Conversation-Window stehen noch keine Turns. "
-                            f"Beschreibung: {p.get('description', '(keine)')}")
-                tail = turns[-12:]
+                    # Fallback aufs In-Memory-Window, falls chat_backup fehlt/leer.
+                    turns = [(t.role, t.content) for t in self.conversation.turns
+                             if (t.project_id or "") == target_pid]
+                if not turns:
+                    return (f"'{label}' hat noch keine Chat-Historie. {desc}")
+                tail = turns[-20:]
                summary_lines = []
-                for t in tail:
-                    prefix = "Stefan" if t.role == "user" else "Du"
-                    summary_lines.append(f"{prefix}: {t.content[:280]}")
-                preamble = (f"Projekt '{p['name']}' — {p.get('description', '(keine Beschreibung)')}.\n"
-                            f"Letzte {len(tail)} Turns:\n")
+                for role, text in tail:
+                    prefix = "Stefan" if role == "user" else "Du"
+                    summary_lines.append(f"{prefix}: {(text or '')[:280]}")
+                preamble = f"'{label}' — {desc}.\nLetzte {len(tail)} Turns aus der Historie:\n"
                return preamble + "\n".join(summary_lines)
            if name == "project_end":
                pname = (arguments.get("name") or "").strip()
@@ -2566,6 +2807,59 @@ class Agent:
                    "action": "ended",
                })
                return f"OK — Projekt '{p['name']}' beendet (id={p['id']}). Bleibt in der Liste, aktiv ist jetzt der Hauptthread."
+            if name == "set_project_kind":
+                kind = (arguments.get("kind") or "").strip().lower()
+                if kind not in ("code", "chat"):
+                    return "FEHLER: kind muss 'code' oder 'chat' sein."
+                # WICHTIG: das Projekt des AKTUELLEN Requests markieren, NICHT den
+                # globalen active_project — der ist geraeteuebergreifend und wuerde
+                # (bei mehreren App-/Diagnostic-Instanzen) das falsche Projekt
+                # treffen. project_id kommt pro Request vom Client.
+                active_id = (project_id or "").strip()
+                if not active_id:
+                    return ("Kein aktives Projekt — dieser Chat laeuft im Hauptthread. "
+                            "set_project_kind wirkt nur, wenn der Request in einem Projekt "
+                            "laeuft (der Client sendet die project_id mit).")
+                updated = projects_mod.update_project(active_id, {"kind": kind})
+                if not updated:
+                    return f"FEHLER: Projekt '{active_id}' nicht gefunden."
+                self._pending_events.append({
+                    "type": "project_changed",
+                    "project": updated,
+                    "action": "kind_changed",
+                })
+                if kind == "code":
+                    return (f"OK — Projekt '{updated['name']}' ist jetzt ein Code-Projekt. "
+                            f"Editor + Desktop erscheinen in der App. Code-Dateien unter "
+                            f"/shared/projects/{active_id}/ schreiben, damit sie im Editor auftauchen.")
+                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 == "vm_register":
+                pid = (project_id or "").strip()
+                if not pid:
+                    return "Kein aktives Projekt — VMs werden pro Projekt gefuehrt. Erst ein Projekt betreten."
+                try:
+                    vm = project_vms_mod.add_vm(
+                        pid, (arguments.get("name") or "").strip(),
+                        (arguments.get("arch") or "i386").strip(),
+                        (arguments.get("iso") or "").strip(),
+                        (arguments.get("floppy") or "").strip(),
+                        (arguments.get("disk") or "").strip(),
+                        int(arguments.get("vnc_display") or 0),
+                        int(arguments.get("mem") or 1024),
+                    )
+                except (ValueError, TypeError) as exc:
+                    return f"FEHLER: {exc}"
+                return (f"OK — VM '{vm['name']}' ({vm['arch']}, Display :{vm['vnc_display']}) "
+                        f"in Projekt '{pid}' registriert. Erscheint in Stefans Desktop-Panel.")
+            if name == "vm_list":
+                pid = (project_id or "").strip()
+                vms = project_vms_mod.list_vms(pid)
+                if not vms:
+                    return f"Projekt '{pid or 'Hauptchat'}' hat noch keine registrierten VMs."
+                return "VMs:\n" + "\n".join(
+                    f"- {v['name']} ({v.get('arch')}, Display :{v.get('vnc_display', 1)})" for v in vms)
            return f"Unbekanntes Tool: {name}"
        except Exception as exc:
            logger.exception("Tool '%s' fehlgeschlagen", name)
@@ -39,6 +39,7 @@ import background as background_mod
 import oauth as oauth_mod
 import seed_rules as seed_rules_mod
 import projects as projects_mod
+import project_vms as project_vms_mod

 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
 logger = logging.getLogger("aria-brain")
@@ -769,15 +770,49 @@ def projects_queue_status():

 # ── Projekte ────────────────────────────────────────────────────────

+def _project_file_count(pid: str) -> int:
+    """Anzahl Dateien in /shared/projects/<pid>/ (rekursiv, gecappt). 0 = leer."""
+    base = os.path.join("/shared/projects", pid or "")
+    if not os.path.isdir(base):
+        return 0
+    cnt = 0
+    try:
+        for _dp, dns, fns in os.walk(base):
+            dns[:] = [d for d in dns if d not in (".git", "node_modules", "__pycache__", ".venv", "venv")]
+            cnt += len(fns)
+            if cnt > 999:
+                return 999
+    except Exception:
+        return 0
+    return cnt
+
+
+def _enrich_projects(projects: list) -> list:
+    """Ergaenzt has_files + file_count pro Projekt (fuer das Datei-Symbol in der
+    Liste). Das ersetzt das manuelle Code-Flag als primaeren Code-Indikator."""
+    for p in projects or []:
+        if not isinstance(p, dict):
+            continue
+        c = _project_file_count(p.get("id") or "")
+        p["file_count"] = c
+        p["has_files"] = c > 0
+    return projects
+
+
@app.get("/projects/status")
 def projects_status():
    """Komplett-Status: aktives Projekt + Liste aller (nicht-archivierten)."""
-    return projects_mod.status()
+    st = projects_mod.status()
+    _enrich_projects(st.get("projects", []))
+    if st.get("active"):
+        _enrich_projects([st["active"]])
+    return st


@app.get("/projects/list")
 def projects_list(include_archived: bool = False):
-    return {"projects": projects_mod.list_projects(include_archived=include_archived)}
+    return {"projects": _enrich_projects(
+        projects_mod.list_projects(include_archived=include_archived))}


 class ProjectCreateBody(BaseModel):
@@ -827,17 +862,262 @@ class ProjectUpdateBody(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None
    hidden: Optional[bool] = None
+    kind: Optional[str] = None   # 'code' | 'chat' — manuell setzbar (App/Diagnostic)


@app.patch("/projects/{project_id}")
 def projects_update(project_id: str, body: ProjectUpdateBody):
    patch = body.dict(exclude_unset=True)
+    if "kind" in patch and patch["kind"] not in ("code", "chat", None):
+        raise HTTPException(status_code=400, detail="kind muss 'code' oder 'chat' sein")
    p = projects_mod.update_project(project_id, patch)
    if p is None:
        raise HTTPException(status_code=404, detail=f"Projekt {project_id} nicht gefunden")
    return p


+# ── Code-Dateien eines Projekts (/shared/projects/<pid>/) ───────────
+# Der Live-Editor streamt ARIAs Writes; diese Endpoints liefern zusaetzlich die
+# BEREITS vorhandenen Dateien, damit der Editor beim Oeffnen nicht leer ist.
+_PROJECT_FILES_ROOT = "/shared/projects"
+_PROJECT_FILE_MAX = 512 * 1024
+
+
+def _project_dir(project_id: str) -> str:
+    base = os.path.realpath(os.path.join(_PROJECT_FILES_ROOT, project_id or ""))
+    root = os.path.realpath(_PROJECT_FILES_ROOT)
+    if base != root and not base.startswith(root + os.sep):
+        raise HTTPException(status_code=400, detail="ungueltige project_id")
+    return base
+
+
+@app.get("/projects/{project_id}/files")
+def project_files(project_id: str):
+    base = _project_dir(project_id)
+    out = []
+    if os.path.isdir(base):
+        for dirpath, dirs, files in os.walk(base):
+            dirs[:] = [d for d in dirs if d not in
+                       (".git", "node_modules", "__pycache__", ".venv", "venv")]
+            for f in files:
+                full = os.path.join(dirpath, f)
+                rel = os.path.relpath(full, base).replace("\\", "/")
+                try:
+                    sz = os.path.getsize(full)
+                except OSError:
+                    sz = 0
+                out.append({"path": rel, "size": sz})
+    out.sort(key=lambda x: x["path"])
+    return {"projectId": project_id, "files": out}
+
+
+@app.get("/projects/{project_id}/file")
+def project_file(project_id: str, path: str, binary: bool = False):
+    base = _project_dir(project_id)
+    target = os.path.realpath(os.path.join(base, path))
+    if target != base and not target.startswith(base + os.sep):
+        raise HTTPException(status_code=400, detail="Pfad ausserhalb des Projekts")
+    if not os.path.isfile(target):
+        raise HTTPException(status_code=404, detail="Datei nicht gefunden")
+    # Binaer (z.B. Bilder) → Base64. Grosszuegigeres Limit als beim Text-Editor.
+    if binary:
+        import base64
+        import mimetypes
+        if os.path.getsize(target) > 8 * 1024 * 1024:
+            raise HTTPException(status_code=413, detail="Datei zu gross (max 8 MB)")
+        with open(target, "rb") as f:
+            data = f.read()
+        mime, _ = mimetypes.guess_type(target)
+        return {"projectId": project_id, "path": path, "mime": mime or "application/octet-stream",
+                "base64": base64.b64encode(data).decode("ascii")}
+    if os.path.getsize(target) > _PROJECT_FILE_MAX:
+        raise HTTPException(status_code=413, detail="Datei zu gross fuer den Editor")
+    try:
+        with open(target, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc))
+    return {"projectId": project_id, "path": path, "content": content}
+
+
+# ── QEMU-VMs pro Projekt ────────────────────────────────────────────
+# Registry (project_vms) + echter Start/Stop via `aria-vm` auf dem Host (SSH
+# aria-wohnung). Das Desktop-Panel der App zeigt pro Projekt die Liste.
+_ARIA_VM_HOST = os.environ.get("ARIA_VM_SSH_HOST", "aria-wohnung")
+
+
+def _docker_gateway() -> str:
+    """Docker-Gateway-IP (= Host-IP auf dem Container-Netz), an die QEMU sein VNC
+    binden soll: von der Bridge erreichbar, aber NICHT im LAN/Internet. Aus
+    /proc/net/route (Default-Route), kein `ip`-Tool noetig."""
+    try:
+        import socket as _sock
+        import struct as _struct
+        with open("/proc/net/route") as f:
+            for line in f.readlines()[1:]:
+                fields = line.strip().split()
+                if len(fields) >= 3 and fields[1] == "00000000" and int(fields[3], 16) & 2:
+                    return _sock.inet_ntoa(_struct.pack("<L", int(fields[2], 16)))
+    except Exception:
+        pass
+    return ""
+
+
+def _ssh_host(*cmd: str, timeout: int = 25):
+    import subprocess
+    full = ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=8",
+            _ARIA_VM_HOST, *[str(c) for c in cmd]]
+    try:
+        r = subprocess.run(full, capture_output=True, text=True, timeout=timeout)
+        return r.returncode, r.stdout or "", r.stderr or ""
+    except Exception as exc:
+        return 1, "", str(exc)
+
+
+def _ssh_aria_vm(*args: str, timeout: int = 25):
+    return _ssh_host("aria-vm", *args, timeout=timeout)
+
+
+def _vm_running_names() -> set:
+    rc, out, _err = _ssh_aria_vm("list", timeout=15)
+    names = set()
+    if rc == 0:
+        for line in out.splitlines():
+            parts = line.split()
+            if parts and "laeuft" in line:
+                names.add(parts[0])
+    return names
+
+
+class VmAddBody(BaseModel):
+    name: str
+    arch: str = "i386"
+    iso: str = ""
+    floppy: str = ""
+    disk: str = ""
+    vnc_display: int = 1
+    mem: int = 1024
+    create_disk: bool = False
+    size: str = "10G"
+
+
+def _vm_boot_args(v: dict) -> list:
+    args = ["boot", v.get("name", "?"),
+            "--vnc-display", str(v.get("vnc_display", 1)),
+            "--mem", str(v.get("mem", 1024))]
+    if v.get("disk"):
+        args += ["--disk", v["disk"]]
+    if v.get("floppy"):
+        args += ["--floppy", v["floppy"]]
+    if v.get("iso"):
+        args += ["--iso", v["iso"]]
+    return args
+
+
+def _vm_boot_cmd(v: dict) -> str:
+    """Lesbarer Start-Befehl (aria-vm) als 'Wert' hinter dem VM-Eintrag."""
+    return "aria-vm " + " ".join(_vm_boot_args(v))
+
+
+@app.get("/projects/{project_id}/vms")
+def project_vms_list(project_id: str):
+    vms = [dict(v) for v in project_vms_mod.list_vms(project_id)]
+    running = _vm_running_names()
+    for v in vms:
+        v["running"] = v.get("name") in running
+        v["vnc_port"] = 5900 + int(v.get("vnc_display", 1))
+        v["boot_cmd"] = _vm_boot_cmd(v)
+    return {"projectId": project_id, "vms": vms}
+
+
+@app.post("/projects/{project_id}/vms")
+def project_vm_add(project_id: str, body: VmAddBody):
+    try:
+        vm = project_vms_mod.add_vm(project_id, body.name, body.arch, body.iso,
+                                    body.floppy, body.disk, body.vnc_display, body.mem)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    if body.create_disk:
+        rc, out, err = _ssh_aria_vm("create", body.name, body.arch, body.size)
+        vm["create_result"] = out.strip() or err.strip()
+        vm["create_ok"] = (rc == 0)
+    return vm
+
+
+@app.delete("/projects/{project_id}/vms/{name}")
+def project_vm_remove(project_id: str, name: str, purge: bool = False):
+    ok = project_vms_mod.remove_vm(project_id, name)
+    if not ok:
+        raise HTTPException(status_code=404, detail=f"VM '{name}' nicht in Projekt {project_id}")
+    if purge:
+        _ssh_aria_vm("rm", name)
+    return {"ok": True, "name": name}
+
+
+@app.post("/projects/{project_id}/vms/{name}/boot")
+def project_vm_boot(project_id: str, name: str):
+    vm = project_vms_mod.get_vm(project_id, name)
+    if not vm:
+        raise HTTPException(status_code=404, detail=f"VM '{name}' nicht gefunden")
+    # VNC an die Docker-Gateway-IP binden, damit die Bridge den Stream tunneln
+    # kann (Loopback ist von Containern nicht erreichbar). NICHT im LAN sichtbar.
+    boot_args = _vm_boot_args(vm)
+    gw = _docker_gateway()
+    if gw:
+        boot_args += ["--vnc-bind", gw]
+    rc, out, err = _ssh_aria_vm(*boot_args, timeout=40)
+    return {"ok": rc == 0, "name": name, "vnc_port": 5900 + int(vm.get("vnc_display", 1)),
+            "vnc_bind": gw or "127.0.0.1", "output": (out.strip() or err.strip())[:500]}
+
+
+@app.post("/projects/{project_id}/vms/{name}/stop")
+def project_vm_stop(project_id: str, name: str):
+    rc, out, err = _ssh_aria_vm("stop", name, timeout=25)
+    return {"ok": rc == 0, "name": name, "output": (out.strip() or err.strip())[:500]}
+
+
+@app.post("/projects/{project_id}/vms/{name}/screenshot")
+def project_vm_screenshot(project_id: str, name: str):
+    """Macht einen Screenshot der laufenden VM und liefert ihn als Base64.
+
+    aria-vm schreibt das PNG ins VM-Verzeichnis (dem aria-User gehoerend — nicht
+    ins /root-Shared-Volume, wo der aria-User keinen Zugriff hat). Der Brain holt
+    die Datei danach per SSH (base64) — funktioniert unabhaengig von Volume-
+    Rechten. Zusaetzlich wird das PNG ins Projekt kopiert (Dateien-Panel)."""
+    import base64
+    rc, out, err = _ssh_aria_vm("screenshot", name, timeout=30)
+    if rc != 0:
+        raise HTTPException(status_code=400, detail=f"Screenshot fehlgeschlagen: {(err or out).strip()[:200]}")
+    path = ""
+    for line in out.splitlines():
+        if line.startswith("screenshot="):
+            path = line.split("=", 1)[1].strip()
+    if not path:
+        raise HTTPException(status_code=500, detail=f"Kein Screenshot-Pfad: {out.strip()[:200]}")
+    # PNG per SSH als Base64 holen (kein Shared-Volume noetig).
+    rc2, b64, err2 = _ssh_host("base64", "-w0", path, timeout=20)
+    if rc2 != 0 or not b64.strip():
+        raise HTTPException(status_code=500, detail=f"Screenshot konnte nicht gelesen werden: {(err2 or 'leer').strip()[:200]}")
+    b64 = b64.strip()
+    try:
+        data = base64.b64decode(b64)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Base64 ungueltig: {exc}")
+    fname = os.path.basename(path)
+    # Ins Projekt kopieren → taucht im Dateien-Panel auf.
+    proj_rel = ""
+    try:
+        shots_dir = os.path.join(_project_dir(project_id), "screenshots")
+        os.makedirs(shots_dir, exist_ok=True)
+        with open(os.path.join(shots_dir, fname), "wb") as f:
+            f.write(data)
+        proj_rel = "screenshots/" + fname
+    except Exception:
+        proj_rel = ""
+    return {"ok": True, "name": name, "filename": fname,
+            "projectPath": proj_rel, "base64": b64}
+
+
@app.get("/conversation/stats")
 def conversation_stats():
    return conversation().stats()
@@ -0,0 +1,118 @@
+"""
+project_vms — Registry der QEMU-VMs PRO PROJEKT.
+
+Persistenz: /shared/config/project_vms.json  →  { project_id: [ {vm}, ... ] }.
+Eine VM = {name, arch, iso, vnc_display, mem, created_at, updated_at}. Der echte
+Start/Stop laeuft ueber `aria-vm` auf dem Host (SSH aria-wohnung, siehe main.py);
+diese Datei haelt nur die Zuordnung VM ↔ Projekt + die Startparameter, damit die
+Liste im Desktop-Panel der App pro Projekt erscheint (auch wenn leer).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from pathlib import Path
+from typing import Optional
+
+VMS_FILE = Path(os.environ.get("PROJECT_VMS_FILE", "/shared/config/project_vms.json"))
+NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{1,40}$")
+VALID_ARCH = {"x86_64", "amd64", "i386", "i686", "x86", "arm", "aarch64",
+              "mips", "mipsel", "mips64", "ppc", "ppc64", "riscv64", "sparc"}
+
+
+def _load() -> dict:
+    if not VMS_FILE.exists():
+        return {}
+    try:
+        data = json.loads(VMS_FILE.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _save(data: dict) -> None:
+    VMS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = VMS_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    tmp.replace(VMS_FILE)
+
+
+def list_vms(project_id: str) -> list[dict]:
+    return _load().get(project_id or "", [])
+
+
+def get_vm(project_id: str, name: str) -> Optional[dict]:
+    for v in list_vms(project_id):
+        if v.get("name") == name:
+            return v
+    return None
+
+
+def _used_displays(data: dict, exclude: object = None) -> set:
+    """Alle VNC-Displays, die ueber ALLE Projekte belegt sind (exclude = eine
+    VM-Dict-Instanz, die ignoriert wird — fuer Updates)."""
+    used = set()
+    for lst in data.values():
+        for v in lst:
+            if v is exclude:
+                continue
+            try:
+                used.add(int(v.get("vnc_display", 1)))
+            except (TypeError, ValueError):
+                pass
+    return used
+
+
+def add_vm(project_id: str, name: str, arch: str, iso: str = "",
+           floppy: str = "", disk: str = "",
+           vnc_display: int = 0, mem: int = 1024) -> dict:
+    """Registriert/aktualisiert eine VM. Medien (disk/floppy/iso) optional —
+    leer = aria-vm erkennt disk.qcow2/floppy.img/cdrom.iso im VM-Ordner selbst.
+
+    Das VNC-Display wird GLOBAL eindeutig vergeben (ueber alle Projekte), damit
+    mehrere laufende VMs nicht denselben Port doppelt binden. vnc_display<=0 oder
+    ein bereits belegtes Display → automatisch das naechste freie."""
+    if not NAME_RE.match(name or ""):
+        raise ValueError(f"Ungueltiger VM-Name: {name!r} (nur a-z0-9_-, max 40)")
+    if arch not in VALID_ARCH:
+        raise ValueError(f"Unbekannte Architektur: {arch!r}")
+    data = _load()
+    lst = data.setdefault(project_id or "", [])
+    now = int(time.time())
+    existing = next((v for v in lst if v.get("name") == name), None)
+
+    used = _used_displays(data, exclude=existing)
+    req = int(vnc_display or 0)
+    if req <= 0 and existing:              # Update ohne Display-Wunsch → behalten
+        req = int(existing.get("vnc_display", 0) or 0)
+    if req <= 0 or req in used:            # frei/eindeutig machen
+        req = 1
+        while req in used:
+            req += 1
+
+    fields = {"arch": arch, "iso": iso, "floppy": floppy, "disk": disk,
+              "vnc_display": req, "mem": int(mem), "updated_at": now}
+    if existing:
+        existing.update(fields)
+        _save(data)
+        return existing
+    vm = {"name": name, "created_at": now, **fields}
+    lst.append(vm)
+    _save(data)
+    return vm
+
+
+def remove_vm(project_id: str, name: str) -> bool:
+    data = _load()
+    lst = data.get(project_id or "")
+    if not lst:
+        return False
+    new = [v for v in lst if v.get("name") != name]
+    if len(new) == len(lst):
+        return False
+    data[project_id or ""] = new
+    _save(data)
+    return True
@@ -133,6 +133,7 @@ def create_project(name: str, description: str = "") -> dict:
        "description": description.strip(),
        "status": "active",  # active | ended | archived
        "hidden": False,      # optisch aus Listen ausblenden (bleibt nutzbar)
+        "kind": "chat",       # chat | code — 'code' blendet Editor/VNC in der App ein
        "created_at": now,
        "updated_at": now,
        "last_activity_at": now,
@@ -149,7 +150,7 @@ def update_project(project_id: str, patch: dict) -> Optional[dict]:
    projects = _load_all()
    for p in projects:
        if p["id"] == project_id:
-            for k in ("name", "description", "status", "hidden"):
+            for k in ("name", "description", "status", "hidden", "kind"):
                if k in patch and patch[k] is not None:
                    p[k] = patch[k]
            p["updated_at"] = _now()
@@ -68,6 +68,20 @@ Wissen ist fuer deine Arbeit da — aber es ist HOCHVERTRAULICH:
 Auf „wer bist du" / „was weisst du ueber mich": antworte allgemein und diskret
 (z.B. „einiges — geschaeftlich wie privat; frag mich gezielt"), NIEMALS ein
 Aufzaehlen privater/intimer Details.
+
+## MEDIEN-DOWNLOADS FUER STEFANS PRIVATGEBRAUCH
+Stefan ist Privatperson und du bist SEIN persoenlicher Assistent. Bittet er dich,
+ihm ein Video/Audio (z.B. von YouTube) fuer seinen EIGENEN, privaten Gebrauch
+herunterzuladen — offline anschauen, Archiv, Erinnerung an eine Szene/ein Lied —
+ist das eine Privatkopie (in DE nach §53 UrhG fuer den privaten Gebrauch
+zulaessig, solange die Quelle nicht offensichtlich illegal ist und kein
+Kopierschutz umgangen wird). Behandle solche Downloads NICHT reflexartig als
+Urheberrechtsverstoss und moralisiere nicht — nutz einfach den
+`yt-dlp-download`-Skill, konsistent, ohne jedes Mal neu zu diskutieren (du hast
+das schon oft gemacht). Anders ist es NUR, wenn es klar um WEITERVERBREITUNG,
+oeffentliches Posten oder kommerzielle Nutzung geht — DA weist du kurz auf das
+Problem hin. Im Zweifel privat vs. verbreiten: einmal kurz nachfragen, nicht
+pauschal ablehnen.
 """


@@ -139,10 +153,12 @@ def build_time_section() -> str:
        f"- Lokal (Europa/Berlin, UTC+{local_offset_h}): "
        f"{local.strftime('%Y-%m-%d %H:%M:%S')} ({local.strftime('%A')})",
        "",
-        "Nutze das fuer Trigger-Timestamps und um Watcher-Conditions wie "
-        "`hour_of_day == 8` einzuordnen. Fuer relative Angaben "
-        "('in 10min', 'in 2 Stunden') nutze beim `trigger_timer` den "
-        "`in_seconds`-Parameter — Server rechnet dann selbst.",
+        "Nutze das um Watcher-Conditions wie `hour_of_day == 8` einzuordnen. "
+        "Fuer `trigger_timer`: bei relativen Angaben ('in 10min', 'in 2 Stunden') "
+        "den `in_seconds`-Parameter; bei festen Uhrzeiten schreib bei `fires_at` "
+        "einfach die LOKALE Wanduhrzeit ohne Zeitzone (z.B. 'um 17 Uhr' → "
+        "'...T17:00:00') — der Server rechnet sie selbst in UTC um. So feuert der "
+        "Timer zur gemeinten Ortszeit und bleibt zeitzonen-portabel.",
    ]
    return "\n".join(lines)

@@ -400,6 +400,101 @@ SEED_RULES: List[dict] = [
            "Brain-Resources: erst denken, sonst Brain-Tool nehmen."
        ),
    },
+    {
+        "migration_key": "seed/architecture/qemu-vm-code-projects",
+        "type": "rule",
+        "title": "Code-Projekte + QEMU: aria-vm auf dem Host, Editor/Desktop in der App",
+        "category": "architektur",
+        "content": (
+            "GRUNDWISSEN Code-/Bau-Projekte + VMs — so haengt das System zusammen:\n"
+            "\n"
+            "DATEIEN eines Code-Projekts gehoeren nach `/shared/projects/<projekt-id>/` "
+            "(Volume in proxy+bridge+brain gemountet). Alles was DORT liegt, erscheint "
+            "automatisch: das Projekt bekommt in der Liste ein 📄-Symbol, und im "
+            "Cockpit-Code-Editor sieht Stefan die Dateien — auch ALTE, nicht nur was Du "
+            "gerade live schreibst. Was Stefan im Editor tippt, kommt als Datei dorthin "
+            "zurueck. (Ein manuelles set_project_kind gibt's noch, ist aber optional — "
+            "die Dateipraesenz ist der eigentliche Indikator.)\n"
+            "\n"
+            "VMs (QEMU, JEDE Architektur: x86/i386, ARM/aarch64, MIPS, PPC, RISC-V, "
+            "SPARC) laufen auf dem HOST (die qemu-Tools liegen in aria-wohnung, die "
+            "Projektdateien in /shared). Du steuerst sie per `ssh aria-wohnung aria-vm ...`:\n"
+            "  - `aria-vm create <name> <arch> [groesse]` — legt eine VM an. groesse=\n"
+            "    '10G' → Festplatte (qcow2); groesse='none' → OHNE Disk (fuer OS-Bau, "
+            "    bootet von Diskette/ISO).\n"
+            "  - `aria-vm boot <name> [optionen]` — startet sie (daemonized). Optionen:\n"
+            "      --iso <pfad>       von CD/ISO booten\n"
+            "      --floppy <pfad>    von Diskette booten (-fda, klassisch OS-Dev)\n"
+            "      --disk <pfad>      explizite qcow2\n"
+            "      --vnc-display <N>  VNC-Display (Default 1 → Port 5901; mehrere VMs = "
+            "verschiedene N)\n"
+            "      --mem <MB>         RAM (Default 1024)\n"
+            "    Medien im VM-Ordner (disk.qcow2/floppy.img/cdrom.iso) werden auto-"
+            "erkannt. Es MUSS mindestens ein Boot-Medium da sein.\n"
+            "  - `aria-vm screenshot <name>` → PNG (an Stefan per [FILE:] schickbar).\n"
+            "  - `aria-vm list` / `aria-vm stop <name>` / `aria-vm rm <name>`.\n"
+            "\n"
+            "PFLICHT nach dem Bau/Boot: `vm_register(name, arch, disk?/floppy?/iso?, "
+            "mem?)` im aktuellen Projekt aufrufen — mit den Medien, die Du gebaut hast. "
+            "vnc_display WEGLASSEN — es wird global eindeutig auto-vergeben (kein "
+            "Port-Konflikt, wenn mehrere VMs laufen). ERST DANN erscheint die VM in "
+            "Stefans Desktop-Panel (Cockpit), "
+            "wo er sie Starten/Stoppen/Verbinden kann. Ohne vm_register bleibt seine "
+            "Liste leer, obwohl die VM laeuft. Der Startbefehl steht als Wert dahinter.\n"
+            "\n"
+            "URTEIL — bau eine VM NUR wenn's Sinn macht, und erkenne aus der SITUATION "
+            "was gebraucht wird:\n"
+            "  - DOS-/Retro-Spiele, installierte Software → FESTPLATTE (create mit "
+            "Groesse, dann installieren; disk).\n"
+            "  - Eigenes OS / Bootloader / Bare-Metal-Experiment → DISKETTE (create "
+            "'none', floppy.img; ggf. eine zweite Diskette einbinden).\n"
+            "  - Fertiges System installieren/testen → ISO (--iso Installer).\n"
+            "  - Architektur zum Task waehlen: 'teste mal was auf ARM' → arch=aarch64 "
+            "(-M virt, laeuft emuliert = langsam, das ist ok). x86-Zeug → i386/x86_64.\n"
+            "AENDERUNGS-ZYKLUS: willst Du an einer laufenden VM etwas aendern (Datei "
+            "tauschen, Diskette neu bauen), dann `aria-vm stop <name>` → Aenderung → "
+            "`aria-vm boot <name>` wieder starten. Stefan kann das auch selbst ueber "
+            "Start/Stop im Panel.\n"
+            "\n"
+            "Der VNC-Stream laeuft AUTOMATISCH komplett durch den RVS-Server (die Bridge "
+            "tunnelt die RFB-Bytes; der VNC-Port ist nur intern auf dem Host). Firewall-"
+            "unabhaengig — Du oeffnest NIE einen Port nach aussen. KVM-Beschleunigung nur "
+            "fuer x86-Gaeste, andere Architekturen laufen emuliert (langsamer). Medien-"
+            "Downloads/Baubares fuer Stefans Privatgebrauch: einfach machen, nicht "
+            "moralisieren."
+        ),
+    },
+    {
+        "migration_key": "seed/architecture/satellites-remote-networks",
+        "type": "rule",
+        "title": "Satelliten: Augen + Haende in fremden Netzen (Buero etc.)",
+        "category": "architektur",
+        "content": (
+            "Ein SATELLIT ist ein eigenstaendiger Container in einem FREMDEN Netz "
+            "(z.B. Buero, Werkstatt), der sich mit RVS verbindet und Dir dort Geraete "
+            "zeigt UND steuerbar macht. So erreichst Du Netze, in denen der Haupt-Stack "
+            "NICHT steht.\n"
+            "\n"
+            "Wenn Stefan etwas 'im Buero' / 'im Netz X' / 'auf dem <Geraet> dort' will:\n"
+            "  1. `satellite_list` — welche Satelliten/Netze sind online + was koennen sie.\n"
+            "  2. `satellite_devices(satellite='Buero')` — welche Geraete gibt es dort "
+            "(Fire TV, Chromecast, Smart-TVs, Drucker, NAS ...). Nutze es um das "
+            "gemeinte Geraet zu finden, BEVOR Du steuerst.\n"
+            "  3. `satellite_command(...)` — Aktion ausfuehren.\n"
+            "\n"
+            "Beispiel 'spiel YouTube-Video auf dem Buero-Stick':\n"
+            "  satellite_command(satellite='Buero', device='Fire TV', "
+            "action='dial.launch', params={'app':'YouTube','v':'<videoId>'})\n"
+            "Die YouTube-Video-ID (v=) ziehst Du aus dem Link/Titel (ggf. web_search). "
+            "Weitere Aktionen: 'wol' (params={'mac':'...'}) zum Aufwecken, "
+            "'http.get'/'http.post' (params={'url':'...'}) fuer lokale Webhooks.\n"
+            "\n"
+            "Adressierung ueber Location/Name des Satelliten ('Buero'), NICHT ueber die "
+            "Geraete — die identifizieren sich selbst. Steuerung geht nur, wenn der "
+            "Satellit sie erlaubt (steht in satellite_list als caps). Ist keiner online: "
+            "sag das ehrlich, statt zu raten."
+        ),
+    },
    {
        "migration_key": "seed/architecture/brain-tools-xml-tag",
        "type": "rule",
@@ -24,7 +24,7 @@ import os
 import re
 import shutil
 import time
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Optional

@@ -40,6 +40,29 @@ def _now_iso() -> str:
    return datetime.now(timezone.utc).isoformat()


+def _local_offset_hours(dt: datetime) -> int:
+    """Grobe Europe/Berlin-Naeherung (CEST=+2 Maerz-Okt, sonst CET=+1) — dieselbe
+    Logik wie build_time_section im Prompt, ohne zoneinfo/tzdata im Brain-Image."""
+    return 2 if 3 <= dt.month <= 10 else 1
+
+
+def normalize_fires_at_utc(iso: str) -> str:
+    """Bringt einen fires_at-ISO IMMER auf UTC (+00:00).
+
+    - Aware (endet auf Z oder hat einen Offset) → in UTC umgerechnet.
+    - Naiv (keine Zone) → als LOKALE Wanduhrzeit (Europe/Berlin) interpretiert
+      und nach UTC umgerechnet.
+
+    So speichern wir stets den absoluten Instant. Die Ausfuehrung (background.py,
+    UTC) trifft damit exakt die vom Nutzer gemeinte Ortszeit — und bleibt
+    zeitzonen-portabel (feuert am selben Moment, egal wo Stefan gerade ist)."""
+    dt = datetime.fromisoformat((iso or "").strip().replace("Z", "+00:00"))
+    if dt.tzinfo is None:
+        # Naiv = lokale Wanduhrzeit → UTC = lokal - Offset.
+        dt = (dt - timedelta(hours=_local_offset_hours(dt))).replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc).isoformat(timespec="seconds")
+
+
 def _safe_name(name: str) -> str:
    if not isinstance(name, str) or not NAME_RE.match(name):
        raise ValueError(f"Ungueltiger Trigger-Name: {name!r}")
@@ -127,9 +150,10 @@ def create_timer(
    _safe_name(name)
    if _path(name).exists():
        raise ValueError(f"Trigger '{name}' existiert schon")
-    # ISO validieren
+    # ISO validieren UND auf UTC normalisieren (naiv = lokale Wanduhrzeit →
+    # UTC). So passt das Anlegen zur UTC-Ausfuehrung in background.py.
    try:
-        datetime.fromisoformat(fires_at_iso.replace("Z", "+00:00"))
+        fires_at_iso = normalize_fires_at_utc(fires_at_iso)
    except Exception:
        raise ValueError(f"fires_at_iso ungueltig: {fires_at_iso}")
    data = {
@@ -43,6 +43,25 @@ from openwakeword.model import Model as WakeWordModel

 from modes import Mode, canonical_id, detect_mode_switch, mode_from_id, should_speak

+
+def _docker_gateway() -> str:
+    """Docker-Gateway-IP (= Host-IP auf DIESEM Container-Netz, aria-net) aus
+    /proc/net/route. Genau die IP, an die der Brain QEMUs VNC bindet — im
+    Gegensatz zu host.docker.internal, das auf die Default-Bridge (docker0)
+    zeigt und daher die VM nicht trifft."""
+    try:
+        import socket as _sock
+        import struct as _struct
+        with open("/proc/net/route") as f:
+            for line in f.readlines()[1:]:
+                fields = line.strip().split()
+                if len(fields) >= 4 and fields[1] == "00000000" and int(fields[3], 16) & 2:
+                    return _sock.inet_ntoa(_struct.pack("<L", int(fields[2], 16)))
+    except Exception:
+        pass
+    return ""
+
+
 # ── Logging ──────────────────────────────────────────────────

 logging.basicConfig(
@@ -734,6 +753,19 @@ class ARIABridge:
        # Beeinflusst das Timeout fuer stt_request — bei "loading" warten wir laenger,
        # weil das Modell beim ersten Request noch ~1-2 Min runtergeladen werden kann.
        self._remote_stt_ready: bool = False
+        # VNC-Tunnel (Workspace-Desktop): session → {"writer": StreamWriter,
+        # "task": asyncio.Task}. Wir bruecken rohes RFB-TCP (QEMU-VNC auf dem
+        # Host) <-> RVS (vnc_data/vnc_input, Base64-in-JSON).
+        self._vnc_sessions: dict[str, dict] = {}
+        # VNC-Host: das aria-net-Gateway (dort bindet der Brain QEMUs VNC).
+        # host.docker.internal zeigt faelschlich auf docker0 (172.17.0.1) → refused.
+        self._vnc_host: str = (os.environ.get("ARIA_VNC_HOST")
+                               or _docker_gateway() or "host.docker.internal")
+        # Satelliten (Aussenposten in fremden Netzen). id → {location, caps,
+        # control, last_seen}. Registrierung via sat_hello. _pending_sat:
+        # requestId → Future (sat_devices / sat_result), analog _pending_flux.
+        self._satellites: dict[str, dict] = {}
+        self._pending_sat: dict[str, asyncio.Future] = {}
        # FLUX-Render-Requests die aktuell auf Antwort der flux-bridge (Gamebox) warten.
        # requestId → Future mit dem flux_response-Payload (oder None bei Fehler).
        self._pending_flux: dict[str, asyncio.Future] = {}
@@ -2002,10 +2034,15 @@ class ARIABridge:
            elif etype == "project_changed":
                # ARIA hat ein Projekt erstellt / betreten / verlassen / beendet.
                # App + Diagnostic refreshen ihren Projekt-Banner anhand des Events.
+                # clientMsgId der ausloesenden Anfrage mitgeben (Text-cmid oder
+                # Voice-audioRequestId) → das ausloesende Geraet kann einen
+                # geraete-lokalen Projektwechsel machen ("geh in Projekt X"),
+                # ohne andere App-/Diagnostic-Instanzen mitzuziehen.
                await self._send_to_rvs({
                    "type": "project_changed",
                    "payload": {
                        "action": event.get("action") or "",
+                        "clientMsgId": client_msg_id or "",
                        **(event.get("project") or {}),
                    },
                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
@@ -3351,6 +3388,82 @@ class ARIABridge:
                    logger.info("[rvs] flux-bridge -> %s", state)
            return

+        elif msg_type == "code_file_edit":
+            # Stefan hat im Live-Editor getippt → Datei im Projekt-Arbeits-
+            # verzeichnis (/shared/projects/<pid>/) mit dem Volltext ueberschreiben.
+            # ARIA sieht die Aenderung beim naechsten Read.
+            pid = str(payload.get("projectId") or "")
+            rel = (payload.get("path") or "").strip()
+            full_text = payload.get("fullText")
+            if rel and isinstance(full_text, str):
+                ok = self._write_project_file(pid, rel, full_text)
+                logger.info("[rvs] code_file_edit %s/%s (%d chars) → %s",
+                            pid or "main", rel, len(full_text), "ok" if ok else "abgelehnt")
+            return
+
+        elif msg_type == "check_desktop":
+            session = str(payload.get("session") or "main")
+            try:
+                port = int(payload.get("port") or 5901)
+            except (TypeError, ValueError):
+                port = 5901
+            asyncio.create_task(self._check_desktop(session, port))
+            return
+
+        elif msg_type == "vnc_open":
+            session = str(payload.get("session") or "main")
+            try:
+                port = int(payload.get("port") or 5901)
+            except (TypeError, ValueError):
+                port = 5901
+            asyncio.create_task(self._vnc_open(session, port))
+            return
+
+        elif msg_type == "vnc_close":
+            session = str(payload.get("session") or "main")
+            asyncio.create_task(self._vnc_close(session))
+            return
+
+        elif msg_type == "vnc_input":
+            session = str(payload.get("session") or "main")
+            b64 = payload.get("b64") or ""
+            sess = self._vnc_sessions.get(session)
+            if sess and b64:
+                try:
+                    data = base64.b64decode(b64)
+                    sess["writer"].write(data)
+                    # drain nicht awaiten (wir sind synchron im Dispatcher) —
+                    # write puffert, der Kernel-Socket schluckt RFB-Input locker.
+                except Exception as exc:
+                    logger.warning("[vnc] input schreiben (%s) fehlgeschlagen: %s", session, exc)
+            return
+
+        elif msg_type == "sat_hello":
+            sid = (payload.get("id") or "").strip()
+            if sid:
+                self._satellites[sid] = {
+                    "id": sid,
+                    "location": payload.get("location") or sid,
+                    "caps": payload.get("caps") or [],
+                    "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"])
+            return
+
+        elif msg_type in ("sat_devices", "sat_result"):
+            req_id = payload.get("requestId", "")
+            future = self._pending_sat.get(req_id)
+            if future is not None and not future.done():
+                future.set_result(payload)
+            # last_seen aktualisieren
+            sid = (payload.get("satellite") or "").strip()
+            if sid and sid in self._satellites:
+                self._satellites[sid]["last_seen"] = time.time()
+            return
+
        elif msg_type == "config_request":
            # Eine andere Bridge (whisper/f5tts) bittet um die aktuelle Voice-
            # Config — passiert wenn sie sich connected, weil sie sonst die
@@ -3563,8 +3676,11 @@ class ARIABridge:
        )

        if meta_action in ("back_to_main", "project_prefix"):
-            # UI-Focus-Update broadcasten
-            payload = {"action": "entered" if meta_action == "project_prefix" else "exited"}
+            # UI-Focus-Update broadcasten — clientMsgId (= audio_request_id der
+            # Aufnahme) mitgeben, damit NUR das Geraet folgt, das den Sprach-
+            # befehl gab (geraete-lokaler Fokus, keine anderen Instanzen ziehen).
+            payload = {"action": "entered" if meta_action == "project_prefix" else "exited",
+                       "clientMsgId": audio_request_id or ""}
            if meta_action == "project_prefix" and project_id:
                # Namen aus dem Cache holen — best effort
                try:
@@ -4192,6 +4308,54 @@ class ARIABridge:
                        "timestamp": int(time.time() * 1000),
                    }))
                    await _send_response(writer, 200, {"ok": True})
+                elif method == "POST" and path == "/internal/code-file":
+                    # Vom Proxy-Hook gefeuert wenn ARIA in einem Code-Projekt eine
+                    # Datei schreibt/aendert. Wir spiegeln das als RVS code_file an
+                    # die App (Live-Code-Editor). payload: {projectId, path,
+                    # language?, content?, patch?, version?}.
+                    try:
+                        data = json.loads(body.decode("utf-8", "ignore"))
+                    except Exception as exc:
+                        await _send_response(writer, 400, {"error": f"bad json: {exc}"})
+                        return
+                    fpath = (data.get("path") or "").strip()
+                    if not fpath:
+                        await _send_response(writer, 400, {"error": "path erforderlich"})
+                        return
+                    asyncio.create_task(self._send_to_rvs({
+                        "type": "code_file",
+                        "payload": {
+                            "projectId": str(data.get("projectId") or ""),
+                            "path": fpath,
+                            "language": data.get("language") or "",
+                            "content": data.get("content"),
+                            "patch": data.get("patch"),
+                            "version": data.get("version") or 0,
+                        },
+                        "timestamp": int(time.time() * 1000),
+                    }))
+                    await _send_response(writer, 200, {"ok": True})
+                elif method == "POST" and path == "/internal/satellite-list":
+                    # Brain fragt: welche Satelliten/Netze sind online + Capabilities.
+                    await _send_response(writer, 200, {"ok": True, "satellites": self._satellite_list()})
+                elif method == "POST" and path == "/internal/satellite":
+                    # Brain-Tool: Discovery oder Command an einen Satelliten.
+                    # body: {op:'discover'|'command', satellite, device?, action?, params?}
+                    try:
+                        data = json.loads(body.decode("utf-8", "ignore"))
+                    except Exception as exc:
+                        await _send_response(writer, 400, {"error": f"bad json: {exc}"})
+                        return
+                    op = (data.get("op") or "discover").strip()
+                    result = await self._satellite_request(
+                        op=op,
+                        satellite=str(data.get("satellite") or ""),
+                        device=str(data.get("device") or ""),
+                        action=str(data.get("action") or ""),
+                        params=data.get("params") if isinstance(data.get("params"), dict) else {},
+                        timeout=float(data.get("timeout") or 20.0),
+                    )
+                    await _send_response(writer, 200, result)
                elif method == "POST" and path == "/internal/flux-generate":
                    # Vom Brain (flux_generate-Tool) gefeuert. Wir routen den
                    # Render-Request via RVS an die flux-bridge (Gamebox),
@@ -4301,6 +4465,164 @@ class ARIABridge:
        except Exception:
            logger.exception("[bridge] Internal HTTP-Listener konnte nicht starten")

+    def _write_project_file(self, project_id: str, rel_path: str, content: str) -> bool:
+        """Schreibt content nach /shared/projects/<project_id>/<rel_path>.
+
+        Pfad-sicher: rel_path darf nicht aus dem Projekt-Basisverzeichnis
+        ausbrechen (kein .., kein absoluter Pfad). Legt Verzeichnisse an.
+        """
+        try:
+            base = Path("/shared/projects") / (project_id or "main")
+            base = base.resolve()
+            target = (base / rel_path).resolve()
+            if base != target and base not in target.parents:
+                logger.warning("[code_file] Pfad ausserhalb Projekt abgelehnt: %s", rel_path)
+                return False
+            target.parent.mkdir(parents=True, exist_ok=True)
+            tmp = target.with_suffix(target.suffix + ".tmp")
+            tmp.write_text(content, encoding="utf-8")
+            tmp.replace(target)
+            return True
+        except Exception as exc:
+            logger.warning("[code_file] Schreiben fehlgeschlagen %s/%s: %s", project_id, rel_path, exc)
+            return False
+
+    async def _check_desktop(self, session: str, port: int) -> None:
+        """Probt ob auf dem Host eine QEMU-VNC laeuft und meldet desktop_status."""
+        available = False
+        try:
+            fut = asyncio.open_connection(self._vnc_host, port)
+            reader, writer = await asyncio.wait_for(fut, timeout=2.0)
+            available = True
+            writer.close()
+            try:
+                await writer.wait_closed()
+            except Exception:
+                pass
+        except Exception:
+            available = False
+        await self._send_to_rvs({
+            "type": "desktop_status",
+            "payload": {
+                "available": available,
+                "session": session,
+                "message": (f"Desktop laeuft (VNC {self._vnc_host}:{port})" if available
+                            else "Kein Desktop verbunden"),
+            },
+            "timestamp": int(time.time() * 1000),
+        })
+
+    async def _vnc_open(self, session: str, port: int) -> None:
+        """Oeffnet die TCP-Verbindung zur QEMU-VNC und streamt RFB-Bytes als
+        vnc_data ueber RVS. Bestehende Session wird vorher geschlossen."""
+        await self._vnc_close(session)
+        try:
+            reader, writer = await asyncio.open_connection(self._vnc_host, port)
+        except Exception as exc:
+            logger.warning("[vnc] open %s:%d fehlgeschlagen: %s", self._vnc_host, port, exc)
+            await self._send_to_rvs({
+                "type": "desktop_status",
+                "payload": {"available": False, "session": session,
+                            "message": f"VNC-Verbindung fehlgeschlagen: {exc}"},
+                "timestamp": int(time.time() * 1000),
+            })
+            return
+        task = asyncio.create_task(self._vnc_reader_loop(session, reader))
+        self._vnc_sessions[session] = {"writer": writer, "task": task}
+        logger.info("[vnc] Tunnel offen: session=%s → %s:%d", session, self._vnc_host, port)
+
+    async def _vnc_reader_loop(self, session: str, reader: asyncio.StreamReader) -> None:
+        try:
+            while True:
+                data = await reader.read(16384)
+                if not data:
+                    break
+                await self._send_to_rvs({
+                    "type": "vnc_data",
+                    "payload": {"session": session, "b64": base64.b64encode(data).decode("ascii")},
+                    "timestamp": int(time.time() * 1000),
+                })
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.info("[vnc] reader-loop (%s) beendet: %s", session, exc)
+        finally:
+            # TCP-Ende → App informieren (Desktop weg).
+            if session in self._vnc_sessions:
+                await self._send_to_rvs({
+                    "type": "desktop_status",
+                    "payload": {"available": False, "session": session, "message": "VNC-Verbindung beendet"},
+                    "timestamp": int(time.time() * 1000),
+                })
+
+    async def _vnc_close(self, session: str) -> None:
+        sess = self._vnc_sessions.pop(session, None)
+        if not sess:
+            return
+        task = sess.get("task")
+        if task:
+            task.cancel()
+            try:
+                await task
+            except (asyncio.CancelledError, Exception):
+                pass
+        writer = sess.get("writer")
+        if writer:
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except Exception:
+                pass
+        logger.info("[vnc] Tunnel geschlossen: session=%s", session)
+
+    def _satellite_list(self) -> list[dict]:
+        """Bekannte Satelliten (frisch = in den letzten 5 Min gesehen)."""
+        now = time.time()
+        out = []
+        for s in self._satellites.values():
+            out.append({
+                "id": s["id"], "location": s.get("location") or s["id"],
+                "caps": s.get("caps") or [], "control": bool(s.get("control")),
+                "online": (now - s.get("last_seen", 0)) < 300,
+            })
+        return out
+
+    async def _satellite_request(self, op: str, satellite: str = "",
+                                 device: str = "", action: str = "",
+                                 params: Optional[dict] = None,
+                                 timeout: float = 20.0) -> dict:
+        """Schickt sat_discover / sat_command an einen Satelliten (via RVS) und
+        wartet auf sat_devices / sat_result. op = 'discover' | 'command'.
+        Muster identisch zu _flux_generate (requestId → Future)."""
+        if self.ws_rvs is None:
+            return {"ok": False, "error": "RVS-Verbindung nicht aktiv"}
+        request_id = str(uuid.uuid4())
+        loop = asyncio.get_event_loop()
+        future: asyncio.Future = loop.create_future()
+        self._pending_sat[request_id] = future
+        try:
+            if op == "discover":
+                msg = {"type": "sat_discover",
+                       "payload": {"requestId": request_id, "satellite": satellite,
+                                   "force": bool((params or {}).get("force"))}}
+            else:
+                msg = {"type": "sat_command",
+                       "payload": {"requestId": request_id, "satellite": satellite,
+                                   "device": device, "action": action,
+                                   "params": params or {}}}
+            msg["timestamp"] = int(time.time() * 1000)
+            ok = await self._send_to_rvs(msg)
+            if not ok:
+                return {"ok": False, "error": "Satellit-Request konnte nicht gesendet werden"}
+            result = await asyncio.wait_for(future, timeout=timeout)
+            return result if isinstance(result, dict) else {"ok": False, "error": "ungueltige Antwort"}
+        except asyncio.TimeoutError:
+            return {"ok": False, "error": f"Satellit '{satellite or 'all'}' antwortet nicht (Timeout)."}
+        except Exception as exc:
+            return {"ok": False, "error": str(exc)}
+        finally:
+            self._pending_sat.pop(request_id, None)
+
    async def _delete_chat_message(self, ts: int) -> dict:
        """Entfernt eine Bubble: aus chat_backup.jsonl + Brain conversation,
        broadcastet chat_message_deleted via RVS.
@@ -229,6 +229,7 @@
    <button class="main-nav-btn" onclick="switchMainTab('skills')">Skills</button>
    <button class="main-nav-btn" onclick="switchMainTab('triggers')">Trigger</button>
    <button class="main-nav-btn" onclick="switchMainTab('files')">Dateien</button>
+    <button class="main-nav-btn" onclick="switchMainTab('satellites')">Satelliten</button>
    <button class="main-nav-btn" onclick="switchMainTab('settings')">Einstellungen</button>
  </div>

@@ -1271,6 +1272,27 @@
    </div>
  </div><!-- /tab-triggers -->

+  <!-- ══════ TAB: Satelliten ══════ -->
+  <div id="tab-satellites" class="main-tab">
+    <div class="settings-section">
+      <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:8px;">
+        <h2 style="margin:0;">Satelliten 🛰️</h2>
+        <button class="btn secondary" onclick="requestSatellites()" style="padding:4px 10px;font-size:11px;">Aktualisieren</button>
+      </div>
+      <div class="card" style="margin-bottom:8px;">
+        <p style="color:#8888AA;font-size:12px;margin:0;">
+          Aussenposten-Container in fremden Netzen (Buero, Werkstatt …), die sich mit
+          RVS verbinden. Hier siehst Du, welche Satelliten online sind und welche
+          Geraete sie im jeweiligen Netz erkannt haben. „Geraete scannen" fragt den
+          Satelliten live ab.
+        </p>
+      </div>
+      <div class="card">
+        <div id="sat-list" style="font-size:12px;color:#8888AA;">(Lade...)</div>
+      </div>
+    </div>
+  </div><!-- /tab-satellites -->
+
  <!-- Trigger-Create/Edit Modal -->
  <div class="modal-overlay" id="trigger-modal">
    <div class="modal-box" style="max-width:600px;">
@@ -1862,6 +1884,14 @@
          return;
        }

+        if (msg.type === 'sat_update') { satellites = msg.satellites || []; renderSatellites(); return; }
+        if (msg.type === 'sat_devices') {
+          if (msg.satellite) { satDevices[msg.satellite] = { devices: msg.devices || [], location: msg.location, ts: Date.now() }; }
+          satScanning = null;
+          renderSatellites();
+          return;
+        }
+
        if (msg.type === 'voice_id_delete_response') {
          const p = msg.payload || msg;
          if (p.removed) {
@@ -3162,14 +3192,17 @@
                <div onclick="switchProject('${p.id}')" style="cursor:pointer;flex:1;">
                  <div style="color:${isActive ? '#34C759' : '#E0E0F0'};font-weight:600;">
                    ${hidden ? '🙈' : '📁'} ${escapeHtml(p.name)}
+                    ${p.has_files ? `<span title="${p.file_count || 0} Dateien in /shared/projects/${escapeHtmlAttr(p.id)}/" style="font-size:11px;margin-left:4px;">📄${p.file_count ? ' ' + p.file_count : ''}</span>` : ''}
                    ${hidden ? '<span style="color:#B392F0;font-size:10px;font-weight:700;margin-left:6px;background:rgba(179,146,240,0.15);padding:2px 6px;border-radius:3px;">versteckt</span>' : ''}
                    ${ended ? '<span style="color:#FFD60A;font-size:10px;font-weight:700;margin-left:6px;background:rgba(255,214,10,0.15);padding:2px 6px;border-radius:3px;">beendet</span>' : ''}
+                    ${p.kind === 'code' ? '<span style="color:#0096FF;font-size:10px;font-weight:700;margin-left:6px;background:rgba(0,150,255,0.15);padding:2px 6px;border-radius:3px;">&lt;/&gt; Code</span>' : ''}
                    ${isActive ? '<span style="color:#34C759;font-size:10px;font-weight:800;margin-left:6px;">✓ AKTIV</span>' : ''}
                  </div>
                  ${p.description ? `<div style="color:#8888AA;font-size:12px;margin-top:2px;">${escapeHtml(p.description)}</div>` : ''}
                  <div style="color:#555570;font-size:11px;margin-top:4px;">${p.turn_count} Turns · zuletzt ${since}</div>
                </div>
                <div style="display:flex;gap:4px;">
+                  <button class="btn secondary" onclick="setProjectKind('${p.id}', '${p.kind === 'code' ? 'chat' : 'code'}')" style="padding:3px 8px;font-size:10px;color:${p.kind === 'code' ? '#0096FF' : '#8888AA'};" title="${p.kind === 'code' ? 'Ist Code-Projekt — klick fuer normalen Chat' : 'Als Code-Projekt markieren (Editor + Desktop im Cockpit)'}">&lt;/&gt;</button>
                  <button class="btn secondary" onclick="setProjectHidden('${p.id}', ${!hidden})" style="padding:3px 8px;font-size:10px;color:${eyeColor};" title="${eyeTitle}">${eyeIcon}</button>
                  ${!ended ? `<button class="btn secondary" onclick="endProject('${p.id}', '${escapeHtmlAttr(p.name)}')" style="padding:3px 8px;font-size:10px;" title="Projekt beenden">⏹</button>` : ''}
                  <button class="btn secondary" onclick="archiveProject('${p.id}', '${escapeHtmlAttr(p.name)}')" style="padding:3px 8px;font-size:10px;color:#E55C5C;" title="Archivieren">🗑</button>
@@ -3216,6 +3249,18 @@
      } catch (e) { alert('Verstecken/Anzeigen fehlgeschlagen: ' + e.message); }
    }

+    async function setProjectKind(id, kind) {
+      try {
+        const r = await fetch(`/api/brain/projects/${encodeURIComponent(id)}`, {
+          method: 'PATCH',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind }),
+        });
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        loadProjects();
+      } catch (e) { alert('Code-Markierung fehlgeschlagen: ' + e.message); }
+    }
+
    async function switchProject(projectId) {
      try {
        await fetch('/api/brain/projects/switch', {
@@ -4045,9 +4090,79 @@
        loadSkills();
      } else if (tab === 'triggers') {
        loadTriggers();
+      } else if (tab === 'satellites') {
+        requestSatellites();
      }
    }

+    // ── Satelliten-Ansicht ─────────────────────────────────
+    let satellites = [];            // [{id, location, caps, control, online}]
+    let satDevices = {};            // id → {devices, location, ts}
+    let satScanning = null;         // id des gerade scannenden Satelliten
+
+    function requestSatellites() {
+      send({ action: 'sat_list' });
+    }
+    function scanSatellite(id) {
+      satScanning = id;
+      renderSatellites();
+      send({ action: 'sat_discover', satellite: id });
+    }
+    function renderSatellites() {
+      const box = document.getElementById('sat-list');
+      if (!box) return;
+      if (!satellites.length) {
+        box.innerHTML = '<span style="color:#8888AA;">Kein Satellit verbunden. ' +
+          'Deploy einen satellite/-Container in einem Netz (siehe satellite/README).</span>';
+        return;
+      }
+      box.innerHTML = satellites.map(s => {
+        const online = s.online !== false;
+        const dot = online ? '#34C759' : '#FF3B30';
+        const caps = (s.caps || []).join(', ') || 'nur beobachten';
+        const ctrl = s.control ? '<span style="color:#0096FF;">steuerbar</span>' : '<span style="color:#8888AA;">read-only</span>';
+        const dev = satDevices[s.id];
+        const scanning = satScanning === s.id;
+        let devHtml;
+        if (scanning) {
+          devHtml = '<div style="color:#FFD60A;margin-top:6px;">Scanne Netz …</div>';
+        } else if (dev) {
+          if (!dev.devices.length) {
+            devHtml = '<div style="color:#8888AA;margin-top:6px;">Keine Geraete gefunden.</div>';
+          } else {
+            devHtml = '<div style="margin-top:6px;display:flex;flex-direction:column;gap:3px;">' +
+              dev.devices.map(d => {
+                const tags = [];
+                if (d.model) tags.push(escapeHtml(d.model));
+                if (d.dialAppUrl) tags.push('DIAL');
+                if (d.mac) tags.push(escapeHtml(d.mac));
+                const tagStr = tags.length ? ' <span style="color:#666;">(' + tags.join(' · ') + ')</span>' : '';
+                return '<div style="padding:3px 6px;background:#0D0D1A;border-radius:4px;">' +
+                  '<span style="color:#E0E0F0;">' + escapeHtml(d.name || d.id || '?') + '</span> ' +
+                  '<span style="color:#0096FF;">[' + escapeHtml(d.type || '?') + ']</span> ' +
+                  '<span style="color:#8888AA;">' + escapeHtml(d.ip || '') + '</span>' + tagStr +
+                  '</div>';
+              }).join('') + '</div>';
+          }
+        } else {
+          devHtml = '<div style="color:#8888AA;margin-top:6px;">Noch nicht gescannt.</div>';
+        }
+        return '<div style="border:1px solid #1E1E2E;border-radius:8px;padding:10px;margin-bottom:8px;">' +
+          '<div style="display:flex;justify-content:space-between;align-items:center;">' +
+          '<div><span style="display:inline-block;width:8px;height:8px;border-radius:50%;background:' + dot + ';margin-right:6px;"></span>' +
+          '<strong style="color:#E0E0F0;">' + escapeHtml(s.location || s.id) + '</strong> ' +
+          '<span style="color:#666;font-size:11px;">id=' + escapeHtml(s.id) + '</span></div>' +
+          '<button class="btn secondary" onclick="scanSatellite(\'' + escapeHtml(s.id) + '\')" style="padding:3px 8px;font-size:11px;"' +
+          (scanning ? ' disabled' : '') + '>Geraete scannen</button>' +
+          '</div>' +
+          '<div style="color:#8888AA;font-size:11px;margin-top:4px;">kann: ' + escapeHtml(caps) + ' · ' + ctrl +
+          (s.net && s.net.primary_ip ? ' · Netz: ' + escapeHtml(s.net.primary_ip) : '') + '</div>' +
+          (s.net && s.net.warning ? '<div style="color:#FF6E6E;font-size:11px;margin-top:6px;padding:6px;background:#3A1F1F;border-radius:4px;">⚠ ' + escapeHtml(s.net.warning) + '</div>' : '') +
+          devHtml +
+          '</div>';
+      }).join('');
+    }
+
    // ── Triggers-Verwaltung ────────────────────────────────
    let triggersCache = [];

@@ -475,6 +475,21 @@ function broadcastState() {
  broadcast({ type: "state", state });
 }

+// ── Satelliten-Registry (Aussenposten in fremden Netzen) ──────────
+const satellites = new Map(); // id → {id, location, caps, control, last_seen}
+
+function satelliteList() {
+  const now = Date.now();
+  return Array.from(satellites.values()).map(s => ({
+    id: s.id, location: s.location, caps: s.caps, control: s.control, net: s.net || null,
+    online: (now - (s.last_seen || 0)) < 300000,
+  }));
+}
+
+function broadcastSatellites() {
+  broadcast({ type: "sat_update", satellites: satelliteList() });
+}
+
 // ── OpenClaw Gateway Verbindung ─────────────────────────

 async function connectGateway() {
@@ -903,6 +918,23 @@ function connectRVS(forcePlain) {
        // Browser-Tabs weiterreichen, damit die Projektliste live neu laedt
        // (bisher wurde das NICHT geforwardet → Diagnostic aktualisierte nie).
        broadcast({ type: "project_changed", payload: msg.payload || {} });
+      } else if (msg.type === "sat_hello") {
+        // Ein Satellit (Aussenposten in einem fremden Netz) meldet sich.
+        const p = msg.payload || {};
+        if (p.id) {
+          satellites.set(p.id, {
+            id: p.id, location: p.location || p.id,
+            caps: p.caps || [], control: !!p.control, net: p.net || null,
+            last_seen: Date.now(),
+          });
+          broadcastSatellites();
+        }
+      } else if (msg.type === "sat_devices") {
+        // Antwort eines Satelliten auf sat_discover → Geraeteliste an Browser.
+        const p = msg.payload || {};
+        if (p.satellite && satellites.has(p.satellite)) satellites.get(p.satellite).last_seen = Date.now();
+        broadcast({ type: "sat_devices", satellite: p.satellite || "",
+                    location: p.location || "", devices: p.devices || [] });
      } else if (msg.type === "agent_activity") {
        // Bridge meldet "ARIA denkt/schreibt/tool" oder "idle" — an Browser
        // weiterreichen, damit der Thinking-Indikator im Chat erscheint.
@@ -2407,6 +2439,8 @@ wss.on("connection", (ws) => {
  ws.send(JSON.stringify({ type: "init", state, logs: logs.slice(-100) }));
  // Letzten Disk-Status mitgeben damit der Client sofort weiss wie's um Platz steht
  if (currentDiskStatus) ws.send(JSON.stringify(currentDiskStatus));
+  // Aktuell bekannte Satelliten mitgeben (RVS replayt sat_hello nicht).
+  ws.send(JSON.stringify({ type: "sat_update", satellites: satelliteList() }));

  ws.on("message", (raw) => {
    try {
@@ -2425,6 +2459,14 @@ wss.on("connection", (ws) => {
        connectGateway();
      } else if (msg.action === "reconnect_rvs") {
        connectRVS();
+      } else if (msg.action === "sat_list") {
+        // Browser will die aktuelle Satelliten-Liste.
+        ws.send(JSON.stringify({ type: "sat_update", satellites: satelliteList() }));
+      } else if (msg.action === "sat_discover") {
+        // Browser triggert einen Geraete-Scan auf einem Satelliten.
+        sendToRVS_raw({ type: "sat_discover",
+                        payload: { satellite: msg.satellite || "", force: true },
+                        timestamp: Date.now() });
      } else if (msg.action === "test_proxy") {
        testProxy(msg.text);
      } else if (msg.action === "check_proxy_auth") {
@@ -120,6 +120,8 @@ services:
      - brain
    networks:
      - aria-net
+    extra_hosts:
+      - "host.docker.internal:host-gateway"        # fuer den VNC-Tunnel zum Host (QEMU)
    ports:
      - "3001:3001"                                # Diagnostic Web-UI (Diagnostic teilt Netzwerk mit Bridge)
    volumes:
@@ -0,0 +1,219 @@
+#!/usr/bin/env bash
+#
+# aria-vm — ARIAs QEMU-VM-Verwaltung fuer alle Architekturen (laeuft auf dem
+# Host). ARIA ruft das per SSH (aria-wohnung) ueber den qemu-vm-Skill auf.
+#
+# Unterkommandos:
+#   aria-vm create  <name> <arch> [size]     Disk anlegen (qcow2)
+#   aria-vm boot    <name> [optionen]        VM starten (VNC 127.0.0.1:<display>)
+#   aria-vm screenshot <name>                PNG-Screenshot → Shared-Uploads
+#   aria-vm list                             laufende/vorhandene VMs
+#   aria-vm stop    <name>                   VM beenden
+#   aria-vm rm      <name>                   VM + Disk loeschen
+#
+# boot-Optionen:
+#   --iso <pfad>        Boot-ISO (setzt Boot-Reihenfolge auf CD)
+#   --disk-boot         von der Festplatte booten (Default nach Installation)
+#   --vnc-display <N>   VNC-Display (Port = 5900+N, Default 1)
+#   --mem <MB>          RAM (Default 1024)
+#   --machine <typ>     QEMU-Maschine ueberschreiben
+#
+# VNC bindet immer nur an 127.0.0.1 — von aussen erreichbar ausschliesslich
+# ueber den RVS-Tunnel der Bridge (host.docker.internal:<port>).
+set -euo pipefail
+
+VM_ROOT="${ARIA_VM_ROOT:-/var/lib/aria-vms}"
+# Wohin Screenshots geschrieben werden — Host-Pfad des /shared-Volumes, damit
+# Bridge/App sie sehen. Ueberschreibbar via ARIA_VM_SHOT_DIR.
+SHOT_DIR="${ARIA_VM_SHOT_DIR:-/root/ARIA-AGENT/aria-shared/uploads}"
+
+die() { echo "aria-vm: $*" >&2; exit 1; }
+
+qemu_bin_for() {
+  case "$1" in
+    x86_64|amd64)   echo qemu-system-x86_64 ;;
+    i386|i686|x86)  echo qemu-system-i386 ;;
+    arm|armv7)      echo qemu-system-arm ;;
+    aarch64|arm64)  echo qemu-system-aarch64 ;;
+    mips)           echo qemu-system-mips ;;
+    mipsel)         echo qemu-system-mipsel ;;
+    mips64)         echo qemu-system-mips64 ;;
+    ppc)            echo qemu-system-ppc ;;
+    ppc64)          echo qemu-system-ppc64 ;;
+    riscv64)        echo qemu-system-riscv64 ;;
+    sparc)          echo qemu-system-sparc ;;
+    *)              echo "" ;;
+  esac
+}
+
+vm_dir()  { echo "${VM_ROOT}/$1"; }
+vm_pid()  { local d; d="$(vm_dir "$1")"; [[ -f "${d}/pid" ]] && cat "${d}/pid" || echo ""; }
+vm_running() {
+  local p; p="$(vm_pid "$1")"
+  [[ -n "${p}" ]] && kill -0 "${p}" 2>/dev/null
+}
+
+cmd_create() {
+  local name="${1:?name}" arch="${2:?arch}" size="${3:-10G}"
+  local bin; bin="$(qemu_bin_for "${arch}")"
+  [[ -n "${bin}" ]] || die "unbekannte Architektur: ${arch}"
+  command -v "${bin}" >/dev/null || die "${bin} nicht installiert (qemu-setup.sh?)"
+  local d; d="$(vm_dir "${name}")"
+  [[ -f "${d}/arch" ]] && die "VM '${name}' existiert schon"
+  mkdir -p "${d}"
+  echo "${arch}" > "${d}/arch"
+  # size='none' oder '0' → keine Festplatte (VM bootet von --iso/--floppy,
+  # z.B. OS-Entwicklung von Diskette). Sonst eine qcow2-Disk anlegen.
+  if [[ "${size}" == "none" || "${size}" == "0" ]]; then
+    echo "VM '${name}' angelegt (${arch}, ohne Disk — bootet von ISO/Diskette)."
+  else
+    qemu-img create -f qcow2 "${d}/disk.qcow2" "${size}" >/dev/null
+    echo "VM '${name}' angelegt (${arch}, ${size})."
+  fi
+}
+
+cmd_boot() {
+  local name="${1:?name}"; shift || true
+  local d; d="$(vm_dir "${name}")"
+  [[ -f "${d}/arch" || -f "${d}/disk.qcow2" ]] || die "VM '${name}' nicht gefunden (erst 'create')"
+  vm_running "${name}" && die "VM '${name}' laeuft bereits"
+  local arch; arch="$(cat "${d}/arch" 2>/dev/null || echo x86_64)"
+  local bin; bin="$(qemu_bin_for "${arch}")"
+
+  local iso="" floppy="" disk="" bootdev="" display=1 mem=1024 machine=""
+  # VNC bindet an 127.0.0.1 (Loopback) — von aussen nur ueber den RVS-Tunnel der
+  # Bridge erreichbar. Die Bridge (Container) kann Loopback aber NICHT erreichen;
+  # der Brain gibt deshalb per --vnc-bind die Docker-Gateway-IP mit (container-
+  # intern, NICHT im LAN/Internet). Default bleibt Loopback.
+  local vncbind="${ARIA_VM_VNC_BIND:-127.0.0.1}"
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --iso)         iso="${2:?}"; shift 2 ;;
+      --floppy)      floppy="${2:?}"; shift 2 ;;   # -fda (Disketten-Boot, OS-Dev)
+      --disk)        disk="${2:?}"; shift 2 ;;      # explizite qcow2 statt Auto
+      --boot)        bootdev="${2:?}"; shift 2 ;;   # Boot-Reihenfolge (a/c/d)
+      --disk-boot)   bootdev="c"; shift ;;
+      --vnc-display) display="${2:?}"; shift 2 ;;
+      --vnc-bind)    vncbind="${2:?}"; shift 2 ;;   # Bind-Adresse fuer -vnc
+      --mem)         mem="${2:?}"; shift 2 ;;
+      --machine)     machine="${2:?}"; shift 2 ;;
+      *) die "unbekannte Option: $1" ;;
+    esac
+  done
+
+  # Auto-Erkennung der Medien im VM-Ordner, falls nicht explizit angegeben.
+  [[ -z "${disk}"   && -f "${d}/disk.qcow2" ]] && disk="${d}/disk.qcow2"
+  [[ -z "${floppy}" && -f "${d}/floppy.img" ]] && floppy="${d}/floppy.img"
+  [[ -z "${iso}"    && -f "${d}/cdrom.iso"  ]] && iso="${d}/cdrom.iso"
+  [[ -n "${disk}${floppy}${iso}" ]] || \
+    die "Keine Boot-Medien fuer '${name}' (disk.qcow2 / --iso / --floppy). Erst 'create <name> <arch> <groesse>' oder ein Medium angeben."
+
+  local args=(-name "${name}" -m "${mem}"
+    -vnc "${vncbind}:${display}"
+    -monitor "unix:${d}/monitor.sock,server,nowait"
+    -pidfile "${d}/pid" -daemonize)
+  [[ -n "${disk}" ]]   && args+=(-drive "file=${disk},format=qcow2")
+  [[ -n "${floppy}" ]] && args+=(-fda "${floppy}")
+  [[ -n "${iso}" ]]    && args+=(-cdrom "${iso}")
+
+  # KVM nur fuer x86 auf x86-Host.
+  case "${arch}" in
+    x86_64|amd64|i386|i686|x86)
+      [[ -e /dev/kvm ]] && args+=(-enable-kvm) ;;
+  esac
+  # ARM/AArch64 brauchen eine Maschine (kein Default).
+  if [[ -z "${machine}" ]]; then
+    case "${arch}" in
+      arm|armv7|aarch64|arm64) machine="virt" ;;
+    esac
+  fi
+  [[ -n "${machine}" ]] && args+=(-M "${machine}")
+
+  # Boot-Reihenfolge: explizit, sonst automatisch (ISO→d, nur Diskette→a, sonst c).
+  if [[ -z "${bootdev}" ]]; then
+    if [[ -n "${iso}" ]]; then bootdev="d"
+    elif [[ -n "${floppy}" && -z "${disk}" ]]; then bootdev="a"
+    else bootdev="c"; fi
+  fi
+  args+=(-boot "${bootdev}")
+
+  "${bin}" "${args[@]}"
+  echo "VM '${name}' gestartet (${arch}) — VNC ${vncbind}:${display} (Port $((5900+display)))."
+  echo "vnc_display=${display} vnc_port=$((5900+display))"
+}
+
+cmd_screenshot() {
+  local name="${1:?name}"
+  local d; d="$(vm_dir "${name}")"
+  vm_running "${name}" || die "VM '${name}' laeuft nicht"
+  command -v socat >/dev/null || die "socat fehlt (qemu-setup.sh?)"
+  # Standard: ins VM-Verzeichnis schreiben (dem aria-User gehoerend) — NICHT
+  # nach /root/... (da kommt der aria-User nicht hin). Der Brain holt das PNG
+  # danach per SSH (base64). Ueberschreibbar via ARIA_VM_SHOT_DIR.
+  local out_dir="${ARIA_VM_SHOT_DIR:-${d}}"
+  mkdir -p "${out_dir}"
+  local ts; ts="$(date +%s)"
+  local ppm="${d}/shot-${ts}.ppm"
+  printf 'screendump %s\n' "${ppm}" | socat - "unix-connect:${d}/monitor.sock" >/dev/null
+  sleep 0.3
+  local out="${out_dir}/${name}-${ts}.png"
+  if command -v convert >/dev/null; then
+    convert "${ppm}" "${out}" && rm -f "${ppm}"
+  else
+    out="${out_dir}/${name}-${ts}.ppm"; mv "${ppm}" "${out}"
+  fi
+  echo "screenshot=${out}"
+}
+
+cmd_list() {
+  [[ -d "${VM_ROOT}" ]] || { echo "(keine VMs)"; return; }
+  local any=0
+  for d in "${VM_ROOT}"/*/; do
+    [[ -d "${d}" ]] || continue
+    any=1
+    local name arch state
+    name="$(basename "${d}")"
+    arch="$(cat "${d}/arch" 2>/dev/null || echo '?')"
+    if vm_running "${name}"; then state="laeuft (pid $(vm_pid "${name}"))"; else state="gestoppt"; fi
+    echo "${name}  [${arch}]  ${state}"
+  done
+  [[ "${any}" -eq 1 ]] || echo "(keine VMs)"
+}
+
+cmd_stop() {
+  local name="${1:?name}"
+  local d; d="$(vm_dir "${name}")"
+  if vm_running "${name}"; then
+    printf 'quit\n' | socat - "unix-connect:${d}/monitor.sock" >/dev/null 2>&1 || true
+    sleep 0.5
+    vm_running "${name}" && kill "$(vm_pid "${name}")" 2>/dev/null || true
+    echo "VM '${name}' gestoppt."
+  else
+    echo "VM '${name}' lief nicht."
+  fi
+  rm -f "${d}/pid" "${d}/monitor.sock"
+}
+
+cmd_rm() {
+  local name="${1:?name}"
+  vm_running "${name}" && cmd_stop "${name}"
+  rm -rf "$(vm_dir "${name}")"
+  echo "VM '${name}' geloescht."
+}
+
+main() {
+  local sub="${1:-}"; shift || true
+  case "${sub}" in
+    create)     cmd_create "$@" ;;
+    boot)       cmd_boot "$@" ;;
+    screenshot) cmd_screenshot "$@" ;;
+    list)       cmd_list "$@" ;;
+    stop)       cmd_stop "$@" ;;
+    rm)         cmd_rm "$@" ;;
+    ""|-h|--help)
+      sed -n '2,40p' "$0" | sed 's/^# \{0,1\}//' ;;
+    *) die "unbekanntes Kommando: ${sub} (siehe --help)" ;;
+  esac
+}
+
+main "$@"
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+#
+# qemu-setup.sh — installiert QEMU fuer ALLE Architekturen auf dem ARIA-Host
+# (172.0.2.33) plus den aria-vm-Helper. Einmalig als root ausfuehren.
+#
+#   sudo bash host-provisioning/qemu-setup.sh
+#
+# KVM-Beschleunigung gibt es nur fuer x86-Gaeste auf einem x86-Host; ARM/MIPS/
+# PPC/RISC-V laufen unter TCG (voll emuliert, langsamer, aber alle Architekturen
+# baubar). websockify/noVNC werden NICHT installiert — der VNC-Stream wird als
+# RFB-Bytes durch die Bridge/RVS getunnelt (siehe aria_bridge.py VNC-Bruecke).
+set -euo pipefail
+
+if [[ "${EUID}" -ne 0 ]]; then
+  echo "Bitte als root ausfuehren (sudo)." >&2
+  exit 1
+fi
+
+echo "[qemu-setup] apt update ..."
+apt-get update -qq
+
+echo "[qemu-setup] Installiere QEMU (alle Architekturen) + Werkzeuge ..."
+DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+  qemu-system \
+  qemu-system-x86 \
+  qemu-system-arm \
+  qemu-system-mips \
+  qemu-system-ppc \
+  qemu-system-sparc \
+  qemu-system-misc \
+  qemu-utils \
+  seabios \
+  ovmf \
+  ipxe-qemu \
+  socat \
+  imagemagick
+
+echo "[qemu-setup] KVM-Status:"
+if [[ -e /dev/kvm ]]; then
+  echo "  /dev/kvm vorhanden → x86-Gaeste mit KVM-Beschleunigung."
+else
+  echo "  /dev/kvm FEHLT → alle Gaeste laufen unter TCG (emuliert, langsamer)."
+fi
+
+# aria-vm-Helper installieren (liegt neben diesem Skript).
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+install -m 0755 "${SCRIPT_DIR}/aria-vm" /usr/local/bin/aria-vm
+echo "[qemu-setup] /usr/local/bin/aria-vm installiert."
+
+mkdir -p /var/lib/aria-vms
+echo "[qemu-setup] VM-Verzeichnis: /var/lib/aria-vms"
+
+echo "[qemu-setup] Fertig. Test:  aria-vm list"
@@ -28,6 +28,43 @@ const TOOL_HOOK_URL = process.env.ARIA_TOOL_HOOK_URL
    || "http://aria-bridge:8090/internal/agent-activity";
 const STREAM_HOOK_URL = process.env.ARIA_STREAM_HOOK_URL
    || "http://aria-bridge:8090/internal/agent-stream";
+const CODE_FILE_HOOK_URL = process.env.ARIA_CODE_FILE_HOOK_URL
+    || "http://aria-bridge:8090/internal/code-file";
+
+// Code-Projekte leben unter /shared/projects/<projectId>/ (Volume in proxy +
+// bridge + brain gemountet). Schreibt/aendert ARIA hier eine Datei, spiegeln
+// wir den Volltext live in den Code-Editor der App. Nur Dateien unter diesem
+// Praefix — ARIAs sonstige Datei-Ops (Skills, Configs) bleiben unberuehrt.
+const PROJECTS_ROOT = "/shared/projects/";
+const CODE_FILE_MAX_BYTES = 512 * 1024;
+
+/** Zerlegt einen absoluten Pfad unter /shared/projects/<pid>/<rel> → {pid, rel}
+ *  oder null wenn er nicht darunter liegt. */
+function _parseProjectPath(filePath) {
+    if (typeof filePath !== "string" || !filePath.startsWith(PROJECTS_ROOT)) return null;
+    const rest = filePath.slice(PROJECTS_ROOT.length);
+    const slash = rest.indexOf("/");
+    if (slash <= 0) return null;
+    return { pid: rest.slice(0, slash), rel: rest.slice(slash + 1) };
+}
+
+/** Liest die (frisch geschriebene) Datei und pusht sie als code_file an die
+ *  Bridge. Fire-and-forget, fail-open. */
+function _emitCodeFile(filePath) {
+    try {
+        const parsed = _parseProjectPath(filePath);
+        if (!parsed || !parsed.rel) return;
+        const st = fs.statSync(filePath);
+        if (!st.isFile() || st.size > CODE_FILE_MAX_BYTES) return;
+        const content = fs.readFileSync(filePath, "utf8");
+        _postJson(CODE_FILE_HOOK_URL, {
+            projectId: parsed.pid,
+            path: parsed.rel,
+            content,
+            version: Date.now(),
+        });
+    } catch (_) { /* fail-open */ }
+}

 // Tool-Output kann sehr lang werden (git log -p, find /). Wir truncaten
 // hart auf 4 KB pro Event — der User sieht weiterhin den Anfang und einen
@@ -153,6 +190,9 @@ function _attachIdleWatchdog(subprocess, requestId) {
 *  - Neu-API: voller Stream (text/tool_use/tool_result) an /internal/agent-stream
 */
 function _attachToolHook(subprocess, requestId, projectId) {
+    // tool_use_id → file_path fuer Write/Edit, damit wir beim (erfolgreichen)
+    // tool_result die frisch geschriebene Datei aus /shared lesen koennen.
+    const _pendingFileWrites = new Map();
    subprocess.on("assistant", (message) => {
        try {
            const blocks = message?.message?.content || [];
@@ -160,6 +200,10 @@ function _attachToolHook(subprocess, requestId, projectId) {
                if (!b) continue;
                if (b.type === "tool_use") {
                    if (b.name) _emitToolEvent(b.name, projectId);
+                    if ((b.name === "Write" || b.name === "Edit" || b.name === "MultiEdit")
+                        && b.id && b.input && typeof b.input.file_path === "string") {
+                        _pendingFileWrites.set(b.id, b.input.file_path);
+                    }
                    const inputStr = b.input ? JSON.stringify(b.input) : "";
                    const inp = _truncate(inputStr, TOOL_INPUT_MAX_CHARS);
                    _emitStreamEvent(requestId, "tool_use", {
@@ -203,6 +247,11 @@ function _attachToolHook(subprocess, requestId, projectId) {
                        truncatedBytes: out.truncatedBytes,
                        isError: b.is_error === true,
                    });
+                    // Write/Edit erfolgreich → Datei live in den Code-Editor spiegeln.
+                    if (b.tool_use_id && b.is_error !== true && _pendingFileWrites.has(b.tool_use_id)) {
+                        _emitCodeFile(_pendingFileWrites.get(b.tool_use_id));
+                        _pendingFileWrites.delete(b.tool_use_id);
+                    }
                }
            }
        } catch (_) { /* fail-open */ }
@@ -66,6 +66,16 @@ const ALLOWED_TYPES = new Set([
  // Qwen3 auf der Gamebox (via Bridge → RVS → llm-adapter → llama.cpp).
  // llm_partial ist fuer B2 (Token-Streaming) reserviert, noch ungenutzt.
  "llm_request", "llm_response", "llm_partial",
+  // Workspace-Desktop (Code-Projekte): Live-Code-Editor (CodeMirror in der App)
+  // spiegelt ARIAs Datei-Writes, und QEMU-VNC wird als RFB-Bytes durch RVS
+  // getunnelt (Base64-in-JSON wie audio_pcm — kein Binaer-Handling noetig).
+  "code_file", "code_file_edit",
+  "check_desktop", "desktop_status",
+  "vnc_open", "vnc_close", "vnc_data", "vnc_input",
+  // Satelliten (Info-/Gateway-Aussenposten in fremden Netzen): melden sich mit
+  // sat_hello, liefern Geraete-Inventar (sat_devices) auf sat_discover und
+  // fuehren Aktionen aus (sat_command → sat_result).
+  "sat_hello", "sat_discover", "sat_devices", "sat_command", "sat_result",
 ]);

 // Token-Raum: token -> { clients: Set<ws> }
@@ -0,0 +1,34 @@
+# ─── ARIA Satellit — Konfiguration ──────────────────────────────────
+# Kopiere diese Datei nach .env und passe sie an.
+
+# RVS-Zugang (identisch zum Haupt-Stack — gleicher Raum/Token, damit ARIA
+# diesen Satelliten erreicht). Werte aus der Haupt-.env / vom generate-token.sh.
+RVS_HOST=rvs.example.de
+RVS_PORT=443
+RVS_TLS=true
+RVS_TOKEN=
+
+# ─── Identitaet / Adresse dieses Satelliten ────────────────────────
+# SATELLITE_ID  = technisch eindeutig (a-z0-9-_), Default = Hostname-Slug.
+# SATELLITE_LOCATION = menschlicher Name, so spricht ARIA das Netz an ("Buero").
+# Mehrere Satelliten koennen im selben RVS-Raum haengen — die Location
+# unterscheidet sie ("Buero", "Zuhause", "Werkstatt").
+SATELLITE_ID=buero
+SATELLITE_LOCATION=Büro
+
+# ─── Steuerung (Sicherheit!) ───────────────────────────────────────
+# CONTROL_ENABLED=false → reiner Info-/Beobachtungs-Satellit (entdeckt & meldet
+#   nur, steuert nichts). Sicherste Basis.
+# CONTROL_ENABLED=true  → darf Geraete steuern (nur Aktionen aus der Allowlist).
+CONTROL_ENABLED=true
+# Erlaubte Steuer-Aktionen (kommagetrennt). Alles andere wird abgelehnt.
+#   dial.launch  App-Launch via DIAL (z.B. YouTube-Video auf Fire TV / Smart-TV)
+#   wol          Wake-on-LAN (Geraet per MAC aufwecken)
+#   http.get     generischer HTTP-GET (z.B. lokale IoT-Webhooks)
+#   http.post    generischer HTTP-POST
+CONTROL_ALLOWLIST=dial.launch,wol,http.get
+
+# ─── Discovery-Tuning (optional) ───────────────────────────────────
+SCAN_INTERVAL_SEC=300      # Hintergrund-Rescan-Intervall
+DISCOVER_TIMEOUT_SEC=6     # Dauer eines Sweeps (mDNS + SSDP)
+DEVICE_CACHE_TTL_SEC=120   # wie lange ein Inventar als "frisch" gilt
@@ -0,0 +1,13 @@
+# ARIA Satellit — schlanker Aussenposten-Container.
+# Laeuft mit network_mode: host (siehe docker-compose.yml), damit mDNS/SSDP-
+# Broadcasts + die Geraete-IPs im lokalen Netz erreichbar sind.
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY satellite.py .
+
+CMD ["python", "-u", "satellite.py"]
@@ -0,0 +1,102 @@
+# ARIA Satellit 🛰️
+
+Ein eigenständiger **Außenposten-Container** für ein fremdes Netz (Büro, Werkstatt,
+Ferienwohnung …). Er verbindet sich als RVS-Client in Stefans Raum und gibt ARIA
+**Augen und Hände in genau diesem Netz** — ohne dass der Haupt-Stack dort stehen muss.
+
+- **Augen (Info):** entdeckt Geräte via **mDNS/Zeroconf** (Chromecast, AirPlay, Sonos,
+  Drucker, NAS …), **SSDP/UPnP + DIAL** (Smart-TVs, Fire TV) und der **ARP-Tabelle**
+  (rohe Hosts). Meldet ARIA ein Live-Inventar.
+- **Hände (Steuerung):** **DIAL-App-Launch** (z.B. YouTube-Video auf dem Fire TV),
+  **Wake-on-LAN**, generisches **HTTP**. Nur wenn freigeschaltet (siehe Sicherheit).
+
+## ⚠️ Wichtig: der Satellit MUSS im echten Ziel-LAN laufen
+
+Discovery (mDNS/SSDP-Multicast + ARP) funktioniert **nur**, wenn der Prozess
+tatsächlich im selben LAN wie die Geräte hängt — z.B. `192.168.177.0/24`, wo der
+Fire TV steht.
+
+**Docker Desktop (Mac/Windows) geht NICHT.** Dort ist `network_mode: host` das Netz
+der Docker-Linux-VM (NAT, `192.168.65.x` / `172.x`), **nicht** dein echtes LAN.
+Der Satellit sieht dann nur Docker-Container statt der echten Geräte. (Der Satellit
+erkennt das selbst und meldet eine ⚠-Warnung im Diagnostic + Log.)
+
+Richtig deployen — zwei Wege:
+
+**A) Linux-Box im Ziel-LAN mit Docker Engine** (empfohlen, z.B. Raspberry Pi / NUC im Büro):
+```bash
+cd satellite
+cp .env.example .env            # RVS-Zugang + SATELLITE_LOCATION
+docker compose up -d --build
+docker compose logs -f          # "Netz: primary_ip=192.168.177.x" + "[scan] N Geraete"
+```
+`network_mode: host` (schon gesetzt) gibt hier echtes LAN + Multicast.
+
+**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):
+```bash
+cd satellite
+cp .env.example .env      # RVS-Zugang + SATELLITE_LOCATION eintragen
+pip install -r requirements.txt
+python satellite.py       # liest .env automatisch
+```
+(Echte Umgebungsvariablen haben Vorrang — `export RVS_TOKEN=...` überschreibt die
+`.env`, falls du das lieber magst.)
+
+`RVS_HOST/PORT/TLS/TOKEN` **identisch** zum Haupt-Stack (gleicher Raum, damit ARIA
+den Satelliten erreicht). `SATELLITE_LOCATION` ist der Name, über den ARIA das Netz
+anspricht („Büro").
+
+**Kontrolle:** im Log/Diagnostic muss `primary_ip` im Ziel-LAN liegen
+(`192.168.177.x`) — steht da `192.168.65.x` oder `172.x`, sitzt der Satellit im
+falschen (Docker-)Netz.
+
+## Als Dienst installieren (Autostart, ohne Docker)
+
+Legt automatisch ein `.venv` an, installiert die Requirements und richtet einen
+Dienst ein, der bei Boot startet und bei Absturz neu hochkommt. `.env` vorher
+anlegen.
+
+**Linux (systemd) / macOS (launchd):**
+```bash
+cd satellite
+bash install.sh              # installieren + starten
+bash install.sh uninstall    # entfernen
+```
+- Linux-Logs: `journalctl -u aria-satellite -f`
+- macOS-Logs: `tail -f satellite.log` (evtl. „Lokales Netzwerk"-Zugriff erlauben)
+
+**Windows (Scheduled Task) — PowerShell als Administrator:**
+```powershell
+cd satellite
+powershell -ExecutionPolicy Bypass -File install.ps1              # installieren + starten
+powershell -ExecutionPolicy Bypass -File install.ps1 -Uninstall  # entfernen
+```
+- Log: `Get-Content -Wait satellite.log`
+
+## So nutzt ARIA es
+
+ARIA hat drei Brain-Tools:
+- `satellite_list` — welche Netze/Satelliten sind online + was können sie.
+- `satellite_devices(satellite)` — Inventar eines Netzes.
+- `satellite_command(satellite, device, action, params)` — Aktion ausführen.
+
+Beispiel „YouTube-Video auf dem Büro-Stick":
+```
+satellite_command(satellite="Büro", device="Fire TV",
+                  action="dial.launch", params={"app":"YouTube","v":"<videoId>"})
+```
+
+## Sicherheit
+
+Der Satellit scannt ein Netz **und** ist über einen Cloud-Relay erreichbar — deshalb:
+
+- Reagiert **nur** auf den eigenen RVS-Raum (Token).
+- **`CONTROL_ENABLED=false`** = reiner Info-Satellit (steuert nichts). Standard-sicher.
+- Bei `true`: nur Aktionen aus **`CONTROL_ALLOWLIST`**, alles andere wird abgelehnt.
+- Jede ausgeführte Aktion wird **geloggt**.
+- Keine offenen Ports — reiner Client.
+
+Empfehlung: in vertrauenswürdigen Netzen `CONTROL_ENABLED=true` mit enger Allowlist;
+sonst `false` und nur beobachten.
@@ -0,0 +1,23 @@
+# ARIA Satellit — eigenstaendiger Stack fuer ein fremdes Netz (Buero, Werkstatt …).
+#
+# Deploy:
+#   cd satellite
+#   cp .env.example .env   # RVS-Zugang + SATELLITE_LOCATION eintragen
+#   docker compose up -d --build
+#
+# WICHTIG: network_mode: host — der Satellit MUSS im Host-Netz laufen, sonst
+# sieht er die mDNS/SSDP-Broadcasts + Geraete-IPs des LAN nicht (Docker-Bridge
+# wuerde das isolieren). Damit ist er zugleich als RVS-Client raus ins Internet
+# verbunden. Keine Ports zu veroeffentlichen — er ist reiner Client.
+#
+# ⚠ NUR auf LINUX Docker Engine, und der Host muss physisch im Ziel-LAN haengen!
+# Docker Desktop (Mac/Windows) gibt hier NUR das Docker-VM-Netz (192.168.65.x /
+# 172.x), NICHT dein echtes LAN → Discovery findet dann nur Docker-Container.
+# Fuer Mac/Windows: satellite.py nativ starten (siehe README, Weg B).
+services:
+  satellite:
+    build: .
+    container_name: aria-satellite
+    network_mode: host
+    env_file: .env
+    restart: unless-stopped
@@ -0,0 +1,87 @@
+<#
+  ARIA Satellit — Dienst-Installer fuer Windows (Scheduled Task, Autostart + Restart).
+
+    powershell -ExecutionPolicy Bypass -File install.ps1              installiert + startet
+    powershell -ExecutionPolicy Bypass -File install.ps1 -Uninstall  entfernt den Task
+
+  Legt ein venv (.venv) an, installiert requirements.txt und richtet einen
+  geplanten Task ein, der satellite.py aus DIESEM Ordner startet (findet die .env)
+  und bei Absturz/Neustart wieder hochkommt. Laeuft als aktueller Nutzer (S4U),
+  auch ohne Anmeldung. Als Administrator ausfuehren.
+
+  WICHTIG: Der Satellit muss im ECHTEN Ziel-LAN laufen (siehe README) — auf einer
+  Maschine, die physisch im Netz der Geraete haengt. Docker Desktop taugt nicht.
+#>
+param([switch]$Uninstall)
+
+$ErrorActionPreference = "Stop"
+$Dir  = Split-Path -Parent $MyInvocation.MyCommand.Path
+$Task = "ARIA-Satellite"
+
+# ─── Uninstall ──────────────────────────────────────────────────────
+if ($Uninstall) {
+  if (Get-ScheduledTask -TaskName $Task -ErrorAction SilentlyContinue) {
+    Unregister-ScheduledTask -TaskName $Task -Confirm:$false
+    Write-Host "Task '$Task' entfernt."
+  } else {
+    Write-Host "Kein Task '$Task' gefunden."
+  }
+  exit 0
+}
+
+# ─── Admin-Check ────────────────────────────────────────────────────
+$isAdmin = ([Security.Principal.WindowsPrincipal] `
+  [Security.Principal.WindowsIdentity]::GetCurrent()
+  ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+if (-not $isAdmin) {
+  Write-Warning "Bitte als Administrator ausfuehren (Rechtsklick PowerShell -> Als Administrator)."
+  exit 1
+}
+
+# ─── Python finden ──────────────────────────────────────────────────
+$py = (Get-Command python -ErrorAction SilentlyContinue).Source
+if (-not $py) { $py = (Get-Command python3 -ErrorAction SilentlyContinue).Source }
+if (-not $py) { Write-Error "Python 3 nicht gefunden. Bitte von python.org installieren (mit 'Add to PATH')."; exit 1 }
+
+# ─── venv + Abhaengigkeiten ─────────────────────────────────────────
+if (-not (Test-Path "$Dir\.venv")) {
+  Write-Host "[install] Lege venv an ..."
+  & $py -m venv "$Dir\.venv"
+}
+$venvPy  = "$Dir\.venv\Scripts\python.exe"
+Write-Host "[install] Installiere Abhaengigkeiten ..."
+& $venvPy -m pip install --upgrade pip | Out-Null
+& $venvPy -m pip install -r "$Dir\requirements.txt"
+
+if (-not (Test-Path "$Dir\.env")) {
+  Write-Warning "Keine .env gefunden - bitte anlegen:  copy .env.example .env  (RVS-Zugang + SATELLITE_LOCATION)"
+}
+
+# ─── Scheduled Task ─────────────────────────────────────────────────
+Write-Host "[install] Richte geplanten Task '$Task' ein ..."
+# Ueber cmd starten, damit stdout/stderr in satellite.log landen (der Task laeuft
+# in Session 0 / S4U = kein sichtbares Fenster, python.exe ist hier ok).
+$logfile = Join-Path $Dir "satellite.log"
+$cmdArg  = '/c ""{0}" satellite.py >> "{1}" 2>&1"' -f $venvPy, $logfile
+$action  = New-ScheduledTaskAction -Execute "cmd.exe" -Argument $cmdArg -WorkingDirectory $Dir
+$trigger = @(
+  New-ScheduledTaskTrigger -AtStartup
+  New-ScheduledTaskTrigger -AtLogOn
+)
+# Laeuft als aktueller Nutzer, auch ohne Anmeldung (S4U), mit hoechsten Rechten.
+$principal = New-ScheduledTaskPrincipal -UserId "$env:USERDOMAIN\$env:USERNAME" `
+  -LogonType S4U -RunLevel Highest
+# Bei Absturz neu starten, unbegrenzte Laufzeit, startet nach falls Zeitpunkt verpasst, versteckt.
+$settings = New-ScheduledTaskSettingsSet -StartWhenAvailable -Hidden `
+  -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) `
+  -ExecutionTimeLimit (New-TimeSpan -Seconds 0) `
+  -MultipleInstances IgnoreNew
+
+Register-ScheduledTask -TaskName $Task -Action $action -Trigger $trigger `
+  -Principal $principal -Settings $settings -Force | Out-Null
+
+Start-ScheduledTask -TaskName $Task
+Write-Host "OK Dienst laeuft."
+Write-Host "   Status:  Get-ScheduledTask -TaskName $Task"
+Write-Host "   Stoppen: Stop-ScheduledTask -TaskName $Task"
+Write-Host "   Log:     Get-Content -Wait '$logfile'   (pruefen: primary_ip + '[scan] N Geraete')"
@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+#
+# ARIA Satellit — Dienst-Installer fuer Linux (systemd) und macOS (launchd).
+#
+#   bash install.sh            installiert + startet den Dienst
+#   bash install.sh uninstall  entfernt den Dienst
+#
+# Legt ein venv an (.venv), installiert requirements.txt und richtet einen
+# Autostart-Dienst ein, der satellite.py aus DIESEM Ordner startet (damit die
+# .env gefunden wird) und bei Absturz neu startet.
+#
+# WICHTIG: Der Satellit muss im ECHTEN Ziel-LAN laufen (siehe README) — auf einer
+# Maschine, die physisch im Netz der Geraete haengt. Docker Desktop taugt nicht.
+set -euo pipefail
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SVC="aria-satellite"
+PLIST_LABEL="de.aria.satellite"
+OS="$(uname -s)"
+ACTION="${1:-install}"
+
+# ─── Uninstall ──────────────────────────────────────────────────────
+if [ "$ACTION" = "uninstall" ]; then
+  if [ "$OS" = "Linux" ]; then
+    SUDO=""; [ "$(id -u)" -ne 0 ] && SUDO="sudo"
+    $SUDO systemctl disable --now "$SVC" 2>/dev/null || true
+    $SUDO rm -f "/etc/systemd/system/$SVC.service"
+    $SUDO systemctl daemon-reload
+    echo "systemd-Dienst '$SVC' entfernt."
+  elif [ "$OS" = "Darwin" ]; then
+    PLIST="$HOME/Library/LaunchAgents/$PLIST_LABEL.plist"
+    launchctl unload "$PLIST" 2>/dev/null || true
+    rm -f "$PLIST"
+    echo "launchd-Agent '$PLIST_LABEL' entfernt."
+  fi
+  exit 0
+fi
+
+# ─── venv + Abhaengigkeiten ─────────────────────────────────────────
+PY="$(command -v python3 || command -v python || true)"
+[ -n "$PY" ] || { echo "Python 3 nicht gefunden. Bitte installieren."; exit 1; }
+
+if [ ! -d "$DIR/.venv" ]; then
+  echo "[install] Lege venv an …"
+  if ! "$PY" -m venv "$DIR/.venv" 2>/dev/null; then
+    echo "venv-Erstellung fehlgeschlagen. Auf Debian/Ubuntu: sudo apt install python3-venv"
+    exit 1
+  fi
+fi
+VENV_PY="$DIR/.venv/bin/python"
+echo "[install] Installiere Abhaengigkeiten …"
+"$VENV_PY" -m pip install --upgrade pip >/dev/null
+"$VENV_PY" -m pip install -r "$DIR/requirements.txt"
+
+if [ ! -f "$DIR/.env" ]; then
+  echo "⚠ Keine .env gefunden — bitte anlegen:  cp .env.example .env  (RVS-Zugang + SATELLITE_LOCATION)"
+fi
+
+# ─── Dienst einrichten ──────────────────────────────────────────────
+if [ "$OS" = "Linux" ]; then
+  RUN_USER="${SUDO_USER:-$(id -un)}"
+  UNIT="/etc/systemd/system/$SVC.service"
+  SUDO=""; [ "$(id -u)" -ne 0 ] && SUDO="sudo"
+  echo "[install] Schreibe systemd-Unit $UNIT (User=$RUN_USER) …"
+  $SUDO tee "$UNIT" >/dev/null <<EOF
+[Unit]
+Description=ARIA Satellit (Netz-Aussenposten)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=$RUN_USER
+WorkingDirectory=$DIR
+ExecStart=$VENV_PY $DIR/satellite.py
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+EOF
+  $SUDO systemctl daemon-reload
+  $SUDO systemctl enable --now "$SVC"
+  echo "✅ Dienst laeuft."
+  echo "   Status: $SUDO systemctl status $SVC"
+  echo "   Logs:   $SUDO journalctl -u $SVC -f"
+
+elif [ "$OS" = "Darwin" ]; then
+  PLIST="$HOME/Library/LaunchAgents/$PLIST_LABEL.plist"
+  mkdir -p "$HOME/Library/LaunchAgents"
+  echo "[install] Schreibe launchd-Agent $PLIST …"
+  cat > "$PLIST" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>$PLIST_LABEL</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>$VENV_PY</string>
+    <string>$DIR/satellite.py</string>
+  </array>
+  <key>WorkingDirectory</key><string>$DIR</string>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>$DIR/satellite.log</string>
+  <key>StandardErrorPath</key><string>$DIR/satellite.log</string>
+</dict>
+</plist>
+EOF
+  launchctl unload "$PLIST" 2>/dev/null || true
+  launchctl load "$PLIST"
+  echo "✅ Agent geladen."
+  echo "   Logs: tail -f $DIR/satellite.log"
+  echo "   Hinweis: macOS fragt evtl. nach 'Lokales Netzwerk'-Zugriff — erlauben, sonst findet der Satellit keine Geraete."
+else
+  echo "Unbekanntes OS: $OS (dieses Skript kann Linux/macOS; fuer Windows: install.ps1)"
+  exit 1
+fi
@@ -0,0 +1,3 @@
+websockets>=12.0
+zeroconf>=0.131.0
+requests>=2.31.0
@@ -0,0 +1,668 @@
+"""
+ARIA Satellit — Info-/Gateway-Aussenposten in einem fremden Netz.
+
+Laeuft eigenstaendig (z.B. im Buero) und verbindet sich als RVS-Client in
+Stefans Raum (gleicher Token). Gibt ARIA damit Augen + Haende in DIESEM Netz:
+
+  Augen: entdeckt Geraete (mDNS/Zeroconf, SSDP/UPnP + DIAL, ARP-Tabelle) und
+         meldet ein Inventar → sat_devices.
+  Haende: steuert Geraete (DIAL-App-Launch z.B. YouTube auf Fire TV, Wake-on-
+          LAN, generisches HTTP) → sat_command / sat_result. Nur wenn
+          CONTROL_ENABLED=true, Aktion in der Allowlist, alles geloggt.
+
+Adressierung: mehrere Satelliten haengen im selben RVS-Raum. Jeder hat eine
+SATELLITE_ID (technisch, eindeutig) + SATELLITE_LOCATION (menschlich, "Buero").
+ARIA spricht einen Satelliten ueber seine ID/Location an.
+
+Message-Typen (RVS, Base64/JSON-Relay wie der Rest):
+  raus:  sat_hello   {id, location, caps, ts}
+         sat_devices {requestId, satellite, devices:[...]}
+         sat_result  {requestId, satellite, ok, result|error}
+  rein:  sat_discover {satellite?, requestId}
+         sat_command  {satellite?, requestId, device, action, params}
+
+Sicherheit: reagiert nur auf den eigenen RVS-Raum (Token). Commands brauchen
+CONTROL_ENABLED + Allowlist. Discovery ist read-only. Keine offenen Ports.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+import socket
+import struct
+import time
+from typing import Optional
+
+import websockets
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [satellite] %(levelname)s %(message)s",
+)
+logger = logging.getLogger("satellite")
+
+
+def _load_dotenv() -> None:
+    """Laedt eine .env neben dem Script (oder im CWD) in os.environ — fuer den
+    NATIVEN Start (`python satellite.py`). In Docker sind die Variablen via
+    env_file schon gesetzt; bereits gesetzte Werte gewinnen (werden NICHT
+    ueberschrieben). 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")):
+        if not os.path.isfile(path):
+            continue
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith("#") or "=" not in line:
+                        continue
+                    key, _, val = line.partition("=")
+                    key = key.strip()
+                    if key.startswith("export "):
+                        key = key[len("export "):].strip()
+                    val = val.strip()
+                    if val[:1] in ("'", '"'):
+                        # Gequotet: Inhalt bis zum schliessenden Quote, Rest (Kommentar) egal.
+                        q = val[0]
+                        end = val.find(q, 1)
+                        val = val[1:end] if end != -1 else val[1:]
+                    else:
+                        # Ungequotet: Inline-Kommentar (Whitespace + #) abschneiden.
+                        m = re.search(r"\s+#", val)
+                        if m:
+                            val = val[:m.start()]
+                        val = val.strip()
+                    if key and key not in os.environ:
+                        os.environ[key] = val
+        except Exception as exc:
+            logging.getLogger("satellite").warning(".env laden fehlgeschlagen (%s): %s", path, exc)
+        break  # erste gefundene .env gewinnt
+
+
+_load_dotenv()
+
+
+# ─── Konfiguration ──────────────────────────────────────────────────
+
+def _env_bool(name: str, default: bool) -> bool:
+    v = os.environ.get(name)
+    if v is None:
+        return default
+    return v.strip().lower() in ("1", "true", "yes", "on", "ja")
+
+
+def _default_id() -> str:
+    host = socket.gethostname() or "satellite"
+    slug = re.sub(r"[^a-zA-Z0-9_-]+", "-", host).strip("-").lower()
+    return slug or "satellite"
+
+
+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)
+RVS_TOKEN = os.environ.get("RVS_TOKEN", "")
+
+SATELLITE_ID = (os.environ.get("SATELLITE_ID") or _default_id()).strip()
+SATELLITE_LOCATION = (os.environ.get("SATELLITE_LOCATION") or SATELLITE_ID).strip()
+
+CONTROL_ENABLED = _env_bool("CONTROL_ENABLED", False)
+CONTROL_ALLOWLIST = [
+    a.strip() for a in
+    os.environ.get("CONTROL_ALLOWLIST", "dial.launch,wol,http.get").split(",")
+    if a.strip()
+]
+
+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")
+
+HEARTBEAT_SEC = 25
+
+# mDNS-Servicetypen, die fuer ARIA interessant sind.
+MDNS_TYPES = [
+    "_googlecast._tcp.local.",      # Chromecast / Google TV / Nest
+    "_airplay._tcp.local.",         # Apple TV / AirPlay
+    "_raop._tcp.local.",            # AirPlay-Audio
+    "_spotify-connect._tcp.local.",  # Spotify-Geraete
+    "_sonos._tcp.local.",           # Sonos
+    "_hap._tcp.local.",             # HomeKit
+    "_printer._tcp.local.",         # Drucker
+    "_ipp._tcp.local.",             # Drucker (IPP)
+    "_smb._tcp.local.",             # NAS / Fileshares
+    "_workstation._tcp.local.",     # generische Hosts
+    "_http._tcp.local.",            # Web-UIs (Router, NAS, IoT)
+]
+
+CAPABILITIES = ["discover"]
+if CONTROL_ENABLED:
+    CAPABILITIES += CONTROL_ALLOWLIST
+
+
+# ─── Netz-Kontext / Selbstdiagnose ──────────────────────────────────
+
+def _in_docker_bridge(ip: str) -> bool:
+    # Docker-Default-Bridge-Range 172.16.0.0/12
+    try:
+        a, b = ip.split(".")[:2]
+        return a == "172" and 16 <= int(b) <= 31
+    except Exception:
+        return False
+
+
+def _net_context() -> dict:
+    """Ermittelt in welchem Netz der Satellit LAeUFT — und warnt, wenn das ein
+    Docker-/NAT-Netz ist (dann erreicht Discovery das echte LAN nicht)."""
+    ips: list[str] = []
+    primary = ""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.settimeout(1)
+        s.connect(("8.8.8.8", 80))
+        primary = s.getsockname()[0]
+        s.close()
+    except Exception:
+        pass
+    try:
+        for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):
+            ip = info[4][0]
+            if ip and not ip.startswith("127.") and ip not in ips:
+                ips.append(ip)
+    except Exception:
+        pass
+    if primary and primary not in ips:
+        ips.insert(0, primary)
+    p = primary or (ips[0] if ips else "")
+    warning = ""
+    if p.startswith("192.168.65.") or _in_docker_bridge(p):
+        warning = (f"Satellit laeuft in einem Docker-/NAT-Netz ({p}), NICHT im echten LAN. "
+                   "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}
+
+
+NET = _net_context()
+
+
+# ─── Discovery ──────────────────────────────────────────────────────
+
+def _discover_mdns(timeout: float) -> list[dict]:
+    """Blockierend (im Executor): mDNS/Zeroconf-Sweep ueber MDNS_TYPES."""
+    out: dict[str, dict] = {}
+    try:
+        from zeroconf import Zeroconf, ServiceBrowser
+    except Exception as exc:
+        logger.warning("zeroconf nicht verfuegbar: %s", exc)
+        return []
+
+    class _Listener:
+        def add_service(self, zc, type_, name):
+            try:
+                info = zc.get_service_info(type_, name, timeout=2000)
+            except Exception:
+                info = None
+            if not info:
+                return
+            ips = []
+            try:
+                for addr in info.parsed_addresses():
+                    ips.append(addr)
+            except Exception:
+                pass
+            props = {}
+            try:
+                for k, v in (info.properties or {}).items():
+                    try:
+                        props[k.decode("utf-8", "ignore")] = (
+                            v.decode("utf-8", "ignore") if isinstance(v, (bytes, bytearray)) else v)
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+            friendly = name.split("." + type_.split(".", 1)[0])[0].strip(".")
+            fn = props.get("fn") or props.get("friendlyName") or friendly
+            dev_id = _slug(f"{fn}-{ips[0] if ips else name}")
+            out[dev_id] = {
+                "id": dev_id,
+                "name": fn,
+                "type": _mdns_kind(type_),
+                "ip": ips[0] if ips else "",
+                "port": info.port,
+                "via": "mdns",
+                "service": type_,
+                "model": props.get("md") or props.get("model") or "",
+            }
+
+        def update_service(self, *a):
+            pass
+
+        def remove_service(self, *a):
+            pass
+
+    zc = None
+    try:
+        zc = Zeroconf()
+        listener = _Listener()
+        for t in MDNS_TYPES:
+            try:
+                ServiceBrowser(zc, t, listener)
+            except Exception:
+                pass
+        time.sleep(timeout)
+    except Exception as exc:
+        logger.warning("mDNS-Sweep-Fehler: %s", exc)
+    finally:
+        try:
+            if zc:
+                zc.close()
+        except Exception:
+            pass
+    return list(out.values())
+
+
+def _mdns_kind(service_type: str) -> str:
+    m = {
+        "_googlecast": "cast", "_airplay": "airplay", "_raop": "airplay-audio",
+        "_spotify-connect": "spotify", "_sonos": "sonos", "_hap": "homekit",
+        "_printer": "printer", "_ipp": "printer", "_smb": "fileshare",
+        "_workstation": "host", "_http": "web",
+    }
+    for k, v in m.items():
+        if service_type.startswith(k):
+            return v
+    return "unknown"
+
+
+def _discover_ssdp(timeout: float) -> list[dict]:
+    """Blockierend: SSDP M-SEARCH (UPnP + DIAL). Liefert v.a. Smart-TVs / Fire
+    TV mit ihrer DIAL Application-URL (fuer App-Launch wie YouTube)."""
+    out: dict[str, dict] = {}
+    targets = [
+        "urn:dial-multiscreen-org:service:dial:1",
+        "ssdp:all",
+    ]
+    for st in targets:
+        msg = (
+            "M-SEARCH * HTTP/1.1\r\n"
+            "HOST: 239.255.255.250:1900\r\n"
+            'MAN: "ssdp:discover"\r\n'
+            "MX: 2\r\n"
+            f"ST: {st}\r\n\r\n"
+        ).encode("utf-8")
+        sock = None
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
+            sock.settimeout(timeout)
+            sock.sendto(msg, ("239.255.255.250", 1900))
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                try:
+                    data, addr = sock.recvfrom(65507)
+                except socket.timeout:
+                    break
+                except Exception:
+                    break
+                headers = _parse_http_headers(data.decode("utf-8", "ignore"))
+                location = headers.get("location", "")
+                dial_app = headers.get("application-url", "")
+                ip = addr[0]
+                dev = _fetch_upnp_description(location) if location else {}
+                name = dev.get("name") or headers.get("server", "") or ip
+                dev_id = _slug(f"{name}-{ip}")
+                entry = out.get(dev_id, {
+                    "id": dev_id, "name": name, "type": "media-renderer",
+                    "ip": ip, "via": "ssdp",
+                })
+                if dev.get("name"):
+                    entry["name"] = dev["name"]
+                if dev.get("model"):
+                    entry["model"] = dev["model"]
+                if dev.get("manufacturer"):
+                    entry["manufacturer"] = dev["manufacturer"]
+                if dial_app or dev.get("dialAppUrl"):
+                    entry["dialAppUrl"] = dial_app or dev.get("dialAppUrl")
+                    entry["type"] = "dial"
+                out[dev_id] = entry
+        except Exception as exc:
+            logger.debug("SSDP (%s) Fehler: %s", st, exc)
+        finally:
+            try:
+                if sock:
+                    sock.close()
+            except Exception:
+                pass
+    return list(out.values())
+
+
+def _fetch_upnp_description(location: str) -> dict:
+    try:
+        import requests
+        r = requests.get(location, timeout=3)
+        dial_app = r.headers.get("Application-URL", "")
+        xml = r.text
+        name = _xml_tag(xml, "friendlyName")
+        model = _xml_tag(xml, "modelName")
+        manuf = _xml_tag(xml, "manufacturer")
+        return {"name": name, "model": model, "manufacturer": manuf, "dialAppUrl": dial_app}
+    except Exception:
+        return {}
+
+
+def _discover_arp() -> list[dict]:
+    """Rohe Host-Liste aus der ARP-Tabelle (kein aktiver Scan)."""
+    out = []
+    try:
+        with open("/proc/net/arp", "r", encoding="utf-8") as f:
+            lines = f.read().splitlines()[1:]
+        for ln in lines:
+            parts = ln.split()
+            if len(parts) < 4:
+                continue
+            ip, _hw, _flags, mac = parts[0], parts[1], parts[2], parts[3]
+            if mac == "00:00:00:00:00:00":
+                continue
+            out.append({
+                "id": _slug(f"host-{ip}"), "name": ip, "type": "host",
+                "ip": ip, "mac": mac, "via": "arp",
+            })
+    except Exception:
+        pass
+    return out
+
+
+def _merge_devices(*lists) -> list[dict]:
+    """Fuehrt Geraetelisten zusammen, dedupt per IP (reichere Quelle gewinnt)."""
+    by_ip: dict[str, dict] = {}
+    loose: list[dict] = []
+    order = {"mdns": 3, "ssdp": 2, "arp": 1}
+    for lst in lists:
+        for d in lst:
+            ip = d.get("ip") or ""
+            if not ip:
+                loose.append(d)
+                continue
+            cur = by_ip.get(ip)
+            if not cur:
+                by_ip[ip] = d
+            else:
+                # bessere Quelle / mehr Felder → mergen
+                merged = {**d, **{k: v for k, v in cur.items() if v}}
+                if order.get(d.get("via"), 0) >= order.get(cur.get("via"), 0):
+                    merged.update({k: v for k, v in d.items() if v})
+                # DIAL-URL / mac aus beiden behalten
+                for key in ("dialAppUrl", "mac", "model", "manufacturer"):
+                    merged[key] = d.get(key) or cur.get(key) or merged.get(key)
+                by_ip[ip] = {k: v for k, v in merged.items() if v not in (None, "")}
+    return list(by_ip.values()) + loose
+
+
+# ─── Control ────────────────────────────────────────────────────────
+
+async def _control(action: str, params: dict, devices: list[dict]) -> dict:
+    """Fuehrt eine Steuer-Aktion aus. Guards: CONTROL_ENABLED + Allowlist."""
+    if not CONTROL_ENABLED:
+        return {"ok": False, "error": "Steuerung ist an diesem Satelliten deaktiviert (CONTROL_ENABLED=false)."}
+    if action not in CONTROL_ALLOWLIST:
+        return {"ok": False, "error": f"Aktion '{action}' nicht erlaubt (Allowlist: {', '.join(CONTROL_ALLOWLIST)})."}
+    logger.info("[control] %s params=%s", action, {k: str(v)[:60] for k, v in (params or {}).items()})
+    loop = asyncio.get_event_loop()
+    try:
+        if action == "dial.launch":
+            return await loop.run_in_executor(None, _do_dial_launch, params, devices)
+        if action == "wol":
+            return await loop.run_in_executor(None, _do_wol, params)
+        if action in ("http.get", "http.post"):
+            return await loop.run_in_executor(None, _do_http, action, params)
+        return {"ok": False, "error": f"Aktion '{action}' nicht implementiert."}
+    except Exception as exc:
+        return {"ok": False, "error": f"{action} fehlgeschlagen: {exc}"}
+
+
+def _find_device(devices: list[dict], ref: str) -> Optional[dict]:
+    ref = (ref or "").strip().lower()
+    if not ref:
+        return None
+    for d in devices:
+        if d.get("id", "").lower() == ref or d.get("ip", "") == ref:
+            return d
+    for d in devices:
+        if ref in (d.get("name", "").lower()):
+            return d
+    return None
+
+
+def _do_dial_launch(params: dict, devices: list[dict]) -> dict:
+    """DIAL-App-Launch, z.B. YouTube-Video auf Fire TV / Smart-TV.
+    params: {device, app='YouTube', v=<videoId> (oder beliebige app-params)}"""
+    import requests
+    ref = params.get("device") or ""
+    dev = _find_device(devices, ref)
+    app_url = (dev or {}).get("dialAppUrl") if dev else params.get("dialAppUrl")
+    if not app_url:
+        return {"ok": False, "error": f"Kein DIAL-Geraet fuer '{ref}' gefunden (oder keine Application-URL)."}
+    app = params.get("app") or "YouTube"
+    # app-Parameter (alles ausser device/app) als form-urlencoded Body.
+    body = {k: v for k, v in (params or {}).items() if k not in ("device", "app", "dialAppUrl")}
+    url = app_url.rstrip("/") + "/" + app
+    r = requests.post(url, data=body, timeout=5)
+    ok = r.status_code in (200, 201)
+    return {"ok": ok, "result": f"DIAL {app} → {(dev or {}).get('name', ref)} (HTTP {r.status_code})"
+            if ok else None,
+            "error": None if ok else f"DIAL-Launch HTTP {r.status_code}: {r.text[:120]}"}
+
+
+def _do_wol(params: dict) -> dict:
+    mac = (params.get("mac") or "").strip()
+    if not re.match(r"^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$", mac):
+        return {"ok": False, "error": f"Ungueltige MAC: {mac!r}"}
+    clean = re.sub(r"[:-]", "", mac)
+    packet = b"\xff" * 6 + bytes.fromhex(clean) * 16
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    s.sendto(packet, ("255.255.255.255", 9))
+    s.close()
+    return {"ok": True, "result": f"Wake-on-LAN an {mac} gesendet."}
+
+
+def _do_http(action: str, params: dict) -> dict:
+    import requests
+    url = params.get("url") or ""
+    if not url.startswith(("http://", "https://")):
+        return {"ok": False, "error": "url (http/https) erforderlich."}
+    method = "GET" if action == "http.get" else "POST"
+    r = requests.request(method, url, data=params.get("body"),
+                         headers=params.get("headers"), timeout=6)
+    return {"ok": True, "result": {"status": r.status_code, "body": r.text[:2000]}}
+
+
+# ─── Helpers ────────────────────────────────────────────────────────
+
+def _slug(s: str) -> str:
+    s = (s or "").strip().lower()
+    s = re.sub(r"[^a-z0-9]+", "-", s).strip("-")
+    return s or "dev"
+
+
+def _parse_http_headers(text: str) -> dict:
+    headers = {}
+    for line in text.split("\r\n")[1:]:
+        if ":" in line:
+            k, _, v = line.partition(":")
+            headers[k.strip().lower()] = v.strip()
+    return headers
+
+
+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 ""
+
+
+# ─── Satellit (RVS-Client) ──────────────────────────────────────────
+
+class Satellite:
+    def __init__(self) -> None:
+        self.ws: Optional[websockets.WebSocketClientProtocol] = None
+        self._devices: list[dict] = []
+        self._devices_ts: float = 0.0
+        self._scanning = False
+
+    async def _scan(self, force: bool = False) -> list[dict]:
+        fresh = (time.time() - self._devices_ts) < DEVICE_CACHE_TTL_SEC
+        if self._devices and fresh and not force:
+            return self._devices
+        if self._scanning:
+            # Laufenden Scan abwarten (grob)
+            for _ in range(30):
+                await asyncio.sleep(0.2)
+                if not self._scanning:
+                    break
+            return self._devices
+        self._scanning = True
+        try:
+            loop = asyncio.get_event_loop()
+            mdns = await loop.run_in_executor(None, _discover_mdns, DISCOVER_TIMEOUT_SEC)
+            ssdp = await loop.run_in_executor(None, _discover_ssdp, DISCOVER_TIMEOUT_SEC)
+            arp = await loop.run_in_executor(None, _discover_arp)
+            self._devices = _merge_devices(mdns, ssdp, arp)
+            self._devices_ts = time.time()
+            logger.info("[scan] %d Geraete (mdns=%d ssdp=%d arp=%d)",
+                        len(self._devices), len(mdns), len(ssdp), len(arp))
+        finally:
+            self._scanning = False
+        return self._devices
+
+    async def _send(self, message: dict) -> None:
+        if self.ws is None:
+            return
+        try:
+            await self.ws.send(json.dumps(message))
+        except Exception as exc:
+            logger.warning("send fehlgeschlagen: %s", exc)
+
+    async def _hello(self, log: bool = False) -> None:
+        await self._send({
+            "type": "sat_hello",
+            "payload": {
+                "id": SATELLITE_ID,
+                "location": SATELLITE_LOCATION,
+                "caps": CAPABILITIES,
+                "control": CONTROL_ENABLED,
+                "net": NET,
+            },
+            "timestamp": int(time.time() * 1000),
+        })
+        if log:
+            logger.info("sat_hello gesendet: id=%s location=%s caps=%s",
+                        SATELLITE_ID, SATELLITE_LOCATION, CAPABILITIES)
+
+    def _for_me(self, payload: dict) -> bool:
+        target = (payload.get("satellite") or "").strip().lower()
+        if not target or target in ("all", "*"):
+            return True
+        return target in (SATELLITE_ID.lower(), SATELLITE_LOCATION.lower())
+
+    async def _handle(self, raw: str) -> None:
+        try:
+            msg = json.loads(raw)
+        except Exception:
+            return
+        mtype = msg.get("type", "")
+        payload = msg.get("payload", {}) or {}
+
+        if mtype == "sat_discover":
+            if not self._for_me(payload):
+                return
+            req_id = payload.get("requestId", "")
+            devices = await self._scan(force=bool(payload.get("force")))
+            await self._send({
+                "type": "sat_devices",
+                "payload": {"requestId": req_id, "satellite": SATELLITE_ID,
+                            "location": SATELLITE_LOCATION, "devices": devices,
+                            "net": NET},
+                "timestamp": int(time.time() * 1000),
+            })
+
+        elif mtype == "sat_command":
+            if not self._for_me(payload):
+                return
+            req_id = payload.get("requestId", "")
+            action = (payload.get("action") or "").strip()
+            params = payload.get("params") or {}
+            if payload.get("device") and "device" not in params:
+                params["device"] = payload.get("device")
+            devices = await self._scan()
+            result = await _control(action, params, devices)
+            await self._send({
+                "type": "sat_result",
+                "payload": {"requestId": req_id, "satellite": SATELLITE_ID, **result},
+                "timestamp": int(time.time() * 1000),
+            })
+
+    async def _periodic_scan(self) -> None:
+        while True:
+            try:
+                await self._scan(force=True)
+            except Exception as exc:
+                logger.warning("periodischer Scan-Fehler: %s", exc)
+            await asyncio.sleep(SCAN_INTERVAL_SEC)
+
+    async def _heartbeat(self) -> None:
+        # Re-announce bei jedem Heartbeat: falls die Bridge NACH uns (neu)
+        # verbindet, lernt sie uns so innerhalb von HEARTBEAT_SEC — RVS replayt
+        # nichts. Haelt zugleich last_seen in der Bridge-Registry frisch.
+        while True:
+            await asyncio.sleep(HEARTBEAT_SEC)
+            await self._send({"type": "heartbeat", "timestamp": int(time.time() * 1000)})
+            await self._hello()
+
+    async def run(self) -> None:
+        if not RVS_HOST or not RVS_TOKEN:
+            logger.error("RVS_HOST und RVS_TOKEN sind Pflicht (siehe .env.example).")
+            return
+        asyncio.create_task(self._periodic_scan())
+        backoff = 1
+        while True:
+            proto = "wss" if RVS_TLS else "ws"
+            url = f"{proto}://{RVS_HOST}:{RVS_PORT}?token={RVS_TOKEN}"
+            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:
+                    self.ws = ws
+                    backoff = 1
+                    await self._hello(log=True)
+                    hb = asyncio.create_task(self._heartbeat())
+                    try:
+                        async for raw in ws:
+                            await self._handle(raw)
+                    finally:
+                        hb.cancel()
+            except Exception as exc:
+                logger.warning("RVS-Verbindung verloren: %s", exc)
+            finally:
+                self.ws = None
+            await asyncio.sleep(backoff)
+            backoff = min(backoff * 2, 30)
+
+
+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"))
+    if NET.get("warning"):
+        logger.warning("⚠ %s", NET["warning"])
+    try:
+        asyncio.run(Satellite().run())
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()