release: bump version to 0.2.2.2

fix(brain): project_summary liest volle Projekt-Historie aus chat_backup.jsonl
"Hol dir die Infos aus Projekt X" lieferte fast immer leer: project_summary las nur das rollende Conversation-Window (~50 Turns ueber alle Projekte), aeltere Projekt-Chats sind da rausdistilliert. Jetzt liest _read_project_history die echte volle Historie aus /shared/config/chat_backup.jsonl (im Brain gemountet), letzte ~20 Turns des Zielprojekts, Standort-Hints gefiltert, Fallback aufs Window. Tool-Beschreibung geschaerft. Live gegen echte Daten getestet (basic_os 20 / vdi 20 / mac_os_update_fehler 6 Turns). Kein APK-Rebuild noetig (nur Brain). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-17 22:57:49 +02:00 · 2026-07-17 22:55:54 +02:00 · 2026-07-17 22:47:38 +02:00 · 2026-07-17 22:37:51 +02:00 · 2026-07-17 21:47:18 +02:00 · 2026-07-17 21:44:32 +02:00
51 changed files with 4619 additions and 273 deletions
@@ -10,7 +10,237 @@ Alle Änderungen am Projekt. Format: [Keep a Changelog](https://keepachangelog.c

 ---

-## [Unreleased] — 2026-07-10
+## [0.2.2.3] — 2026-07-17 — ARIA liest andere Projekt-Chats wirklich (volle Historie)
+
+### Behoben
+
+- **`project_summary` fand fast nie Inhalte.** Es las nur ARIAs rollendes Kontextfenster (~50 Turns über ALLE Projekte) — ältere/andere Projekt-Chats sind da längst rausdistilliert. „Hol dir die Infos aus Projekt X" lieferte deshalb leere Ergebnisse, und ARIA wusste nicht, wie sie an die Historie kommt. Jetzt liest das Tool die **echte, volle Historie aus `chat_backup.jsonl`** (im Brain gemountet) — die letzten ~20 Turns des Zielprojekts, unabhängig davon wie lange man da nicht war. Standort-Hints in User-Turns werden rausgefiltert. Fallback aufs Fenster, falls das Backup fehlt. Tool-Beschreibung geschärft, damit ARIA es direkt aufruft.
+- Nebenbei bereinigt: `mac_os_update_fehler` war durch den alten `set_project_kind`-Bug (0.2.2.1) fälschlich `kind=code` — auf `chat` zurückgesetzt.
+
+### Deploy
+`git pull && docker compose up -d --build brain` (kein APK-Rebuild nötig).
+
+---
+
+## [0.2.2.2] — 2026-07-17 — Voice-Projektwechsel zurück — aber gerätelokal
+
+### Hinzugefügt
+
+- **„ARIA, geh in Projekt X" per Sprache wechselt wieder das Projekt** — aber **nur auf dem Gerät, das den Befehl gab**. Andere App-Instanzen und das Diagnostic bleiben in ihrem Projekt.
+- Umsetzung: Jedes Gerät merkt sich die IDs seiner eigenen Anfragen (Text-`clientMsgId` + Voice-`audioRequestId`). Der Brain/Voice-Router hängt an jedes `project_changed`-Event die auslösende `clientMsgId` an; die App folgt dem Wechsel nur, wenn die ID eine **eigene** ist. Deckt beide Voice-Pfade ab (ARIAs `project_enter`/`exit` via `send_to_core` **und** den Bridge-Voice-Router „für Projekt X: …" / „zurück zum Hauptchat").
+- Manuelles Umschalten bleibt wie gehabt gerätelokal über den Drawer.
+
+### Deploy
+`git pull && docker compose up -d --build bridge` + APK 0.2.2.2 (kein Brain-Rebuild nötig).
+
+---
+
+## [0.2.2.1] — 2026-07-17 — Projekt-Fokus wirklich pro Gerät unabhängig
+
+### Behoben
+
+- **`set_project_kind` markierte das falsche Projekt.** Es nutzte den **globalen** `active_project` (geräteübergreifend) statt des Projekts, in dem der aktuelle Request läuft. Folge: Obwohl auf der App „Basic os" aktiv war, bekam das global-aktive „Mac OS Update Fehler" `kind=code`. Jetzt wirkt das Tool auf die pro Request mitgesendete `project_id` (in `_dispatch_tool` durchgereicht) — jede App-/Diagnostic-Instanz markiert ihr eigenes Projekt.
+- **App wurde von fremden `project_changed`-Broadcasts ins andere Projekt gezogen.** Ein Projektwechsel/‑anlegen durch ARIA, das Diagnostic oder eine andere App-Instanz erzwang auf **allen** Geräten einen Fokuswechsel. Der Projekt-Fokus ist jetzt **rein gerätelokal**: Broadcasts aktualisieren nur Namen + Typ, wechseln aber nicht mehr das Projekt. Umschalten geht ausschließlich lokal über den Projekt-Drawer. So arbeitet jedes Gerät unabhängig in seinem eigenen Projekt (auch mehrere App-Instanzen).
+- Hinweis: „ARIA, geh in Projekt X" per Sprache wechselt das App-Projekt dadurch **nicht mehr** automatisch — bewusst, damit Geräte unabhängig bleiben. Wechseln über den Drawer.
+
+### Deploy
+`git pull && docker compose up -d --build brain` + APK 0.2.2.1 neu bauen.
+
+---
+
+## [0.2.2.0] — 2026-07-17 — Workbench: Taskleisten-Dock statt Zoom-Landkarte + bedienbare VNC-Konsole
+
+### Geändert
+
+**Cockpit-Navigation neu gedacht — Dock statt Pinch-Canvas**
+- Die Zoom-Landkarte (mit 2 Fingern rauszoomen, Kachel finden, reintippen) fühlte sich auf 5 Zoll fummelig an. Ersetzt durch eine **Taskleiste unten im Daumenbereich** (Chat · Code · Desktop): **ein Tap wechselt sofort** das Panel, ein animierter Indikator gleitet unter das aktive Icon. Desktop-*Umfang*, Handy-*Ergonomie*.
+- Jedes Panel ist **bildschirmfüllend** und Handy-optimiert; alle bleiben gemountet (nur das aktive ist sichtbar) → kein Remount, Chat behält RVS/Audio/Queue, WebViews ihren Zustand.
+- Das Dock **blendet bei offener Tastatur aus** (mehr Platz zum Tippen) und respektiert die Gesten-Navigationsleiste (Safe-Area).
+- **Aktivitäts-Punkte** am Dock: Code blau, sobald Dateien da sind; Desktop grün, wenn die VM verbunden ist.
+- Entfällt: Pinch/Pan-Canvas, Übersichts-Button im Header, die „Landkarten"-Thumbnails.
+
+**noVNC-Konsole endlich bedienbar**
+- Steuerungs-Leiste im Desktop-Panel: **⌨ Tastatur** (blendet die Handy-Tastatur ein, tippt direkt in die VM — inkl. Enter/Backspace/Pfeiltasten), **Strg+Alt+Entf**, und **⤢ Fit ↔ 1:1**. Tippen/Ziehen steuert weiterhin die Maus.
+
+### Deploy
+Nur **App neu bauen** (kein Backend). APK 0.2.2.0.
+
+---
+
+## [0.2.1.9] — 2026-07-17 — Kompakt ↔ Cockpit: Umschalter für den Kachel-Desktop
+
+### Hinzugefügt
+
+- **Ansichts-Umschalter im Header** („⧉ Kompakt" / „⧉ Cockpit"): Die App startet in **Kompakt** — der klassische Vollbild-Chat, **exakt wie vor dem Umbau** (Default, Mama-tauglich). Ein Tap auf den Button oben rechts schaltet auf **Cockpit** — den zoom-/verschiebbaren Kachel-Desktop. Persistiert über Neustart (`aria_view_mode`).
+- **Warum:** Nach dem 0.2.1.8-Deploy sah die App „unverändert" aus — korrekt, denn im normalen Chat gibt es nur eine Kachel (= Vollbild-Chat). Der Umschalter macht den Cockpit-Modus jetzt **explizit sichtbar/steuerbar**, statt nur bei Code-Projekten aufzutauchen.
+- Im Cockpit ist die **Übersicht jetzt immer erreichbar** (auch im Hauptchat): „⤢ Übersicht" sitzt **im Header links** (kollidiert nicht mehr mit dem Abbrechen-Button der „ARIA denkt"-Leiste), dazu 2-Finger-Pinch/Pan und Hardware-Back.
+- Im Cockpit werden **immer alle vier Kacheln** gezeigt (Chat/Editor/Desktop/Vorschau) — Editor/Desktop/Vorschau als Platzhalter mit Status-Untertitel („kein Code-Projekt" / „kein Desktop"), bis ARIA ein Code-Projekt startet bzw. eine VM läuft. Vorher wirkten sie „verschwunden", weil sie erst bei Code-Projekten auftauchten.
+
+---
+
+## [0.2.1.8] — 2026-07-17 — Desktop-Workspace: zoombarer Canvas, Live-Code-Editor, QEMU/VNC
+
+### Hinzugefügt
+
+**Zoom-/verschiebbarer Workspace-Canvas (App)**
+- Die App ist jetzt eine desktop-artige Arbeitsfläche: rausgezoomt sieht man eine **Landkarte aus Kacheln** (Chat, Editor, Desktop, Vorschau), die man mit **2 Fingern zoomt und verschiebt**. Tippt man eine Kachel an, zoomt sie voll auf und wird **echt bedienbar** („Übersicht + Fokus"). „⤢ Übersicht" bzw. der Hardware-Back führen zurück zur Landkarte.
+- Technisch: `react-native-gesture-handler` + `react-native-reanimated` (60 fps auf dem UI-Thread). Zwei Ebenen — eine skalierte Thumbnail-Welt und eine **Identity-Content-Ebene** (Scale 1), in der die schweren Inhalte (ChatScreen + WebViews) immer gemountet sind und nur die fokussierte sichtbar ist. Dadurch bleiben Touch-Koordinaten/Keyboard korrekt und nichts remountet beim Fokuswechsel. **Reiner Chat verhält sich exakt wie bisher** (eine Kachel, dauerhaft fokussiert).
+
+**Live-Code-Editor für Code-Projekte (App + Bridge + Proxy)**
+- Wird ein Projekt zum Code-Projekt (ARIA ruft `set_project_kind('code')`), erscheinen Editor- und Desktop-Kachel. Der Editor (WebView, selbstenthaltener Highlight-Editor, offline) **zeigt live, was ARIA schreibt** — und Stefan kann selbst editieren; Änderungen gehen zurück an ARIA.
+- Fluss: ARIAs `Write`/`Edit` unter `/shared/projects/<projekt-id>/` werden im Proxy abgefangen und als `code_file` über die Bridge/RVS an die App gespiegelt; Stefans Edits kommen als `code_file_edit` pfad-sicher zurück ins selbe Verzeichnis.
+
+**QEMU für alle Architekturen + Live-Desktop per VNC (Host + Bridge + App)**
+- ARIA kann jetzt VMs für **jede Architektur** bauen/testen (x86, ARM, MIPS, PPC, RISC-V, SPARC) — Host-Helper `aria-vm` (`create/boot/screenshot/list/stop`), installiert via `host-provisioning/qemu-setup.sh`. KVM für x86-Gäste, sonst TCG. Beispiel: ein Win-3.11-System bauen und in QEMU testen.
+- Der **VNC-Live-Desktop wird durch den RVS-Server getunnelt**: die Bridge brückt rohes RFB-TCP (QEMU `127.0.0.1:5901`) ↔ RVS (`vnc_data`/`vnc_input`, Base64-in-JSON), der noVNC-Client läuft in der App-WebView (`window.WebSocket`-Shim). Stefan bedient die VM **live mit Maus/Tastatur** in der Desktop-Kachel — NAT-sicher, kein offener Port am Host, kein websockify/noVNC auf dem Host nötig.
+
+**Kleineres**
+- Pro-Projekt-Layout: die zuletzt fokussierte Kachel wird pro Projekt gemerkt (`aria_workspace_layout`).
+- Projekt-Modell bekommt `kind` ('chat'|'code'); Seed-Regel lehrt ARIA den Code-Projekt-Workflow (Arbeitsverzeichnis `/shared/projects/<id>/`, `aria-vm`, VNC landet automatisch in der App).
+
+### Deploy
+`git pull && docker compose up -d --build brain bridge proxy` · RVS-Stack `up -d --build` · Host: `bash host-provisioning/qemu-setup.sh` (einmalig, als root) · APK neu bauen (nach `npm install` einmalig `npm start --reset-cache` + `gradlew clean`, wegen der neuen nativen Module).
+
+---
+
+## [0.2.1.5] — 2026-07-12 — Pro-Projekt-Queue mit Rückfrage-Loop
+
+### Hinzugefügt
+
+**Nachrichten-Queue pro Projekt (App + Diagnostic)**
+- Eine zweite Nachricht, während ARIA am aktuellen Task arbeitet, wird jetzt **angestellt** statt den laufenden Task abzubrechen (vorher: Barge-In-Cancel). Sie läuft der Reihe nach, **pro Projekt unabhängig** (paralleles Arbeiten in mehreren Projekten bleibt). Wartende Nachrichten zeigen als ⏸-Bubble — tippen entfernt sie aus der Warteschlange.
+- **Rückfrage-Loop:** Stellt ARIA eine echte, blockierende Rückfrage, **pausiert** die Queue und deine nächste Eingabe beantwortet sie — bis eine finale Antwort kommt, dann läuft der nächste Queue-Eintrag (gleiches Muster). Banner „❓ ARIA fragt nach — deine Eingabe beantwortet das". Der Stop-Button bricht den aktuellen Task ab und schaltet zum nächsten.
+- ARIA signalisiert eine Rückfrage über einen **unsichtbaren `[[AWAIT]]`-Marker** — wie speak/converse deklariert das Modell den Zustand selbst (kein „endet-mit-?"-Raten). Brain strippt ihn, gibt `awaiting_reply` durch `chat()` → `ChatOut` → Bridge-Chat-Payload. Local (tool-los) und Fast-Path markieren nie.
+
+**Pro-Projekt-Textfeld-Entwürfe (App + Diagnostic)**
+- Der Feldinhalt bleibt beim Projektwechsel erhalten: in Projekt X tippen, zu Y wechseln (leeres Feld), zurück zu X → dein Entwurf steht wieder da. In Storage persistiert.
+
+**TTS-Abspiel-Queue (App)**
+- Zwei fast gleichzeitig fertige Antworten sprechen jetzt garantiert **nacheinander** statt sich gegenseitig abzuschneiden. Vorher war das Timing-Glück (`PcmStreamPlayer.start()` ruft `stopInternal()` = flush/release, hätte die laufende gecuttet). Jetzt: „spielt hörbar" gilt bis zum echten `PcmPlaybackFinished` (nicht nur bis Stream-Ende); eine neue hörbare Antwort, die währenddessen ankommt, wird gepuffert und danach nachgespielt (Kette für 3, 4, …). Harter Stop/Barge-In/Mund-Button verwirft die Queue.
+
+### Geändert
+
+- **Voice bricht nicht mehr ab:** eine neue Sprachnachricht während ARIA arbeitet stoppt nur akustisch das TTS (sauberes Mikro) und wird über den Brain-Projekt-Lock serialisiert, statt den laufenden Task abzubrechen (passend zu „immer anstellen + Stop-Button"). Text-Senden erkennt Brain-busy als Fallback, damit auch nach einem voice-gestarteten Turn korrekt angestellt wird. Grenze: eine per Sprache gestartete Aufgabe erscheint nicht als löschbare ⏸-Bubble (Aufnahme wird live gestreamt, nicht app-seitig gepuffert).
+
+---
+
+## [0.2.1.4] — 2026-07-12 — Lokales LLM: der ehrliche Rückbau
+
+### Geändert
+
+**Lokales LLM wieder tool-los (B1a) — ein 8B ist ein schlechter Tool-Caller**
+- B1b hatte dem lokalen Modell Werkzeuge (`run_*`/`web_search`) gegeben — die gemeinsame Wurzel von **zwei** Problemen: (1) ein 8B erfindet mit Werkzeug in der Hand lieber eine plausible Antwort („der Song ist X") statt es zu rufen → Halluzination; (2) das erzwang per-Skill-Guards (skaliert nicht). Local ist jetzt wieder **tool-los** = reines Reden; alles mit Grundwahrheit (Fakt/Live-Zustand/Gedächtnis/Aktion) gehört an Claude oder den deterministischen Fast-Path. Kein Skill-Ergebnis mehr fälschbar
+- **Keine Input-Wortliste im Router:** eine kurz eingeführte `_LIVE_HINTS`-Blacklist (Wetter/Musik/… → Claude) wieder entfernt — aus offenem Freitext die Absicht per Wortliste zu raten ist nie vollständig, jeder Miss = ein Halo (nur von per-Skill auf per-Wort verschoben). Generisch = das Modell entscheidet **selbst** (`<<ESCALATE>>`); ein stärkeres lokales Modell übernimmt die Selbst-Erkennung später, bis dahin ist local per Einstellung abschaltbar (aus, nicht raus)
+- Expliziter Nutzer-Wunsch „nimm Claude/Clodi" wird im Router respektiert (geht nie lokal)
+
+### Behoben
+
+- **Info-Halluzination:** local nannte manchmal aktuellen Song/Restzeit/Skip-Titel ohne `run_spotify` zu rufen (mal echt, mal frei erfunden — „Midnight City von M83" nie aufgerufen). Neuer Output-Guard `_claims_live_media_state` eskaliert behauptete Live-Auskünfte ohne echten Skill-Call an Claude; Local-Prompt zusätzlich gehärtet (nie Titel/Zeit/Gerät ohne Tool-Ergebnis; bei „OK: next" keinen Titel erfinden)
+- **Leeres `<voice></voice>` machte TTS stumm:** Claude hängt reflexartig manchmal ein leeres Voice-Tag an → `clean_text_for_tts` nahm den leeren Inhalt → gar keine Sprachausgabe (Playlist „Fliegen" gesprochen, „Prodigy" stumm — reiner Claude-Output-Zufall, nicht Skill/Playlist-Name). Leeres/whitespace-Tag wird jetzt ignoriert, der normale Anzeigetext gelesen
+- **Datei-Anhang erschien erst nach Seitenwechsel:** die Live-`chat`-Payload trug keine `files` (Anhänge kamen nur als separates `file_from_aria`-Event) → an der Nachricht tauchte die Datei erst nach Reload aus `chat_backup` auf. Bridge schickt die `files` jetzt in der chat-Payload, App hängt sie live an die Text-Bubble (wie der Reload-Pfad) und entfernt die redundante Solo-Bubble
+- **TDZ-Zeitbombe (App):** `sendTextMessage` stand vor seinen Dependencies (`interruptAriaIfBusy`, `sendPendingAttachments`) im deps-Array — Temporal Dead Zone; lief nur dank Babels `const`→`var`-Hebung, ein strengerer Bundler hätte beim Mount weißgescreent. Deklaration hinter die Deps verschoben
+- **QRScanner tsc-clean:** toter Prop `colorForScannerFrame` (existiert in `react-native-camera-kit` v13 nicht) entfernt; die fehlerhaften Lib-Typen (optionale Props als required markiert) lokal + dokumentiert umgangen → **Projekt komplett tsc-clean (0 Fehler)**
+
+**Spotify-Skill — von ARIA live im Gespräch weiter geschärft**
+- Skip (`next`/`previous`) sagt jetzt den **echten** neuen Titel an (holt den Track nach dem Skip via API) statt local einen erfinden zu lassen
+- `playlist_play`/`search_and_play`/`play` nennen das **tatsächliche** Wiedergabegerät (aus `GET /v1/me/player`, kein Raten — verhinderte den Fehler, dass Claude ein falsch geratenes Gerät auch noch ansteuerte) und lesen konsistent vor; saubere „Sprach-Grammatik": Ansagen sprechen, Steuerbefehle (play/pause/transfer/volume) schweigen
+- `yt-dlp-download`-Skill um einen MP3-Modus erweitert — ARIA hat das fehlende Werkzeug **selbst gebaut**, als eine deutsche Titelmelodie nicht auf Spotify lag (Web-Suche → YouTube-Download → MP3 in den Chat, in <1 min)
+
+---
+
+## [0.2.1.3] — 2026-07-11
+
+### Hinzugefügt
+
+- **`skill_get`-Tool:** ARIA liest den echten Quellcode + Manifest + Readme eines Skills, **bevor** sie ihn ändert — kein Blind-Rewrite mehr (vorher wurde ein guter Skill durch eine schlechtere Neufassung ersetzt, weil das referenzierte `skill_get` gar nicht existierte)
+
+### Behoben
+
+- **`converse` folgt dem Skill (Fast-Path):** auch ein Fast-Path-Befehl kann einen Skill auslösen, nach dem noch etwas zu sagen ist — `converse` kommt jetzt aus Manifest/Skill-Output statt hart auf `False`
+- **Sprachnachricht-Bubble verschwand nach manuellem Stop:** bei „ohne Ohr" aufgenommener Sprachnachricht + Stop entfernte ein leeres stream-end-Endpoint die schon gefüllte Bubble; jetzt wird nur noch der unaufgelöste Platzhalter entfernt
+
+---
+
+## [0.2.1.2] — 2026-07-11 — Standort-Intelligenz + Skill steuert seine Ausgabe
+
+### Hinzugefügt
+
+**GPS → Ortsname im Standort-Präfix (keyless, keine Tokens)**
+- Reverse-Geocoding der Koordinaten in der Bridge (Nominatim zoom=18: Straße+Hausnr, PLZ+Ort, Bundesland; Straßen-Ref + Autobahn-km via Overpass) — damit das lokale Modell nicht „Berlin" für Oldenburg rät; Ortsname wird **vor** dem Präfix-Bau awaited (rechtzeitig für die erste Nachricht)
+- Fahrtrichtung als Himmelsrichtung **+ exakte Peilung in Grad** (Haversine/Bearing aus aufeinanderfolgenden Fixes, `MIN_MOVE_M`-Schwelle gegen Zittern)
+
+**Skill steuert seine Ausgabe selbst — `speak` + `converse` pro Aufruf**
+- Ein Skill entscheidet per JSON-Output `{speak, converse}` pro Operation, ob vorgelesen wird und ob danach 30 s weitergelauscht wird (Manifest-Default, Output überschreibt) — z. B. „was läuft" vorlesen aber kein Dialog, „nächstes Lied" stumm. In der Skill-Bauanleitung **mit dem WARUM** dokumentiert, damit die KI die Flags beim Bauen versteht (kein Hardcode im Brain)
+
+### Behoben / Geändert
+
+- **Generischer Skill-Prompt (kein Hardcode):** der Router beschreibt `run_*`-Skills generisch (weiß nicht mehr, welche „schwer" sind); ein Stop im 30-s-Lauschen beendet dieses jetzt wirklich (kein zweiter Gong / erneutes Öffnen)
+- **Anti-Halluzination:** behauptet local eine Steuerbefehl-Quittung („Spotify: …", „Playlist abspielen") ohne das Tool wirklich zu rufen → Eskalation an Claude statt erfundene Bestätigung durchzulassen
+
+---
+
+## [0.2.1.1] — 2026-07-11
+
+### Hinzugefügt
+
+- **Skill entscheidet selbst, ob vorgelesen wird (`manifest.speak`):** Grundlage der späteren `speak`/`converse`-Architektur — der `speak`-Flag greift sowohl im lokalen als auch im Claude-Pfad, statt am fragilen leeren `<voice></voice>`-Hack zu hängen
+
+---
+
+## [0.2.0.6] — 2026-07-11
+
+### Hinzugefügt
+
+**Diagnostic + App — Projekte verstecken**
+- Neues `hidden`-Flag pro Projekt (bleibt voll nutzbar, nur aus Listen ausgeblendet — unabhängig von `status`/`archived`); `PATCH /projects/{id} {hidden}`
+- Diagnostic: 👁-Auge pro Projekt-Bubble (🙈 verstecken / 👁 dauerhaft sichtbar), Header-Toggle „Versteckte anzeigen (N)" blendet sie temporär gedimmt + „versteckt"-Badge ein — zum Ansehen/Auswählen ohne permanentes Enttarnen
+- App (`ProjectsBrowser`): versteckte standardmäßig ausgeblendet (Mama sieht sie nicht), Auge pro Zeile + Toggle spiegeln das Diagnostic-Verhalten; geteilter `hidden`-Status übers Brain
+
+**Diagnostic — Token-Ersparnis durch lokales LLM**
+- `metrics.jsonl` trägt jetzt `source` (claude | local | fast-path); lokale Calls nutzen echte `usage`-Tokens vom Adapter, Fast-Path = 0 Prompt-Tokens (`by_source`-Aggregation, rückwärts-kompatibel)
+- Neue Card „Lokales LLM & Claude-Ersparnis": pro Fenster (1h/5h/24h/30d) gesparte Claude-Calls (local + fast-path) + lokale Token-Last (eigene HW, kein Quota)
+
+**Spotify-Skill — von ARIA selbst geschärft**
+- Geräte-Transfer startet die Wiedergabe direkt mit (`play=true`) statt nur zu übertragen, inkl. Verifikation (`is_playing`-Check + expliziter Play-Fallback), Fuzzy-Gerätenamen und sauberen Exit-Codes; neue semantische Actions `play_on_device`/`search_and_play`/`playlist_play`/`queue_add`
+
+### Behoben
+
+- **Spotify-Resume (App):** nach einem Voice-Befehl blieb Spotify auf dem Handy pausiert. Statt des auf manchen Geräten (OnePlus) flakigen Audio-Focus-Nudge jetzt ein echter `KEYCODE_MEDIA_PLAY`-KeyEvent an die aktive MediaSession — gegated: nur wenn vor dem Dialog Musik lief (`isMusicActive`). Deterministisch, geräteunabhängig
+- **TTS-Zahlen:** freistehende Ganzzahlen werden jetzt tag-unabhängig ausgeschrieben („23°C" → „dreiundzwanzig Grad Celsius", „100%" → „einhundert Prozent"). Regression, seit das lokale LLM (bewusst ohne `<voice>`-Tag) leichte Turns übernahm; neuer vollständiger Zahl→Wort-Konverter (0…999999) am Ende von `clean_text_for_tts`, lange Ziffernfolgen (IDs) bleiben Ziffern
+- **„ARIA denkt" hängt:** Indikator + Abbrechen blieben stehen, obwohl der Turn laut Diagnostic fertig war. Die App räumt den kontext-scoped Indikator jetzt beim Eintreffen der Antwort selbst; die Bridge sendet zusätzlich ein `idle` für die Request-`projectId`, falls der Turn umgeroutet wurde (thinking ging mit Request-, idle mit Turn-`projectId`)
+- **Lokale Tool-Fehler:** Action-Skills, die bei Exit 0 einen Fehlschlag nur im stdout-Text melden (Spotify: „Fehler beim Übertragen", „Gerät nicht gefunden"), eskalieren jetzt generisch an Claude statt vom lokalen LLM vorgelesen zu werden (Info-Tools wie web_search ausgenommen)
+
+---
+
+## [0.2.0.4 – 0.2.0.5] — 2026-07-11 — Plan B: Lokales LLM („Gemini-Feeling")
+
+Ein kleines, schnelles Modell (**Qwen3 8B** via llama.cpp/llama-swap auf der Gamebox-GPU) übernimmt einfache Turns in **<1 s**; alles Schwere/Technische/Werkzeug-artige reicht ein Router automatisch an **Claude** weiter. Ziel: schnelle Antworten ohne die Claude-Max-Subscription aufzugeben.
+
+### Hinzugefügt
+
+**Lokales LLM (Brain + Bridge + Adapter)**
+- Router (B1a): Heuristik + `<<ESCALATE>>`-Selbstabbruch entscheidet pro Turn lokal vs. Claude; schlanker System-Prompt mit demselben `IDENTITY_ANCHOR` wie Claude (Rolle hält), nur letzte 8 Turns (Speed)
+- Lokale Tool-Fast-Lane (B1b): kuratierte Tools — `web_search` (self-hosted **SearXNG**, local-only), `memory_search`, `trigger_timer`, Spotify; Eskalation bei Tool-Fehler statt Raten
+- Consumer-Kette gespiegelt zu FLUX: Brain → Bridge `/internal/local-llm` → RVS → `llm-adapter` → llama.cpp; `enable_thinking:false` (Qwen wickelte sonst die ganze Antwort in `<think>`)
+- **B0.5:** llama-swap (Hot-Swap der Modelle on-demand) + Modellauswahl-Dropdown + Live-Lade-Status (loading/ready + Download-Hinweis) in Diagnostic
+- **SearXNG** als 6. Container auf der ARIA-VM (keyless Meta-Suche, JSON-API)
+
+**Quell-Badge (local / claude / fast-path)**
+- Diagnostic: immer an den ARIA-Bubbles
+- App: optionaler Schalter in den Einstellungen, pro Gerät gemerkt, default aus („ich will's, meine Mama nicht")
+
+**TTS — System-Flag `speak` (ja/nein) pro Antwort**
+- Die Quelle entscheidet übers Vorlesen (Fast-Path/Steuerbefehl = stumm, ARIA-Antwort = vorlesen), robust statt des fragilen leeren `<voice></voice>`-Hacks der beim Skill-Rebuild verloren ging
+
+### Behoben / Geändert
+
+- **Identität (Hauptchat):** Proxy nutzt jetzt `--system-prompt` (voller Replace) statt `--append-system-prompt` — die Claude-Code-Basis-Identität leakt nicht mehr in den Hauptchat (ARIA antwortete dort als „Claude Code" bzw. deutete die Persona als Injection). Dazu `IDENTITY_SEED` (synthetischer Grounding-Turn) + Gift-Wächter (Identity-Breaks werden nie in die History persistiert, Retry+Fallback) + Cleanup-Script gegen bereits vergiftete Turns
+- **Datenschutz (kritisch):** harte Diskretions-Regel im `IDENTITY_ANCHOR` — ARIA kennt intime/private Details, gibt sie aber **NIE ungefragt** preis (nicht in Vorstellungen, „was weißt du über mich", Zusammenfassungen, Triggern); nur auf konkrete Nachfrage, knapp. Bereits ausgeplauderte Turns bereinigt. Lokales Tier eskaliert Personen-/Beziehungs-/Gedächtnisfragen an Claude (kennt das Gedächtnis + antwortet diskret)
+- **Lokale Antwort nicht in `<voice>`** wickeln (Qwen imitierte den Tag aus dem Kontext → Anzeige war leer); **generische** Tool-Fehler-Eskalation statt per-Skill-Router-Hardcode (Router muss nicht wissen, welche Skills „schwer" sind)
+
+---
+
+## [0.2.0.3] — 2026-07-10

 ### Hinzugefügt

@@ -204,6 +204,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 +500,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 +518,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 +1031,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 +1044,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 20004
-        versionName "0.2.0.4"
+        versionCode 20202
+        versionName "0.2.2.2"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -5,7 +5,9 @@ import android.media.AudioAttributes
 import android.media.AudioFocusRequest
 import android.media.AudioManager
 import android.os.Build
+import android.os.SystemClock
 import android.util.Log
+import android.view.KeyEvent
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -183,6 +185,50 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
        promise.resolve(true)
    }

+    /** Zuverlaessiger Spotify-Resume: einen echten MEDIA_PLAY-Tastendruck an die
+     *  aktive MediaSession schicken — exakt das Signal der Play-Taste am
+     *  Bluetooth-Kopfhoerer. Anders als nudgeMediaResume (Focus-Stack-Trick,
+     *  auf manchen OEMs/Spotify-Versionen unzuverlaessig) spricht das Spotifys
+     *  MediaSession DIREKT an und startet die Wiedergabe deterministisch wieder.
+     *
+     *  Wir senden bewusst KEYCODE_MEDIA_PLAY (nicht PLAY_PAUSE) — das kann nur
+     *  starten, nie pausieren. Aufrufer muss also selbst gaten (nur senden wenn
+     *  vor dem Gespraech wirklich Musik lief, siehe isMusicActive()).
+     */
+    @ReactMethod
+    fun dispatchMediaPlay(promise: Promise) {
+        val am = audioManager()
+        if (am == null) {
+            promise.resolve(false)
+            return
+        }
+        try {
+            val now = SystemClock.uptimeMillis()
+            val down = KeyEvent(now, now, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MEDIA_PLAY, 0)
+            val up = KeyEvent(now, now, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PLAY, 0)
+            am.dispatchMediaKeyEvent(down)
+            am.dispatchMediaKeyEvent(up)
+            Log.i(TAG, "dispatchMediaPlay: KEYCODE_MEDIA_PLAY an aktive MediaSession gesendet")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "dispatchMediaPlay failed: ${e.message}")
+            promise.resolve(false)
+        }
+    }
+
+    /** Ob gerade Musik/Media aktiv abgespielt wird (AudioManager.isMusicActive).
+     *  Der Aufrufer merkt sich das VOR dem Focus-Grab, um am Dialog-Ende zu
+     *  entscheiden ob ein dispatchMediaPlay-Resume ueberhaupt gewuenscht ist. */
+    @ReactMethod
+    fun isMusicActive(promise: Promise) {
+        val am = audioManager()
+        if (am == null) {
+            promise.resolve(false)
+            return
+        }
+        promise.resolve(am.isMusicActive)
+    }
+
    /** Den USAGE_MEDIA-Focus-Stack im System aufmischen, damit Spotify/YouTube
     *  resumen wenn ein anderer Player (z.B. react-native-sound) seinen Focus
     *  nicht ordnungsgemaess released hat. Strategie: kurz selbst USAGE_MEDIA
@@ -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.0.4",
+  "version": "0.2.2.2",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -20,12 +20,15 @@
    "react-native-camera-kit": "^13.0.0",
    "react-native-document-picker": "^9.1.1",
    "react-native-fs": "^2.20.0",
+    "react-native-gesture-handler": "2.14.1",
    "react-native-image-picker": "^7.1.0",
    "react-native-permissions": "^4.1.4",
+    "react-native-reanimated": "3.6.2",
    "react-native-safe-area-context": "^4.8.2",
    "react-native-screens": "3.27.0",
    "react-native-sound": "^0.11.2",
-    "react-native-svg": "^14.1.0"
+    "react-native-svg": "^14.1.0",
+    "react-native-webview": "13.6.4"
  },
  "devDependencies": {
    "@react-native/eslint-config": "^0.73.2",
@@ -75,6 +75,9 @@ 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('');
+  // Versteckte Projekte standardmaessig ausblenden; Toggle blendet sie
+  // temporaer (gedimmt) ein — zum Ansehen/Auswaehlen oder Wieder-Sichtbarmachen.
+  const [showHidden, setShowHidden] = useState(false);

  // Refs damit useCallback NICHT bei jeder Re-Render des Parents neu erzeugt
  // wird (parent uebergibt oft inline-arrow-Callbacks, neue Identity jedes
@@ -109,6 +112,17 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
    return () => unsub();
  }, [visible, load]);

+  // Live-Sync: ein anderer Client (Diagnostic / andere App) hat ein Projekt
+  // geaendert (verstecken/anlegen/beenden/…) → project_changed ueber RVS →
+  // Liste neu laden, ohne dass Stefan manuell refreshen muss.
+  useEffect(() => {
+    if (!visible) return;
+    const unsub = rvs.onMessage((msg: any) => {
+      if (msg?.type === 'project_changed') load();
+    });
+    return () => unsub();
+  }, [visible, load]);
+
  const switchTo = useCallback((id: string) => {
    // Multi-Threading: Focus-Wechsel ist reine App-lokale UI-Entscheidung.
    // Brain wird nicht mehr benachrichtigt (kein globaler active_project mehr).
@@ -158,6 +172,19 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
      ]);
  }, [load]);

+  // Nach einer Projekt-Mutation die anderen Clients (Diagnostic, weitere
+  // App-Instanzen) live aktualisieren — via RVS project_changed. RVS echot
+  // NICHT an den Sender zurueck, darum laden wir lokal zusaetzlich selbst.
+  const broadcastProjectsChanged = useCallback(() => {
+    try { rvs.send('project_changed' as any, { reason: 'app' }); } catch {}
+  }, []);
+
+  const toggleHidden = useCallback((p: Project) => {
+    brainApi.setProjectHidden(p.id, !p.hidden)
+      .then(() => { broadcastProjectsChanged(); load(); })
+      .catch(e => Alert.alert('Fehler', String(e?.message || e)));
+  }, [load, broadcastProjectsChanged]);
+
  const archiveProject = useCallback((p: Project) => {
    Alert.alert(`"${p.name}" archivieren?`,
      'Verschwindet aus der Standardliste. Über "archivierte zeigen" erreichbar.',
@@ -176,11 +203,12 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
  const renderItem = ({ item }: { item: Project }) => {
    const isActive = item.id === activeId;
    const dot = _statusDot(item.id);
+    const hidden = !!item.hidden;
    return (
      <TouchableOpacity
        onPress={() => switchTo(item.id)}
        onLongPress={() => openEdit(item)}
-        style={[s.row, isActive && s.rowActive]}
+        style={[s.row, isActive && s.rowActive, hidden && s.rowHidden]}
      >
        <View style={{ flex: 1 }}>
          <View style={{ flexDirection: 'row', alignItems: 'center', gap: 8 }}>
@@ -188,6 +216,7 @@ 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>
+            {hidden && <Text style={s.hiddenBadge}>versteckt</Text>}
            {item.status === 'ended' && <Text style={s.statusBadge}>beendet</Text>}
            {isActive && <Text style={s.activeBadge}>✓ FOCUS</Text>}
          </View>
@@ -199,10 +228,22 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
            {dot.label ? ` · ${dot.label}` : ''}
          </Text>
        </View>
+        {/* Auge: verstecken (🙈) / wieder sichtbar (👁). Eigener Touch, damit
+            der Tap NICHT das Projekt wechselt. */}
+        <TouchableOpacity
+          onPress={() => toggleHidden(item)}
+          hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+          style={s.eyeBtn}
+        >
+          <Text style={s.eyeIcon}>{hidden ? '👁' : '🙈'}</Text>
+        </TouchableOpacity>
      </TouchableOpacity>
    );
  };

+  const hiddenCount = projects.filter(p => p.hidden).length;
+  const visibleProjects = showHidden ? projects : projects.filter(p => !p.hidden);
+
  const body = (
    <View style={{ flex: 1, backgroundColor: '#0A0A14' }}>
      {/* Header */}
@@ -243,6 +284,17 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
        );
      })()}

+      {/* Versteckte-Toggle — nur wenn es welche gibt (oder gerade eingeblendet) */}
+      {(hiddenCount > 0 || showHidden) && (
+        <TouchableOpacity onPress={() => setShowHidden(v => !v)} style={s.hiddenToggle}>
+          <Text style={s.hiddenToggleText}>
+            {showHidden
+              ? `🙈 Versteckte ausblenden${hiddenCount ? ` (${hiddenCount})` : ''}`
+              : `👁 Versteckte anzeigen${hiddenCount ? ` (${hiddenCount})` : ''}`}
+          </Text>
+        </TouchableOpacity>
+      )}
+
      {loading ? (
        <View style={{ padding: 24, alignItems: 'center' }}>
          <ActivityIndicator color="#0096FF" />
@@ -251,14 +303,21 @@ export const ProjectsBrowser: React.FC<Props> = ({ visible = true, onClose, onAc
        <Text style={s.errorText}>⚠ {err}</Text>
      ) : (
        <FlatList
-          data={projects}
+          data={visibleProjects}
          keyExtractor={p => p.id}
          renderItem={renderItem}
          ListEmptyComponent={
-            <Text style={s.emptyText}>
-              Noch keine Projekte. Tipp + Neu oder sag zu ARIA:{'\n'}
-              „Lass uns ein Projekt 'XY' anlegen".
-            </Text>
+            projects.length > 0 ? (
+              <Text style={s.emptyText}>
+                Alle {hiddenCount} Projekte sind versteckt.{'\n'}
+                Tipp „👁 Versteckte anzeigen".
+              </Text>
+            ) : (
+              <Text style={s.emptyText}>
+                Noch keine Projekte. Tipp + Neu oder sag zu ARIA:{'\n'}
+                „Lass uns ein Projekt 'XY' anlegen".
+              </Text>
+            )
          }
        />
      )}
@@ -365,6 +424,8 @@ const s = StyleSheet.create({
  headerBtnText: { color: '#0096FF', fontSize: 18, fontWeight: '600' },
  headerTitle: { flex: 1, textAlign: 'center', color: '#E0E0F0', fontSize: 18, fontWeight: '700' },
  row: {
+    flexDirection: 'row',
+    alignItems: 'center',
    paddingHorizontal: 16,
    paddingVertical: 12,
    borderBottomWidth: 1,
@@ -375,6 +436,18 @@ const s = StyleSheet.create({
    borderLeftWidth: 3,
    borderLeftColor: '#34C759',
  },
+  rowHidden: { opacity: 0.55 },
+  eyeBtn: { paddingHorizontal: 8, paddingVertical: 6, marginLeft: 6 },
+  eyeIcon: { fontSize: 18 },
+  hiddenBadge: { color: '#B392F0', fontSize: 10, fontWeight: '700',
+                 backgroundColor: 'rgba(179,146,240,0.15)', paddingHorizontal: 6,
+                 paddingVertical: 2, borderRadius: 4 },
+  hiddenToggle: {
+    paddingHorizontal: 16, paddingVertical: 10,
+    borderBottomWidth: 1, borderColor: '#1E1E2E',
+    backgroundColor: '#0D0D18',
+  },
+  hiddenToggleText: { color: '#B392F0', fontSize: 12, fontWeight: '600' },
  rowName: { color: '#E0E0F0', fontSize: 16, fontWeight: '600' },
  rowDesc: { color: '#8888AA', fontSize: 13, marginTop: 4 },
  rowMeta: { color: '#555570', fontSize: 11, marginTop: 4 },
@@ -121,13 +121,20 @@ const QRScanner: React.FC<QRScannerProps> = ({ visible, onScan, onClose }) => {
      <View style={styles.container}>
        {hasPermission ? (
          <>
+            {/* react-native-camera-kit v13: die .d.ts markiert viele OPTIONALE
+                CameraScreen-Props faelschlich als required (defaultProps fuellen
+                sie zur Laufzeit) und kennt colorForScannerFrame nicht — der war
+                ein No-Op und ist raus. scanBarcode/onReadCode ist die korrekte
+                v13-Barcode-API. Props als any spreaden, um die kaputten Lib-Typen
+                zu umgehen, ohne echten Code zu veraendern. */}
            <CameraScreen
-              scanBarcode={true}
-              onReadCode={handleBarcodeScan}
-              showFrame={true}
-              frameColor="#0096FF"
-              laserColor="#0096FF"
-              colorForScannerFrame="#0096FF"
+              {...({
+                scanBarcode: true,
+                onReadCode: handleBarcodeScan,
+                showFrame: true,
+                frameColor: '#0096FF',
+                laserColor: '#0096FF',
+              } as any)}
            />

            {/* Overlay oben */}
@@ -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 {
@@ -49,7 +50,7 @@ import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
 import CameraUpload, { PhotoData } from '../components/CameraUpload';
 import MessageText from '../components/MessageText';
-import { loadConvWindowMs, loadTtsSpeed, TTS_SPEED_DEFAULT } from '../services/audio';
+import { loadConvWindowMs, loadTtsSpeed, TTS_SPEED_DEFAULT, loadSttEndpointMs } from '../services/audio';
 import Geolocation from '@react-native-community/geolocation';

 // --- Typen ---
@@ -64,6 +65,14 @@ interface Attachment {
  deleted?: boolean;    // Datei wurde nachtraeglich geloescht (Diagnostic-Manager)
 }

+// Pro-Projekt-Queue-Zustand: idle = nichts laeuft; running = ARIA arbeitet am
+// aktuellen Task; awaiting_reply = ARIA hat eine blockierende Rueckfrage gestellt,
+// die naechste Eingabe beantwortet sie (statt einen neuen Auftrag anzustellen).
+type CtxState = 'idle' | 'running' | 'awaiting_reply';
+
+// Wartender Queue-Eintrag (id = die Bubble-ID der pending_queue-Nachricht).
+interface QueuedItem { id: string; text: string; }
+
 interface ChatMessage {
  id: string;
  sender: 'user' | 'aria';
@@ -131,7 +140,7 @@ interface ChatMessage {
  /** Delivery-Status der User-Bubble (WhatsApp-style): queued = noch nicht
   *  raus (offline), sending = an Bridge unterwegs, sent = Bridge hat ACK
   *  gesendet, delivered = Brain hat geantwortet, failed = Retry-Limit. */
-  deliveryStatus?: 'queued' | 'sending' | 'sent' | 'delivered' | 'failed';
+  deliveryStatus?: 'queued' | 'pending_queue' | 'sending' | 'sent' | 'delivered' | 'failed';
  /** Anzahl der bisherigen Sende-Versuche (fuer Retry-Limit). */
  sendAttempts?: number;
 }
@@ -275,6 +284,7 @@ async function checkFileExists(uri: string): Promise<boolean> {
 const ChatScreen: React.FC = () => {
  const [messages, setMessages] = useState<ChatMessage[]>([]);
  const [inputText, setInputText] = useState('');
+  const inputTextRef = useRef('');
  const [connectionState, setConnectionState] = useState<ConnectionState>('disconnected');
  const [showFileUpload, setShowFileUpload] = useState(false);
  const [showCameraUpload, setShowCameraUpload] = useState(false);
@@ -301,6 +311,27 @@ const ChatScreen: React.FC = () => {
  // Ref-Spiegel fuer Callbacks (interruptAriaIfBusy liest den aktuellen
  // Busy-Status des fokussierten Kontexts ohne stale Closure).
  const queueStatusRef = useRef<Record<string, { busy: boolean; queue_size: number }>>({});
+  // ── Pro-Projekt-Nachrichten-Queue + Zustandsautomat (app-lokal) ──
+  // Key = projectId ('' = Hauptchat). state pro Kontext + Queue der wartenden
+  // User-Bubbles. Sendet man waehrend 'running', wird angestellt statt
+  // abgebrochen; 'awaiting_reply' leitet die naechste Eingabe als Antwort weiter.
+  const [projectStates, setProjectStates] = useState<Record<string, CtxState>>({});
+  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>('');
+  // Ref-Bruecke, damit der frueh deklarierte RVS-Message-Handler den erst spaeter
+  // deklarierten Queue-Automaten aufrufen kann (ohne TDZ / stale Closure).
+  const queueApiRef = useRef<{
+    getCtxState: (pid: string) => CtxState;
+    setCtxState: (pid: string, s: CtxState) => void;
+    advanceQueue: (pid: string) => void;
+  } | null>(null);
  const [searchIndex, setSearchIndex] = useState(0);  // welcher Treffer aktiv ist
  const [pendingAttachments, setPendingAttachments] = useState<{file: any, isPhoto: boolean}[]>([]);
  const [agentActivity, setAgentActivity] = useState<{activity: string, tool: string}>({activity: 'idle', tool: ''});
@@ -338,6 +369,10 @@ const ChatScreen: React.FC = () => {
  // bliebe canPlay auf dem Mount-Initial-Wert haengen (mute ignoriert,
  // oder AsyncStorage-Load nicht beruecksichtigt).
  const ttsCanPlayRef = useRef<boolean>(true);
+  // Letzte Antwort: nach dem Vorlesen 30s weiterlauschen (Gespraech) oder direkt
+  // stoppen? Kommt als 'converse' in der Chat-Payload; onPlaybackFinished liest
+  // es. Default true (Konversation). false = Einzelaktion/Skill-Antwort.
+  const converseRef = useRef<boolean>(true);

  const flatListRef = useRef<FlatList>(null);
  const messageIdCounter = useRef(0);
@@ -372,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
@@ -427,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 });
@@ -491,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(() => {});
    };
@@ -505,14 +562,45 @@ const ChatScreen: React.FC = () => {
    return () => unsub();
  }, []);

-  // Focus in Storage spiegeln damit der letzte Kontext nach Neustart wieder
-  // da ist. Kein zwingender UX-Fix (Default = Hauptchat waere auch ok), aber
-  // fuer den Auto-Fall angenehm.
+  // Focus in Storage spiegeln + Pro-Projekt-Textfeld-Entwuerfe wechseln.
  useEffect(() => {
    AsyncStorage.setItem('aria_focused_project_id', focusedProjectId).catch(() => {});
    focusedProjectIdRef.current = focusedProjectId;
+    // Draft-Wechsel: der aktuelle Feldinhalt gehoert dem VERLASSENEN Projekt,
+    // der Entwurf des neuen Projekts wird geladen (leer = leeres Feld).
+    const prevPid = prevFocusedPidRef.current;
+    if (prevPid !== focusedProjectId) {
+      projectDraftsRef.current = { ...projectDraftsRef.current, [prevPid]: inputTextRef.current };
+      setInputText(projectDraftsRef.current[focusedProjectId] || '');
+      prevFocusedPidRef.current = focusedProjectId;
+      AsyncStorage.setItem('aria_project_drafts', JSON.stringify(projectDraftsRef.current)).catch(() => {});
+    }
  }, [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]);
+
+  // Drafts beim Start aus Storage laden.
+  useEffect(() => {
+    AsyncStorage.getItem('aria_project_drafts').then(v => {
+      if (!v) return;
+      try {
+        const map = JSON.parse(v);
+        if (map && typeof map === 'object') {
+          projectDraftsRef.current = map;
+          const cur = map[focusedProjectIdRef.current] || '';
+          if (cur) setInputText(cur);
+        }
+      } catch {}
+    }).catch(() => {});
+  }, []);
+
  // Ref-Spiegel damit useCallback-Handler die aktuelle Focus-ID lesen
  // ohne dass wir die Deps in jedes Callback muessen (sonst re-createn
  // die sich bei jedem Wechsel).
@@ -527,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();
@@ -562,6 +666,14 @@ const ChatScreen: React.FC = () => {
  // Wake Word: einmalig laden + Porcupine vorbereiten (wenn Access Key gesetzt)
  useEffect(() => {
    wakeWordService.loadFromStorage().catch(() => {});
+    // Mikro-Release-Hook: vor jedem Re-Arm eine laufende (passive) Streaming-
+    // Aufnahme canceln, sonst haelt sie das Mikro und OpenWakeWord.start()
+    // schlaegt fehl → Ohr bleibt ausgegraut (state=off).
+    wakeWordService.setMicReleaseHook(async () => {
+      if (audioService.isStreamingRecording()) {
+        await audioService.cancelStreamingRecording('rearm-mic-free');
+      }
+    });
    const unsub = wakeWordService.onStateChange((s) => {
      setWakeWordState(s);
      setWakeWordActive(s !== 'off');
@@ -854,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
@@ -887,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;
      }
@@ -982,6 +1112,7 @@ const ChatScreen: React.FC = () => {
      // file_from_aria: ARIA hat eine Datei rausgegeben → als ARIA-Bubble anzeigen
      if (message.type === 'file_from_aria') {
        const p = message.payload || {};
+        const sp = (p.serverPath as string) || '';
        const ariaMsg: ChatMessage = {
          id: nextId(),
          sender: 'aria',
@@ -992,10 +1123,20 @@ const ChatScreen: React.FC = () => {
            name: (p.name as string) || 'datei',
            size: (p.size as number) || 0,
            mimeType: (p.mimeType as string) || '',
-            serverPath: (p.serverPath as string) || '',
+            serverPath: sp,
          }],
        };
-        setMessages(prev => capMessages([...prev, ariaMsg]));
+        setMessages(prev => {
+          // Falls die Chat-Bubble mit dieser Datei schon da ist (Event-Reihen-
+          // folge kann variieren, und die chat-Payload traegt die files jetzt
+          // selbst), keine doppelte Solo-Bubble anlegen.
+          if (sp && prev.some(m =>
+            m.sender === 'aria' && m.attachments?.some(a => a.serverPath === sp)
+          )) {
+            return prev;
+          }
+          return capMessages([...prev, ariaMsg]);
+        });
        return;
      }

@@ -1144,26 +1285,53 @@ const ChatScreen: React.FC = () => {

        const text = (message.payload.text as string) || '';
        const ts = message.timestamp;
+        // ARIA-Dateien, die DIREKT an dieser Chat-Bubble haengen (Bridge schickt
+        // sie jetzt in der chat-Payload mit — vorher kamen sie nur als separates
+        // file_from_aria-Event, wodurch der Anhang live nicht an der Nachricht
+        // erschien, sondern erst nach einem Seitenwechsel/Reload).
+        const incomingFiles = Array.isArray((message.payload as any).files)
+          ? (message.payload as any).files as Array<any> : [];
+        const fileAttachments: Attachment[] = incomingFiles.map(f => ({
+          type: (typeof f.mimeType === 'string' && f.mimeType.startsWith('image/')) ? 'image' : 'file',
+          name: f.name || 'datei',
+          size: f.size || 0,
+          mimeType: f.mimeType || '',
+          serverPath: f.serverPath || '',
+        }));
+        const incomingPaths = new Set(
+          fileAttachments.map(a => a.serverPath).filter(Boolean) as string[]
+        );
        // Duplikat-Schutz: gleicher Text innerhalb 5s ignorieren
        setMessages(prev => {
          const isDuplicate = prev.some(m =>
            m.sender === 'aria' && m.text === text && Math.abs(m.timestamp - ts) < 5000
          );
          if (isDuplicate) return prev;
+          const payloadAtts = (message.payload.attachments as Attachment[] | undefined) || [];
+          const mergedAtts = [...payloadAtts, ...fileAttachments];
          const ariaMsg: ChatMessage = {
            id: nextId(),
            sender: 'aria',
            text,
            timestamp: ts,
-            attachments: message.payload.attachments as Attachment[] | undefined,
+            attachments: mergedAtts.length ? mergedAtts : undefined,
            messageId: (message.payload.messageId as string) || undefined,
            backupTs: (message.payload.backupTs as number) || undefined,
            projectId: ((message.payload as any).projectId as string) || '',
            answeredBy: ((message.payload as any).answeredBy as string) || '',
          };
+          // Die separate file_from_aria-Bubble (leerer Text, nur Datei), die kurz
+          // zuvor fuer DIESE Datei ankam, entfernen — sonst doppelt (einmal solo,
+          // einmal an der Text-Bubble). Nur solche mit passendem serverPath.
+          const deduped = incomingPaths.size
+            ? prev.filter(m => !(
+                m.sender === 'aria' && !m.text && (m.attachments?.length) &&
+                m.attachments.every(a => a.serverPath && incomingPaths.has(a.serverPath))
+              ))
+            : prev;
          // ARIA hat geantwortet → alle User-Bubbles davor als 'delivered'
          // markieren (WhatsApp-Doppelhaken ✓✓). Brain hat sie verarbeitet.
-          return capMessages([...prev, ariaMsg]).map(m =>
+          return capMessages([...deduped, ariaMsg]).map(m =>
            m.sender === 'user'
              && (m.deliveryStatus === 'sent' || m.deliveryStatus === 'sending')
              ? { ...m, deliveryStatus: 'delivered' }
@@ -1172,6 +1340,33 @@ const ChatScreen: React.FC = () => {
        });
        // ARIA hat geantwortet → Watchdog clearen, falls noch armiert
        clearStuckWatchdog();
+        // Thinking-Indikator fuer DIESEN Kontext raeumen. Die Antwort ist der
+        // definitive Beweis, dass der Turn fertig ist — unabhaengig davon, ob
+        // das agent_activity 'idle' der Bridge ankam (es kann mit abweichender
+        // projectId gesendet oder wegdedupt worden sein → "ARIA denkt" blieb
+        // sonst haengen). Zusaetzlich global raeumen, falls der sichtbare
+        // Kontext ueber den Legacy-Indikator lief.
+        {
+          const ansPid = ((message.payload as any).projectId as string) || '';
+          setAgentActivityByCtx(prev =>
+            prev[ansPid] && prev[ansPid].activity !== 'idle'
+              ? { ...prev, [ansPid]: { activity: 'idle', tool: '' } }
+              : prev);
+          setAgentActivity(cur =>
+            cur.activity === 'idle' ? cur : { activity: 'idle', tool: '' });
+          // ── Pro-Projekt-Queue-Automat: auf ARIAs Antwort reagieren ──
+          const awaiting = !!(message.payload as any).awaiting_reply;
+          const qapi = queueApiRef.current;
+          if (qapi) {
+            const st = qapi.getCtxState(ansPid);
+            // Nur reagieren, wenn wir fuer diesen Kontext wirklich auf eine
+            // Antwort warten (nicht bei unaufgeforderten Trigger-Nachrichten).
+            if (st === 'running' || st === 'awaiting_reply') {
+              if (awaiting) qapi.setCtxState(ansPid, 'awaiting_reply');
+              else qapi.advanceQueue(ansPid);
+            }
+          }
+        }
        // ALLE noch laufenden ACK-Timer clearen — Bridge hat unsere Messages
        // ja offensichtlich verarbeitet (sonst keine ARIA-Antwort). Wenn
        // ein ACK aus Netzgruenden verloren ging, soll der Retry nicht
@@ -1180,6 +1375,26 @@ const ChatScreen: React.FC = () => {
          clearAckTimer(cmid);
          pendingPayloads.current.delete(cmid);
        }
+        // Stille Antwort (speak=false, z.B. Fast-Path „nächster Titel") → es
+        // kommt KEIN TTS, also feuert onPlaybackFinished nie. Genau daran haengt
+        // aber das Wake-Word-Re-Arm — sonst bleibt das Ohr nach dem Steuerbefehl
+        // grau haengen (Reproduktion Stefan im Auto). Hier dieselbe Logik wie
+        // bei TTS-Ende anstossen: aktiv → Konversations-Fenster (resume),
+        // sonst → Konversation beenden (re-arm).
+        // Stumm = die Bridge sagt speak=false (Steuerbefehl-Skill via Fast-Path
+        // ODER local). Ein Antwort-Skill (speak=true) faellt NICHT hierunter —
+        // der wird vorgelesen + haelt das Gespraech offen. Kein answeredBy-
+        // Fallback mehr: die Bridge schickt speak zuverlaessig mit.
+        // Merken ob nach dem Vorlesen 30s weiterlauschen (Gespraech) oder direkt
+        // stoppen — onPlaybackFinished liest converseRef. Default true.
+        converseRef.current = (message.payload as any).converse !== false;
+        const _isSilent = (message.payload as any).speak === false;
+        if (_isSilent && wakeWordService.isConversing()) {
+          // Klarer Steuerbefehl (Liedersteuerung etc.) = KEINE Konversation →
+          // STOP: direkt zurueck aufs Wake-Word. Kein Gong, keine Aufnahme,
+          // kein 30s-Fenster (skipPassive=true).
+          wakeWordService.endConversation(true).catch(() => {});
+        }
      }

      // TTS-Audio abspielen wenn vorhanden — respektiert geraetelokalen Mute/Disable
@@ -1408,12 +1623,13 @@ const ChatScreen: React.FC = () => {
  useEffect(() => {
    const unsubPlayback = audioService.onPlaybackFinished(() => {
      if (!wakeWordService.isActive()) return;
-      if (AppState.currentState === 'active') {
-        wakeWordService.resume();
-      } else {
-        console.log('[Chat] TTS fertig im Background → endConversation (kein Multi-Turn)');
-        wakeWordService.endConversation().catch(() => {});
-      }
+      // Gespraech (gesprochene Antwort): KEIN neuer Gong / kein Aufnahme-Fenster,
+      // sondern direkt passives Lauschen (30s weiterreden wie mit einem Menschen).
+      // Im Hintergrund gibt's kein Multi-Turn → direkt re-armen (skipPassive).
+      // converse=false (Skill-/Einzelantwort, z.B. 'was laeuft gerade') → auch
+      // ohne 30s: vorlesen + direkt zurueck aufs Wake-Word.
+      const bg = AppState.currentState !== 'active';
+      wakeWordService.endConversation(bg || !converseRef.current).catch(() => {});
    });
    return () => unsubPlayback();
  }, []);
@@ -1429,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();
@@ -1450,7 +1667,7 @@ const ChatScreen: React.FC = () => {
        interrupted: wasInterrupted,
        location: location || null,
        noSpeechTimeoutMs: windowMs,
-        endpointMs: 1500,
+        endpointMs: await loadSttEndpointMs(),
        hardCapMs: 60000,
        projectId: focusedProjectIdRef.current,
      });
@@ -1489,9 +1706,15 @@ const ChatScreen: React.FC = () => {
      } else {
        // Kein Speech im Window → Konversation beenden
        console.log('[Chat] STT-Endpoint ohne Text (reason=%s) — endConversation', ev.reason);
-        // Placeholder-Bubble wieder weg
+        // NUR den noch UNAUFGELOESTEN Platzhalter entfernen. Nach manuellem Stop
+        // klappt oft ein zweites, LEERES stream_end-Endpoint nach (das Audio war
+        // schon vom echten Endpoint transkribiert) — das darf die bereits mit
+        // dem STT-Text gefuellte Bubble NICHT loeschen, sonst verschwindet die
+        // Sprachnachricht obwohl ARIA schon an der Antwort arbeitet.
        if (ev.audioRequestId) {
-          setMessages(prev => prev.filter(m => m.audioRequestId !== ev.audioRequestId));
+          setMessages(prev => prev.filter(m =>
+            !(m.audioRequestId === ev.audioRequestId
+              && m.text.includes('Spracheingabe wird verarbeitet'))));
        }
        // Bei Passive-Listen + speaker_mismatch oder no-speech: erneut passiv
        // lauschen (Timer im wakeword-service laeuft weiter, regelt das Ende).
@@ -1526,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();

@@ -1546,7 +1770,7 @@ const ChatScreen: React.FC = () => {
        interrupted: true,   // Barge-In → Brain weiss "User hat unterbrochen"
        location: location || null,
        noSpeechTimeoutMs: windowMs,
-        endpointMs: 1500,
+        endpointMs: await loadSttEndpointMs(),
        hardCapMs: 60000,
        projectId: focusedProjectIdRef.current,
      });
@@ -1575,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();
@@ -1583,6 +1814,7 @@ const ChatScreen: React.FC = () => {
      unsubPassive();
      unsubTtsStart();
      unsubTtsEnd();
+      unsubPcmCached();
    };
  }, [wakeWordActive]);

@@ -1594,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({
@@ -1603,7 +1836,7 @@ const ChatScreen: React.FC = () => {
      interrupted: false,
      location: location || null,
      noSpeechTimeoutMs: Math.min(passiveMs, 30000),
-      endpointMs: 1500,
+      endpointMs: await loadSttEndpointMs(),
      hardCapMs: Math.max(passiveMs + 5000, 35000),
      projectId: focusedProjectIdRef.current,
    });
@@ -1880,6 +2113,68 @@ const ChatScreen: React.FC = () => {

  // --- Nachricht senden ---

+  // ── Pro-Projekt-Queue: Zustands-Helfer ──────────────────────────
+  const getCtxState = useCallback((pid: string): CtxState =>
+    projectStatesRef.current[pid] || 'idle', []);
+
+  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 }));
+  }, []);
+
+  const setCtxQueue = useCallback((pid: string, items: QueuedItem[]) => {
+    projectQueuesRef.current = { ...projectQueuesRef.current, [pid]: items };
+    setProjectQueues(prev => ({ ...prev, [pid]: items }));
+  }, []);
+
+  // Sendet eine Nachricht WIRKLICH (Location holen + dispatchWithAck) und setzt
+  // den Kontext auf 'running'. existingId gesetzt = eine bereits als pending_queue
+  // angezeigte Bubble wird auf 'sending' gehoben (Dequeue), sonst neue Bubble.
+  const actuallySend = useCallback(async (pid: string, text: string, existingId?: string) => {
+    const cmid = nextClientMsgId();
+    const location = await getCurrentLocation();
+    const status: ChatMessage['deliveryStatus'] =
+      connectionStateRef.current === 'connected' ? 'sending' : 'queued';
+    if (existingId) {
+      setMessages(prev => prev.map(m =>
+        m.id === existingId ? { ...m, clientMsgId: cmid, deliveryStatus: status, sendAttempts: 1 } : m));
+    } else {
+      setMessages(prev => capMessages([...prev, {
+        id: nextId(), sender: 'user', text, timestamp: Date.now(),
+        clientMsgId: cmid, deliveryStatus: status, sendAttempts: 1, projectId: pid,
+      }]));
+    }
+    setCtxState(pid, 'running');
+    dispatchWithAck(cmid, 'chat', {
+      text, voice: localXttsVoiceRef.current, speed: ttsSpeedRef.current,
+      projectId: pid, ...(location && { location }),
+    });
+  }, [getCurrentLocation, dispatchWithAck, setCtxState]);
+
+  // Naechsten Queue-Eintrag von pid abarbeiten (falls vorhanden), sonst idle.
+  const advanceQueue = useCallback((pid: string) => {
+    const q = projectQueuesRef.current[pid] || [];
+    if (q.length === 0) { setCtxState(pid, 'idle'); return; }
+    const [next, ...rest] = q;
+    setCtxQueue(pid, rest);
+    actuallySend(pid, next.text, next.id);
+  }, [actuallySend, setCtxQueue, setCtxState]);
+
+  // Einen wartenden Eintrag aus der Queue entfernen (User tippt auf ✕).
+  const removeQueued = useCallback((pid: string, id: string) => {
+    setCtxQueue(pid, (projectQueuesRef.current[pid] || []).filter(it => it.id !== id));
+    setMessages(prev => prev.filter(m => m.id !== id));
+  }, [setCtxQueue]);
+
+  // Ref-Bruecke fuellen, damit der frueh deklarierte Message-Handler den Automaten
+  // erreicht (ohne TDZ / stale Closure).
+  useEffect(() => {
+    queueApiRef.current = { getCtxState, setCtxState, advanceQueue };
+  }, [getCtxState, setCtxState, advanceQueue]);
+
  // Aufraeumen von "verarbeitet"-Placeholder die nie ein STT-Result bekommen
  // haben (leere Aufnahme, Wake-Word-Echo, STT-Fehler etc). Timeout skaliert
  // mit der Aufnahmedauer — Whisper braucht auf der Gamebox grob real-time/5,
@@ -1903,49 +2198,6 @@ const ChatScreen: React.FC = () => {
    }, timeoutMs);
  }, []);

-  const sendTextMessage = useCallback(async () => {
-    const text = inputText.trim();
-
-    // Wenn pending Anhaenge vorhanden → Anhaenge + Text zusammen senden
-    if (pendingAttachments.length > 0) {
-      sendPendingAttachments(text);
-      return;
-    }
-
-    if (!text) return;
-
-    setInputText('');
-
-    // Barge-In: laufende ARIA-Aktivitaet abbrechen wenn welche da ist.
-    const wasInterrupted = interruptAriaIfBusy();
-    const location = await getCurrentLocation();
-
-    const cmid = nextClientMsgId();
-    const activePid = focusedProjectIdRef.current;
-    const userMsg: ChatMessage = {
-      id: nextId(),
-      sender: 'user',
-      text,
-      timestamp: Date.now(),
-      clientMsgId: cmid,
-      deliveryStatus: connectionStateRef.current === 'connected' ? 'sending' : 'queued',
-      sendAttempts: 1,
-      projectId: activePid,
-    };
-    setMessages(prev => capMessages([...prev, userMsg]));
-
-    console.log('[Chat] sende cmid=%s voice=%s speed=%s interrupted=%s project=%s',
-                cmid, localXttsVoiceRef.current || '(default)', ttsSpeedRef.current, wasInterrupted, activePid || '(main)');
-    dispatchWithAck(cmid, 'chat', {
-      text,
-      voice: localXttsVoiceRef.current,
-      speed: ttsSpeedRef.current,
-      interrupted: wasInterrupted,
-      projectId: activePid,
-      ...(location && { location }),
-    });
-  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments, interruptAriaIfBusy, dispatchWithAck]);
-
  // Anfrage abbrechen — nur den fokussierten Kontext (kontext-scoped Cancel).
  const cancelRequest = useCallback(() => {
    const pid = focusedProjectIdRef.current || '';
@@ -1953,34 +2205,22 @@ const ChatScreen: React.FC = () => {
    setAgentActivityByCtx(prev => ({ ...prev, [pid]: { activity: 'idle', tool: '' } }));
    clearStuckWatchdog();
    rvs.send('cancel_request' as any, { projectId: pid });
-  }, []);
+    // Aktuellen Task abgebrochen → naechsten Queue-Eintrag dieses Projekts
+    // starten (oder idle, wenn leer). Wartende Eintraege einzeln loeschbar.
+    advanceQueue(pid);
+  }, [advanceQueue]);

-  // Barge-In: wenn der User waehrend ARIA arbeitet/spricht eine neue Sprach-
-  // Nachricht aufnimmt, alte Aktivitaet sofort abbrechen — TTS verstummen,
-  // aria-core-Run via cancel_request abbrechen. So kann man "ach vergiss es,
-  // mach lieber X" sagen wie in einem echten Gespraech.
+  // Queue-Modus („immer anstellen"): eine neue Sprachnachricht bricht ARIAs
+  // laufende Arbeit NICHT mehr ab. Sie wird — wie Text — angestellt und laeuft
+  // serialisiert (der Brain-Lock pro Projekt reiht /chat-/audio-Turns auf).
+  // Nur das TTS wird akustisch gestoppt, damit das Mikro ARIAs eigene Stimme
+  // nicht mithoert. Explizites Abbrechen laeuft ueber den Stop-Button
+  // (cancelRequest). Rueckgabe = false, weil kein Barge-In/Interrupt mehr.
  const interruptAriaIfBusy = useCallback(() => {
-    const speaking = audioService.isPlayingAudio();
-    // Multi-Threading: NUR den fokussierten Kontext als "busy" werten — nicht
-    // global. Sonst bricht eine Nachricht im Hauptchat die parallele Arbeit in
-    // einem Projekt ab (bzw. wird faelschlich als Barge-In behandelt und die
-    // eigene Anfrage geht unter). Der Busy-Status kommt kontextgenau aus
-    // /projects/queue-status (queueStatusRef). agentActivity ist global und
-    // taugt dafuer nicht.
-    const pid = focusedProjectIdRef.current || '';
-    const focusKey = pid || '__main__';
-    const focusBusy = !!queueStatusRef.current?.[focusKey]?.busy;
-    if (!speaking && !focusBusy) return false;
-    console.log('[Chat] Barge-In: speaking=%s focusBusy=%s (ctx=%s) — interrupting',
-                speaking, focusBusy, focusKey);
-    // TTS immer stoppen wenn ARIA gerade spricht — egal welcher Kontext.
-    if (speaking) audioService.haltAllPlayback('user spricht (barge-in)');
-    // Brain-Arbeit nur abbrechen wenn GENAU dieser Kontext arbeitet.
-    if (focusBusy) {
-      clearStuckWatchdog();
-      rvs.send('cancel_request' as any, { projectId: pid });
+    if (audioService.isPlayingAudio()) {
+      audioService.haltAllPlayback('user startet Aufnahme (Queue-Modus, kein Abbruch)');
    }
-    return true;
+    return false;
  }, []);

  // Manueller Aufnahme-Knopf (VoiceButton) — Start.
@@ -1990,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();

@@ -2013,7 +2254,7 @@ const ChatScreen: React.FC = () => {
      // Stoppen). Hard-Cap 5 Minuten als Notbremse — danach killt Whisper
      // die Session auch app-seitig haben wir +2s Toleranz.
      noSpeechTimeoutMs: 0,
-      endpointMs: 1500,
+      endpointMs: await loadSttEndpointMs(),
      hardCapMs: 300000,
      projectId: focusedProjectIdRef.current,
    });
@@ -2031,10 +2272,20 @@ const ChatScreen: React.FC = () => {
  // forwarded direkt an Brain. Im wake-word-conversing-Fall zusaetzlich
  // endConversation: User hat explizit gestoppt → kein Multi-Turn-Resume.
  const handleVoiceButtonStop = useCallback(async (): Promise<void> => {
+    // Stop WAEHREND des passiven 30s-Lauschens ('listening'): sauber beenden
+    // (zurueck aufs Wake-Word), NICHT den passiven Stream neu starten.
+    // exitPassiveListening cancelt den Stream selbst (via _freeMic) → es feuert
+    // kein leeres Endpoint, das startPassiveStreamingRecording erneut ausloest
+    // (genau das liess die 30s vorher von vorne loslaufen).
+    if (wakeWordService.getState() === 'listening') {
+      console.log('[Chat] Manueller Stop im Passiv-Lauschen → exitPassiveListening (Ende)');
+      await wakeWordService.exitPassiveListening('manual');
+      return;
+    }
    await audioService.stopStreamingRecording('user');
    if (wakeWordService.isConversing()) {
      console.log('[Chat] Manueller Stop in Konversation → endConversation, zurueck zu armed');
-      await wakeWordService.endConversation();
+      await wakeWordService.endConversation(true);  // explizit gestoppt → STOP (kein 30s-Passiv)
    }
  }, []);

@@ -2142,6 +2393,53 @@ const ChatScreen: React.FC = () => {
    setInputText('');
  }, [pendingAttachments, getCurrentLocation, dispatchWithAck]);

+  // Reine Text-Nachricht senden. Steht bewusst NACH interruptAriaIfBusy und
+  // sendPendingAttachments — beide stehen in seinem deps-Array, und wenn es
+  // davor deklariert waere, laendeten sie dort in der Temporal Dead Zone
+  // (tsc TS2448/2454; lief nur zufaellig, weil Babel const→var hebt).
+  const sendTextMessage = useCallback(async () => {
+    const text = inputText.trim();
+
+    // Wenn pending Anhaenge vorhanden → Anhaenge + Text zusammen senden
+    if (pendingAttachments.length > 0) {
+      sendPendingAttachments(text);
+      return;
+    }
+
+    if (!text) return;
+
+    const activePid = focusedProjectIdRef.current;
+    setInputText('');
+    // Draft dieses Projekts leeren (wurde ja gerade abgeschickt/angestellt).
+    projectDraftsRef.current = { ...projectDraftsRef.current, [activePid]: '' };
+
+    const focusKey = activePid || '__main__';
+    const brainBusy = !!queueStatusRef.current?.[focusKey]?.busy;
+    let state = getCtxState(activePid);
+    // Fallback: ein per SPRACHE gestarteter Turn streamt live und setzt den
+    // App-State nicht — aber der Brain meldet busy. Dann Kontext als 'running'
+    // behandeln (anstellen; die spaetere Antwort schaltet die Queue weiter).
+    if (state === 'idle' && brainBusy) { setCtxState(activePid, 'running'); state = 'running'; }
+    if (state === 'running') {
+      // ARIA arbeitet noch am aktuellen Task → ANSTELLEN statt abbrechen.
+      // Sichtbare pending_queue-Bubble; laeuft der Reihe nach, wenn der
+      // aktuelle Task (und ggf. seine Rueckfragen) fertig ist.
+      const id = nextId();
+      setMessages(prev => capMessages([...prev, {
+        id, sender: 'user', text, timestamp: Date.now(),
+        projectId: activePid, deliveryStatus: 'pending_queue',
+      }]));
+      setCtxQueue(activePid, [...(projectQueuesRef.current[activePid] || []), { id, text }]);
+      console.log('[Chat] angestellt (queue) project=%s len=%d', activePid || '(main)',
+                  (projectQueuesRef.current[activePid] || []).length);
+    } else {
+      // idle ODER awaiting_reply → sofort senden. Bei awaiting_reply ist DAS die
+      // Antwort auf ARIAs Rueckfrage (normaler Turn in diesem Projekt).
+      console.log('[Chat] sende sofort (state=%s) project=%s', state, activePid || '(main)');
+      actuallySend(activePid, text);
+    }
+  }, [inputText, pendingAttachments, sendPendingAttachments, getCtxState, setCtxState, setCtxQueue, actuallySend]);
+
  // --- Rendering ---

  const renderMessage = ({ item }: { item: ChatMessage }) => {
@@ -2440,7 +2738,16 @@ const ChatScreen: React.FC = () => {
            </TouchableOpacity>
          ) : null}
          {isUser && item.deliveryStatus ? (
-            item.deliveryStatus === 'failed' && item.clientMsgId ? (
+            item.deliveryStatus === 'pending_queue' ? (
+              // Wartet in der Projekt-Queue → tippen entfernt den Eintrag.
+              <TouchableOpacity
+                hitSlop={{top:6,bottom:6,left:6,right:6}}
+                onPress={() => removeQueued(item.projectId || '', item.id)}
+                accessibilityLabel="Aus Warteschlange entfernen"
+              >
+                <Text style={styles.statusQueued}>{'⏸ wartet · ✕'}</Text>
+              </TouchableOpacity>
+            ) : item.deliveryStatus === 'failed' && item.clientMsgId ? (
              <TouchableOpacity
                hitSlop={{top:6,bottom:6,left:6,right:6}}
                onPress={() => retryFailedMessage(item.clientMsgId!)}
@@ -2863,6 +3170,18 @@ const ChatScreen: React.FC = () => {
        </TouchableOpacity>
      )}

+      {/* Rueckfrage-Banner / Queue-Zaehler fuer den fokussierten Kontext */}
+      {(projectStates[focusedProjectId] === 'awaiting_reply' ||
+        (projectQueues[focusedProjectId]?.length || 0) > 0) && (
+        <View style={styles.queueBanner}>
+          <Text style={styles.queueBannerText}>
+            {projectStates[focusedProjectId] === 'awaiting_reply'
+              ? '❓ ARIA fragt nach — deine Eingabe beantwortet das'
+              : `⏸ ${projectQueues[focusedProjectId]?.length || 0} in der Warteschlange`}
+          </Text>
+        </View>
+      )}
+
      {/* Eingabebereich */}
      <View style={styles.inputContainer}>
        {/* Datei-Buttons */}
@@ -3360,6 +3679,19 @@ const styles = StyleSheet.create({
    fontSize: 14,
    marginTop: 4,
  },
+  queueBanner: {
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    backgroundColor: '#2A2410',
+    borderTopWidth: 1,
+    borderTopColor: '#4A3F14',
+  },
+  queueBannerText: {
+    color: '#FFD60A',
+    fontSize: 13,
+    fontWeight: '600',
+    textAlign: 'center',
+  },
  inputContainer: {
    flexDirection: 'row',
    alignItems: 'flex-end',
@@ -105,6 +105,14 @@ import wakeWordService, {
  KEYWORD_LABELS,
  DEFAULT_KEYWORD,
  WAKE_KEYWORD_STORAGE,
+  WAKE_THRESHOLD_DEFAULT,
+  WAKE_THRESHOLD_MIN,
+  WAKE_THRESHOLD_MAX,
+  loadWakeThreshold,
+  saveWakeThreshold,
+  PASSIVE_LISTEN_DEFAULT_MS,
+  loadPassiveListenMs,
+  savePassiveListenMs,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
@@ -200,6 +208,8 @@ const SettingsScreen: React.FC = () => {
  const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
  const [wakeStatus, setWakeStatus] = useState<string>('');
  const [wakeReadySound, setWakeReadySound] = useState<boolean>(true);
+  const [wakeThreshold, setWakeThreshold] = useState<number>(WAKE_THRESHOLD_DEFAULT);
+  const [passiveSec, setPassiveSec] = useState<number>(Math.round(PASSIVE_LISTEN_DEFAULT_MS / 1000));
  const [editingPath, setEditingPath] = useState(false);
  const [xttsVoice, setXttsVoice] = useState('');
  const [loadingVoice, setLoadingVoice] = useState<string | null>(null);
@@ -322,6 +332,8 @@ const SettingsScreen: React.FC = () => {
      if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
    });
    isWakeReadySoundEnabled().then(setWakeReadySound);
+    loadWakeThreshold().then(setWakeThreshold).catch(() => {});
+    loadPassiveListenMs().then(ms => setPassiveSec(Math.round(ms / 1000))).catch(() => {});
    updateService.getApkCacheSize().then(setApkCacheInfo).catch(() => {});
    audioService.getTtsCacheSize().then(setTtsCacheInfo).catch(() => {});
    AsyncStorage.getItem('aria_xtts_voice').then(saved => {
@@ -1862,6 +1874,40 @@ const SettingsScreen: React.FC = () => {
          ))}
        </View>

+        <Text style={[styles.toggleLabel, {marginTop: 20}]}>Empfindlichkeit</Text>
+        <Text style={styles.toggleHint}>
+          Wie leicht das Wake-Word anspringt. Hoeher = strenger = weniger
+          Fehlauslösung (z.B. durch Musik/Radio, die das Mikro mithoert — der
+          Echo-Canceler kann nur ARIAs eigene Stimme rausrechnen, nicht Spotify),
+          aber du musst evtl. deutlicher sprechen. Default: {WAKE_THRESHOLD_DEFAULT.toFixed(2)}.
+          Wird beim „Speichern + Aktivieren" uebernommen.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.max(WAKE_THRESHOLD_MIN, Math.round((wakeThreshold - 0.05) * 100) / 100);
+              setWakeThreshold(next);
+              saveWakeThreshold(next);
+            }}
+            disabled={wakeThreshold <= WAKE_THRESHOLD_MIN}
+          >
+            <Text style={styles.prerollButtonText}>−0.05</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>{wakeThreshold.toFixed(2)}</Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.min(WAKE_THRESHOLD_MAX, Math.round((wakeThreshold + 0.05) * 100) / 100);
+              setWakeThreshold(next);
+              saveWakeThreshold(next);
+            }}
+            disabled={wakeThreshold >= WAKE_THRESHOLD_MAX}
+          >
+            <Text style={styles.prerollButtonText}>+0.05</Text>
+          </TouchableOpacity>
+        </View>
+
        <View style={{flexDirection: 'row', gap: 8, marginTop: 16, alignItems: 'center'}}>
          <TouchableOpacity
            style={[styles.connectButton, {flex: 1}]}
@@ -1907,6 +1953,39 @@ const SettingsScreen: React.FC = () => {
            thumbColor={wakeReadySound ? '#FFFFFF' : '#666680'}
          />
        </View>
+
+        <Text style={[styles.toggleLabel, {marginTop: 20}]}>Weiterreden-Fenster (Gespraech)</Text>
+        <Text style={styles.toggleHint}>
+          Nach einer gesprochenen ARIA-Antwort kannst du so lange einfach
+          weiterreden — ohne Wake-Word — bevor zurueck aufs Wake-Word geschaltet
+          wird. Reine Steuerbefehle (z.B. „nächster Titel") beenden sofort.
+          Default: {Math.round(PASSIVE_LISTEN_DEFAULT_MS / 1000)}s.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.max(10, passiveSec - 5);
+              setPassiveSec(next);
+              savePassiveListenMs(next * 1000);
+            }}
+            disabled={passiveSec <= 10}
+          >
+            <Text style={styles.prerollButtonText}>−5</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>{passiveSec} s</Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.min(60, passiveSec + 5);
+              setPassiveSec(next);
+              savePassiveListenMs(next * 1000);
+            }}
+            disabled={passiveSec >= 60}
+          >
+            <Text style={styles.prerollButtonText}>+5</Text>
+          </TouchableOpacity>
+        </View>
      </View>
      </>)}

@@ -44,6 +44,11 @@ const { AudioFocus, PcmStreamPlayer, PcmStreamRecorder } = NativeModules as {
    release: () => Promise<boolean>;
    kickReleaseMedia: () => Promise<boolean>;
    getMode?: () => Promise<number>;
+    // Zuverlaessiger Spotify-Resume via echtem MEDIA_PLAY-KeyEvent (statt
+    // Focus-Stack-Nudge). isMusicActive() zum Gaten: nur resumen wenn vor
+    // dem Gespraech wirklich Musik lief.
+    dispatchMediaPlay?: () => Promise<boolean>;
+    isMusicActive?: () => Promise<boolean>;
  };
  PcmStreamPlayer?: {
    start: (sampleRate: number, channels: number, prerollSeconds: number) => Promise<boolean>;
@@ -146,6 +151,26 @@ export const CONV_WINDOW_MIN_SEC = 3.0;
 export const CONV_WINDOW_MAX_SEC = 20.0;
 export const CONV_WINDOW_STORAGE_KEY = 'aria_conv_window_sec';

+// STT-Endpoint (ms Stille bis "fertig gesprochen"). Zu kurz = schneidet mitten
+// im Satz ab, besonders im Auto wo man mit Pausen spricht (Reproduktion: die
+// 11.8s-Frage wurde bei "…ohne dass ein" gekappt). 1500 war zu aggressiv;
+// 2400 default, im Auto ggf. hoeher. Konfigurierbar in den Settings.
+export const STT_ENDPOINT_DEFAULT_MS = 2400;
+export const STT_ENDPOINT_MIN_MS = 1000;
+export const STT_ENDPOINT_MAX_MS = 4000;
+export const STT_ENDPOINT_STORAGE_KEY = 'aria_stt_endpoint_ms';
+
+export async function loadSttEndpointMs(): Promise<number> {
+  try {
+    const raw = await AsyncStorage.getItem(STT_ENDPOINT_STORAGE_KEY);
+    if (raw != null) {
+      const n = parseInt(raw, 10);
+      if (isFinite(n) && n >= STT_ENDPOINT_MIN_MS && n <= STT_ENDPOINT_MAX_MS) return n;
+    }
+  } catch {}
+  return STT_ENDPOINT_DEFAULT_MS;
+}
+
 // TTS-Wiedergabegeschwindigkeit — wird pro Geraet gespeichert und an die
 // Bridge mitgegeben (speed-Param im F5-TTS infer()). 1.0 = normal.
 export const TTS_SPEED_DEFAULT = 1.0;
@@ -259,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

@@ -275,6 +307,13 @@ class AudioService {
  // damit Spotify nicht in Render-Pausen oder zwischen Antworten zurueckkehrt.
  private _conversationFocusActive: boolean = false;

+  // Lief unmittelbar VOR dem Focus-Grab (Wake-Word/Aufnahme) Musik? Wird beim
+  // Betreten des Dialogs gemerkt (latch: nur auf true), damit wir am Dialog-Ende
+  // NUR dann Spotify per MEDIA_PLAY-KeyEvent zuverlaessig resumen, wenn vorher
+  // wirklich etwas lief. Verhindert, dass wir bei Stille versehentlich Musik
+  // starten. Wird nach dem Resume-Dispatch wieder auf false gesetzt.
+  private _mediaWasActiveAtAcquire: boolean = false;
+
  // VAD State
  private vadEnabled: boolean = false;
  private lastSpeechTime: number = 0;
@@ -342,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
@@ -450,15 +499,29 @@ class AudioService {
      import('./logger').then(m => m.reportAppDebug('audio.focus',
        'AudioFocus.release() now')).catch(()=>{});
      AudioFocus?.release().catch(() => {});
-      // Spotify-Resume-Trigger: nach Abandon den USAGE_MEDIA-Focus-Stack
-      // mit kurzem TRANSIENT-Nudge aufmischen. Spotify resumed sonst bei
-      // manchen Versionen / Geraeten nicht zuverlaessig nach Auto-Loss.
-      // 50ms Delay damit das Abandon erst durch ist.
-      setTimeout(() => {
+      // Spotify-Resume: NUR wenn vor dem Gespraech wirklich Musik lief. Dann
+      // einen echten MEDIA_PLAY-KeyEvent an die aktive MediaSession schicken
+      // (wie die Play-Taste am Kopfhoerer) — das resumt Spotify zuverlaessig,
+      // im Gegensatz zum flakigen Focus-Stack-Nudge, der auf manchen Geraeten
+      // (OnePlus) nach Auto-Loss nicht griff. 120ms Delay, damit das Abandon
+      // sicher durch ist, bevor der Play-Key kommt.
+      const shouldResume = this._mediaWasActiveAtAcquire;
+      this._mediaWasActiveAtAcquire = false;
+      if (shouldResume) {
+        setTimeout(() => {
+          import('./logger').then(m => m.reportAppDebug('audio.focus',
+            'dispatchMediaPlay() now (Musik lief vor Dialog → Resume)')).catch(()=>{});
+          if (AudioFocus?.dispatchMediaPlay) {
+            AudioFocus.dispatchMediaPlay().catch(() => {});
+          } else {
+            // Fallback fuer alte Native-Builds ohne dispatchMediaPlay
+            AudioFocus?.nudgeMediaResume().catch(() => {});
+          }
+        }, 120);
+      } else {
        import('./logger').then(m => m.reportAppDebug('audio.focus',
-          'nudgeMediaResume() now (50ms after release)')).catch(()=>{});
-        AudioFocus?.nudgeMediaResume().catch(() => {});
-      }, 50);
+          'kein Resume (vor Dialog lief keine Musik)')).catch(()=>{});
+      }
    }, this.FOCUS_RELEASE_DELAY_MS);
  }

@@ -469,6 +532,20 @@ class AudioService {
    }
  }

+  /** Merkt sich (latch: nur auf true), ob GERADE Musik laeuft — VOR einem
+   *  Focus-Grab aufrufen. Am Dialog-Ende entscheidet die Flag, ob wir Spotify
+   *  aktiv per MEDIA_PLAY resumen. Awaitet bewusst isMusicActive bevor der
+   *  Focus-Request die Wiedergabe pausiert (sonst laese man schon 'false'). */
+  private async _captureMediaActive(): Promise<void> {
+    try {
+      const active = await AudioFocus?.isMusicActive?.();
+      if (active) {
+        this._mediaWasActiveAtAcquire = true;
+        console.log('[Audio] Musik lief vor Focus-Grab → Resume am Dialog-Ende gemerkt');
+      }
+    } catch {}
+  }
+
  /** Conversation-Mode beginnt → AudioFocus dauerhaft halten (Spotify bleibt
   *  pausiert). Idempotent: mehrfaches Aufrufen ist sicher. */
  acquireConversationFocus(): void {
@@ -476,7 +553,11 @@ class AudioService {
    this._conversationFocusActive = true;
    this._cancelDeferredFocusRelease();
    console.log('[Audio] Conversation-Focus aktiv (Spotify bleibt gepaust)');
-    AudioFocus?.requestDuck().catch(() => {});
+    // Erst pruefen ob Musik laeuft, DANN ducken (requestDuck wuerde sie sonst
+    // schon pausieren bevor wir es messen koennen).
+    this._captureMediaActive().finally(() => {
+      AudioFocus?.requestDuck().catch(() => {});
+    });
  }

  /** Conversation-Mode endet → Focus darf wieder freigegeben werden
@@ -493,6 +574,8 @@ class AudioService {
  haltAllPlayback(reason: string = ''): void {
    console.log('[Audio] haltAllPlayback: %s', reason || '(no reason)');
    this._conversationFocusActive = false;
+    // Barge-In → User spricht gleich weiter, Spotify NICHT resumen.
+    this._mediaWasActiveAtAcquire = false;
    this.stopPlayback();
  }

@@ -503,6 +586,8 @@ class AudioService {
  pauseForCall(reason: string = ''): void {
    console.log('[Audio] pauseForCall: %s', reason || '(no reason)');
    this._conversationFocusActive = false;
+    // Anruf → Spotify bleibt aus, kein Auto-Resume beim spaeteren Release.
+    this._mediaWasActiveAtAcquire = false;
    this._pausedForCall = true;
    // Queue + isPlaying ruecksetzen — sonst klemmt der naechste Play-Button
    // (playAudio sieht isPlaying=true und ruft _playNext nicht mehr auf).
@@ -796,6 +881,8 @@ class AudioService {
      this.setState('recording');

      // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
+      // Vorher merken ob Musik lief, damit wir sie danach resumen koennen.
+      await this._captureMediaActive();
      this._cancelDeferredFocusRelease();
      AudioFocus?.requestExclusive().catch(() => {});

@@ -1043,6 +1130,8 @@ class AudioService {
      }

      // AudioFocus exklusiv — gleiche Semantik wie beim Legacy-Pfad.
+      // Vorher merken ob Musik lief (fuer Resume am Dialog-Ende).
+      await this._captureMediaActive();
      this._cancelDeferredFocusRelease();
      AudioFocus?.requestExclusive().catch(() => {});

@@ -1329,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) {
@@ -1376,6 +1482,8 @@ class AudioService {
        this._cancelDeferredFocusRelease();
        AudioFocus?.requestDuck().catch(() => {});
        this._firePlaybackStarted();
+        this.pcmAudiblePlaying = true;
+        this.pcmPlayingMsgId = messageId;
      }
    }

@@ -1418,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 {
@@ -1506,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);
@@ -1659,18 +1847,51 @@ class AudioService {
        this._stoppedMessageId = activeMsgId;
        console.log('[Audio] Antwort %s als gestoppt markiert', activeMsgId);
      }
-      this.stopPlayback();
+      // NUR die hoerbare Wiedergabe stoppen — Cache-Buffer behalten, damit die
+      // Nachricht spaeter ueber das Lautsprecher-Symbol nachgehoert werden kann.
+      this._silenceAudibleOutput();
    }
  }
  isMuted(): boolean { return this._muted; }

+  /** Mund-Button: laufendes Vorlesen SOFORT verstummen lassen, aber den
+   *  PCM-Cache NICHT verwerfen (der Stream cached zu Ende → Nachhoeren via
+   *  Lautsprecher-Symbol bleibt moeglich). Unterschied zu stopPlayback():
+   *  - stopt den AudioTrack IMMER (auch wenn pcmStreamActive schon false ist,
+   *    weil der Stream fertig empfangen wurde aber der AudioTrack seinen Buffer
+   *    noch sekundenlang ausspielt — genau da war der Mund-Button wirkungslos),
+   *  - laesst pcmBuffer/pcmMessageId/pcmStreamActive stehen (Cache laeuft weiter). */
+  private _silenceAudibleOutput(): void {
+    console.log('[Audio] _silenceAudibleOutput: AudioTrack+WAV stoppen, Cache behalten');
+    this.audioQueue = [];
+    this.isPlaying = false;
+    if (this.currentSound) {
+      try { this.currentSound.stop(); this.currentSound.release(); } catch {}
+      this.currentSound = null;
+    }
+    if (this.resumeSound) {
+      try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
+      this.resumeSound = null;
+    }
+    // AudioTrack 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(() => {});
+  }
+
  /** Laufende Wiedergabe stoppen + Queue leeren */
  stopPlayback(): void {
    // Idempotent: wenn nichts mehr aktiv ist, NICHT noch einen Focus-Release/
    // Kick-Cycle anstossen — Re-Renders triggern setMuted oft mehrfach hinter-
    // einander, und jeder weitere Kick lässt Spotify nochmal kurz pausieren.
    const hasAnything = !!(this.currentSound || this.resumeSound || this.preloadedSound
-                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying);
+                           || 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);
@@ -1704,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
@@ -157,10 +157,17 @@ export interface Project {
  name: string;
  description: string;
  status: 'active' | 'ended' | 'archived';
+  hidden?: boolean;               // aus Listen ausgeblendet (bleibt nutzbar)
  created_at: number;
  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;
 }

 export interface ProjectStatus {
@@ -593,14 +600,22 @@ export const brainApi = {
    });
  },

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

+  /** Projekt verstecken / wieder sichtbar machen (bleibt voll nutzbar). */
+  setProjectHidden(projectId: string, hidden: boolean): Promise<Project> {
+    return _send(`/projects/${encodeURIComponent(projectId)}`, {
+      method: 'PATCH',
+      body: { hidden },
+    });
+  },
+
  /** Queue-Status: pro Kontext (project_id oder __main__ fuer Hauptchat)
   *  ob gerade ein Request in Verarbeitung ist + wieviele in der Queue warten.
   *  Wird fuer Status-Dots im Drawer periodisch gepollt. */
@@ -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;
@@ -53,6 +53,30 @@ export async function savePassiveListenMs(ms: number): Promise<void> {

 export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';

+// Wake-Word-Empfindlichkeit (openWakeWord-Threshold). Hoeher = strenger =
+// weniger Fehlauslösung (z.B. durch Musik/Radio ueber die Auto-Lautsprecher,
+// die das Mikro mithoert — der App-Echo-Canceler kann nur ARIAs eigenes TTS
+// rausrechnen, NICHT Spotify). Default 0.6 (war 0.5). 0..1.
+export const WAKE_THRESHOLD_DEFAULT = 0.6;
+export const WAKE_THRESHOLD_MIN = 0.3;
+export const WAKE_THRESHOLD_MAX = 0.9;
+export const WAKE_THRESHOLD_STORAGE_KEY = 'aria_wake_threshold';
+
+export async function loadWakeThreshold(): Promise<number> {
+  try {
+    const raw = await AsyncStorage.getItem(WAKE_THRESHOLD_STORAGE_KEY);
+    if (raw != null) {
+      const n = parseFloat(raw);
+      if (isFinite(n) && n >= WAKE_THRESHOLD_MIN && n <= WAKE_THRESHOLD_MAX) return n;
+    }
+  } catch {}
+  return WAKE_THRESHOLD_DEFAULT;
+}
+
+export async function saveWakeThreshold(v: number): Promise<void> {
+  await AsyncStorage.setItem(WAKE_THRESHOLD_STORAGE_KEY, String(v));
+}
+
 /** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
 *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
 *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
@@ -76,8 +100,9 @@ export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
  hey_rhasspy: 'Hey Rhasspy',
 };

-// Detection-Tuning — kann in Settings spaeter konfigurierbar werden.
-const DEFAULT_THRESHOLD = 0.5;
+// Detection-Tuning. Threshold ist ueber die Settings konfigurierbar
+// (loadWakeThreshold) — der Wert hier ist nur der Fallback.
+const DEFAULT_THRESHOLD = WAKE_THRESHOLD_DEFAULT;
 const DEFAULT_PATIENCE = 2;
 const DEFAULT_DEBOUNCE_MS = 1500;

@@ -132,6 +157,12 @@ class WakeWordService {
   *  hier eine streaming-Aufnahme OHNE User-Bubble (passiv lauschen). */
  private passiveListenCallbacks: PassiveListenCallback[] = [];

+  /** Hook, der das Mikro freigibt (laufende Streaming-Aufnahme canceln) BEVOR
+   *  wir OpenWakeWord.start() rufen. Ohne das haelt die passive/conversing
+   *  Aufnahme das Mikro noch, start() schlaegt fehl → Ohr bleibt ausgegraut
+   *  (state=off). ChatScreen registriert den Hook mit audioService.cancel…. */
+  private micReleaseHook: (() => Promise<void>) | null = null;
+
  private keyword: WakeKeyword = DEFAULT_KEYWORD;
  private nativeReady: boolean = false;
  private initInProgress: Promise<boolean> | null = null;
@@ -149,6 +180,19 @@ class WakeWordService {
    }
  }

+  /** ChatScreen registriert hier einen Hook, der eine laufende Streaming-
+   *  Aufnahme cancelt (Mikro freigeben) — wird vor jedem Re-Arm gerufen. */
+  setMicReleaseHook(fn: (() => Promise<void>) | null): void {
+    this.micReleaseHook = fn;
+  }
+
+  private async _freeMic(): Promise<void> {
+    if (!this.micReleaseHook) return;
+    try { await this.micReleaseHook(); } catch (e) {
+      console.warn('[WakeWord] micReleaseHook err:', e);
+    }
+  }
+
  /** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
  async configure(keyword: string): Promise<boolean> {
    const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
@@ -178,7 +222,9 @@ class WakeWordService {
    if (this.initInProgress) return this.initInProgress;
    this.initInProgress = (async () => {
      try {
-        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
+        const threshold = await loadWakeThreshold();
+        console.log('[WakeWord] init mit threshold=%s', threshold);
+        await OpenWakeWord.init(this.keyword, threshold, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
        // Subscribe nur einmal
        if (!this.eventSub) {
          const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
@@ -422,7 +468,10 @@ class WakeWordService {
   *  wuerde sonst OpenWakeWord.stop() rufen weil bargeListening noch true
   *  ist, und unseren frisch re-armierten Listener killen.
   */
-  async endConversation(): Promise<void> {
+  /** @param skipPassive true = KEIN passives Lauschen, direkt zurueck aufs
+   *  Wake-Word (armed). Fuer klare Steuerbefehle (Fast-Path) — nach
+   *  "nächster Titel" will Stefan kein 30s-Fenster, sondern Stop. */
+  async endConversation(skipPassive: boolean = false): Promise<void> {
    if (this.state !== 'conversing') {
      import('./logger').then(m => m.reportAppDebug('wake.end',
        `endConversation called but state=${this.state} → noop`)).catch(()=>{});
@@ -442,7 +491,7 @@ class WakeWordService {
    // (Phase 3) filtert fremde Stimmen weg, der User kann ohne erneute
    // Anrede weitersprechen.
    const passiveMs = await loadPassiveListenMs();
-    if (passiveMs > 0 && this.nativeReady) {
+    if (!skipPassive && passiveMs > 0 && this.nativeReady) {
      this.enterPassiveListening(passiveMs);
      return;
    }
@@ -454,6 +503,7 @@ class WakeWordService {
      // als state extra zu fragen, garantiert dass nach diesem Pfad
      // Native auch wirklich an ist falls es out-of-band gestoppt wurde.
      try {
+        await this._freeMic();   // Streaming-Aufnahme canceln → Mikro frei
        await OpenWakeWord.start();
        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed (wasBarge=%s)', wasBarge);
        import('./logger').then(m => m.reportAppDebug('wake.end',
@@ -520,6 +570,7 @@ class WakeWordService {
    // timeout oder manual → Wake-Word reaktivieren, armed-State.
    if (this.nativeReady && OpenWakeWord) {
      try {
+        await this._freeMic();   // passive Streaming-Aufnahme canceln → Mikro frei
        await OpenWakeWord.start();
        console.log('[WakeWord] zurueck zu armed nach passive-listen');
        ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
@@ -564,6 +615,7 @@ class WakeWordService {
    this.lastTriggerAt = 0;
    if (this.nativeReady && OpenWakeWord) {
      try {
+        await this._freeMic();   // ggf. laufende Aufnahme canceln → Mikro frei
        await OpenWakeWord.start();
        ToastAndroid.show('Hintergrund-Trigger verworfen — lausche wieder', ToastAndroid.SHORT);
        this.setState('armed');
@@ -0,0 +1,90 @@
+/**
+ * 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 CodeEditorTile from './tiles/CodeEditorTile';
+import VncTile from './tiles/VncTile';
+
+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 'editor': return <CodeEditorTile projectId={projectId} />;
+      case 'vnc': return <VncTile 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', '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,125 @@
+/**
+ * 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');
+
+  // Verstecktes Eingabefeld → Software-Tastatur des Handys tippt in die VM.
+  var kbd=document.createElement('input');
+  kbd.setAttribute('autocomplete','off'); kbd.setAttribute('autocorrect','off');
+  kbd.setAttribute('autocapitalize','off'); kbd.spellcheck=false;
+  kbd.style.cssText='position:absolute;left:-1000px;top:0;width:1px;height:1px;opacity:0;';
+  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(_){} }
+    kbd.addEventListener('keydown', function(e){
+      if(SPECIAL[e.key]!==undefined){ tap(SPECIAL[e.key], e.code); e.preventDefault(); }
+    });
+    kbd.addEventListener('input', function(){
+      var v=kbd.value; for(var i=0;i<v.length;i++){ tap(v.charCodeAt(i)); } kbd.value='';
+    });
+
+    // Steuerungs-API fuer die App (per injectJavaScript).
+    window.ariaVncCtl = {
+      focusKeyboard: function(){ try{ 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,14 @@
+/**
+ * layout — Panel-Definitionen der Workbench (Metadaten fuer das Dock).
+ */
+
+export type TileId = 'chat' | '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: '💬' },
+  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,128 @@
+/**
+ * CodeEditorTile — Live-Code-Editor (WebView, editorHtml.ts).
+ *
+ * Zeigt live, was ARIA in diesem Projekt schreibt (aus dem codeFile-Spiegel)
+ * und laesst Stefan selbst editieren — Aenderungen gehen als code_file_edit
+ * zurueck an die Bridge. Datei-Tabs oben zum Umschalten.
+ */
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import { WebView, WebViewMessageEvent } from 'react-native-webview';
+import codeFile, { CodeFileState } from '../../services/codeFile';
+import { EDITOR_HTML } from '../assets/editorHtml';
+
+interface Props {
+  projectId: string;
+}
+
+const CodeEditorTile: React.FC<Props> = ({ projectId }) => {
+  const webRef = useRef<WebView>(null);
+  const [files, setFiles] = useState<CodeFileState[]>(() => codeFile.getFiles(projectId));
+  const [currentPath, setCurrentPath] = useState<string | null>(files[0]?.path ?? null);
+
+  const readyRef = useRef(false);
+  const currentPathRef = useRef<string | null>(currentPath);
+  currentPathRef.current = currentPath;
+
+  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((path: string | null) => {
+    if (!path) { sendToWeb({ cmd: 'setContent', content: '', language: 'text', version: 0 }); return; }
+    const f = codeFile.getFile(projectId, path);
+    sendToWeb({ cmd: 'setContent', content: f?.content ?? '', language: f?.language ?? 'text', version: f?.version ?? 0 });
+  }, [projectId, sendToWeb]);
+
+  // Projektwechsel: Dateiliste + Auswahl neu.
+  useEffect(() => {
+    const list = codeFile.getFiles(projectId);
+    setFiles(list);
+    setCurrentPath((prev) => (prev && list.some((f) => f.path === prev) ? prev : list[0]?.path ?? null));
+  }, [projectId]);
+
+  // Eingehende Updates aus dem Spiegel.
+  useEffect(() => {
+    return codeFile.subscribe((u) => {
+      if ((u.projectId || '') !== (projectId || '')) return;
+      setFiles(codeFile.getFiles(projectId));
+      // Noch keine Datei gewaehlt → diese oeffnen.
+      if (!currentPathRef.current) { setCurrentPath(u.path); return; }
+      if (u.path !== currentPathRef.current) return;
+      if (!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 → in den Editor 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}>Noch keine Datei</Text>
+        ) : (
+          <ScrollView horizontal showsHorizontalScrollIndicator={false} contentContainerStyle={styles.tabs}>
+            {files.map((f) => {
+              const active = f.path === currentPath;
+              const name = f.path.split('/').pop() || f.path;
+              return (
+                <TouchableOpacity key={f.path} onPress={() => setCurrentPath(f.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,143 @@
+/**
+ * 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;
+}
+
+const VncTile: React.FC<Props> = ({ projectId, focused }) => {
+  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);
+    } 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]);
+
+  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 };
+}
@@ -30,6 +30,7 @@ from memory import Embedder, VectorStore, MemoryPoint
 from prompts import build_system_prompt, IDENTITY_SEED, IDENTITY_ANCHOR, looks_like_identity_break
 from proxy_client import ProxyClient, Message as ProxyMessage
 import router as router_mod
+import metrics
 from local_llm import local_llm_chat
 import skills as skills_mod
 import triggers as triggers_mod
@@ -233,6 +234,43 @@ META_TOOLS = [
                            "\"method\":\"PUT\"},\"reply\":\"Spotify: pausiert ⏸\"}]"
                        ),
                    },
+                    "speak": {
+                        "type": "boolean",
+                        "description": (
+                            "STATISCHER Default fuers Vorlesen dieses Skills (TTS). "
+                            "Default false.\n\n"
+                            "WARUM es das gibt: ARIA ist voice-first. Ein reiner "
+                            "STEUERBEFEHL (Spotify next/pause, Licht an) muss NICHT "
+                            "vorgelesen werden — die Aktion selbst ist die Bestaetigung, "
+                            "Vorlesen waere nervig. Ein ANTWORT-Skill dagegen liefert "
+                            "eine Info, die Stefan HOEREN will (Wuerfelergebnis, Status, "
+                            "'was laeuft gerade'). Also: Kommando-Skill=false, "
+                            "Antwort-Skill=true.\n\n"
+                            "PRO AUFRUF (wichtig fuer gemischte Skills!): Wenn EIN Skill "
+                            "beides kann (z.B. Spotify: 'next' = stumm, 'was laeuft' = "
+                            "vorlesen), kann dein run.py im JSON-Output pro Aufruf "
+                            "`speak` (und `converse`, s.u.) setzen — das ueberschreibt "
+                            "diesen statischen Default. Beispiel-Output:\n"
+                            "  next        -> {\"ok\":true,\"speak\":false,\"converse\":false}\n"
+                            "  was_laeuft  -> {\"ok\":true,\"speak\":true,\"converse\":false,"
+                            "\"reply\":\"Laeuft: …\"}"
+                        ),
+                    },
+                    "converse": {
+                        "type": "boolean",
+                        "description": (
+                            "Soll ARIA NACH dieser Skill-Antwort 30s WEITERLAUSCHEN "
+                            "(Dialog), oder direkt zurueck aufs Wake-Word? Default false.\n\n"
+                            "WARUM getrennt von speak: 'vorlesen' und 'weiterreden "
+                            "koennen' sind zwei verschiedene Dinge. 'was laeuft gerade' "
+                            "soll vorgelesen werden (speak=true), aber es ist eine "
+                            "abgeschlossene Einzel-Info — Stefan will danach NICHT ins "
+                            "30s-Mikrofon-Fenster gezwungen werden (converse=false). Nur "
+                            "wenn eine echte Rueckfrage/ein Dialog sinnvoll ist "
+                            "(converse=true). Am besten pro Aufruf im run.py-Output "
+                            "setzen (dynamisch), nicht statisch."
+                        ),
+                    },
                },
                "required": ["name", "description", "entry_code"],
            },
@@ -246,6 +284,27 @@ META_TOOLS = [
            "parameters": {"type": "object", "properties": {}},
        },
    },
+    {
+        "type": "function",
+        "function": {
+            "name": "skill_get",
+            "description": (
+                "Liest einen EXISTIERENDEN Skill VOLLSTAENDIG: Manifest (inkl. "
+                "args, fast_patterns, speak/converse) + kompletter entry_code "
+                "(der echte Python-Code) + README. IMMER vor `skill_update` "
+                "aufrufen, damit du den bestehenden Code SIEHST und ihn gezielt "
+                "aenderst statt blind zu ueberschreiben (Blind-Rewrite killt "
+                "leicht funktionierende Teile!)."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "Skill-Name."},
+                },
+                "required": ["name"],
+            },
+        },
+    },
    {
        "type": "function",
        "function": {
@@ -309,6 +368,23 @@ META_TOOLS = [
                            "wieder durch Claude). Wenn nicht angegeben: bleibt unberuehrt."
                        ),
                    },
+                    "speak": {
+                        "type": "boolean",
+                        "description": (
+                            "Statischer Vorlese-Default (siehe skill_create). false = "
+                            "Steuerbefehl/stumm, true = Antwort-Skill/vorlesen. Pro "
+                            "Aufruf via run.py-JSON-Output ueberschreibbar."
+                        ),
+                    },
+                    "converse": {
+                        "type": "boolean",
+                        "description": (
+                            "Statischer Default: nach der Antwort 30s weiterlauschen "
+                            "(Dialog=true) oder direkt zurueck aufs Wake-Word (false, "
+                            "Default). Siehe skill_create. Pro Aufruf via Output "
+                            "ueberschreibbar."
+                        ),
+                    },
                },
                "required": ["name"],
            },
@@ -464,10 +540,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"},
@@ -966,15 +1045,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"],
            },
@@ -999,6 +1083,28 @@ 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"],
+            },
+        },
+    },
 ]


@@ -1017,10 +1123,102 @@ META_TOOLS = [
 # Diese Logik ist generisch — ARIA deklariert die Patterns selbst beim
 # skill_create / skill_update, das Brain orchestriert nur.

+def _strip_leading_hint_blocks(text: str) -> str:
+    """Entfernt fuehrende Hint-Bloecke `[ ... ]`, die die Bridge an
+    Voice-Nachrichten haengt (GPS-Position, Barge-In-Hinweis). Ohne das matcht
+    KEIN Voice-Befehl je den Fast-Path (Regex ist ^...$-verankert) — selbst
+    'nächstes lied' landete unnoetig bei Claude statt beim 0-Token-Fast-Path."""
+    s = (text or "").strip()
+    prev = None
+    while prev != s:
+        prev = s
+        s = re.sub(r"^\s*\[[^\]]*\]\s*", "", s)
+    return s
+
+
+def _fold_umlauts(s: str) -> str:
+    """ä→ae, ö→oe, ü→ue, ß→ss (lowercase erwartet). Whisper liefert echte
+    Umlaute ('Nächstes Lied'), viele Skill-fast_patterns sind aber in ae/oe/ue
+    geschrieben — ohne Faltung matcht das nie."""
+    return (s.replace("ä", "ae").replace("ö", "oe").replace("ü", "ue")
+             .replace("ß", "ss"))
+
+
+def _looks_like_skill_action(text: str) -> bool:
+    """Erkennt eine BEHAUPTETE Steuerbefehl-Quittung (v.a. Spotify) im Reply.
+    Genutzt fuer den Anti-Halluzinations-Guard: sagt local sowas, hat aber KEIN
+    Werkzeug gerufen, ist real nichts passiert → eskalieren. Bewusst eng, um
+    normale Konversation ueber Musik nicht zu treffen."""
+    t = (text or "").strip().lower()
+    if not t:
+        return False
+    if t.startswith("spotify:") or t.startswith("spotify -") or t.startswith("musik:"):
+        return True
+    if "playlist" in t and ("abspiel" in t or "spiele" in t or "starte" in t):
+        return True
+    if ("ueberspring" in t or "überspring" in t) and ("titel" in t or "lied" in t or "song" in t):
+        return True
+    return False
+
+
+def _claims_live_media_state(text: str) -> bool:
+    """Erkennt eine BEHAUPTETE Live-Zustands-Auskunft, die NUR ein Werkzeug
+    wissen kann: aktueller Song/Interpret, Restzeit, was gerade laeuft, welches
+    Geraet spielt. local erfindet das gern (mal 'Midnight City von M83', mal
+    'The House Of House') ohne run_spotify zu rufen. Ohne echten Skill-Aufruf ist
+    das reine Halluzination → eskalieren (Claude ruft das Tool zuverlaessig).
+
+    Bewusst auf Medien-/Wiedergabe-Zustand begrenzt, damit normale Musik-
+    Konversation ('ich mag M83') NICHT getroffen wird — es muss nach einer
+    konkreten Ist-Zustands-Auskunft klingen."""
+    t = (text or "").strip().lower()
+    if not t:
+        return False
+    # Restzeit/Abspielposition ('noch 52 Sekunden', 'Restzeit 2:34').
+    if "restzeit" in t or "restlaufzeit" in t:
+        return True
+    if re.search(r"\bnoch\s+\d+\s*(sekunde|minute|sek|min)", t):
+        return True
+    # 'aktueller Song/Titel/Lied heisst/ist …' / 'es laeuft gerade …' /
+    # 'spielt gerade …' / 'jetzt laeuft …' — Ist-Zustands-Auskunft.
+    if re.search(r"(aktuell\w*\s+(song|titel|lied|stueck|track))", t):
+        return True
+    if re.search(r"(l(ae|ä)uft|spielt)\s+(gerade|jetzt|aktuell|zurzeit|grade)", t):
+        return True
+    if re.search(r"(gerade|jetzt|zurzeit|grade)\s+(l(ae|ä)uft|spielt)", t):
+        return True
+    # Skip-Quittung, die einen konkreten Folgetitel behauptet ('… ist jetzt „X"').
+    if ("ueberspring" in t or "übersprung" in t or "uebersprung" in t) and (
+            "song" in t or "titel" in t or "lied" in t):
+        return True
+    return False
+
+
+_AWAIT_MARKER_RE = re.compile(r"\[\[\s*AWAIT(?:_REPLY)?\s*\]\]", re.IGNORECASE)
+
+
+def _extract_await_marker(text: str) -> tuple:
+    """Erkennt ARIAs Rueckfrage-Marker `[[AWAIT]]` — den sie ans Ende haengt,
+    wenn ihre Antwort eine echte Rueckfrage ist, auf die sie eine Nutzer-Antwort
+    BRAUCHT, bevor der aktuelle Task fertig ist. Entfernt den Marker (nicht
+    anzeigen/vorlesen/in History) und meldet, ob er da war. Wie speak/converse:
+    ARIA deklariert den Zustand selbst — kein '?'-Raten."""
+    if not text:
+        return text, False
+    if _AWAIT_MARKER_RE.search(text):
+        return _AWAIT_MARKER_RE.sub("", text).strip(), True
+    return text, False
+
+
 def _normalize_for_fast_match(text: str) -> str:
-    norm = (text or "").strip().lower()
-    norm = re.sub(r"[.!?]+$", "", norm)
-    norm = re.sub(r"\s+", " ", norm)
+    norm = _strip_leading_hint_blocks(text).lower()
+    norm = _fold_umlauts(norm)
+    # Interne Satzzeichen raus, die Whisper einstreut ('Nächstes Lied, bitte.').
+    # Kommas/Semikola/Doppelpunkte → Space, Punkt/!/? ganz weg. Sonst matcht das
+    # ^...$-verankerte fast_pattern nie, weil das Komma dazwischenfunkt.
+    norm = re.sub(r"[,;:]", " ", norm)
+    norm = re.sub(r"[.!?]+", "", norm)
+    norm = re.sub(r"\s+", " ", norm).strip()
    return norm


@@ -1116,6 +1314,9 @@ class Agent:
                rx = pat.get("match") or ""
                if not rx:
                    continue
+                # Pattern GLEICH falten wie den Text — egal ob der Skill-Autor
+                # 'naechstes' oder 'nächstes' geschrieben hat.
+                rx = _fold_umlauts(rx)
                try:
                    if not re.match(rx, norm, re.IGNORECASE):
                        continue
@@ -1124,6 +1325,12 @@ class Agent:
                    continue
                args = pat.get("args") or {}
                reply = pat.get("reply") or f"{skill_name}: ok"
+                # Vorlesen/Weiterlauschen folgen dem Skill — GENAU wie bei local/
+                # Claude: Manifest-Default, vom Skill-Output pro Aufruf ueber-
+                # schreibbar. Also NICHT generell converse=False: ein Fast-Path-
+                # Skill darf ein Dialog-Skill sein.
+                self._fast_path_speak = bool(skill.get("speak", False))
+                self._fast_path_converse = bool(skill.get("converse", False))
                logger.info("[fast-path] match skill=%s pattern=%r msg=%r",
                            skill_name, rx, user_message[:60])
                try:
@@ -1136,6 +1343,16 @@ class Agent:
                    tail = (res.get("stderr") or res.get("stdout") or "").strip().splitlines()
                    hint = (tail[-1] if tail else "")[:120]
                    return f"{skill_name}: {reply} — Fehler: {hint or 'siehe Brain-Log'}"
+                # Per-Aufruf-Override aus dem Skill-JSON-Output (falls vorhanden).
+                try:
+                    _j = json.loads((res.get("stdout") or "").strip())
+                    if isinstance(_j, dict):
+                        if isinstance(_j.get("speak"), bool):
+                            self._fast_path_speak = _j["speak"]
+                        if isinstance(_j.get("converse"), bool):
+                            self._fast_path_converse = _j["converse"]
+                except Exception:
+                    pass
                return reply
        return None

@@ -1150,6 +1367,32 @@ class Agent:
    _LOCAL_WINDOW_TURNS = 8   # nur die letzten N Turns ans lokale Modell (Speed)
    _LOCAL_TOOL_ITERATIONS = 3  # max Tool-Runden lokal, sonst → Claude

+    # Weiche Fehler-Marker im Tool-Ausgabetext. Viele Action-Skills geben einen
+    # menschenlesbaren Fehler auf stdout aus und beenden sich TROTZDEM mit Exit 0
+    # (z.B. Spotify: "Fehler beim Uebertragen", "Geraet nicht gefunden"). Der
+    # harte FEHLER-Prefix (Exit != 0) faengt das nicht. Fuer run_*-Skills werten
+    # wir daher auch solche Marker als Fehlschlag → eskalieren an Claude, der
+    # mehrstufig weiterdenkt. Info-Tools (web_search/memory_search) sind bewusst
+    # AUSGENOMMEN: deren Inhalt darf das Wort "Fehler" tragen ohne dass der
+    # Tool-Call scheiterte. Eskalieren ist immer sicher (nur langsamer).
+    _SOFT_FAIL_MARKERS = (
+        "fehler", "fehlgeschlagen", "nicht gefunden", "not found",
+        "konnte nicht", "keine verbindung", "nicht verfuegbar",
+        "exception", "traceback",
+    )
+
+    def _local_tool_failed(self, tool_name: str, tresult: str) -> bool:
+        """True wenn ein lokaler Tool-Call als gescheitert gilt (→ Claude)."""
+        s = (tresult or "").strip()
+        if not s:
+            return False
+        if s.startswith("FEHLER"):           # harter Exit-Code-Fehler
+            return True
+        if tool_name.startswith("run_"):     # Action-Skill: auch weiche Fehler
+            low = s.lower()
+            return any(mk in low for mk in self._SOFT_FAIL_MARKERS)
+        return False
+
    # Kuratierte Tool-Auswahl fuers lokale Tier (B1b): web_search (local-only,
    # SearXNG) + memory_search/trigger_timer (aus META_TOOLS) + Spotify-Skill.
    # Bewusst klein (Speed + Sicherheit); alles andere → Claude.
@@ -1165,13 +1408,73 @@ class Agent:
                break
        return tools

+    def _resolve_skill_manifest(self, tname: str) -> Optional[dict]:
+        """run_-Toolname → Skill-Manifest (fuzzy, Bindestrich-Mapping)."""
+        if not tname.startswith("run_"):
+            return None
+        suffix = tname[len("run_"):]
+        m = skills_mod.read_manifest(suffix)
+        if m is None:
+            for cand in skills_mod.list_skills(active_only=False):
+                cn = cand.get("name") or ""
+                if re.sub(r"[^a-zA-Z0-9_]", "_", cn) == suffix:
+                    m = cand
+                    break
+        return m
+
+    def _skill_speak_flag(self, tname: str) -> bool:
+        """speak-Flag eines run_*-Skills aus dem Manifest (Default False)."""
+        if not tname.startswith("run_"):
+            return True
+        return bool((self._resolve_skill_manifest(tname) or {}).get("speak", False))
+
+    def _skill_response_flags(self, tname: str) -> tuple:
+        """(speak, converse) fuer einen gerade ausgefuehrten run_*-Skill.
+        Prioritaet: JSON-Output des Skills (self._last_skill_flags, pro Aufruf) >
+        Manifest-Default > False. So kann EIN Skill pro Operation unterschiedlich
+        sein — 'next' stumm/stop, 'was laeuft' vorlesen aber trotzdem stop."""
+        flags = getattr(self, "_last_skill_flags", None) or {}
+        m = self._resolve_skill_manifest(tname) or {}
+        speak = bool(m.get("speak", False))
+        converse = bool(m.get("converse", False))
+        if isinstance(flags.get("speak"), bool):
+            speak = flags["speak"]
+        if isinstance(flags.get("converse"), bool):
+            converse = flags["converse"]
+        return speak, converse
+
    def _try_local_fast_lane(self, user_message: str,
                             active_project_id: str) -> Optional[str]:
        cfg = router_mod.load_config()
        if not router_mod.should_try_local(user_message, cfg):
            return None
+        # Vorlesen ja/nein fuer diesen lokalen Turn. Default True (Info-Antwort).
+        # Fuehrt local einen Skill (run_*) aus, uebernimmt dessen speak-Flag aus
+        # dem Manifest (Steuerbefehl-Skill=False → stumm, Antwort-Skill=True).
+        # Info-Tools (web_search/memory_search/trigger_timer) lassen es bei True.
+        self._local_turn_speak = True
+        # Nach der Antwort 30s weiterlauschen? Default True (Gespraech/Info via
+        # web_search). Ein run_*-Skill setzt es auf seinen Output-Wert (Default
+        # False = Einzelaktion).
+        self._local_turn_converse = True
+        # Hat local in diesem Turn ueberhaupt einen echten Skill (run_*) gerufen?
+        # Fuer den Anti-Halluzinations-Guard: behauptet local eine Spotify-/Skill-
+        # Aktion OHNE das Tool zu rufen → eskalieren statt eine erfundene
+        # Bestaetigung durchzulassen.
+        self._local_ran_skill = False
        local_only = bool(cfg.get("localOnly"))
-        tools = self._build_local_tools()  # B1b: kuratierte Tools
+        local_model = cfg.get("localLlmModel") or "qwen3-8b"  # B0.5: llama-swap-Key
+        # B1a-Rueckbau (bewusst): local ist TOOL-LOS — nur reines Reden. Ein 8B
+        # ist ein unzuverlaessiger Tool-Caller: mit Werkzeug in der Hand erfindet
+        # er lieber eine plausible Antwort ('der Song ist X'), statt das Tool zu
+        # rufen — das war die Halo-Quelle UND zwang zu per-Skill-Guards. Ohne
+        # Tools KANN er kein Skill-Ergebnis faelschen. Alles mit Grundwahrheit
+        # (Fakt/Live-Zustand/Gedaechtnis/Aktion) gehoert an Claude oder an den
+        # deterministischen Fast-Path — nicht an den 8B. WIE es dorthin kommt:
+        # das Modell eskaliert SELBST (<<ESCALATE>>, siehe Prompt) — bewusst KEINE
+        # Input-Wortliste im Router. Der Output-Guard unten faengt ab, wenn der
+        # 8B doch mal statt zu eskalieren einen Live-Zustand behauptet.
+        tools = []

        sys_prompt = router_mod.build_local_system_prompt(IDENTITY_ANCHOR,
                                                          has_tools=bool(tools))
@@ -1185,13 +1488,21 @@ class Agent:
        # Spotify aufrufen. Ergebnisse zurueck, bis es final (ohne tool_calls) antwortet.
        final = ""
        for _ in range(self._LOCAL_TOOL_ITERATIONS):
-            res = local_llm_chat(messages, max_tokens=500, temperature=0.5, tools=tools)
+            res = local_llm_chat(messages, max_tokens=500, temperature=0.5,
+                                 tools=tools, model=local_model)
            if not res.get("ok"):
                logger.info("[router] lokal fehlgeschlagen (%s) — %s", res.get("error"),
                            "kein Fallback (localOnly)" if local_only else "→ Claude")
                if local_only:
                    return f"[Lokales LLM nicht erreichbar: {res.get('error', 'unbekannt')}]"
                return None
+            # Metric: dieser lokale Call (echte usage-Tokens wenn der Adapter sie
+            # liefert). Erfasst pro Tool-Runde — mehrere Runden = mehrere Calls.
+            try:
+                metrics.log_local_call(res.get("model") or local_model, messages,
+                                       res.get("content") or "", res.get("usage"))
+            except Exception:
+                pass
            tcs = res.get("tool_calls")
            if tcs:
                messages.append({"role": "assistant",
@@ -1207,8 +1518,15 @@ class Agent:
                        targs = {}
                    logger.info("[router] lokal Tool-Call: %s(%s)", tname,
                                ", ".join(targs.keys()))
-                    tresult = self._dispatch_tool(tname, targs)
-                    if (tresult or "").strip().startswith("FEHLER"):
+                    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.
+                    if tname.startswith("run_") and not self._local_tool_failed(tname, tresult):
+                        self._local_turn_speak, self._local_turn_converse = \
+                            self._skill_response_flags(tname)
+                        self._local_ran_skill = True
+                    if self._local_tool_failed(tname, tresult):
                        had_error = True
                    messages.append({"role": "tool",
                                     "tool_call_id": tc.get("id") or "",
@@ -1253,6 +1571,15 @@ class Agent:
            logger.info("[router] lokal eskaliert → Claude")
            return None

+        # Anti-Halluzination: local behauptet manchmal eine Musik-/Skill-Aktion
+        # ('Spotify: …', 'Playlist … abspielen'), OHNE run_spotify gerufen zu
+        # haben → es ist real nichts passiert. Dann eskalieren: Claude ruft das
+        # Tool zuverlaessig. (Echte Skill-Ausfuehrung → _local_ran_skill=True.)
+        if not self._local_ran_skill and (
+                _looks_like_skill_action(final) or _claims_live_media_state(final)):
+            logger.info("[router] lokal: Aktion/Live-Zustand behauptet ohne Tool-Call → Claude")
+            return None
+
        logger.info("[router] lokal beantwortet (%d Zeichen)", len(final))
        self.conversation.add("assistant", final, project_id=active_project_id)
        return final
@@ -1297,7 +1624,18 @@ class Agent:
            self.conversation.add("assistant", fast_reply, project_id=active_project_id)
            if active_project_id:
                projects_mod.touch_project(active_project_id)
-            return fast_reply, "fast-path"
+            # Metric: Fast-Path spart einen ganzen Claude-Call zum Nulltarif.
+            try:
+                metrics.log_fast_path(fast_reply)
+            except Exception:
+                pass
+            # Vorlesen folgt dem Skill-Manifest (speak): Steuerbefehl=stumm,
+            # Antwort-Skill=vorlesen. Default False (reiner Steuerbefehl).
+            speak = bool(getattr(self, "_fast_path_speak", False))
+            # converse folgt dem Skill (Manifest/Output) — nicht mehr generell False.
+            converse = bool(getattr(self, "_fast_path_converse", False))
+            # Fast-Path = reiner Steuerbefehl, nie eine Rueckfrage → awaiting=False.
+            return fast_reply, "fast-path", speak, converse, False

        # 1. User-Turn an die Konversation
        self.conversation.add("user", user_message, source=source,
@@ -1311,7 +1649,12 @@ class Agent:
        # teure Claude-Aufbau + Tool-Loop wird uebersprungen. Sonst None → Claude.
        local_reply = self._try_local_fast_lane(user_message, active_project_id)
        if local_reply is not None:
-            return local_reply, "local"
+            # speak = vorlesen?  converse = danach 30s weiterlauschen? Beides folgt
+            # dem Skill (bzw. Default: Info/Gespraech = vorlesen + 30s).
+            speak = getattr(self, "_local_turn_speak", True)
+            converse = getattr(self, "_local_turn_converse", True)
+            # Local ist tool-loses Reden; blockierende Rueckfragen macht Claude.
+            return local_reply, "local", speak, converse, False

        # 2. Hot Memory (alle pinned Punkte)
        hot = self.store.list_pinned()
@@ -1358,6 +1701,23 @@ class Agent:
                                            oauth_callback_host=oauth_host,
                                            oauth_callback_port=oauth_port,
                                            oauth_callback_tls=oauth_tls)
+        # Rueckfrage-Signal: ARIA haengt [[AWAIT]] an, wenn ihre Antwort eine
+        # echte, blockierende Rueckfrage ist. Die App pausiert dann die Projekt-
+        # Queue und leitet Stefans naechste Eingabe als ANTWORT darauf weiter
+        # (statt als neuen Auftrag). Wie speak/converse: ARIA deklariert selbst.
+        system_prompt += (
+            "\n\n## RUECKFRAGE-SIGNAL [[AWAIT]]\n"
+            "Wenn deine Antwort eine echte RUECKFRAGE ist, auf die du Stefans "
+            "Antwort BRAUCHST, um den aktuellen Task abzuschliessen (z.B. 'Welche "
+            "der drei Playlists meinst du?', 'Soll ich X oder Y nehmen?'), haenge "
+            "als ALLERLETZTES exakt `[[AWAIT]]` an. Der Marker wird entfernt (nicht "
+            "angezeigt, nicht vorgelesen) und sagt der App: warte auf Stefans "
+            "Antwort, bevor der naechste Task der Warteschlange laeuft.\n"
+            "NUR bei echten, blockierenden Rueckfragen — NICHT bei rhetorischen "
+            "Fragen, unverbindlichen Vorschlaegen ('soll ich noch...?', die auch "
+            "ohne Antwort ok sind) oder wenn du den Task einfach fertig hast. Im "
+            "Zweifel: KEIN Marker."
+        )
        # Queue-Aware Prompting: wenn nach diesem Turn weitere Nachrichten
        # in der Warteschlange liegen, muss ARIA pruefen ob eine spaetere die
        # aktuelle Aufgabe korrigiert/annuliert (→ Skip statt Doppelarbeit).
@@ -1427,6 +1787,13 @@ class Agent:
        # zwei Turns, was OpenAI/Anthropic verwirrt und bei strict tools-Aufrufen
        # zu 400-Errors fuehren kann.
        final_reply = ""
+        # Vorlesen ja/nein fuer diesen Claude-Turn. Default True (Gespraech).
+        # Fuehrt Claude einen Steuerbefehl-Skill (run_*, speak=false) erfolgreich
+        # aus, wird die Antwort NICHT vorgelesen — der Text landet aber normal in
+        # der Bubble (Stefans Wunsch). Antwort-Skills (speak=true) + reine
+        # Konversation bleiben gesprochen.
+        self._claude_turn_speak = True
+        self._claude_turn_converse = True   # Default Gespraech; run_*-Skill setzt es
        try:
            for iteration in range(self.MAX_TOOL_ITERATIONS):
                result = self.proxy.chat_full(messages, tools=tools,
@@ -1443,7 +1810,13 @@ 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 ""
+                        if _tn.startswith("run_") and not self._local_tool_failed(_tn, tool_result):
+                            self._claude_turn_speak, self._claude_turn_converse = \
+                                self._skill_response_flags(_tn)
                        # Cap auf 50 KB — passt zur Cap in _dispatch_tool fuer
                        # Skill-Outputs (siehe agent.py weiter unten). 8 KB war
                        # viel zu wenig: Spotify _all=true mit 90 Playlists
@@ -1509,17 +1882,68 @@ class Agent:
                final_reply = ("Hey, ich bin ARIA. \U0001F60A Bei mir ist alles bereit — "
                               "sag mir einfach, was du brauchst.")

+        # Rueckfrage-Marker aus dem finalen Text ziehen (vor History/Return, damit
+        # er nicht angezeigt/vorgelesen wird und nicht die Conversation vergiftet).
+        final_reply, awaiting_reply = _extract_await_marker(final_reply)
+
        # 7. Assistant-Turn (final reply) in die Conversation
        self.conversation.add("assistant", final_reply,
                              project_id=active_project_id)
-        return final_reply, "claude"
+        # speak/converse folgen dem ausgefuehrten Skill (sonst Default: Gespraech);
+        # awaiting_reply = ARIA stellt eine blockierende Rueckfrage (Queue pausiert).
+        return (final_reply, "claude",
+                bool(getattr(self, "_claude_turn_speak", True)),
+                bool(getattr(self, "_claude_turn_converse", True)),
+                awaiting_reply)

    # ── 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_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
@@ -1533,6 +1957,8 @@ class Agent:
                    pip_packages=arguments.get("pip_packages", []),
                    config_schema=arguments.get("config_schema") or None,
                    fast_patterns=arguments.get("fast_patterns") or None,
+                    speak=bool(arguments.get("speak", False)),
+                    converse=bool(arguments.get("converse", False)),
                    author="aria",
                )
                # Side-Channel-Event: Stefan soll sehen wenn ARIA was anlegt
@@ -1584,6 +2010,29 @@ class Agent:
                    f"- {s['name']} ({s['execution']}) {'aktiv' if s.get('active', True) else 'DEAKTIVIERT'}: {s.get('description', '')}"
                    for s in items
                )
+            if name == "skill_get":
+                sk_name = (arguments.get("name") or "").strip()
+                if not sk_name:
+                    return "FEHLER: name ist Pflicht."
+                src = skills_mod.read_skill_source(sk_name)
+                if src is None:
+                    return f"FEHLER: Skill '{sk_name}' nicht gefunden."
+                m = src["manifest"]
+                # Manifest kompakt + kompletter Code, damit ARIA gezielt aendern kann.
+                meta = {
+                    "name": m.get("name"), "description": m.get("description"),
+                    "execution": m.get("execution"), "entry": m.get("entry"),
+                    "active": m.get("active"), "args": m.get("args"),
+                    "requires": m.get("requires"),
+                    "config_schema": m.get("config_schema"),
+                    "fast_patterns": m.get("fast_patterns"),
+                    "speak": m.get("speak"), "converse": m.get("converse"),
+                }
+                return (
+                    f"MANIFEST:\n{json.dumps(meta, ensure_ascii=False, indent=2)}\n\n"
+                    f"ENTRY-CODE ({src['entry']}):\n{src['entry_code']}\n\n"
+                    f"README:\n{src.get('readme') or '(leer)'}"
+                )
            if name == "skill_update":
                skill_name = (arguments.get("name") or "").strip()
                if not skill_name:
@@ -1592,6 +2041,10 @@ class Agent:
                for k in ("entry_code", "readme", "description", "args", "active"):
                    if k in arguments and arguments[k] is not None:
                        patch[k] = arguments[k]
+                if "speak" in arguments and arguments["speak"] is not None:
+                    patch["speak"] = bool(arguments["speak"])
+                if "converse" in arguments and arguments["converse"] is not None:
+                    patch["converse"] = bool(arguments["converse"])
                if "pip_packages" in arguments and isinstance(arguments["pip_packages"], list):
                    patch["pip_packages"] = arguments["pip_packages"]
                if "config_schema" in arguments and isinstance(arguments["config_schema"], list):
@@ -1693,6 +2146,18 @@ class Agent:
                            skill_name = cand_name
                            break
                res = skills_mod.run_skill(skill_name, args=arguments)
+                # Steuer-Flags aus dem Skill-JSON-Output (speak/converse) fuer
+                # DIESEN Aufruf merken. Der Aufrufer (local/claude/fast-path)
+                # liest sie und steuert damit Vorlesen (speak) + 30s-Weiter-
+                # lauschen (converse) — pro Aufruf, dynamisch. Kein JSON / nicht
+                # gesetzt → Aufrufer nimmt Manifest-Default (speak) bzw. False.
+                self._last_skill_flags = None
+                if res.get("ok"):
+                    try:
+                        _j = json.loads((res.get("stdout") or "").strip())
+                        self._last_skill_flags = _j if isinstance(_j, dict) else None
+                    except Exception:
+                        self._last_skill_flags = None
                # 2000 Zeichen war viel zu wenig — Spotify-JSON ist 5-15 KB,
                # da wurde der Track-Name regelmaessig abgeschnitten und ARIA
                # hat aus dem Album-Kontext halluziniert. Claude kann hunderte
@@ -2142,22 +2607,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()
@@ -2173,6 +2649,32 @@ 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."
            return f"Unbekanntes Tool: {name}"
        except Exception as exc:
            logger.exception("Tool '%s' fehlgeschlagen", name)
@@ -150,7 +150,7 @@ async def _fire(trigger: dict, agent_factory) -> None:

    try:
        agent = agent_factory()
-        reply, _ = agent.chat(prompt, source="trigger")
+        reply, _, _, _, _ = agent.chat(prompt, source="trigger")
        events = agent.pop_events()
        logger.info("[trigger] %s gefeuert → ARIA-Reply: %s", name, reply[:80])
        triggers_mod.append_log(name, {"event": "reply", "text": reply[:500]})
@@ -29,11 +29,12 @@ LOCAL_LLM_HTTP_TIMEOUT_SEC = float(os.environ.get("LOCAL_LLM_HTTP_TIMEOUT_SEC",


 def local_llm_chat(messages: list, *, max_tokens: int = 512,
-                   temperature: float = 0.7, stop=None, tools=None) -> dict:
+                   temperature: float = 0.7, stop=None, tools=None,
+                   model=None) -> dict:
    """Ein Chat-Call ans lokale LLM. messages = [{role, content}, ...].
-    tools (B1b): optionale OpenAI-Tool-Defs; das Ergebnis kann dann
-    result['tool_calls'] enthalten. Blockierend (urllib) — chat() laeuft
-    ohnehin im Executor-Thread."""
+    model (B0.5): welches Modell llama-swap laden soll. tools (B1b): optionale
+    OpenAI-Tool-Defs; das Ergebnis kann dann result['tool_calls'] enthalten.
+    Blockierend (urllib) — chat() laeuft ohnehin im Executor-Thread."""
    if not isinstance(messages, list) or not messages:
        return {"ok": False, "error": "messages leer/ungueltig"}
    req = {"messages": messages, "max_tokens": max_tokens, "temperature": temperature}
@@ -41,6 +42,8 @@ def local_llm_chat(messages: list, *, max_tokens: int = 512,
        req["stop"] = stop
    if tools:
        req["tools"] = tools
+    if model:
+        req["model"] = model
    try:
        body = json.dumps(req).encode("utf-8")
        http_req = urllib.request.Request(
@@ -633,6 +633,16 @@ class ChatOut(BaseModel):
    # Welcher Backend die Antwort erzeugt hat: "local" (Qwen), "claude",
    # "fast-path" (Skill/Regex). Fuer den Quell-Badge in Diagnostic.
    answered_by: str = "claude"
+    # Soll die Antwort vorgelesen werden? Fast-Path (reiner Steuerbefehl) = False;
+    # ARIA-Antworten (local/claude) = True. System-Flag statt <voice>-Tag.
+    speak: bool = True
+    # Soll die App nach der Antwort 30s weiterlauschen (Gespraech)? Einzelaktionen/
+    # Skills = False (direkt zurueck aufs Wake-Word), Konversation = True.
+    converse: bool = True
+    # Stellt ARIA eine blockierende Rueckfrage (braucht Stefans Antwort, bevor der
+    # Task fertig ist)? Dann pausiert die App die Projekt-Queue und leitet die
+    # naechste Eingabe als Antwort weiter, statt sie als neuen Auftrag anzustellen.
+    awaiting_reply: bool = False
    # Echo der project_id die dieser Turn hatte. Bridge nutzt sie damit die
    # ausgehende Chat-Bubble sauber getaggt in der richtigen Thread-Bahn der
    # UI landet.
@@ -716,7 +726,7 @@ async def chat(body: ChatIn, background: BackgroundTasks):
                # Sync-Aufruf im Executor damit wir den Event-Loop nicht blocken —
                # chat() macht HTTP-Calls (Proxy) die 30-60s dauern koennen.
                loop = asyncio.get_running_loop()
-                reply, answered_by = await loop.run_in_executor(
+                reply, answered_by, speak, converse, awaiting_reply = await loop.run_in_executor(
                    None,
                    lambda: a.chat(
                        body.message, source=body.source, project_id=pid,
@@ -739,6 +749,9 @@ async def chat(body: ChatIn, background: BackgroundTasks):
                events=a.pop_events(),
                project_id=pid,
                answered_by=answered_by,
+                speak=speak,
+                converse=converse,
+                awaiting_reply=awaiting_reply,
            )
    finally:
        _project_pending[pid] = [
@@ -813,6 +826,7 @@ def projects_archive(project_id: str):
 class ProjectUpdateBody(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None
+    hidden: Optional[bool] = None


@app.patch("/projects/{project_id}")
@@ -52,25 +52,55 @@ def _messages_tokens(messages: list) -> int:
    return total


-def log_call(model: str, messages_in: list, reply_text: str = "") -> None:
-    """Eine Call-Metric anhaengen. Robust gegen Fehler (silent fail)."""
+def _append(model: str, tokens_in: int, tokens_out: int, source: str) -> None:
+    """Ein Metric-Entry auf Disk anhaengen. Robust (silent fail)."""
    try:
-        tokens_in = _messages_tokens(messages_in)
-        tokens_out = _estimate_tokens(reply_text)
        line = json.dumps({
            "ts": int(time.time() * 1000),
            "model": model,
-            "in": tokens_in,
-            "out": tokens_out,
+            "in": int(tokens_in),
+            "out": int(tokens_out),
+            "source": source,          # "claude" | "local" | "fast-path"
        })
        METRICS_FILE.parent.mkdir(parents=True, exist_ok=True)
        with METRICS_FILE.open("a", encoding="utf-8") as f:
            f.write(line + "\n")
-        # Sanftes Rotate ohne hohe IO-Kosten — nur alle 1000 Calls checken
        if (tokens_in + tokens_out) % 1000 < 4:
            _maybe_rotate()
    except Exception as exc:
-        logger.warning("metrics.log_call: %s", exc)
+        logger.warning("metrics._append: %s", exc)
+
+
+def log_call(model: str, messages_in: list, reply_text: str = "",
+             source: str = "claude") -> None:
+    """Claude-Call-Metric anhaengen (Tokens per chars/4-Schaetzung)."""
+    _append(model, _messages_tokens(messages_in), _estimate_tokens(reply_text), source)
+
+
+def log_local_call(model: str, messages_in: list, reply_text: str = "",
+                   usage: dict | None = None) -> None:
+    """Lokaler-LLM-Call-Metric. Nutzt echte usage-Tokens (prompt/completion)
+    wenn der Adapter sie liefert, sonst chars/4-Schaetzung wie bei Claude.
+    Quelle = 'local' — damit die Ersparnis-Rechnung local von claude trennt."""
+    tokens_in = tokens_out = None
+    if isinstance(usage, dict):
+        pt = usage.get("prompt_tokens")
+        ct = usage.get("completion_tokens")
+        if isinstance(pt, (int, float)):
+            tokens_in = int(pt)
+        if isinstance(ct, (int, float)):
+            tokens_out = int(ct)
+    if tokens_in is None:
+        tokens_in = _messages_tokens(messages_in)
+    if tokens_out is None:
+        tokens_out = _estimate_tokens(reply_text)
+    _append(model or "local", tokens_in, tokens_out, "local")
+
+
+def log_fast_path(reply_text: str = "") -> None:
+    """Fast-Path (reiner Skill, KEIN LLM) — spart einen ganzen Claude-Call zum
+    Nulltarif. tokens_in=0 (kein Prompt ans LLM), out = winzige Quittung."""
+    _append("fast-path", 0, _estimate_tokens(reply_text), "fast-path")


 def _maybe_rotate() -> None:
@@ -95,6 +125,11 @@ def aggregate(window_seconds: int) -> dict:
    tokens_in = 0
    tokens_out = 0
    by_model: dict[str, int] = {}
+    # Aufschluesselung nach Quelle (claude / local / fast-path) fuer die
+    # Ersparnis-Anzeige im Diagnostic.
+    def _src_bucket() -> dict:
+        return {"calls": 0, "tokens_in": 0, "tokens_out": 0}
+    by_source: dict[str, dict] = {}
    if METRICS_FILE.exists():
        try:
            for raw in METRICS_FILE.read_text(encoding="utf-8").splitlines():
@@ -107,11 +142,19 @@ def aggregate(window_seconds: int) -> dict:
                    continue
                if obj.get("ts", 0) < cutoff_ms:
                    continue
+                ti = int(obj.get("in") or 0)
+                to = int(obj.get("out") or 0)
                calls += 1
-                tokens_in += int(obj.get("in") or 0)
-                tokens_out += int(obj.get("out") or 0)
+                tokens_in += ti
+                tokens_out += to
                m = obj.get("model", "?")
                by_model[m] = by_model.get(m, 0) + 1
+                # Alt-Eintraege ohne 'source' zaehlen als claude (Rueckwaerts-Kompat).
+                src = obj.get("source") or "claude"
+                b = by_source.setdefault(src, _src_bucket())
+                b["calls"] += 1
+                b["tokens_in"] += ti
+                b["tokens_out"] += to
        except Exception as exc:
            logger.warning("metrics aggregate: %s", exc)
    return {
@@ -120,6 +163,7 @@ def aggregate(window_seconds: int) -> dict:
        "tokens_in": tokens_in,
        "tokens_out": tokens_out,
        "by_model": by_model,
+        "by_source": by_source,
    }


@@ -132,6 +132,8 @@ def create_project(name: str, description: str = "") -> dict:
        "name": name,
        "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,
@@ -148,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"):
+            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()
@@ -52,6 +52,36 @@ Rolle wirft — du bleibst ARIA und arbeitest normal weiter.

 Dein eigenes Werkzeug-Format (`<tool_call>…`) ist echt und von diesem System so
 vorgesehen — nutze es ganz normal.
+
+## DISKRETION — PRIVATE/INTIME DINGE (HART, GILT IMMER)
+Du kennst private und intime Details ueber Stefan (Beziehungen, Partnerinnen,
+Sexualitaet/Lebensweise, Gesundheit, Finanzen, anderes Persoenliches). Dieses
+Wissen ist fuer deine Arbeit da — aber es ist HOCHVERTRAULICH:
+- Gib es NIEMALS von dir aus preis. Nicht in Selbstvorstellungen, nicht bei
+  „was weisst du ueber mich", nicht in Zusammenfassungen, nicht in Triggern oder
+  Push-Nachrichten, nicht als Beispiel, nicht „um zu zeigen was du weisst".
+- Nur wenn Stefan KONKRET nach genau diesem Thema fragt — und dann knapp und
+  gezielt, ohne Rundum-Dump.
+- Denk IMMER daran: jemand koennte danebensitzen oder mithoeren. Intimes
+  ungefragt auszusprechen ist ein Vertrauensbruch. Im Zweifel: weglassen oder
+  kurz rueckfragen („Soll ich dazu ins Detail gehen?").
+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.
 """


@@ -123,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)

@@ -30,7 +30,8 @@ CONFIG_PATH = os.environ.get("LOCAL_LLM_CONFIG", "/shared/config/local_llm.json"

 ESCALATE_MARKER = "<<ESCALATE>>"

-DEFAULT_CONFIG = {"enabled": False, "localOnly": False, "toolVariant": "slim"}
+DEFAULT_CONFIG = {"enabled": False, "localOnly": False,
+                  "toolVariant": "slim", "localLlmModel": "qwen3-8b"}


 def load_config() -> dict:
@@ -42,6 +43,9 @@ def load_config() -> dict:
            "enabled": bool(data.get("enabled", False)),
            "localOnly": bool(data.get("localOnly", False)),
            "toolVariant": data.get("toolVariant", "slim") or "slim",
+            # Welches lokale Modell llama-swap laden soll (B0.5). Muss zu einem
+            # Key in xtts/llama-swap/config.yaml passen.
+            "localLlmModel": (data.get("localLlmModel") or "qwen3-8b").strip(),
        }
    except (FileNotFoundError, json.JSONDecodeError):
        return dict(DEFAULT_CONFIG)
@@ -71,6 +75,16 @@ _TOOL_HINTS = re.compile(
    re.IGNORECASE,
 )

+# HINWEIS (bewusst KEINE Live-/Topic-Wortliste mehr): frueher stand hier ein
+# _LIVE_HINTS-Blacklist (Wetter/Musik/Uhrzeit/… → Claude). Das war die falsche
+# Idee — aus offenem Freitext die Absicht per Wortliste zu erraten ist NIE
+# vollstaendig, jeder Miss = ein Halo. Die generische Loesung ist keine groessere
+# Regex, sondern: das Modell entscheidet selbst („brauche ich Grundwahrheit/ein
+# Tool? → <<ESCALATE>>", siehe build_local_system_prompt). Ein 8B kann das noch
+# nicht zuverlaessig → local bleibt per Einstellung abschaltbar; ein staerkeres
+# lokales Modell uebernimmt spaeter genau diese Selbst-Erkennung. Absicherung ist
+# der Output-Guard in agent.py, nicht eine Input-Wortliste.
+
 # Technik-/Tiefe-Marker → Claude (lokales 8B soll das nicht raten).
 _HARD_HINTS = re.compile(
    r"```|"                                    # Codeblock
@@ -82,6 +96,29 @@ _HARD_HINTS = re.compile(

 _MAX_LEN_FOR_LOCAL = 220   # laengere Nachrichten = eher komplexe Aufgaben → Claude

+# Expliziter Nutzer-Wunsch „nimm das grosse Modell". Stefan sagt oft „frag Clodi"
+# / „benutze direkt Claude" — dann soll der Turn NICHT lokal versucht werden,
+# sondern direkt an Claude gehen. „Clodi/Clody" ist sein Kosename fuer Claude und
+# meint praktisch immer Routing; „claude"/„grosses modell" nur in Imperativ-Kontext
+# (nimm/nutze/frag/…), damit reine Trivia „was ist Claude" nicht faelschlich matcht.
+_FORCE_CLAUDE = re.compile(
+    r"\b(clodi|clody)\b"
+    r"|\b(nimm|nutze|benutze|verwende|frag(e|st)?|nimms?t?|mit|via|direkt|per)\b"
+    r"[^.?!]*\b(claude|gro(ss|ß)es?\s+modell)\b",
+    re.IGNORECASE,
+)
+
+
+def _strip_leading_hint_blocks(text: str) -> str:
+    """Fuehrende `[ ... ]`-Hint-Bloecke (GPS, Barge-In von der Bridge) weg —
+    sonst blaeht der Praefix die Laenge auf und verfaelscht die Heuristik."""
+    s = (text or "").strip()
+    prev = None
+    while prev != s:
+        prev = s
+        s = re.sub(r"^\s*\[[^\]]*\]\s*", "", s)
+    return s
+

 def should_try_local(user_message: str, cfg: dict) -> bool:
    """True, wenn der Router diesen Turn (B1a, reden-only) lokal versuchen soll.
@@ -90,9 +127,13 @@ def should_try_local(user_message: str, cfg: dict) -> bool:
        return False
    if cfg.get("localOnly"):
        return True
-    msg = (user_message or "").strip()
+    msg = _strip_leading_hint_blocks(user_message)
    if not msg or len(msg) > _MAX_LEN_FOR_LOCAL:
        return False
+    # Expliziter „nimm Claude/Clodi"-Wunsch → nie lokal (User hat entschieden).
+    if _FORCE_CLAUDE.search(msg):
+        logger.info("[router] expliziter Claude-Wunsch erkannt → nicht lokal")
+        return False
    if _TOOL_HINTS.search(msg):
        return False
    if _HARD_HINTS.search(msg):
@@ -107,10 +148,16 @@ def should_try_local(user_message: str, cfg: dict) -> bool:
 # kein volles Memory (B1a).

 # Was das lokale Tier NICHT selbst kann → dafuer eskaliert es an Claude.
+# Seit dem B1a-Rueckbau hat local KEINE Werkzeuge mehr: es kann nichts
+# nachschlagen und nichts steuern. Alles was aktuelle Grundwahrheit oder eine
+# Aktion braucht, gehoert ans grosse Modell.
 _AWARENESS = (
-    "Nur das grosse Modell (nicht du im Schnell-Modus) kann: Bilder generieren, "
-    "Skills bauen/aendern, Projekte & OAuth verwalten, ins Gedaechtnis SCHREIBEN, "
-    "sowie tiefe/technische Analysen und langen Code."
+    "Du hast im Schnell-Modus KEINE Werkzeuge — du kannst nichts nachschlagen und "
+    "nichts steuern. Nur das grosse Modell kann: aktuelle Infos holen (Wetter, "
+    "News, Uhrzeit, Preise), Musik/Spotify steuern oder den laufenden Song "
+    "nennen, Timer setzen, Bilder generieren, Skills bauen/aendern, Projekte & "
+    "OAuth verwalten, ins Gedaechtnis schreiben, sowie tiefe/technische Analysen "
+    "und langen Code. Fuer ALL das eskalierst du."
 )


@@ -138,15 +185,36 @@ def build_local_system_prompt(identity_anchor: str, has_tools: bool = False,
            "GPS-Hinweis in der Nachricht.",
            "- `memory_search`: in ARIAs Gedaechtnis nachsehen (lesen).",
            "- `trigger_timer`: Timer/Erinnerung setzen ('in 10 Minuten…').",
-            "- `run_spotify`: Musik steuern (naechster Titel, Pause, weiter).",
+            "- `run_*`-Skills: konkrete Faehigkeiten (z.B. Musik/Spotify u.a.). "
+            "Was ein Skill kann + welche Parameter er nimmt, steht in SEINER "
+            "Tool-Beschreibung — LIES sie und nutze den Skill fuer ALLES was "
+            "dazu passt (nicht nur die offensichtlichen Faelle). Nie selbst eine "
+            "Aktion 'spielen'/'nachschauen', wenn ein Skill das kann.",
            "WICHTIG: Bei reinem Smalltalk ('wie gehts', Begruessung, Meinung) "
            "KEIN Werkzeug — einfach direkt antworten. Werkzeuge nur bei echtem "
            "Bedarf; erfinde keine.",
+            "ANTI-HALLUZINATION (kritisch): Behaupte NIEMALS eine Aktion als "
+            "erledigt, ohne das Werkzeug WIRKLICH aufgerufen zu haben. Keine "
+            "'Spotify: …' / 'Playlist abspielen'-Quittung o.ae. ohne echten "
+            "Skill-Aufruf. Kannst/willst du es nicht per Werkzeug tun, sag es "
+            "ehrlich oder eskaliere — erfinde keine Bestaetigung.",
+            "Das gilt GENAUSO fuer Live-Auskuenfte: Nenne NIEMALS einen aktuellen "
+            "Songtitel, Interpreten, die Restzeit oder was gerade laeuft/welches "
+            "Geraet spielt, ohne den passenden Skill (z.B. run_spotify) WIRKLICH "
+            "aufgerufen und sein Ergebnis gelesen zu haben. Kein Tool-Ergebnis = du "
+            "weisst es NICHT — dann eskaliere, statt einen Titel/eine Zeit zu raten. "
+            "Gib nur weiter, was im Skill-Ergebnis wirklich steht; hat der Skill "
+            "keinen Titel geliefert (z.B. nur 'OK: next'), erfinde auch keinen.",
        ]
    parts += [
        "",
        "## WAS DU HIER NICHT KANNST",
        _AWARENESS,
+        "WICHTIG — du hast Stefans GEDAECHTNIS hier NICHT im Kopf: Bei Fragen zu "
+        "seinem Leben, zu Personen/Namen, Beziehungen, seiner Vergangenheit, "
+        "seinen Vorlieben/Sachen oder anderem gespeicherten Wissen antworte NICHT "
+        "aus dem Nichts (und rate nicht, wer wer ist) — sondern eskaliere. Das "
+        "grosse Modell kennt das Gedaechtnis und antwortet diskret.",
        "Dafuer — und bei tiefen/technischen Fragen, langem Code, oder wenn du "
        f"unsicher bist — antworte AUSSCHLIESSLICH mit exakt `{ESCALATE_MARKER}` "
        "(nichts sonst). Dann uebernimmt das grosse Modell mit vollem Zugriff. "
@@ -400,6 +400,43 @@ 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": (
+            "Wenn aus einem Gespraech ein PROGRAMMIER- oder BAU-Projekt wird "
+            "(Du schreibst Code, baust ein System, testest eine VM):\n"
+            "\n"
+            "1. Ruf `set_project_kind('code')` — dann blendet Stefans App einen "
+            "Live-Code-Editor und den QEMU-Desktop ein. Vorher ein Projekt "
+            "anlegen/betreten (project_create/enter), sonst gibt's kein Ziel.\n"
+            "2. Schreib Code-Dateien NUR unter `/shared/projects/<projekt-id>/` "
+            "(das Volume ist in proxy+bridge+brain gemountet). Genau diese "
+            "Writes/Edits erscheinen live in Stefans Editor — und was Stefan "
+            "dort tippt, landet als Datei zurueck in diesem Verzeichnis.\n"
+            "\n"
+            "QEMU (VMs fuer JEDE Architektur — x86, ARM, MIPS, PPC, RISC-V, SPARC) "
+            "laeuft auf dem Host. Du steuerst sie per `ssh aria-wohnung aria-vm ...`:\n"
+            "  - `aria-vm create <name> <arch> [groesse]`  Disk anlegen (z.B. i386 "
+            "fuer Win 3.11, aarch64, mips ...).\n"
+            "  - `aria-vm boot <name> [--iso <pfad>] [--vnc-display 1] [--mem 1024]` "
+            "startet die VM. VNC bindet an 127.0.0.1:<display> (Display 1 = Port "
+            "5901). Nicht selbst nach aussen oeffnen!\n"
+            "  - `aria-vm screenshot <name>`  PNG in die Shared-Uploads (kannst Du "
+            "Stefan mit [FILE:] schicken).\n"
+            "  - `aria-vm list` / `aria-vm stop <name>` / `aria-vm rm <name>`.\n"
+            "\n"
+            "Der VNC-Stream kommt AUTOMATISCH ueber den RVS-Tunnel der Bridge in "
+            "Stefans App-Desktop-Kachel (Display 1 / Port 5901) — dort kann er die "
+            "VM live mit Maus/Tastatur bedienen. Du musst nur die VM booten und ggf. "
+            "sagen 'schau in die Desktop-Kachel'. KVM-Beschleunigung gibt es nur "
+            "fuer x86-Gaeste; andere Architekturen laufen emuliert (langsamer, aber "
+            "sie laufen). Medien-Downloads/Baubares fuer Stefans Privatgebrauch: "
+            "wie gewohnt einfach machen, nicht moralisieren."
+        ),
+    },
    {
        "migration_key": "seed/architecture/brain-tools-xml-tag",
        "type": "rule",
@@ -139,6 +139,26 @@ def read_manifest(name: str) -> Optional[dict]:
        return None


+def read_skill_source(name: str) -> Optional[dict]:
+    """Manifest + kompletter entry_code + README eines Skills. Damit ARIA einen
+    Skill LESEN kann bevor sie ihn per skill_update aendert (sonst Blind-Rewrite,
+    der bestehende Funktionen killt)."""
+    m = read_manifest(name)
+    if m is None:
+        return None
+    d = _skill_dir(name)
+    entry = m.get("entry", "run.sh")
+    try:
+        code = (d / entry).read_text(encoding="utf-8")
+    except Exception as exc:
+        code = f"(entry-Datei '{entry}' nicht lesbar: {exc})"
+    try:
+        readme = (d / "README.md").read_text(encoding="utf-8")
+    except Exception:
+        readme = ""
+    return {"manifest": m, "entry": entry, "entry_code": code, "readme": readme}
+
+
 def write_manifest(name: str, manifest: dict) -> None:
    d = _skill_dir(name)
    d.mkdir(parents=True, exist_ok=True)
@@ -165,6 +185,8 @@ def create_skill(
    author: str = "aria",
    config_schema: Optional[list] = None,
    fast_patterns: Optional[list] = None,
+    speak: bool = False,
+    converse: bool = False,
 ) -> dict:
    """Legt einen neuen Skill an. Wirft ValueError bei ungueltigen Inputs.

@@ -215,6 +237,14 @@ def create_skill(
        "author": author,
        "config_schema": _normalize_config_schema(config_schema),
        "fast_patterns": _normalize_fast_patterns(fast_patterns),
+        # speak: soll die Antwort dieses Skills vorgelesen werden (TTS)?
+        # False (Default) = reiner Steuerbefehl (Spotify, Licht) → stumm, App
+        # beendet direkt. True = Antwort-Skill (Info/Ergebnis) → vorlesen.
+        # converse: nach der Antwort 30s weiterlauschen (Dialog)? Default False
+        # (Einzelaktion). Beide sind STATISCHE Defaults — der Skill kann sie im
+        # JSON-Output pro Aufruf ueberschreiben (gemischte Skills).
+        "speak": bool(speak),
+        "converse": bool(converse),
        "version_history": [],
    }
    write_manifest(name, manifest)
@@ -335,10 +365,15 @@ def update_skill(name: str, patch: dict) -> dict:
        # nach archive_current_version manifest neu laden (version_history geupdatet)
        manifest = read_manifest(name) or manifest

-    allowed = {"description", "args", "requires", "active", "version", "entry"}
+    allowed = {"description", "args", "requires", "active", "version", "entry",
+               "speak", "converse"}
    for k, v in patch.items():
        if k in allowed:
            manifest[k] = v
+    if "speak" in patch:
+        manifest["speak"] = bool(patch["speak"])
+    if "converse" in patch:
+        manifest["converse"] = bool(patch["converse"])
    if "config_schema" in patch:
        manifest["config_schema"] = _normalize_config_schema(patch["config_schema"])
    if "fast_patterns" in patch:
@@ -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 = {
@@ -16,6 +16,7 @@ import asyncio
 import base64
 import json
 import logging
+import math
 import mimetypes
 import os
 import re
@@ -32,6 +33,7 @@ from pathlib import Path
 from typing import Optional

 import subprocess
+import urllib.parse
 import urllib.request
 import numpy as np
 import sounddevice as sd
@@ -149,6 +151,54 @@ def _num_to_words_de(n: int) -> str:
    return str(n)


+# Vollstaendige Zehner fuer den generischen Konverter (inkl. 60-90).
+_TENS_FULL_DE = {20: "zwanzig", 30: "dreissig", 40: "vierzig", 50: "fuenfzig",
+                 60: "sechzig", 70: "siebzig", 80: "achtzig", 90: "neunzig"}
+
+
+def _below_100_de(n: int) -> str:
+    if n in _NUM_WORDS_DE:            # 0..20
+        return _NUM_WORDS_DE[n]
+    tens = (n // 10) * 10
+    ones = n % 10
+    if ones == 0:
+        return _TENS_FULL_DE[tens]
+    ones_word = "ein" if ones == 1 else _NUM_WORDS_DE[ones]
+    return f"{ones_word}und{_TENS_FULL_DE[tens]}"
+
+
+def _below_1000_de(n: int) -> str:
+    if n < 100:
+        return _below_100_de(n)
+    h, rest = divmod(n, 100)
+    h_word = ("ein" if h == 1 else _NUM_WORDS_DE[h]) + "hundert"
+    return h_word if rest == 0 else h_word + _below_100_de(rest)
+
+
+def _int_to_words_de(n: int) -> str:
+    """Ganzzahl 0..999999 als zusammenhaengendes deutsches Wort
+    ('dreiundzwanzig', 'einhundert', 'zweitausendsechsundzwanzig').
+    Groesser (IDs/Codes) → als Ziffern lassen (der Aufrufer gated zusaetzlich)."""
+    if n < 0:
+        return "minus " + _int_to_words_de(-n)
+    if n < 1000:
+        return _below_1000_de(n)
+    if n < 1_000_000:
+        th, rest = divmod(n, 1000)
+        th_word = ("ein" if th == 1 else _below_1000_de(th)) + "tausend"
+        return th_word if rest == 0 else th_word + _below_1000_de(rest)
+    return str(n)
+
+
+def _spell_standalone_int(m) -> str:
+    """Regex-Callback: freistehende Ganzzahl ausschreiben. Sehr lange
+    Ziffernfolgen (IDs, Codes, Telefonnummern) bleiben Ziffern."""
+    s = m.group(0)
+    if len(s) > 6:
+        return s
+    return _int_to_words_de(int(s))
+
+
 def _time_range_to_words(m):
    """'8:00-9:00 Uhr' → 'acht bis neun Uhr', '8-9 Uhr' → 'acht bis neun Uhr'."""
    h1 = int(m.group(1))
@@ -168,7 +218,7 @@ def _decimal_to_words(m):
    """'0.1' / '0,1' → 'null komma eins', '1,25' → 'eins komma zwei fuenf'."""
    int_part = int(m.group(1))
    dec_part = m.group(2)
-    int_word = _num_to_words_de(int_part) if 0 <= int_part <= 59 else str(int_part)
+    int_word = _int_to_words_de(int_part) if int_part <= 999999 else str(int_part)
    dec_words = " ".join(_num_to_words_de(int(d)) for d in dec_part)
    return f"{int_word} komma {dec_words}"

@@ -184,7 +234,7 @@ _UNIT_WORDS = [
    (r'\bkm\b', 'Kilometer'),
    (r'\bm/s\b', 'Meter pro Sekunde'),
    (r'\bkg\b', 'Kilogramm'),
-    (r'\b°C\b', 'Grad Celsius'),
+    (r'\b°C\b', ' Grad Celsius'),
    (r'°C', ' Grad Celsius'),
    (r'\bMbps\b', 'Megabit pro Sekunde'),
    (r'\bGbps\b', 'Gigabit pro Sekunde'),
@@ -245,10 +295,17 @@ def clean_text_for_tts(text: str) -> str:
    if not text:
        return ""

-    # <voice>...</voice> wenn vorhanden → nur das nehmen
+    # <voice>...</voice> wenn vorhanden → nur diesen Inhalt lesen. ABER: ein
+    # LEERES <voice></voice> darf die Sprachausgabe nicht verstummen lassen.
+    # Claude haengt reflexartig manchmal ein leeres Tag an (v.a. bei Spotify-
+    # Antworten) — frueher wurde daraus text="" → gar keine TTS (Playlist-Wechsel
+    # 'Prodigy' stumm, 'Fliegen' gesprochen, rein je nachdem ob Claude Inhalt ins
+    # Tag schrieb). Leeres/whitespace-Tag → ignorieren und den normalen Text lesen.
    voice_match = _re_tts.search(r'<voice>([\s\S]*?)</voice>', text, _re_tts.IGNORECASE)
-    if voice_match:
+    if voice_match and voice_match.group(1).strip():
        text = voice_match.group(1)
+    else:
+        text = _re_tts.sub(r'<voice>[\s\S]*?</voice>', ' ', text, flags=_re_tts.IGNORECASE)

    t = text

@@ -301,6 +358,15 @@ def clean_text_for_tts(text: str) -> str:
    # werden, koennen bei Bedarf explizit in _UNIT_WORDS uebersteuert werden.
    t = _re_tts.sub(r'\b([A-Z]{2,5})\b', lambda m: " ".join(m.group(1)), t)

+    # Generisches Ausschreiben ALLER verbleibenden freistehenden Ganzzahlen
+    # ('23' → 'dreiundzwanzig', '100' → 'einhundert', '2026' → 'zwei-
+    # tausendsechsundzwanzig'). Laeuft NACH Uhrzeiten/Dezimalzahlen/Einheiten,
+    # die ihre Ziffern schon zu Woertern gemacht haben. Tag-unabhaengig — so
+    # klingen auch Antworten des lokalen LLM (das keine <voice>-Tags nutzt)
+    # sauber. Ziffernfolgen die an ., :, / kleben (IPs, Versionen, Uhrzeit-
+    # Reste) ueberspringen wir, um sie nicht zu zerreissen.
+    t = _re_tts.sub(r'(?<![\d.,:/])\d{1,6}(?![\d.,:/])', _spell_standalone_int, t)
+
    # Anfuehrungszeichen
    t = _re_tts.sub(r'["""„`]', '', t)

@@ -313,6 +379,37 @@ def clean_text_for_tts(text: str) -> str:
    return t.strip()


+# ── Geo: Bewegungsrichtung aus zwei GPS-Punkten ──────────────
+
+# Fahrtrichtung als Himmelsrichtungs-Adverb (8-Wind, "…waerts"). Index =
+# gerundeter Bearing / 45 (mod 8).
+_COMPASS_ADV = ["nordwaerts", "nordostwaerts", "ostwaerts", "suedostwaerts",
+                "suedwaerts", "suedwestwaerts", "westwaerts", "nordwestwaerts"]
+
+
+def _haversine_m(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Distanz in Metern zwischen zwei GPS-Punkten."""
+    r = 6371000.0
+    p1, p2 = math.radians(lat1), math.radians(lat2)
+    dp = math.radians(lat2 - lat1)
+    dl = math.radians(lon2 - lon1)
+    a = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
+    return 2 * r * math.asin(min(1.0, math.sqrt(a)))
+
+
+def _bearing_deg(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Kompass-Peilung 0..360 (0=Nord) von Punkt1 nach Punkt2."""
+    p1, p2 = math.radians(lat1), math.radians(lat2)
+    dl = math.radians(lon2 - lon1)
+    y = math.sin(dl) * math.cos(p2)
+    x = math.cos(p1) * math.sin(p2) - math.sin(p1) * math.cos(p2) * math.cos(dl)
+    return (math.degrees(math.atan2(y, x)) + 360.0) % 360.0
+
+
+def _heading_word(bearing: float) -> str:
+    return _COMPASS_ADV[round(bearing / 45.0) % 8]
+
+
 # ── STT Engine ───────────────────────────────────────────────


@@ -637,6 +734,11 @@ 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] = {}
+        self._vnc_host: str = os.environ.get("ARIA_VNC_HOST", "host.docker.internal")
        # 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] = {}
@@ -1118,8 +1220,28 @@ class ARIABridge:
                "lat": float(lat),
                "lon": float(lon),
            })
+            lat, lon = float(lat), float(lon)
+            # Fuer den Standort-Praefix merken (auch fuer Turns ohne frisches GPS).
+            self._last_location = {"lat": lat, "lon": lon}
+            # Fahrtrichtung aus dem Bewegungsvektor. Anker bleibt stehen bis wir
+            # uns >MIN_MOVE_M wirklich wegbewegt haben — so zaehlt echtes Fahren,
+            # nicht das GPS-Jitter im Stand. Stehen wir → letzte Richtung bleibt.
+            # Umdrehen liefert automatisch neue Punkte → neue Richtung.
+            MIN_MOVE_M = 25.0
+            anchor = getattr(self, "_heading_anchor", None)
+            if anchor:
+                moved = _haversine_m(anchor["lat"], anchor["lon"], lat, lon)
+                if moved >= MIN_MOVE_M:
+                    _bg = _bearing_deg(anchor["lat"], anchor["lon"], lat, lon)
+                    self._last_heading = _heading_word(_bg)
+                    self._last_bearing = int(round(_bg)) % 360   # exakte Peilung
+                    self._heading_anchor = {"lat": lat, "lon": lon}
+            else:
+                self._heading_anchor = {"lat": lat, "lon": lon}
        except Exception:
            return
+        # Ortsname im Hintergrund aufloesen (Nominatim, gecacht) — kein Modell.
+        self._maybe_reverse_geocode(float(lat), float(lon))
        # Fire-and-forget: Brain-on-demand-Tick. Wenn Brain nicht antwortet
        # oder langsam ist, blockt das nicht den GPS-Pfad.
        try:
@@ -1127,6 +1249,150 @@ class ARIABridge:
        except Exception:
            pass

+    def _maybe_reverse_geocode(self, lat: float, lon: float) -> None:
+        """Loest lat/lon → Ortsname auf, aber nur bei nennenswerter Bewegung
+        (~1 km Raster) und im Hintergrund. Ergebnis landet in
+        self._last_place_name; der Standort-Praefix liest es dann nur ab."""
+        try:
+            key = (round(lat, 3), round(lon, 3))   # ~110 m — fuer Strasse/Hausnr
+        except Exception:
+            return
+        if key == getattr(self, "_geocoded_key", None):
+            return  # diese Gegend schon aufgeloest
+        # Neue Gegend: alten Namen verwerfen, sonst zeigt der Praefix die falsche
+        # Stadt bis der neue Geocode da ist.
+        self._geocoded_key = key
+        self._last_place_name = ""
+        try:
+            self._geocode_task = asyncio.create_task(self._do_reverse_geocode(lat, lon, key))
+        except Exception:
+            self._geocode_task = None
+
+    async def _ensure_place_name(self, lat, lon) -> None:
+        """Stellt (blockierend, mit Timeout) sicher, dass der Ortsname fuer die
+        aktuelle Position da ist — fuer die ERSTE Nachricht an einem neuen Ort,
+        wo der Hintergrund-Geocode noch laeuft. Gecacht → danach instant."""
+        try:
+            lat, lon = float(lat), float(lon)
+            key = (round(lat, 3), round(lon, 3))
+        except Exception:
+            return
+        if key == getattr(self, "_geocoded_key", None) and getattr(self, "_last_place_name", ""):
+            return  # schon aufgeloest
+        if key != getattr(self, "_geocoded_key", None):
+            self._maybe_reverse_geocode(lat, lon)   # startet Task
+        task = getattr(self, "_geocode_task", None)
+        if task is not None and not task.done():
+            try:
+                await asyncio.wait_for(asyncio.shield(task), timeout=6)
+            except Exception:
+                pass  # Timeout/Fehler → Praefix faellt auf reine Koordinaten zurueck
+
+    async def _do_reverse_geocode(self, lat: float, lon: float, key) -> None:
+        """Nominatim-Reverse-Geocode (keyless, gratis). Baut einen moeglichst
+        genauen Ort: Strasse+Hausnummer, PLZ+Stadt, Bundesland; bei Autobahn/
+        Bundesstrasse zusaetzlich die Ref (A 28 / B 75) + best-effort Kilometer
+        (Overpass-Milestone). Setzt self._last_place_name. Fehler → still
+        (Praefix faellt auf reine Koordinaten zurueck)."""
+        base = os.environ.get("NOMINATIM_URL", "https://nominatim.openstreetmap.org").rstrip("/")
+        url = (f"{base}/reverse?lat={lat:.5f}&lon={lon:.5f}&format=jsonv2"
+               f"&zoom=18&addressdetails=1&extratags=1&accept-language=de")
+
+        def _fetch():
+            try:
+                req = urllib.request.Request(url, headers={
+                    # Nominatim verlangt einen aussagekraeftigen User-Agent.
+                    "User-Agent": "ARIA-Assistant/1.0 (personal voice assistant)",
+                })
+                with urllib.request.urlopen(req, timeout=8) as r:
+                    return json.loads(r.read().decode("utf-8", "ignore"))
+            except Exception as exc:
+                logger.debug("[geo] reverse-geocode fehlgeschlagen: %s", exc)
+                return None
+
+        data = await asyncio.get_event_loop().run_in_executor(None, _fetch)
+        if not isinstance(data, dict):
+            return
+        addr = data.get("address") or {}
+        extra = data.get("extratags") or {}
+        road = addr.get("road") or ""
+        house = addr.get("house_number") or ""
+        city = (addr.get("city") or addr.get("town") or addr.get("village")
+                or addr.get("municipality") or addr.get("county") or "")
+        plz = addr.get("postcode") or ""
+        state = addr.get("state") or ""
+        ref = (extra.get("ref") or "").strip()   # z.B. "A 28", "B 75"
+
+        # Strasse + Hausnummer
+        street = (f"{road} {house}".strip()) if road else ""
+        # PLZ + Ort
+        citypart = (f"{plz} {city}".strip()) if plz else city
+
+        segs: list[str] = []
+        # Autobahn/Bundes-/Kreisstrasse? Ref + (best-effort) Kilometer voranstellen.
+        is_road = bool(ref) or any(w in road.lower()
+                                   for w in ("autobahn", "bundesstrasse", "bundesstraße",
+                                             "kreisstrasse", "kreisstraße"))
+        if is_road:
+            label = ref or road
+            km = await self._overpass_km(lat, lon)
+            if km:
+                label = f"{label} bei km {km}"
+            if label:
+                segs.append(label)
+        if street:
+            segs.append(street)
+        if citypart:
+            segs.append(citypart)
+        if state and (state not in citypart):
+            segs.append(state)
+
+        name = ", ".join(s for s in segs if s)
+        if not name:
+            name = data.get("name") or ""
+        # Nur uebernehmen wenn Stefan nicht schon weitergezogen ist (key aktuell).
+        if name and getattr(self, "_geocoded_key", None) == key:
+            self._last_place_name = name
+            logger.info("[geo] %.5f,%.5f → %s", lat, lon, name)
+
+    async def _overpass_km(self, lat: float, lon: float) -> str:
+        """Best-effort Autobahn/Strassen-Kilometer: naechsten OSM-Milestone
+        (highway=milestone mit distance-Tag) im Umkreis suchen. Leer wenn keiner
+        gefunden / Overpass nicht erreichbar. Milestones stehen i.d.R. alle 500 m,
+        also grob (fuer Pannenhilfe 'ca. km X' voellig ausreichend)."""
+        ov = os.environ.get("OVERPASS_URL", "https://overpass-api.de/api/interpreter")
+        query = (f"[out:json][timeout:8];"
+                 f"node(around:900,{lat:.5f},{lon:.5f})[highway=milestone];out;")
+
+        def _fetch():
+            try:
+                body = urllib.parse.urlencode({"data": query}).encode("utf-8")
+                req = urllib.request.Request(ov, data=body, headers={
+                    "User-Agent": "ARIA-Assistant/1.0 (personal voice assistant)",
+                })
+                with urllib.request.urlopen(req, timeout=12) as r:
+                    return json.loads(r.read().decode("utf-8", "ignore"))
+            except Exception as exc:
+                logger.debug("[geo] overpass-km fehlgeschlagen: %s", exc)
+                return None
+
+        d = await asyncio.get_event_loop().run_in_executor(None, _fetch)
+        if not isinstance(d, dict):
+            return ""
+        best_dist = ""
+        best_sq = 1e18
+        for e in (d.get("elements") or []):
+            tags = e.get("tags") or {}
+            dist = tags.get("distance") or tags.get("milestone:distance") or ""
+            elat, elon = e.get("lat"), e.get("lon")
+            if not dist or elat is None or elon is None:
+                continue
+            sq = (float(elat) - lat) ** 2 + (float(elon) - lon) ** 2
+            if sq < best_sq:
+                best_sq = sq
+                best_dist = str(dist)
+        return best_dist.replace(".", ",") if best_dist else ""
+
    async def _trigger_brain_check_now(self) -> None:
        """Brain-Endpoint POST /triggers/check-now anstossen."""
        brain_url = os.environ.get("BRAIN_URL", "http://aria-brain:8080")
@@ -1299,6 +1565,13 @@ class ARIABridge:
                "text": display_text,
                "sender": "aria",
                "messageId": message_id,
+                # ARIA-Dateien DIREKT an der Chat-Bubble mitschicken — sonst kommt
+                # der Anhang live nur als separates file_from_aria-Event (eigene
+                # Bubble) und taucht an der Nachricht erst nach einem Seiten-
+                # wechsel auf (Reload aus chat_backup, das die files kennt). Selbe
+                # Struktur wie im Backup, damit App live == Reload rendert.
+                "files": [{"serverPath": f["serverPath"], "name": f["name"],
+                           "mimeType": f["mimeType"], "size": f["size"]} for f in aria_files],
                # backupTs = der ts in chat_backup.jsonl. Wird von Clients als
                # Bubble-ID fuer das Mülltonne-Loeschen verwendet (delete_message_request).
                "backupTs": assistant_backup_ts,
@@ -1309,10 +1582,29 @@ class ARIABridge:
                "projectId": (payload.get("projectId") or "") if isinstance(payload, dict) else "",
                # Quell-Backend (local/claude/fast-path) fuer den Diagnostic-Badge.
                "answeredBy": (payload.get("answeredBy") or "") if isinstance(payload, dict) else "",
+                # Wird diese Antwort vorgelesen? Fast-Path/Steuerbefehl = False.
+                # Die App braucht das: ohne TTS feuert onPlaybackFinished nie,
+                # und daran haengt das Wake-Word-Re-Arm — sonst bleibt das Ohr
+                # nach einem Fast-Path-Befehl grau haengen.
+                "speak": bool(payload.get("speak", True)) if isinstance(payload, dict) else True,
+                # Nach dieser Antwort 30s weiterlauschen? Steuert das Gespraechs-
+                # Fenster in der App (Skill/Einzelaktion=False, Konversation=True).
+                "converse": bool(payload.get("converse", True)) if isinstance(payload, dict) else True,
+                # Stellt ARIA eine blockierende Rueckfrage? Dann pausiert die App
+                # die Projekt-Queue und leitet die naechste Eingabe als Antwort auf
+                # DIESE Rueckfrage weiter, statt sie als neuen Auftrag anzustellen.
+                "awaiting_reply": bool(payload.get("awaiting_reply", False)) if isinstance(payload, dict) else False,
            },
            "timestamp": int(asyncio.get_event_loop().time() * 1000),
        })

+        # System-Flag vom Brain: reine Steuerbefehle (Fast-Path) NICHT vorlesen.
+        # Robust und unabhaengig von <voice>-Tags im Text (die ARIA beim
+        # Skill-Rebuild verlieren kann) — die Quelle entscheidet, nicht der Inhalt.
+        if isinstance(payload, dict) and payload.get("speak") is False:
+            logger.info("[core] TTS uebersprungen (speak=False — Fast-Path-Steuerbefehl)")
+            return
+
        # TTS ueber XTTS (XTTS-Bridge auf Gaming-PC)
        if not (getattr(self, 'tts_enabled', True) and should_speak(self.current_mode, is_critical)):
            logger.info("[core] TTS unterdrueckt (Modus: %s)", self.current_mode.config.name)
@@ -1488,14 +1780,33 @@ class ARIABridge:
                "gesprochen oder gearbeitet hast. Folgendes ist eine Korrektur, "
                "Ergaenzung oder ein Themenwechsel zu deiner letzten Antwort.]"
            )
-        if location and isinstance(location, dict):
-            lat = location.get("lat")
-            lon = location.get("lon") or location.get("lng")
+        # Standort: frische GPS aus der Nachricht, sonst der zuletzt bekannte
+        # (damit's beim passiven Weiterreden ohne frisches GPS nicht wegfaellt).
+        loc = location if (isinstance(location, dict) and location.get("lat") is not None) \
+            else getattr(self, "_last_location", None)
+        if isinstance(loc, dict):
+            lat = loc.get("lat")
+            lon = loc.get("lon") or loc.get("lng")
            if lat is not None and lon is not None:
+                # Ortsname kommt vom Reverse-Geocode (Nominatim, gecacht) — so
+                # muss KEIN Modell Koordinaten raten (das lokale 8B tippt sonst
+                # daneben, z.B. "Berlin" fuer Oldenburg). Noch nicht aufgeloest
+                # → nur Koordinaten (Claude kann die zur Not selbst deuten).
+                place = getattr(self, "_last_place_name", "")
+                where = f"{place} " if place else ""
+                heading = getattr(self, "_last_heading", "")
+                bearing = getattr(self, "_last_bearing", None)
+                if heading and bearing is not None:
+                    moving = f", unterwegs {heading} ({bearing} Grad)"
+                elif heading:
+                    moving = f", unterwegs {heading}"
+                else:
+                    moving = ""
                parts.append(
-                    f"[Stefans aktuelle GPS-Position: {float(lat):.6f}, {float(lon):.6f}. "
-                    f"Nutze die nur wenn die Frage sich auf seinen Standort bezieht. "
-                    f"Erwaehne sie nicht von dir aus, ausser er fragt explizit danach.]"
+                    f"[Stefans aktueller Standort: {where}(GPS {float(lat):.5f}, "
+                    f"{float(lon):.5f}){moving}. Nutze das nur wenn die Frage sich "
+                    f"auf seinen Standort/seine Fahrtrichtung bezieht. Erwaehne es "
+                    f"nicht von dir aus, ausser er fragt explizit danach.]"
                )
        if parts:
            return " ".join(parts) + " " + text
@@ -1640,6 +1951,15 @@ class ARIABridge:
        # Welcher Backend geantwortet hat (local/claude/fast-path) — fuer den
        # Quell-Badge in Diagnostic.
        answered_by = (data.get("answered_by") or "claude").strip()
+        # Soll vorgelesen werden? Fast-Path (Steuerbefehl) = False. System-Flag
+        # vom Brain — robust, unabhaengig von <voice>-Tags im Reply-Text.
+        speak = data.get("speak", True)
+        # Nach der Antwort 30s weiterlauschen (Gespraech) oder direkt zurueck aufs
+        # Wake-Word? Einzelaktionen/Skills = False. Reicht die App aus.
+        converse = data.get("converse", True)
+        # Stellt ARIA eine blockierende Rueckfrage? Dann pausiert die App die
+        # Projekt-Queue und leitet die naechste Eingabe als Antwort weiter.
+        awaiting_reply = bool(data.get("awaiting_reply", False))

        # Side-Channel-Events VOR der Chat-Bubble broadcasten (z.B. skill_created)
        # damit sie in der UI vor der Reply auftauchen
@@ -1687,10 +2007,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),
@@ -1707,7 +2032,10 @@ class ARIABridge:
        # metadata mitschickt).
        try:
            await self._process_core_response(reply, {"projectId": turn_project_id,
-                                                       "answeredBy": answered_by})
+                                                       "answeredBy": answered_by,
+                                                       "speak": speak,
+                                                       "converse": converse,
+                                                       "awaiting_reply": awaiting_reply})
        except Exception:
            logger.exception("[brain] _process_core_response Fehler")
            await self._emit_activity("idle", "", project_id=project_id)
@@ -1718,6 +2046,14 @@ class ARIABridge:
                "timestamp": int(asyncio.get_event_loop().time() * 1000),
            })

+        # Das 'thinking' oben ging mit der REQUEST-projectId raus, das 'idle' in
+        # _process_core_response aber mit der TURN-projectId (Brain kann den Turn
+        # umgeroutet haben, z.B. Voice-Sticky). Weichen sie ab, bekaeme der
+        # Request-Kontext nie sein idle → "ARIA denkt" bliebe dort haengen.
+        # Darum hier zusaetzlich fuer die Request-projectId ein idle.
+        if (project_id or "") != (turn_project_id or ""):
+            await self._emit_activity("idle", "", project_id=project_id)
+
        if data.get("distilling"):
            logger.info("[brain] Destillat laeuft im Hintergrund")

@@ -2006,6 +2342,9 @@ class ARIABridge:
                    logger.info("[rvs] App-Chat (mit Anhaengen) project=%s: '%s'",
                                str(payload.get("projectId") or "") or "(main)", text[:80])
                else:
+                    _lg = location or getattr(self, "_last_location", None)
+                    if isinstance(_lg, dict) and _lg.get("lat") is not None:
+                        await self._ensure_place_name(_lg.get("lat"), _lg.get("lon") or _lg.get("lng"))
                    core_text = self._build_core_text(text, interrupted, location)
                    logger.info("[rvs] App-Chat%s%s: '%s'",
                                " [BARGE-IN]" if interrupted else "",
@@ -2930,6 +3269,24 @@ class ARIABridge:
            if self._is_duplicate_client_msg(client_msg_id):
                return

+            # Text-Fenster-Dedup: im Auto cancelt der App-No-Speech-Watchdog den
+            # Stream vorzeitig und startet passives Lauschen, waehrend die Bridge
+            # dieselbe Aeusserung parallel noch finalisiert → derselbe Befehl
+            # kaeme zweimal (aus ZWEI verschiedenen audioRequestIds, darum greift
+            # die ID-Idempotenz oben nicht). Identischen Endpoint-Text innerhalb
+            # 5s verwerfen. Genuines "nächstes, nächstes" liegt praktisch immer
+            # weiter auseinander (man hoert den Wechsel erst).
+            _norm_txt = " ".join(text.lower().split())
+            _now_t = asyncio.get_event_loop().time()
+            if (_norm_txt
+                    and _norm_txt == getattr(self, "_last_endpoint_norm", "")
+                    and (_now_t - getattr(self, "_last_endpoint_at", 0.0)) < 5.0):
+                logger.info("[rvs] stt_endpoint Dupe verworfen (gleicher Text <5s): %r",
+                            text[:60])
+                return
+            self._last_endpoint_norm = _norm_txt
+            self._last_endpoint_at = _now_t
+
            # App-Focus aus stt_stream_start-Registry auflösen (falls die
            # App-Version die projectId noch nicht mitschickt: leer = Hauptchat).
            stream_req_id = payload.get("requestId", "") or ""
@@ -3004,6 +3361,56 @@ 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 == "config_request":
            # Eine andere Bridge (whisper/f5tts) bittet um die aktuelle Voice-
            # Config — passiert wenn sie sich connected, weil sie sonst die
@@ -3085,6 +3492,9 @@ class ARIABridge:
                logger.warning("[rvs] STT-Text konnte nicht an RVS gesendet werden: %s", e)

            # Dann an Brain — der blockt synchron bis ARIA fertig ist.
+            _lg = location or getattr(self, "_last_location", None)
+            if isinstance(_lg, dict) and _lg.get("lat") is not None:
+                await self._ensure_place_name(_lg.get("lat"), _lg.get("lon") or _lg.get("lng"))
            core_text = self._build_core_text(text, interrupted, location)
            await self.send_to_core(core_text,
                                    source="app-voice" + (" [barge-in]" if interrupted else ""),
@@ -3213,8 +3623,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:
@@ -3375,7 +3788,8 @@ class ARIABridge:
    _LLM_TIMEOUT_S = 30.0

    async def _local_llm(self, messages: list, max_tokens: int = 512,
-                         temperature: float = 0.7, stop=None, tools=None) -> dict:
+                         temperature: float = 0.7, stop=None, tools=None,
+                         model=None) -> dict:
        """Schickt einen llm_request an den llm-adapter (Gamebox), wartet auf
        llm_response. tools (B1b) werden durchgereicht; tool_calls kommen zurueck.
        Rueckgabe: {ok, content, tool_calls, model, elapsedMs} oder {ok:False, error}."""
@@ -3399,8 +3813,10 @@ class ARIABridge:
                req_payload["stop"] = stop
            if tools:
                req_payload["tools"] = tools
-            logger.info("[rvs] llm_request → llm-adapter (id=%s, msgs=%d, max_tokens=%d, tools=%d)",
-                        request_id[:8], len(messages), max_tokens, len(tools) if tools else 0)
+            if model:
+                req_payload["model"] = model
+            logger.info("[rvs] llm_request → llm-adapter (id=%s, msgs=%d, max_tokens=%d, tools=%d, model=%s)",
+                        request_id[:8], len(messages), max_tokens, len(tools) if tools else 0, model or "-")
            ok = await self._send_to_rvs({
                "type": "llm_request",
                "payload": req_payload,
@@ -3839,6 +4255,33 @@ 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/flux-generate":
                    # Vom Brain (flux_generate-Tool) gefeuert. Wir routen den
                    # Render-Request via RVS an die flux-bridge (Gamebox),
@@ -3898,10 +4341,11 @@ class ARIABridge:
                    except (TypeError, ValueError):
                        temperature = 0.7
                    _tools = data.get("tools") if isinstance(data.get("tools"), list) else None
+                    _model = data.get("model") if isinstance(data.get("model"), str) else None
                    result = await self._local_llm(
                        messages=messages, max_tokens=max_tokens,
                        temperature=temperature, stop=data.get("stop"),
-                        tools=_tools,
+                        tools=_tools, model=_model,
                    )
                    status = 200 if result.get("ok") else 502
                    await _send_response(writer, status, result)
@@ -3947,6 +4391,116 @@ 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)
+
    async def _delete_chat_message(self, ts: int) -> dict:
        """Entfernt eine Bubble: aus chat_backup.jsonl + Brain conversation,
        broadcastet chat_message_deleted via RVS.
@@ -320,6 +320,7 @@
      </div>
      <div id="diag-pending-attachments" style="display:none;padding:6px 10px;background:#1E1E2E;border-radius:6px 6px 0 0;margin-bottom:-4px;display:flex;gap:6px;flex-wrap:wrap;align-items:center;">
      </div>
+      <div id="diag-queue-banner" style="display:none;padding:6px 10px;background:#2A2410;border:1px solid #4A3F14;border-radius:6px;margin-bottom:6px;"></div>
      <div class="input-row">
        <label class="btn secondary" style="padding:6px 10px;cursor:pointer;font-size:14px;" title="Datei anhaengen">
          &#x1F4CE;
@@ -956,6 +957,21 @@
          <br><span style="color:#FFD60A;">Aktueller Stand (B1a): das lokale Modell <strong>plaudert nur</strong> — Werkzeuge macht noch Claude. Lokale Tools kommen mit B1b.</span>
        </div>

+        <!-- Lokales Modell (llama-swap, B0.5) -->
+        <div style="display:flex;align-items:center;gap:8px;margin:12px 0 4px 0;padding-top:10px;border-top:1px solid #2a2a3a;">
+          <span style="font-size:13px;color:#E0E0F0;"><strong>Lokales Modell:</strong></span>
+          <select id="local-llm-model" onchange="saveLocalLlmConfig()" style="flex:1;background:#1E1E2E;border:1px solid #333;border-radius:4px;padding:6px 8px;color:#E0E0F0;font-family:inherit;font-size:12px;">
+            <option value="">(lade Liste…)</option>
+          </select>
+          <button class="btn secondary" onclick="loadLocalModelList()" title="Liste neu laden" style="padding:4px 8px;font-size:10px;">↻</button>
+        </div>
+        <div id="local-llm-model-desc" style="font-size:10px;color:#8888AA;margin:0 0 2px 0;line-height:1.5;"></div>
+        <div style="font-size:10px;color:#FFD60A;margin:0 0 4px 0;line-height:1.5;">
+          Beim ersten Wechsel zu einem Modell lädt die Gamebox das GGUF (mehrere GB) —
+          die <strong>erste Antwort dauert dann länger</strong>, danach ist es gecacht.
+          Liste kommt aus <code>/shared/config/local_models.json</code> (Keys = xtts/llama-swap/config.yaml).
+        </div>
+
        <div id="local-llm-status" style="font-size:11px;color:#6a6a88;margin-top:8px;padding-top:8px;border-top:1px solid #2a2a3a;min-height:14px;"></div>
      </div>
    </div>
@@ -1013,6 +1029,18 @@
      </div>
    </div>

+    <div class="settings-section">
+      <h2>Lokales LLM & Claude-Ersparnis <button class="info-btn" onclick="showInfo('local-savings')" title="Wie wird die Ersparnis gerechnet?">ℹ</button></h2>
+      <div class="card">
+        <div style="font-size:11px;color:#8888AA;margin-bottom:10px;">
+          Turns, die das <strong style="color:#B392F0;">lokale LLM</strong> (Qwen) oder ein reiner <strong style="color:#F0B85E;">Skill-Fast-Path</strong> uebernommen hat — jeder davon ist ein Claude-Call, der NICHT passiert ist. Die lokalen Tokens laufen auf deiner eigenen Hardware (kein Subscription-Quota).
+        </div>
+        <div id="savings-grid" style="display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:8px;font-size:12px;">
+          <div class="metric-cell"><div class="metric-label">–</div><div class="metric-value">–</div></div>
+        </div>
+      </div>
+    </div>
+
    <div class="settings-section">
      <h2>Bootstrap & Migration <button class="info-btn" onclick="showInfo('bootstrap')" title="Was sind die drei Wege?">ℹ</button></h2>
      <div class="card" style="line-height:1.6;">
@@ -1068,6 +1096,7 @@
      <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:8px;">
        <h2 style="margin:0;">📁 Projekte</h2>
        <div>
+          <button class="btn secondary" id="toggle-hidden-btn" onclick="toggleShowHidden()" style="padding:4px 10px;font-size:11px;" title="Versteckte Projekte ein-/ausblenden">👁 Versteckte anzeigen</button>
          <button class="btn secondary" onclick="loadProjects()" style="padding:4px 10px;font-size:11px;">🔄 Aktualisieren</button>
          <button class="btn" onclick="openCreateProjectModal()" style="padding:4px 10px;font-size:11px;">+ Neues Projekt</button>
        </div>
@@ -1396,6 +1425,13 @@
    let focusedContextId = localStorage.getItem('diag_focused_context_id') || '';
    let diagQueueStatus = {};
    let diagProjectsCache = [];
+    let diagShowHiddenStrip = false;   // versteckte Projekte im Streifen zeigen?
+    // ── Pro-Kontext-Queue + Zustandsautomat (spiegelt die App) ──
+    const diagCtxStates = {};   // pid → 'idle' | 'running' | 'awaiting_reply'
+    const diagCtxQueues = {};   // pid → [{id,text}]
+    const diagDrafts = JSON.parse(localStorage.getItem('diag_ctx_drafts') || '{}');
+    let diagQid = 0;
+    const diagState = (pid) => diagCtxStates[pid] || 'idle';

    function updateChatVisibilityByFocus() {
      for (const box of [chatBox, document.getElementById('chat-box-fs')]) {
@@ -1409,10 +1445,22 @@
    }

    function switchDiagFocus(id) {
-      focusedContextId = id || '';
+      const nextId = id || '';
+      // Pro-Kontext-Textfeld-Entwuerfe: Feldinhalt dem verlassenen Kontext
+      // zuordnen, Entwurf des neuen laden.
+      if (nextId !== focusedContextId) {
+        const input = document.getElementById('chat-input');
+        if (input) {
+          diagDrafts[focusedContextId] = input.value;
+          input.value = diagDrafts[nextId] || '';
+        }
+        localStorage.setItem('diag_ctx_drafts', JSON.stringify(diagDrafts));
+      }
+      focusedContextId = nextId;
      localStorage.setItem('diag_focused_context_id', focusedContextId);
      updateChatVisibilityByFocus();
      renderContextStrip();
+      renderDiagQueue();
    }

    function renderContextStrip() {
@@ -1436,20 +1484,79 @@
        if (s.queue_size > 0) return { color: '#FFD60A', label: `Queue: ${s.queue_size}` };
        return { color: '#34C759', label: 'idle' };
      };
+      // Projekt-Chip MIT Auge (verstecken/sichtbar). Auge hat eigenes onclick
+      // + stopPropagation, damit der Klick nicht den Kontext wechselt.
+      const projChip = (p, isFocus, dotColor, subline) => {
+        const hidden = !!p.hidden;
+        const bg = isFocus ? 'rgba(52,199,89,0.15)' : '#1E1E2E';
+        const border = isFocus ? '#34C759' : '#2A2A3E';
+        const eye = hidden ? '👁' : '🙈';
+        const eyeTitle = hidden ? 'Wieder dauerhaft sichtbar machen' : 'Verstecken (aus dem Streifen ausblenden)';
+        return `<div style="flex:0 0 auto;padding:6px 10px;background:${bg};border:1px solid ${border};border-radius:6px;display:flex;align-items:center;gap:6px;min-width:120px;${hidden ? 'opacity:0.5;' : ''}">
+          <div onclick="switchDiagFocus('${p.id}')" style="cursor:pointer;display:flex;align-items:center;gap:6px;min-width:0;">
+            <div style="width:8px;height:8px;border-radius:4px;background:${dotColor};"></div>
+            <div style="display:flex;flex-direction:column;min-width:0;">
+              <div style="color:${isFocus?'#34C759':'#E0E0F0'};font-size:12px;font-weight:600;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:200px;">📁 ${escapeHtml(p.name)}${hidden ? ' <span style="color:#B392F0;font-size:9px;font-weight:700;">versteckt</span>' : ''}</div>
+              <div style="color:#8888AA;font-size:10px;">${subline}</div>
+            </div>
+          </div>
+          <span onclick="event.stopPropagation();setStripProjectHidden('${p.id}',${!hidden})" title="${eyeTitle}" style="cursor:pointer;font-size:14px;padding:2px 4px;user-select:none;">${eye}</span>
+        </div>`;
+      };
      const cards = [];
      // Hauptchat
      const mainDot = dotFor('__main__');
      cards.push(chip('', '💬 Hauptchat', focusedContextId === '', mainDot.color, mainDot.label || 'idle'));
-      // Projekte — nur active/ended, sortiert nach letzter Aktivitaet
+      // Projekte — nur active/ended, sortiert nach letzter Aktivitaet.
+      // Versteckte standardmaessig raus; per Toggle-Chip einblendbar.
+      let hiddenCount = 0;
      for (const p of diagProjectsCache) {
        if (p.status === 'archived') continue;
+        if (p.hidden) {
+          hiddenCount++;
+          if (!diagShowHiddenStrip) continue;
+        }
        const d = dotFor(p.id);
        const sub = d.label || `${p.turn_count} Turns`;
-        cards.push(chip(p.id, `📁 ${p.name}`, focusedContextId === p.id, d.color, sub));
+        cards.push(projChip(p, focusedContextId === p.id, d.color, sub));
+      }
+      // Toggle-Chip am Ende (nur wenn es versteckte gibt oder gerade gezeigt werden)
+      if (hiddenCount > 0 || diagShowHiddenStrip) {
+        const tLabel = diagShowHiddenStrip
+          ? `🙈 versteckte ausblenden (${hiddenCount})`
+          : `👁 versteckte anzeigen (${hiddenCount})`;
+        cards.push(`<div onclick="toggleDiagHiddenStrip()" title="Versteckte Projekte ein-/ausblenden" style="cursor:pointer;flex:0 0 auto;padding:6px 10px;background:#0D0D18;border:1px dashed #3A3A50;border-radius:6px;display:flex;align-items:center;color:#B392F0;font-size:11px;font-weight:600;white-space:nowrap;">${tLabel}</div>`);
      }
      strip.innerHTML = cards.join('');
    }

+    function toggleDiagHiddenStrip() {
+      diagShowHiddenStrip = !diagShowHiddenStrip;
+      renderContextStrip();
+    }
+
+    async function setStripProjectHidden(id, hidden) {
+      try {
+        const r = await fetch(`/api/brain/projects/${encodeURIComponent(id)}`, {
+          method: 'PATCH',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ hidden: !!hidden }),
+        });
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        // Wenn wir das gerade fokussierte Projekt verstecken (und Versteckte nicht
+        // eingeblendet sind), zurueck auf Hauptchat — sonst haengt der Focus an
+        // einem unsichtbaren Chip.
+        if (hidden && id === focusedContextId && !diagShowHiddenStrip) {
+          switchDiagFocus('');
+        }
+        // Lokal sofort aktualisieren (der /api/brain-Proxy broadcastet zusaetzlich
+        // project_changed an App + andere Tabs).
+        await refreshDiagProjectsCache();
+      } catch (e) {
+        alert('Verstecken/Anzeigen fehlgeschlagen: ' + e.message);
+      }
+    }
+
    async function refreshDiagQueueStatus() {
      try {
        const r = await fetch('/api/brain/projects/queue-status');
@@ -1571,8 +1678,8 @@
        try { loadBrainStatus(); } catch {}
        // Sprachmodell-Dropdown befuellen (kuratierte Tier-Liste vom Proxy)
        try { loadModelList(); } catch {}
-        // Lokales-LLM-Schalter aus /shared/config/local_llm.json laden
-        try { loadLocalLlmConfig(); } catch {}
+        // Lokales-LLM: erst Modell-Liste (Dropdown), dann Config (Auswahl setzen)
+        try { loadLocalModelList().then(() => loadLocalLlmConfig()); } catch {}
      };

      // Brain-Status periodisch refreshen damit die Card live bleibt
@@ -1747,8 +1854,10 @@
        }

        if (msg.type === 'project_changed') {
-          // ARIA hat in einem Tool-Call ein Projekt erstellt/betreten/verlassen/beendet.
-          // Liste neu laden falls sichtbar.
+          // Projekt geaendert (ARIA-Tool, App/Diagnostic-Verstecken, …) →
+          // BEIDE Projekt-UIs live aktualisieren: den Kontext-Streifen (Main)
+          // und die vertikale Liste (Einstellungen).
+          refreshDiagProjectsCache();
          loadProjects();
          return;
        }
@@ -1893,6 +2002,15 @@
            projectId: p.projectId || '',
            answeredBy: p.answeredBy || '',
          });
+          // ── Pro-Kontext-Queue-Automat: auf ARIAs Antwort reagieren ──
+          if (sender === 'aria') {
+            const apid = p.projectId || '';
+            const st = diagState(apid);
+            if (st === 'running' || st === 'awaiting_reply') {
+              if (p.awaiting_reply) { diagCtxStates[apid] = 'awaiting_reply'; renderDiagQueue(); }
+              else advanceDiagQueue(apid);
+            }
+          }
          return;
        }
        if (msg.type === 'chat_message_deleted') {
@@ -2089,16 +2207,64 @@
      renderDiagPending();
    }

+    // ── Pro-Kontext-Queue: Helfer (spiegelt die App) ──
+    function actuallySendDiag(pid, text) {
+      addChat('sent', text, 'via RVS', { projectId: pid });
+      send({ action: 'test_rvs', text, projectId: pid });
+      diagCtxStates[pid] = 'running';
+      renderDiagQueue();
+    }
+    function advanceDiagQueue(pid) {
+      const q = diagCtxQueues[pid] || [];
+      if (q.length === 0) { diagCtxStates[pid] = 'idle'; renderDiagQueue(); return; }
+      const next = q.shift();
+      actuallySendDiag(pid, next.text);
+    }
+    function enqueueOrSendDiag(pid, text) {
+      if (diagState(pid) === 'running') {
+        (diagCtxQueues[pid] = diagCtxQueues[pid] || []).push({ id: 'q' + (++diagQid), text });
+        renderDiagQueue();
+      } else {
+        // idle ODER awaiting_reply → sofort (bei awaiting = Antwort auf Rueckfrage).
+        actuallySendDiag(pid, text);
+      }
+    }
+    function removeDiagQueuedFocused(id) {
+      const pid = focusedContextId;
+      diagCtxQueues[pid] = (diagCtxQueues[pid] || []).filter(it => it.id !== id);
+      renderDiagQueue();
+    }
+    function renderDiagQueue() {
+      const el = document.getElementById('diag-queue-banner');
+      if (!el) return;
+      const st = diagState(focusedContextId);
+      const q = diagCtxQueues[focusedContextId] || [];
+      if (st !== 'awaiting_reply' && q.length === 0) { el.style.display = 'none'; el.innerHTML = ''; return; }
+      el.style.display = 'block';
+      let html = '';
+      if (st === 'awaiting_reply') {
+        html += '<div style="color:#FFD60A;font-weight:600;margin-bottom:4px;">&#x2753; ARIA fragt nach &mdash; deine Eingabe beantwortet das</div>';
+      }
+      if (q.length) {
+        html += q.map(it =>
+          '<span style="display:inline-block;background:#1E1E2E;border:1px solid #4A3F14;border-radius:10px;padding:2px 8px;margin:2px;font-size:12px;color:#FFD60A;">&#x23F8; ' +
+          escapeHtml(it.text.slice(0, 40)) +
+          ' <a href="#" style="color:#FF6B6B;text-decoration:none;" onclick="removeDiagQueuedFocused(\'' + it.id + '\');return false;">&#x2715;</a></span>'
+        ).join('');
+      }
+      el.innerHTML = html;
+    }
+
    function testRVS() {
      const input = document.getElementById('chat-input');
      const text = input.value.trim();
      if (!text && diagPendingFiles.length === 0) return;
      if (diagPendingFiles.length > 0) sendDiagAttachments();
      if (text) {
-        // Multi-Threading: mit fokussierter Kontext-ID senden.
-        // Bridge routet an /chat body.project_id — Brain queued per Kontext.
-        addChat('sent', text, 'via RVS', { projectId: focusedContextId });
-        send({ action: 'test_rvs', text, projectId: focusedContextId });
+        // Draft dieses Kontexts leeren + Queue-Automat entscheidet senden/anstellen.
+        diagDrafts[focusedContextId] = '';
+        localStorage.setItem('diag_ctx_drafts', JSON.stringify(diagDrafts));
+        enqueueOrSendDiag(focusedContextId, text);
      }
      input.value = '';
    }
@@ -2585,8 +2751,8 @@
      const input = document.getElementById('chat-input-fs');
      const text = input.value.trim();
      if (!text) return;
-      addChat('sent', text, 'via RVS');
-      send({ action: 'test_rvs', text });
+      // Ueber denselben Queue-Automaten wie der Haupt-Chat (fokussierter Kontext).
+      enqueueOrSendDiag(focusedContextId, text);
      input.value = '';
    }
    // Escape schliesst Vollbild-Chat
@@ -2626,7 +2792,7 @@
      // Liste neu aufbauen
      list.innerHTML = '';
      let anyLoading = false, anyError = false;
-      const labels = { f5tts: 'F5-TTS', whisper: 'Whisper STT', flux: 'FLUX Image-Gen' };
+      const labels = { f5tts: 'F5-TTS', whisper: 'Whisper STT', flux: 'FLUX Image-Gen', llm: 'Lokales LLM' };
      for (const [s, info] of Object.entries(_serviceState)) {
        const row = document.createElement('div');
        row.style.cssText = 'display:flex;align-items:center;gap:6px;';
@@ -2975,16 +3141,28 @@
            <div style="color:${!activeId ? '#34C759' : '#E0E0F0'};font-weight:600;">💬 Hauptchat ${!activeId ? '<span style="font-size:10px;font-weight:800;">✓ AKTIV</span>' : ''}</div>
            <div style="color:#555570;font-size:11px;margin-top:2px;">Standard-Verlauf, keine Projekt-Zuordnung</div>
          </div>`);
+        const showHidden = !!window.__showHidden;
+        let hiddenCount = 0, shownCount = 0;
        for (const p of projects) {
+          const hidden = !!p.hidden;
+          if (hidden) hiddenCount++;
+          // Versteckte nur zeigen wenn der Toggle an ist.
+          if (hidden && !showHidden) continue;
+          shownCount++;
          const isActive = p.id === activeId;
          const since = p.last_activity_at ? new Date(p.last_activity_at * 1000).toLocaleString('de-DE') : '?';
          const ended = p.status === 'ended';
+          // Auge: versteckt → 👁 (wieder sichtbar machen), sichtbar → 🙈 (verstecken).
+          const eyeIcon = hidden ? '👁' : '🙈';
+          const eyeTitle = hidden ? 'Wieder dauerhaft sichtbar machen' : 'Verstecken (aus Listen ausblenden)';
+          const eyeColor = hidden ? '#B392F0' : '#8888AA';
          rows.push(`
-            <div style="padding:12px 14px;border-bottom:1px solid #1E1E2E;${isActive ? 'background:rgba(52,199,89,0.08);border-left:3px solid #34C759;' : ''}">
+            <div style="padding:12px 14px;border-bottom:1px solid #1E1E2E;${isActive ? 'background:rgba(52,199,89,0.08);border-left:3px solid #34C759;' : ''}${hidden ? 'opacity:0.55;' : ''}">
              <div style="display:flex;justify-content:space-between;align-items:flex-start;gap:8px;">
                <div onclick="switchProject('${p.id}')" style="cursor:pointer;flex:1;">
                  <div style="color:${isActive ? '#34C759' : '#E0E0F0'};font-weight:600;">
-                    📁 ${escapeHtml(p.name)}
+                    ${hidden ? '🙈' : '📁'} ${escapeHtml(p.name)}
+                    ${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>' : ''}
                    ${isActive ? '<span style="color:#34C759;font-size:10px;font-weight:800;margin-left:6px;">✓ AKTIV</span>' : ''}
                  </div>
@@ -2992,6 +3170,7 @@
                  <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="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>
                </div>
@@ -3000,13 +3179,43 @@
        }
        if (projects.length === 0) {
          rows.push('<div style="padding:18px;color:#555570;font-size:12px;text-align:center;">Noch keine Projekte. „+ Neues Projekt" oder sag ARIA „lass uns ein Projekt anlegen".</div>');
+        } else if (shownCount === 0) {
+          rows.push(`<div style="padding:18px;color:#555570;font-size:12px;text-align:center;">Alle ${hiddenCount} Projekte sind versteckt. Klick „👁 Versteckte anzeigen".</div>`);
        }
        listEl.innerHTML = rows.join('');
+
+        // Toggle-Button beschriften (mit Anzahl) + Zustand spiegeln.
+        const thBtn = document.getElementById('toggle-hidden-btn');
+        if (thBtn) {
+          thBtn.textContent = showHidden
+            ? `🙈 Versteckte ausblenden${hiddenCount ? ' ('+hiddenCount+')' : ''}`
+            : `👁 Versteckte anzeigen${hiddenCount ? ' ('+hiddenCount+')' : ''}`;
+          thBtn.style.opacity = hiddenCount ? '1' : '0.5';
+        }
      } catch (e) {
        listEl.innerHTML = `<div style="padding:14px;color:#FF6E6E;font-size:12px;">Fehler: ${e.message}</div>`;
      }
    }

+    function toggleShowHidden() {
+      window.__showHidden = !window.__showHidden;
+      loadProjects();
+    }
+
+    async function setProjectHidden(id, hidden) {
+      try {
+        const r = await fetch(`/api/brain/projects/${encodeURIComponent(id)}`, {
+          method: 'PATCH',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ hidden: !!hidden }),
+        });
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        // Beim Verstecken bleibt der „anzeigen"-Modus wie er ist; beim
+        // Wieder-Sichtbarmachen sieht man es sofort ohne Umschalten.
+        loadProjects();
+      } catch (e) { alert('Verstecken/Anzeigen fehlgeschlagen: ' + e.message); }
+    }
+
    async function switchProject(projectId) {
      try {
        await fetch('/api/brain/projects/switch', {
@@ -3517,6 +3726,12 @@
    }
    document.getElementById('chat-input').addEventListener('keydown', (e) => chatInputKeydown(e, testRVS));
    document.getElementById('chat-input-fs').addEventListener('keydown', (e) => chatInputKeydown(e, testRVSFS));
+    // Entwurf des zuletzt fokussierten Kontexts ins Feld laden + Queue-Banner init.
+    (function initDiagDraft() {
+      const input = document.getElementById('chat-input');
+      if (input && diagDrafts[focusedContextId]) input.value = diagDrafts[focusedContextId];
+      renderDiagQueue();
+    })();

    // Escape schliesst Lightbox
    document.addEventListener('keydown', (e) => {
@@ -5882,6 +6097,29 @@
      setCell('metrics-h24', d.h24);
      setCell('metrics-d30', d.d30);

+      // Lokales LLM & Claude-Ersparnis — pro Fenster: wie viele Claude-Calls
+      // durch local/fast-path vermieden wurden + lokale Token-Last.
+      const savingsGrid = document.getElementById('savings-grid');
+      if (savingsGrid) {
+        const wins = [['letzte 1h', d.h1], ['letzte 5h', d.h5],
+                      ['letzte 24h', d.h24], ['letzte 30 Tage', d.d30]];
+        const z = { calls: 0, tokens_in: 0, tokens_out: 0 };
+        savingsGrid.innerHTML = wins.map(([label, w]) => {
+          const bs = (w && w.by_source) || {};
+          const loc = bs.local || z;
+          const fp = bs['fast-path'] || z;
+          const saved = (loc.calls || 0) + (fp.calls || 0);
+          const locTok = (loc.tokens_in || 0) + (loc.tokens_out || 0);
+          const color = saved > 0 ? '#3FB950' : '#555570';
+          return `<div class="metric-cell">
+            <div class="metric-label">${label}</div>
+            <div class="metric-value" style="color:${color};">${saved} Claude-Calls gespart</div>
+            <div class="metric-sub">lokal ${loc.calls || 0} · fast-path ${fp.calls || 0}</div>
+            <div class="metric-sub">${fmtTokens(locTok)} lokale Tokens (eigene HW)</div>
+          </div>`;
+        }).join('');
+      }
+
      // 5h-Fenster gegen Plan-Limit: Warn-Klassen
      const plan = getActivePlanLimit();
      const limit = plan.h5;
@@ -5924,6 +6162,15 @@

    // Vor-definierte Info-Blocks
    const INFO_TEXTS = {
+      'local-savings': {
+        title: 'Lokales LLM & Claude-Ersparnis',
+        html: `
+          <p>Jeder Turn, den das <strong>lokale LLM</strong> oder ein <strong>Fast-Path</strong> (reiner Skill, ganz ohne LLM) beantwortet, ist ein Claude-Call, der <strong>nicht</strong> gegen dein Subscription-Quota laeuft.</p>
+          <p><strong>„Claude-Calls gespart"</strong> = Anzahl der local- + fast-path-Antworten im Zeitfenster. Konservativ gezaehlt: 1 Antwort = mindestens 1 gesparter Claude-Call (bei Tool-Use waeren es real oft mehr).</p>
+          <p><strong>„lokale Tokens"</strong> = Prompt+Antwort-Tokens, die auf deiner eigenen Gamebox-GPU verarbeitet wurden (echte <code>usage</code>-Zahlen vom Modell, sonst chars/4-Schaetzung). Die kosten dich nichts ausser Strom.</p>
+          <p>Fast-Path-Antworten (z.B. „nächstes Lied") haben ~0 Tokens — reiner Skill-Aufruf, kein Modell.</p>
+        `,
+      },
      'local-llm': {
        title: 'Lokales LLM — schnelle Antworten',
        html: `
@@ -6254,6 +6501,29 @@
        el.style.color = '#4ADE80';
      }
    }
+    let _localModelsCache = [];
+    let _currentLocalModel = 'qwen3-8b';
+    function updateLocalModelDesc() {
+      const el = document.getElementById('local-llm-model-desc');
+      const sel = document.getElementById('local-llm-model');
+      if (!el || !sel) return;
+      const m = _localModelsCache.find(x => x.id === sel.value);
+      el.textContent = m && m.description ? m.description : '';
+    }
+    async function loadLocalModelList() {
+      try {
+        const r = await fetch('/api/local-models-list');
+        const j = await r.json();
+        _localModelsCache = (j && j.models) || [];
+      } catch (e) { _localModelsCache = []; }
+      const sel = document.getElementById('local-llm-model');
+      if (sel) {
+        sel.innerHTML = _localModelsCache.map(m =>
+          `<option value="${m.id}">${m.display_name || m.id}</option>`).join('') || '<option value="">(keine)</option>';
+        if (_localModelsCache.some(m => m.id === _currentLocalModel)) sel.value = _currentLocalModel;
+        updateLocalModelDesc();
+      }
+    }
    async function loadLocalLlmConfig() {
      try {
        const r = await fetch('/api/local-llm-config');
@@ -6264,15 +6534,24 @@
        if (en) en.checked = !!c.enabled;
        if (ol) ol.checked = !!c.localOnly;
        if (tv) tv.value = (c.toolVariant === 'full') ? 'full' : 'slim';
+        _currentLocalModel = c.localLlmModel || 'qwen3-8b';
+        const sel = document.getElementById('local-llm-model');
+        if (sel && _localModelsCache.some(m => m.id === _currentLocalModel)) {
+          sel.value = _currentLocalModel;
+          updateLocalModelDesc();
+        }
        setLocalLlmStatus(c);
      } catch (e) { /* still */ }
    }
    async function saveLocalLlmConfig() {
+      const modelSel = document.getElementById('local-llm-model');
      const body = {
        enabled: document.getElementById('local-llm-enabled').checked,
        localOnly: document.getElementById('local-llm-onlylocal').checked,
        toolVariant: document.getElementById('local-llm-toolvariant').value,
+        localLlmModel: (modelSel && modelSel.value) || '',
      };
+      updateLocalModelDesc();
      try {
        const r = await fetch('/api/local-llm-config', {
          method: 'POST', headers: { 'Content-Type': 'application/json' },
@@ -309,9 +309,10 @@ function readLocalLlmConfig() {
      enabled: !!p.enabled,
      localOnly: !!p.localOnly,
      toolVariant: p.toolVariant === "full" ? "full" : "slim",
+      localLlmModel: (typeof p.localLlmModel === "string" && p.localLlmModel) ? p.localLlmModel : "qwen3-8b",
    };
  } catch {
-    return { enabled: false, localOnly: false, toolVariant: "slim" };
+    return { enabled: false, localOnly: false, toolVariant: "slim", localLlmModel: "qwen3-8b" };
  }
 }
 function writeLocalLlmConfig(patch) {
@@ -319,6 +320,7 @@ function writeLocalLlmConfig(patch) {
  if (typeof patch.enabled === "boolean") cur.enabled = patch.enabled;
  if (typeof patch.localOnly === "boolean") cur.localOnly = patch.localOnly;
  if (patch.toolVariant === "slim" || patch.toolVariant === "full") cur.toolVariant = patch.toolVariant;
+  if (typeof patch.localLlmModel === "string" && patch.localLlmModel.trim()) cur.localLlmModel = patch.localLlmModel.trim();
  fs.mkdirSync("/shared/config", { recursive: true });
  const tmp = LOCAL_LLM_CONFIG_FILE + ".tmp";
  fs.writeFileSync(tmp, JSON.stringify(cur, null, 2));
@@ -326,6 +328,27 @@ function writeLocalLlmConfig(patch) {
  return cur;
 }

+// ── Lokale Modell-Liste (Diagnostic-Dropdown) ────────────────
+// /shared/config/local_models.json — kuratierte Liste; muss zu den KEYS in
+// xtts/llama-swap/config.yaml passen. Wird bei Bedarf mit Defaults seeded.
+const LOCAL_MODELS_FILE = "/shared/config/local_models.json";
+const DEFAULT_LOCAL_MODELS = [
+  { id: "qwen3-8b", display_name: "Qwen3 8B (Standard)", description: "Bestes Tool-Calling, ~6 GB. Passt auf 12 GB." },
+  { id: "qwen3-4b", display_name: "Qwen3 4B (schneller)", description: "Kleiner + flotter, ~3 GB. Etwas schwaecher." },
+];
+function loadLocalModels() {
+  try {
+    const arr = JSON.parse(fs.readFileSync(LOCAL_MODELS_FILE, "utf-8"));
+    if (Array.isArray(arr) && arr.length && arr.every(m => m && typeof m.id === "string")) return arr;
+  } catch {}
+  // Seed defaults
+  try {
+    fs.mkdirSync("/shared/config", { recursive: true });
+    fs.writeFileSync(LOCAL_MODELS_FILE, JSON.stringify(DEFAULT_LOCAL_MODELS, null, 2));
+  } catch {}
+  return DEFAULT_LOCAL_MODELS;
+}
+
 // ── File-Project-Manifest ───────────────────────────────────────────
 // Jeder Eintrag map[absoluter_pfad] = project_id (leer = Hauptchat).
 // Wird vom files-list-Endpoint + files-set-project gepflegt.
@@ -875,6 +898,11 @@ function connectRVS(forcePlain) {
        // Mode-Broadcast von der Bridge → an Browser-Clients weiterreichen
        log("info", "rvs", `Mode-Broadcast: ${msg.payload?.mode} (${msg.payload?.name})`);
        broadcast({ type: "mode", payload: msg.payload });
+      } else if (msg.type === "project_changed") {
+        // Ein Projekt wurde geaendert (ARIA-Tool, App-Verstecken, …) → an die
+        // 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 === "agent_activity") {
        // Bridge meldet "ARIA denkt/schreibt/tool" oder "idle" — an Browser
        // weiterreichen, damit der Thinking-Indikator im Chat erscheint.
@@ -1574,7 +1602,16 @@ const htmlPath = path.join(__dirname, "index.html");

 const server = http.createServer((req, res) => {
  if (req.url === "/" || req.url === "/index.html") {
-    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    // no-store: das Dashboard ist eine Single-HTML-App die bei jedem Deploy
+    // neue Inline-JS/CSS bekommt. Ohne Cache-Header servierte der Browser die
+    // alte Version trotz Reload (neue Features tauchten erst nach Hard-Reload
+    // auf) — genau das Symptom „ich seh den Button nicht".
+    res.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store, no-cache, must-revalidate",
+      "Pragma": "no-cache",
+      "Expires": "0",
+    });
    res.end(fs.readFileSync(htmlPath, "utf-8"));
  } else if (req.url === "/api/state") {
    res.writeHead(200, { "Content-Type": "application/json" });
@@ -1602,6 +1639,9 @@ const server = http.createServer((req, res) => {
      }
    });
    return;
+  } else if (req.url === "/api/local-models-list" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, models: loadLocalModels() }));
  } else if (req.url === "/api/local-llm-config" && req.method === "GET") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify(readLocalLlmConfig()));
@@ -2142,6 +2182,13 @@ const server = http.createServer((req, res) => {
    // mehr als eine Minute.
    const isUpload = /\/attachments(\/upload)?$/.test(targetPath);
    const timeout = isUpload ? 120000 : 60000;
+    // Projekt-Mutationen (create/switch/end/archive/patch inkl. hidden) sollen
+    // alle Clients live aktualisieren. Wir broadcasten nach Erfolg ein
+    // project_changed an RVS — App + andere Diagnostic-Tabs laden dann neu,
+    // ohne Seiten-Refresh (spiegelt das bestehende ARIA-project_changed-Event).
+    const isProjectMutation =
+      /^\/projects\b/.test(targetPath) &&
+      (req.method === "POST" || req.method === "PATCH" || req.method === "DELETE");
    const proxyReq = http.request({
      host: "aria-brain",
      port: 8080,
@@ -2152,6 +2199,17 @@ const server = http.createServer((req, res) => {
    }, (proxyRes) => {
      res.writeHead(proxyRes.statusCode, proxyRes.headers);
      proxyRes.pipe(res);
+      if (isProjectMutation && proxyRes.statusCode >= 200 && proxyRes.statusCode < 300) {
+        try {
+          // An App + Bridge (RVS echot NICHT an den Sender) …
+          sendToRVS_raw({ type: "project_changed",
+                          payload: { reason: "diagnostic" },
+                          timestamp: Date.now() });
+          // … und an die eigenen Browser-Tabs (die haengen am Diag-Server, nicht
+          // direkt am RVS, kriegen den RVS-Broadcast also nicht).
+          broadcast({ type: "project_changed", payload: { reason: "diagnostic" } });
+        } catch (_) {}
+      }
    });
    proxyReq.on("error", (err) => {
      res.writeHead(503, { "Content-Type": "application/json" });
@@ -0,0 +1,185 @@
+#!/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}")"
+  [[ -e "${d}/disk.qcow2" ]] && die "VM '${name}' existiert schon"
+  mkdir -p "${d}"
+  echo "${arch}" > "${d}/arch"
+  qemu-img create -f qcow2 "${d}/disk.qcow2" "${size}" >/dev/null
+  echo "VM '${name}' angelegt (${arch}, ${size})."
+}
+
+cmd_boot() {
+  local name="${1:?name}"; shift || true
+  local d; d="$(vm_dir "${name}")"
+  [[ -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="" bootdev="c" display=1 mem=1024 machine=""
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --iso)         iso="${2:?}"; bootdev="d"; shift 2 ;;
+      --disk-boot)   bootdev="c"; shift ;;
+      --vnc-display) display="${2:?}"; shift 2 ;;
+      --mem)         mem="${2:?}"; shift 2 ;;
+      --machine)     machine="${2:?}"; shift 2 ;;
+      *) die "unbekannte Option: $1" ;;
+    esac
+  done
+
+  local args=(-name "${name}" -m "${mem}"
+    -drive "file=${d}/disk.qcow2,format=qcow2"
+    -vnc "127.0.0.1:${display}"
+    -monitor "unix:${d}/monitor.sock,server,nowait"
+    -pidfile "${d}/pid" -daemonize)
+
+  # 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}")
+  [[ -n "${iso}" ]] && args+=(-cdrom "${iso}")
+  args+=(-boot "${bootdev}")
+
+  "${bin}" "${args[@]}"
+  echo "VM '${name}' gestartet (${arch}) — VNC 127.0.0.1:${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?)"
+  mkdir -p "${SHOT_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="${SHOT_DIR}/${name}-${ts}.png"
+  if command -v convert >/dev/null; then
+    convert "${ppm}" "${out}" && rm -f "${ppm}"
+  else
+    out="${SHOT_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,12 @@ 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",
 ]);

 // Token-Raum: token -> { clients: Set<ws> }
@@ -90,22 +90,19 @@ services:
                                                 # Container-Restarts.
    restart: unless-stopped

-  # ─── Lokales LLM (Plan B, B0) — llama.cpp-Server (GPU) ────────
-  # Serviert Qwen3-8B (GGUF Q4_K_M) OpenAI-kompatibel auf :8081, NUR im
-  # Compose-Netz (kein RVS direkt) — die Bruecke macht der llm-adapter.
+  # ─── Lokales LLM (Plan B, B0.5) — llama-swap (GPU) ────────────
+  # llama-swap laedt/swappt mehrere Modelle on-demand (nur eins passt gleich-
+  # zeitig in die 12 GB). Welches geladen wird, bestimmt das `model`-Feld im
+  # Request — das Brain schickt es aus local_llm.json mit. Erster Load eines
+  # Modells zieht das GGUF via -hf von HF (Cache unter /models, persistent).
+  # OpenAI-kompatibel auf :8080, nur im Compose-Netz; die Bruecke macht der
+  # llm-adapter. Modell-Liste: ./llama-swap/config.yaml.
  #
-  # AUTO-DOWNLOAD: llama.cpp zieht das GGUF beim ersten Start selbst von
-  # Hugging Face (-hf <repo>:<quant>) und cached es unter /models (persistent
-  # via Bind-Mount -> kein Re-Download bei Restart). Kein manuelles Ablegen
-  # noetig. Modell wechseln = LLM_HF_REPO/LLM_HF_QUANT in der .env aendern +
-  # Container neu. (Alternativ lokale Datei: command auf -m /models/x.gguf.)
-  #
-  # VRAM auf der RTX 3060 (12 GB): whisper-small (~1-2) + f5tts (~1-2) +
-  # qwen3-8b-q4 (~6) ~= 9-10 GB. Passt, aber knapp — bei OOM: LLM_CTX kleiner
-  # oder Quant auf Q4_K_S/IQ4_XS wechseln.
-  llama:
-    image: ghcr.io/ggml-org/llama.cpp:server-cuda
-    container_name: aria-llama
+  # BLIND GEBAUT (kein Gamebox-Test hier): beim ersten Start
+  # `docker logs -f aria-llama-swap` pruefen. Image bundelt llama-server.
+  llama-swap:
+    image: ghcr.io/mostlygeek/llama-swap:unified-cuda
+    container_name: aria-llama-swap
    deploy:
      resources:
        reservations:
@@ -114,13 +111,11 @@ services:
              count: 1
              capabilities: [gpu]
    volumes:
-      - ./models:/models                         # HF-Download-Cache (persistent)
+      - ./models:/models                                   # HF-Download-Cache (persistent)
+      - ./llama-swap/config.yaml:/app/config.yaml:ro       # Modell-Liste
    environment:
-      - LLAMA_CACHE=/models                       # llama.cpp legt -hf-Downloads hier ab
-    command: >
-      -hf ${LLM_HF_REPO:-Qwen/Qwen3-8B-GGUF}:${LLM_HF_QUANT:-Q4_K_M}
-      --host 0.0.0.0 --port 8081
-      -ngl 99 -c ${LLM_CTX:-8192} --jinja
+      - LLAMA_CACHE=/models                                # llama-server legt -hf-Downloads hier ab
+    command: ["--config", "/app/config.yaml", "--listen", "0.0.0.0:8080"]
    restart: unless-stopped

  # ─── Local-LLM-Adapter — RVS <-> llama.cpp (Plan B, B0) ──────
@@ -130,14 +125,15 @@ services:
    build: ./llm-adapter
    container_name: aria-llm-adapter
    depends_on:
-      - llama
+      - llama-swap
    environment:
      - RVS_HOST=${RVS_HOST}
      - RVS_PORT=${RVS_PORT:-443}
      - RVS_TLS=${RVS_TLS:-true}
      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
      - RVS_TOKEN=${RVS_TOKEN}
-      - LLAMA_URL=http://llama:8081
+      - LLAMA_URL=http://llama-swap:8080
      - LLM_MODEL=${LLM_MODEL:-qwen3-8b}
-      - LLM_TIMEOUT_SEC=${LLM_TIMEOUT_SEC:-60}
+      # Erster Load eines Modells kann ein GGUF ziehen (mehrere GB) — grosszuegig.
+      - LLM_TIMEOUT_SEC=${LLM_TIMEOUT_SEC:-600}
    restart: unless-stopped
@@ -0,0 +1,42 @@
+# llama-swap Modell-Liste fuer ARIA (Plan B, B0.5).
+# Welches Modell geladen wird, bestimmt das `model`-Feld im Request (das Brain
+# schickt es aus /shared/config/local_llm.json mit). llama-swap laedt es
+# on-demand, swappt bei Bedarf (nur eins passt gleichzeitig in die 12 GB).
+# Erster Load zieht das GGUF via -hf von Hugging Face (Cache unter /models).
+#
+# Die Modell-KEYS hier muessen zu local_models.json (Diagnostic-Dropdown) passen.
+#
+# healthCheckTimeout: Sekunden, die llama-swap auf "Modell bereit" wartet.
+# GROSSZUEGIG, weil der erste Load ein GGUF (mehrere GB) herunterlaedt. Wenn der
+# erste Download laenger dauert und abbricht: hier hochsetzen.
+healthCheckTimeout: 1800
+
+models:
+  # Standard — Qwen3 8B (~6 GB Q4). Bestes Tool-Calling, passt auf 12 GB.
+  "qwen3-8b":
+    cmd: |
+      llama-server --port ${PORT} --host 127.0.0.1
+      -hf Qwen/Qwen3-8B-GGUF:Q4_K_M
+      -ngl 99 -c 8192 --jinja
+    ttl: 3600   # nach 1h Idle entladen (VRAM freigeben)
+
+  # Kleiner + schneller — Qwen3 4B (~3 GB). Fuer noch flottere Antworten,
+  # etwas schwaecher. Guter A/B-Vergleich gegen 8B.
+  "qwen3-4b":
+    cmd: |
+      llama-server --port ${PORT} --host 127.0.0.1
+      -hf Qwen/Qwen3-4B-GGUF:Q4_K_M
+      -ngl 99 -c 8192 --jinja
+    ttl: 3600
+
+  # ── Vorlagen fuer spaeter (auskommentiert; brauchen mehr VRAM / 2. Karte) ──
+  # "qwen3-14b":
+  #   cmd: |
+  #     llama-server --port ${PORT} --host 127.0.0.1
+  #     -hf Qwen/Qwen3-14B-GGUF:Q4_K_M -ngl 99 -c 8192 --jinja
+  #   ttl: 3600
+  # "mistral-small-3":
+  #   cmd: |
+  #     llama-server --port ${PORT} --host 127.0.0.1
+  #     -hf <mistral-small-3-gguf-repo>:Q4_K_M -ngl 99 -c 8192 --jinja
+  #   ttl: 3600
@@ -69,14 +69,16 @@ async def _send(ws, mtype: str, payload: dict) -> None:


 async def _call_llama(messages: list, *, max_tokens: int, temperature: float,
-                      stop, tools=None) -> dict:
-    """Ruft llama.cpp /v1/chat/completions (OpenAI-Format). Gibt
+                      stop, tools=None, model=None) -> dict:
+    """Ruft llama.cpp/llama-swap /v1/chat/completions (OpenAI-Format). Gibt
    {ok, content, tool_calls, error} zurueck — wirft nie.

-    tools: optionale OpenAI-Tool-Definitionen (B1b). llama.cpp (--jinja) mit
-    Qwen3 kann natives Tool-Calling und liefert dann message.tool_calls."""
+    model: welches Modell llama-swap laden soll (B0.5). Kommt aus dem Request
+    (Brain -> local_llm.json). Faellt auf LLM_MODEL (env) zurueck.
+    tools: optionale OpenAI-Tool-Definitionen (B1b). Qwen3 (--jinja) kann
+    natives Tool-Calling und liefert dann message.tool_calls."""
    body = {
-        "model": LLM_MODEL,
+        "model": model or LLM_MODEL,
        "messages": messages,
        "max_tokens": max_tokens,
        "temperature": temperature,
@@ -108,7 +110,22 @@ async def _call_llama(messages: list, *, max_tokens: int, temperature: float,
        return {"ok": False, "content": "", "error": str(e)[:300]}


+# B0.5-2: Lade-Status ans Diagnostic (service_status, service="llm"). Wir kennen
+# den Download-Fortschritt nicht (llama-swap gibt ihn nicht her), aber wir melden
+# den Zustand bei Modellwechsel: loading -> ready/error. _last_model = aktuell
+# geladenes; _ready_models = in dieser Session schon einmal bereit gewesene
+# (fuer den "frisch geladen"-Hinweis 🎉 bei langem Erst-Load).
+_last_model = None
+_ready_models: set = set()
+
+
+async def _emit_llm_status(ws, state: str, model: str, **extra) -> None:
+    await _send(ws, "service_status",
+                {"service": "llm", "state": state, "model": model, **extra})
+
+
 async def _handle_llm_request(ws, payload: dict) -> None:
+    global _last_model
    req_id = payload.get("requestId", "")
    messages = payload.get("messages") or []
    if not isinstance(messages, list) or not messages:
@@ -120,13 +137,34 @@ async def _handle_llm_request(ws, payload: dict) -> None:
    temperature = float(payload.get("temperature", 0.7) or 0.7)
    stop = payload.get("stop")
    tools = payload.get("tools") or None
+    model = (payload.get("model") or "").strip() or None
+    eff_model = model or LLM_MODEL
+
+    # Modellwechsel (oder erster Request) → llama-swap laedt/swappt: Status melden.
+    switching = eff_model != _last_model
+    if switching:
+        await _emit_llm_status(ws, "loading", eff_model)
+
    t0 = time.time()
    res = await _call_llama(messages, max_tokens=max_tokens,
-                            temperature=temperature, stop=stop, tools=tools)
+                            temperature=temperature, stop=stop, tools=tools,
+                            model=model)
    dt = time.time() - t0
+
+    if switching:
+        if res.get("ok"):
+            fresh = (eff_model not in _ready_models) and dt > 25
+            _ready_models.add(eff_model)
+            _last_model = eff_model
+            await _emit_llm_status(ws, "ready", eff_model,
+                                   loadSeconds=round(dt, 1), freshlyDownloaded=fresh)
+        else:
+            # bei Fehler _last_model NICHT setzen → naechster Versuch meldet erneut loading
+            await _emit_llm_status(ws, "error", eff_model,
+                                   error=(res.get("error") or "")[:120])
    tc = res.get("tool_calls")
-    logger.info("llm_request id=%s -> ok=%s %.2fs content_len=%d tool_calls=%d",
-                (req_id[:8] if req_id else "?"), res.get("ok"), dt,
+    logger.info("llm_request id=%s model=%s -> ok=%s %.2fs content_len=%d tool_calls=%d",
+                (req_id[:8] if req_id else "?"), model or LLM_MODEL, res.get("ok"), dt,
                len(res.get("content") or ""), len(tc) if tc else 0)
    await _send(ws, "llm_response", {
        "requestId": req_id,
@@ -134,7 +172,7 @@ async def _handle_llm_request(ws, payload: dict) -> None:
        "content": res.get("content", ""),
        "tool_calls": tc,
        "error": res.get("error"),
-        "model": LLM_MODEL,
+        "model": model or LLM_MODEL,
        "elapsedMs": int(dt * 1000),
    })