release: bump version to 0.2.2.2

"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>

CHANGELOG.md

@@ -10,13 +10,71 @@ Alle Änderungen am Projekt. Format: [Keep a Changelog](https://keepachangelog.c
 
 ---
 
+## [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 mit nur einer Kachel): „⤢ Übersicht"-Button (unten rechts, weg von den Chat-Kopf-Icons), 2-Finger-Pinch/Pan, Hardware-Back.
+- 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.
 
 ---
 

README.md

@@ -500,7 +500,7 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 
 ### Features
 
-- **Desktop-Workspace (zoombarer Canvas)**: Die App ist eine desktop-artige Arbeitsfläche — rausgezoomt eine **Landkarte aus Kacheln** (Chat/Editor/Desktop/Vorschau), die man mit **2 Fingern zoomt und verschiebt**; Tippen auf eine Kachel zoomt sie voll auf und macht sie echt bedienbar („Übersicht + Fokus"). Reiner Chat verhält sich exakt wie bisher (eine Kachel, dauerhaft fokussiert). Zurück per „⤢ Übersicht" oder Hardware-Back. Basiert auf gesture-handler + reanimated; interaktive Inhalte werden nie unter Zoom-Transform gerendert (Keyboard/Touch bleiben korrekt)
+- **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
@@ -1044,7 +1044,8 @@ 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-Workspace**: zoom-/verschiebbarer Kachel-Canvas (gesture-handler + reanimated), „Übersicht + Fokus" — Chat/Editor/Desktop/Vorschau als Kacheln; reiner Chat unverändert (eine Kachel)
+- [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

android/android/app/build.gradle

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

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.2.1.9",
+  "version": "0.2.2.2",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/screens/ChatScreen.tsx

@@ -407,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
@@ -462,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 });
@@ -992,10 +1009,18 @@ const ChatScreen: React.FC = () => {
         if (p.id && (p.kind === 'code' || p.kind === 'chat')) {
           projectFocus.setKind(p.id, p.kind);
         }
-        if (action === 'entered' || action === 'created') {
-          if (p.id) setFocusedProjectId(p.id);
-        } else if (action === 'exited') {
-          setFocusedProjectId('');
+        // 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;
       }
@@ -1620,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();
@@ -1723,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();
 
@@ -1799,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({
@@ -2202,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();
 

android/src/workspace/Tile.tsx

@@ -1,61 +0,0 @@
-/**
- * Tile — leichte Thumbnail-Darstellung einer Kachel in der gezoomten "Landkarte".
- *
- * Zeigt NUR Icon + Titel (+ optionalen Untertitel). Die schweren, interaktiven
- * Inhalte (ChatScreen, WebViews) liegen NICHT hier, sondern in der separaten
- * Identity-Content-Ebene des WorkspaceCanvas — Thumbnails werden nie skaliert
- * interaktiv. Ein Tap fokussiert die Kachel (zoomt sie voll auf).
- */
-
-import React from 'react';
-import { StyleSheet, Text, View } from 'react-native';
-import { Gesture, GestureDetector } from 'react-native-gesture-handler';
-import { runOnJS } from 'react-native-reanimated';
-import { TileId, TileRect, TILE_META } from './layout';
-
-interface Props {
-  id: TileId;
-  /** Welt-View-lokales Rect (relativ zur Bounds-Ecke). */
-  rect: TileRect;
-  subtitle?: string;
-  onFocus: (id: TileId) => void;
-}
-
-const Tile: React.FC<Props> = ({ id, rect, subtitle, onFocus }) => {
-  const meta = TILE_META[id];
-  const tap = Gesture.Tap()
-    .maxDuration(300)
-    .onEnd((_e, success) => {
-      if (success) runOnJS(onFocus)(id);
-    });
-
-  return (
-    <GestureDetector gesture={tap}>
-      <View style={[styles.tile, { left: rect.x, top: rect.y, width: rect.w, height: rect.h }]}>
-        <Text style={styles.icon}>{meta.icon}</Text>
-        <Text style={styles.title}>{meta.title}</Text>
-        {!!subtitle && <Text style={styles.subtitle} numberOfLines={2}>{subtitle}</Text>}
-        <Text style={styles.hint}>Tippen zum Öffnen</Text>
-      </View>
-    </GestureDetector>
-  );
-};
-
-const styles = StyleSheet.create({
-  tile: {
-    position: 'absolute',
-    backgroundColor: '#12122A',
-    borderRadius: 32,
-    borderWidth: 3,
-    borderColor: '#1E1E2E',
-    alignItems: 'center',
-    justifyContent: 'center',
-    padding: 40,
-  },
-  icon: { fontSize: 220, marginBottom: 24 },
-  title: { color: '#FFFFFF', fontSize: 96, fontWeight: '800' },
-  subtitle: { color: '#9090B0', fontSize: 52, marginTop: 20, textAlign: 'center' },
-  hint: { color: '#555570', fontSize: 46, marginTop: 40 },
-});
-
-export default Tile;

android/src/workspace/WorkspaceCanvas.tsx

@@ -1,241 +0,0 @@
-/**
- * WorkspaceCanvas — die zoom-/verschiebbare "Landkarte" plus Fokus-Modus.
- *
- * Zwei Ebenen uebereinander:
- *  1. Welt-Ebene (skaliert/verschoben): nur leichte Thumbnail-Kacheln. Hier
- *     wirken 2-Finger-Pinch-Zoom + 2-Finger-Pan (nur in der Uebersicht).
- *  2. Identity-Content-Ebene (Scale 1, nie transformiert): die schweren,
- *     interaktiven Inhalte (ChatScreen + WebViews). Alle sichtbaren Kacheln
- *     sind hier IMMER gemountet; nur die fokussierte ist per display sichtbar.
- *     Dadurch bleiben Touch-Koordinaten/Keyboard korrekt und nichts remountet
- *     beim Fokuswechsel.
- *
- * Tap auf eine Thumbnail-Kachel → Fokus (voll aufgezoomt + interaktiv). Der
- * "⤢ Übersicht"-Button bzw. der Hardware-Back fuehren zurueck zur Landkarte.
- * Bei nur einer Kachel (reiner Chat) ist diese dauerhaft fokussiert und der
- * Canvas verhaelt sich exakt wie der bisherige Vollbild-Chat.
- */
-
-import React, { useEffect, useMemo, useState } from 'react';
-import { BackHandler, StyleSheet, Text, TouchableOpacity, useWindowDimensions, View } from 'react-native';
-import Animated, { useAnimatedStyle, useSharedValue, withTiming } from 'react-native-reanimated';
-import { Gesture, GestureDetector } from 'react-native-gesture-handler';
-
-import {
-  boundsOf, Camera, focusCamera, overviewCamera, TileId, TILE_RECTS, toLocal,
-} from './layout';
-import Tile from './Tile';
-import { useWorkspaceLayout } from './useWorkspaceLayout';
-import ChatTile from './tiles/ChatTile';
-import CodeEditorTile from './tiles/CodeEditorTile';
-import VncTile from './tiles/VncTile';
-import PreviewTile from './tiles/PreviewTile';
-
-interface Props {
-  projectId: string;
-  visibleTiles: TileId[];
-  subtitles?: Partial<Record<TileId, string>>;
-}
-
-const ANIM = { duration: 260 };
-const MIN_SCALE = 0.15;
-const MAX_SCALE = 4;
-
-const WorkspaceCanvas: React.FC<Props> = ({ projectId, visibleTiles, subtitles }) => {
-  const { width: vw, height: vh } = useWindowDimensions();
-  const [focusedTileId, setFocusedTileId] = useState<TileId | null>('chat');
-
-  const visibleKey = visibleTiles.join(',');
-  const bounds = useMemo(() => boundsOf(visibleTiles), [visibleKey]);
-  const worldW = bounds.w;
-  const worldH = bounds.h;
-  const { loaded: layoutLoaded, getFocus, saveFocus } = useWorkspaceLayout(projectId);
-
-  // Kamera (shared values fuer 60fps auf dem UI-Thread).
-  const scale = useSharedValue(1);
-  const tx = useSharedValue(0);
-  const ty = useSharedValue(0);
-  const savedScale = useSharedValue(1);
-  const savedTx = useSharedValue(0);
-  const savedTy = useSharedValue(0);
-
-  // Verschwindet die fokussierte Kachel aus der Sichtbarkeit → auf Chat zurueck.
-  useEffect(() => {
-    if (focusedTileId && !visibleTiles.includes(focusedTileId)) {
-      setFocusedTileId('chat');
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [visibleKey]);
-
-  // Zuletzt fokussierte Kachel pro Projekt wiederherstellen.
-  useEffect(() => {
-    if (!layoutLoaded) return;
-    const stored = getFocus();
-    if (stored === undefined) return;
-    if (stored === null || visibleTiles.includes(stored)) setFocusedTileId(stored);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [projectId, layoutLoaded, visibleKey]);
-
-  // Fokus-Wahl persistieren.
-  useEffect(() => {
-    if (layoutLoaded) saveFocus(focusedTileId);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [focusedTileId, layoutLoaded]);
-
-  // Kamera auf das Ziel fahren (Fokus-Rect oder Uebersicht).
-  useEffect(() => {
-    const cam: Camera = focusedTileId
-      ? focusCamera(toLocal(TILE_RECTS[focusedTileId], bounds), worldW, worldH, vw, vh)
-      : overviewCamera(worldW, worldH, vw, vh);
-    scale.value = withTiming(cam.scale, ANIM);
-    tx.value = withTiming(cam.tx, ANIM);
-    ty.value = withTiming(cam.ty, ANIM);
-    savedScale.value = cam.scale;
-    savedTx.value = cam.tx;
-    savedTy.value = cam.ty;
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [focusedTileId, visibleKey, vw, vh]);
-
-  // Hardware-Back: im Fokus → zurueck zur Uebersicht.
-  useEffect(() => {
-    const onBack = () => {
-      if (focusedTileId) {
-        setFocusedTileId(null);
-        return true;
-      }
-      return false;
-    };
-    const sub = BackHandler.addEventListener('hardwareBackPress', onBack);
-    return () => sub.remove();
-  }, [focusedTileId]);
-
-  // Gesten nur in der Uebersicht (Fokus-Modus: Touches fallen an die Kachel).
-  const gesturesEnabled = !focusedTileId;
-  const canvasGesture = useMemo(() => {
-    const pinch = Gesture.Pinch()
-      .enabled(gesturesEnabled)
-      .onUpdate((e) => {
-        'worklet';
-        scale.value = Math.max(MIN_SCALE, Math.min(MAX_SCALE, savedScale.value * e.scale));
-      })
-      .onEnd(() => {
-        'worklet';
-        savedScale.value = scale.value;
-      });
-    const pan = Gesture.Pan()
-      .enabled(gesturesEnabled)
-      .minPointers(2)
-      .onUpdate((e) => {
-        'worklet';
-        tx.value = savedTx.value + e.translationX;
-        ty.value = savedTy.value + e.translationY;
-      })
-      .onEnd(() => {
-        'worklet';
-        savedTx.value = tx.value;
-        savedTy.value = ty.value;
-      });
-    return Gesture.Simultaneous(pinch, pan);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [gesturesEnabled]);
-
-  const worldStyle = useAnimatedStyle(() => ({
-    transform: [
-      { translateX: tx.value },
-      { translateY: ty.value },
-      { scale: scale.value },
-    ],
-  }));
-
-  const renderContent = (id: TileId) => {
-    switch (id) {
-      case 'chat': return <ChatTile />;
-      case 'editor': return <CodeEditorTile projectId={projectId} />;
-      case 'vnc': return <VncTile projectId={projectId} focused={focusedTileId === 'vnc'} />;
-      case 'preview': return <PreviewTile />;
-      default: return null;
-    }
-  };
-
-  return (
-    <View style={styles.root}>
-      {/* Ebene 1 — skalierte Landkarte mit Thumbnails */}
-      <View style={StyleSheet.absoluteFill} pointerEvents={focusedTileId ? 'none' : 'auto'}>
-        <GestureDetector gesture={canvasGesture}>
-          <Animated.View style={[styles.world, { width: worldW, height: worldH }, worldStyle]}>
-            {visibleTiles.map((id) => (
-              <Tile
-                key={id}
-                id={id}
-                rect={toLocal(TILE_RECTS[id], bounds)}
-                subtitle={subtitles?.[id]}
-                onFocus={setFocusedTileId}
-              />
-            ))}
-          </Animated.View>
-        </GestureDetector>
-      </View>
-
-      {/* Ebene 2 — Identity-Content, immer gemountet, nur fokussierte sichtbar */}
-      <View style={StyleSheet.absoluteFill} pointerEvents={focusedTileId ? 'box-none' : 'none'}>
-        {visibleTiles.map((id) => (
-          <View
-            key={id}
-            style={[StyleSheet.absoluteFill, { display: focusedTileId === id ? 'flex' : 'none' }]}
-          >
-            {renderContent(id)}
-          </View>
-        ))}
-      </View>
-
-      {/* Steuerung */}
-      {focusedTileId && (
-        <TouchableOpacity style={styles.overviewBtn} onPress={() => setFocusedTileId(null)} activeOpacity={0.8}>
-          <Text style={styles.overviewBtnText}>⤢ Übersicht</Text>
-        </TouchableOpacity>
-      )}
-      {!focusedTileId && (
-        <View style={styles.hintBar} pointerEvents="none">
-          <Text style={styles.hintText}>Kachel antippen zum Öffnen · 2 Finger: zoomen & schieben</Text>
-        </View>
-      )}
-    </View>
-  );
-};
-
-const styles = StyleSheet.create({
-  root: { flex: 1, backgroundColor: '#0D0D1A' },
-  world: { position: 'absolute', left: 0, top: 0 },
-  // Unten rechts (ueber der Chat-Eingabezeile) — weg von ChatScreens Kopf-Icons.
-  overviewBtn: {
-    position: 'absolute',
-    bottom: 88,
-    right: 14,
-    backgroundColor: 'rgba(18,18,42,0.92)',
-    borderColor: '#0096FF',
-    borderWidth: 1,
-    borderRadius: 18,
-    paddingHorizontal: 14,
-    paddingVertical: 8,
-    elevation: 4,
-  },
-  overviewBtnText: { color: '#0096FF', fontSize: 14, fontWeight: '700' },
-  hintBar: {
-    position: 'absolute',
-    bottom: 16,
-    left: 0,
-    right: 0,
-    alignItems: 'center',
-  },
-  hintText: {
-    color: '#9090B0',
-    fontSize: 12,
-    backgroundColor: 'rgba(18,18,42,0.85)',
-    paddingHorizontal: 12,
-    paddingVertical: 6,
-    borderRadius: 14,
-    overflow: 'hidden',
-  },
-});
-
-export default WorkspaceCanvas;

android/src/workspace/WorkspaceDeck.tsx

@@ -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;

android/src/workspace/WorkspaceDock.tsx

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

android/src/workspace/WorkspaceScreen.tsx

@@ -1,13 +1,11 @@
 /**
- * WorkspaceScreen — Screen-Wrapper fuer den Workspace-Canvas.
+ * WorkspaceScreen — Screen-Wrapper fuer die Workbench.
  *
- * Buendelt die Signale, die entscheiden welche Kacheln sichtbar sind:
- *  - projectFocus: aktives Projekt + dessen kind ('code'|'chat')
- *  - codeFile:     kam schon eine Code-Datei rein? (Live-Reveal des Editors)
- *  - desktop:      ist ein QEMU-Desktop verfuegbar? (Live-Reveal der VNC-Kachel)
+ * Kompakt-Modus → klassischer Vollbild-Chat (wie vor dem Umbau).
+ * Cockpit-Modus  → Workbench mit Taskleisten-Dock: Chat · Code · Desktop.
  *
- * Ersetzt den bisherigen Chat-Tab: die ChatScreen lebt als Kachel im Canvas,
- * bleibt aber genau eine Instanz.
+ * 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';
@@ -16,8 +14,10 @@ import codeFile from '../services/codeFile';
 import desktop from '../services/desktop';
 import viewMode, { ViewModeValue } from '../services/viewMode';
 import ChatScreen from '../screens/ChatScreen';
-import { TileId, visibleTilesFor } from './layout';
-import WorkspaceCanvas from './WorkspaceCanvas';
+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());
@@ -47,23 +47,18 @@ const WorkspaceScreen: React.FC = () => {
     return unsub;
   }, [pid, kind]);
 
-  const visibleTiles: TileId[] = useMemo(
-    () => visibleTilesFor({ kind, hasCode, hasDesktop }),
-    [kind, hasCode, hasDesktop],
-  );
-
-  const subtitles = useMemo(
-    () => ({ chat: pid ? projectFocus.getProjectName(pid) : 'Hauptchat' } as Partial<Record<TileId, string>>),
-    [pid, focus.projectNameById],
-  );
+  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: zoombarer Kachel-Desktop.
-  return <WorkspaceCanvas projectId={pid} visibleTiles={visibleTiles} subtitles={subtitles} />;
+  // Cockpit: Workbench mit Dock.
+  return <WorkspaceDeck projectId={pid} panels={COCKPIT_PANELS} badges={badges} />;
 };
 
 export default WorkspaceScreen;

android/src/workspace/assets/novncHtml.ts

@@ -76,10 +76,20 @@ export const NOVNC_HTML = `<!doctype html><html><head><meta charset="utf-8">
   };
 
   var msg=document.getElementById('msg');
-  // noVNC per ESM vom CDN laden.
+
+  // 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'}); });
@@ -88,6 +98,24 @@ export const NOVNC_HTML = `<!doctype html><html><head><meta charset="utf-8">
       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?)';

android/src/workspace/layout.ts

@@ -1,95 +1,14 @@
 /**
- * layout — Kachel-Geometrie + Kamera-Mathematik fuer den Workspace-Canvas.
- *
- * Welt-Koordinaten = Pixel bei Scale 1. Kacheln liegen auf einem festen 2x2-
- * Raster. Die "Welt-View" (Animated.View) ist exakt die Bounding-Box der gerade
- * sichtbaren Kacheln; Kinder werden relativ zu deren Ursprung positioniert.
- *
- * RN 0.73 kennt noch kein transformOrigin — Scale dreht um die View-MITTE.
- * Alle Kamera-Formeln rechnen deshalb mit Center-Origin:
- *   screen = center + scale*(p - center) + translate
- * wobei center = (worldW/2, worldH/2) (die Welt-View sitzt bei screen 0,0).
+ * layout — Panel-Definitionen der Workbench (Metadaten fuer das Dock).
  */
 
 export type TileId = 'chat' | 'editor' | 'vnc' | 'preview';
 
-export interface TileRect { x: number; y: number; w: number; h: number; }
-
-export interface TileDef { id: TileId; title: string; icon: string; }
-
-// Feste Kachelgroesse im Welt-Raster (Pixel bei Scale 1).
-const TILE_W = 1100;
-const TILE_H = 1500;
-const GAP = 140;
-
-/** Absolute Welt-Rects pro Kachel (2x2-Raster). */
-export const TILE_RECTS: Record<TileId, TileRect> = {
-  chat: { x: 0, y: 0, w: TILE_W, h: TILE_H },
-  editor: { x: TILE_W + GAP, y: 0, w: TILE_W, h: TILE_H },
-  vnc: { x: 0, y: TILE_H + GAP, w: TILE_W, h: TILE_H },
-  preview: { x: TILE_W + GAP, y: TILE_H + GAP, w: TILE_W, h: TILE_H },
-};
+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: 'Editor', icon: '📝' },
+  editor: { id: 'editor', title: 'Code', icon: '📝' },
   vnc: { id: 'vnc', title: 'Desktop', icon: '🖥️' },
   preview: { id: 'preview', title: 'Vorschau', icon: '🖼️' },
 };
-
-// Reihenfolge fuer stabiles Rendering.
-export const TILE_ORDER: TileId[] = ['chat', 'editor', 'vnc', 'preview'];
-
-export interface VisibilitySignals {
-  kind: 'code' | 'chat';
-  hasCode: boolean; // schon ein code_file empfangen
-  hasDesktop: boolean; // Desktop verfuegbar gemeldet
-}
-
-/** Welche Kacheln sind fuer den aktuellen Kontext sichtbar?
- *  Chat ist immer da; Code-Projekt (explizit ODER durch ein Live-Signal)
- *  blendet Editor/Desktop/Vorschau ein. */
-export function visibleTilesFor(sig: VisibilitySignals): TileId[] {
-  const isCode = sig.kind === 'code' || sig.hasCode || sig.hasDesktop;
-  if (!isCode) return ['chat'];
-  return ['chat', 'editor', 'vnc', 'preview'];
-}
-
-/** Bounding-Box mehrerer Kacheln. */
-export function boundsOf(ids: TileId[]): TileRect {
-  if (ids.length === 0) return { x: 0, y: 0, w: TILE_W, h: TILE_H };
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const id of ids) {
-    const r = TILE_RECTS[id];
-    minX = Math.min(minX, r.x);
-    minY = Math.min(minY, r.y);
-    maxX = Math.max(maxX, r.x + r.w);
-    maxY = Math.max(maxY, r.y + r.h);
-  }
-  return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
-}
-
-/** Rect in Welt-View-lokale Koordinaten (relativ zur Bounds-Ecke) umrechnen. */
-export function toLocal(rect: TileRect, bounds: TileRect): TileRect {
-  return { x: rect.x - bounds.x, y: rect.y - bounds.y, w: rect.w, h: rect.h };
-}
-
-export interface Camera { scale: number; tx: number; ty: number; }
-
-/** Kamera, die ein (lokales) Rect bildschirmfuellend zeigt (Fokus-Modus). */
-export function focusCamera(localRect: TileRect, worldW: number, worldH: number, vw: number, vh: number): Camera {
-  const s = Math.min(vw / localRect.w, vh / localRect.h);
-  const pcx = localRect.x + localRect.w / 2;
-  const pcy = localRect.y + localRect.h / 2;
-  const tx = vw / 2 - worldW / 2 - s * (pcx - worldW / 2);
-  const ty = vh / 2 - worldH / 2 - s * (pcy - worldH / 2);
-  return { scale: s, tx, ty };
-}
-
-/** Kamera, die die gesamte Welt zentriert einpasst (Uebersicht). */
-export function overviewCamera(worldW: number, worldH: number, vw: number, vh: number, pad = 0.86): Camera {
-  const s = Math.min(vw / worldW, vh / worldH) * pad;
-  const tx = vw / 2 - worldW / 2;
-  const ty = vh / 2 - worldH / 2;
-  return { scale: s, tx, ty };
-}

android/src/workspace/tiles/PreviewTile.tsx

@@ -1,40 +0,0 @@
-/**
- * PreviewTile — zeigt den letzten Screenshot/Vorschau-Frame eines Code-Projekts
- * (z. B. aria-vm screenshot). Fuellt sich, sobald ARIA ein Bild in den
- * Vorschau-Kanal legt; bis dahin ein ruhiger Platzhalter.
- *
- * (Screenshot-Anbindung folgt mit dem QEMU-Track; hier zunaechst die Kachel.)
- */
-
-import React from 'react';
-import { Image, StyleSheet, Text, View } from 'react-native';
-
-interface Props {
-  imageUri?: string;
-}
-
-const PreviewTile: React.FC<Props> = ({ imageUri }) => {
-  return (
-    <View style={styles.container}>
-      {imageUri ? (
-        <Image source={{ uri: imageUri }} style={styles.image} resizeMode="contain" />
-      ) : (
-        <>
-          <Text style={styles.icon}>🖼️</Text>
-          <Text style={styles.text}>Noch keine Vorschau</Text>
-          <Text style={styles.sub}>Screenshots der VM erscheinen hier.</Text>
-        </>
-      )}
-    </View>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: { flex: 1, backgroundColor: '#0D0D1A', alignItems: 'center', justifyContent: 'center' },
-  image: { width: '100%', height: '100%' },
-  icon: { fontSize: 64, marginBottom: 16 },
-  text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
-  sub: { color: '#9090B0', fontSize: 14, marginTop: 8 },
-});
-
-export default PreviewTile;

android/src/workspace/tiles/VncTile.tsx

@@ -1,15 +1,14 @@
 /**
  * VncTile — Live-Desktop der QEMU-VM (noVNC in einer WebView, RFB durch RVS).
  *
- * Nur im Fokus aktiv: dann wird die WebView gemountet, bei 'ready' der
- * RVS-VNC-Tunnel geoeffnet (desktop.openVnc). Server-Bytes (vnc_data) werden in
- * die WebView injiziert, RFB-Bytes der WebView (vnc_send) gehen als vnc_input
- * zurueck. Verlaesst man die Kachel, wird der Tunnel geschlossen (die VM laeuft
- * auf dem Host weiter).
+ * 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, View } from 'react-native';
+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';
@@ -24,23 +23,24 @@ const VncTile: React.FC<Props> = ({ projectId, focused }) => {
   const [status, setStatus] = useState<'idle' | 'connecting' | 'connected' | 'disconnected'>('idle');
   const unsubDataRef = useRef<null | (() => void)>(null);
 
-  // Aufraeumen: Tunnel zu + Daten-Abo weg.
   const teardown = useCallback(() => {
     if (unsubDataRef.current) { unsubDataRef.current(); unsubDataRef.current = null; }
     desktop.closeVnc();
   }, []);
 
-  // Fokus verloren / Unmount → Tunnel schliessen.
   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') {
-      // WebView + RFB bereit → Tunnel oeffnen und Server-Bytes einspeisen.
       setStatus('connecting');
       unsubDataRef.current = desktop.onVncData((b64) => {
         const js = `window.ariaVnc && window.ariaVnc.onData(${JSON.stringify(b64)}); true;`;
@@ -62,11 +62,12 @@ const VncTile: React.FC<Props> = ({ projectId, focused }) => {
       <View style={styles.placeholder}>
         <Text style={styles.icon}>🖥️</Text>
         <Text style={styles.text}>Desktop</Text>
-        <Text style={styles.sub}>Antippen zum Verbinden</Text>
+        <Text style={styles.sub}>Panel öffnen zum Verbinden</Text>
       </View>
     );
   }
 
+  const connected = status === 'connected';
   return (
     <View style={styles.container}>
       <WebView
@@ -79,8 +80,25 @@ const VncTile: React.FC<Props> = ({ projectId, focused }) => {
         domStorageEnabled
         mixedContentMode="always"
         androidLayerType="hardware"
+        keyboardDisplayRequiresUserAction={false}
       />
-      {status !== 'connected' && (
+
+      {/* 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' : ''}
@@ -98,7 +116,27 @@ const styles = StyleSheet.create({
   icon: { fontSize: 64, marginBottom: 16 },
   text: { color: '#FFFFFF', fontSize: 18, fontWeight: '700' },
   sub: { color: '#9090B0', fontSize: 14, marginTop: 8 },
-  overlay: { position: 'absolute', top: 10, left: 0, right: 0, alignItems: 'center' },
+  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' },
 });
 

aria-brain/agent.py

@@ -1045,12 +1045,15 @@ META_TOOLS = [
         "function": {
             "name": "project_summary",
             "description": (
-                "Schau in einen ANDEREN Chat rein und fass zusammen was dort zuletzt "
-                "passiert ist (letzte ~12 Turns). Funktioniert fuer jedes Projekt (per "
-                "Name, Fuzzy-Match) UND fuer den Hauptchat (name='Hauptchat'). Nutze es "
-                "IMMER wenn Stefan sagt 'hol dir die Infos aus Projekt X', 'schau mal in "
-                "den Hauptchat/in Projekt Y rein', 'was war zuletzt bei ...', 'hol mich "
-                "ab' — 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",
@@ -1515,7 +1518,7 @@ class Agent:
                         targs = {}
                     logger.info("[router] lokal Tool-Call: %s(%s)", tname,
                                 ", ".join(targs.keys()))
-                    tresult = self._dispatch_tool(tname, targs)
+                    tresult = self._dispatch_tool(tname, targs, active_project_id)
                     # Echter Skill (run_*) erfolgreich? Dann uebernimmt dieser
                     # Turn das speak-Flag des Skills (Steuerbefehl=stumm,
                     # Antwort-Skill=vorlesen). Letzter Skill gewinnt.
@@ -1807,7 +1810,7 @@ class Agent:
                     ))
                     # Tools ausfuehren + Ergebnis als role=tool zurueck
                     for tc in result.tool_calls:
-                        tool_result = self._dispatch_tool(tc["name"], tc["arguments"])
+                        tool_result = self._dispatch_tool(tc["name"], tc["arguments"], active_project_id)
                         # Steuerbefehl-Skill (run_*, speak=false) erfolgreich
                         # ausgefuehrt → Antwort nicht vorlesen (letzter Skill gewinnt).
                         _tn = tc.get("name") or ""
@@ -1895,10 +1898,52 @@ class Agent:
 
     # ── Tool-Dispatcher ───────────────────────────────────────
 
-    def _dispatch_tool(self, name: str, arguments: dict) -> str:
+    def _read_project_history(self, project_id: str, limit: int = 20) -> list:
+        """Liest die VOLLE Chat-Historie eines Projekts aus dem geteilten
+        chat_backup.jsonl (/shared/config, auch im Brain gemountet).
+
+        Noetig, weil das rollende Conversation-Window nur die letzten ~50 Turns
+        ueber ALLE Projekte haelt — aeltere/andere Projekt-Chats sind da laengst
+        rausdistilliert. Gibt die letzten `limit` (role, text)-Paare zurueck,
+        gefiltert auf project_id ('' = Hauptthread). Fuehrende Hint-Bloecke
+        ([Standort: ...]) in User-Turns werden entfernt."""
+        path = "/shared/config/chat_backup.jsonl"
+        out: list = []
+        try:
+            if not os.path.exists(path):
+                return []
+            with open(path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        o = json.loads(line)
+                    except Exception:
+                        continue
+                    role = o.get("role")
+                    text = o.get("text")
+                    if not role or text is None:
+                        continue
+                    # nur echte Gespraechs-Turns (keine skill/memory/system-Eintraege)
+                    if role not in ("user", "assistant", "aria"):
+                        continue
+                    if (o.get("project_id") or "") != (project_id or ""):
+                        continue
+                    if role == "user":
+                        text = _strip_leading_hint_blocks(text)
+                    out.append((role, text))
+        except Exception as exc:
+            logger.warning("project_summary: chat_backup lesen fehlgeschlagen: %s", exc)
+            return []
+        return out[-limit:]
+
+    def _dispatch_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
@@ -2566,23 +2611,29 @@ class Agent:
                 # aus einem Projekt heraus in den Hauptthread reinschauen kann.
                 if pname.lower() in {"hauptchat", "hauptthread", "haupt", "main",
                                      "mainchat", "haupt-chat", "hauptchat-thread"}:
-                    turns = [t for t in self.conversation.turns if not t.project_id]
+                    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')."
-                    turns = [t for t in self.conversation.turns if t.project_id == p["id"]]
+                    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"'{label}' hat im aktuellen Conversation-Window noch keine "
-                            f"Turns. {desc}")
-                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"'{label}' — {desc}.\nLetzte {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()
@@ -2602,13 +2653,18 @@ class Agent:
                 kind = (arguments.get("kind") or "").strip().lower()
                 if kind not in ("code", "chat"):
                     return "FEHLER: kind muss 'code' oder 'chat' sein."
-                active_id = projects_mod.get_active()
+                # 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 — Du bist im Hauptthread. Erst ein Projekt "
-                            "anlegen/betreten (project_create/project_enter), dann set_project_kind.")
+                    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: aktives Projekt '{active_id}' nicht gefunden."
+                    return f"FEHLER: Projekt '{active_id}' nicht gefunden."
                 self._pending_events.append({
                     "type": "project_changed",
                     "project": updated,

bridge/aria_bridge.py

@@ -2007,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),
@@ -3618,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: