docs: README + issue.md auf die neue Brain-Architektur

README.md
  - Architektur-Diagramm: aria-core (OpenClaw) raus, qdrant + brain rein
  - Tabelle der Deployments aktualisiert
  - .env-Beschreibung: minimal, nur Tokens + RVS, Rest lebt in
    runtime.json (gepflegt ueber Diagnostic)
  - aria-setup.sh-Beschreibung: nur noch SSH-Key-Setup
  - Datenverzeichnis-Baum: brain/qdrant + brain/data + brain-import
  - Docker-Volumes-Tabelle neu (Bind-Mounts statt named Volumes)
  - Diagnostic-Tabs (Main, Gehirn, Dateien, Einstellungen) ersetzen
    die alte Feature-Liste
  - Backup/Reset-Sektion: drei Wiederherstellungswege (brain-import
    Migration, Bootstrap-Snapshot, komplettes Gehirn)
  - Container-Restart statt doctor/aria-restart
  - docker-Befehle: brain/qdrant statt aria-core
  - Phase A erledigt-Liste + Phase B Status (Punkte 1-4 erledigt:
    Brain-Skeleton, Migration, Conversation-Loop, Skills-System)

issue.md
  - "Brain (Phase B)"-Sektion ganz oben unter Offen
  - 9 erledigte Refactor-Punkte abgehakt
  - Aria-core-spezifische TODOs entfernt (Compact-Auto, Session-Reset,
    alle-.env-via-Diagnostic war eh schon erledigt)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

README.md

@@ -57,38 +57,44 @@ ARIA hat zwei Rollen:
 │  ┌─────────────────────────────────────────────────┐    │
 │  │  [proxy]    claude-max-api-proxy Container        │    │
 │  │             Claude Max Sub → lokale API           │    │
-│  │             Port 3456, mit sed-Patches fuer       │    │
-│  │             Tool-Permissions + Host-Binding       │    │
 │  │                                                   │    │
-│  │  [aria]     OpenClaw Container (aria-core)        │    │
-│  │             Gateway, Sessions, Memory, Skills     │    │
-│  │             Liest BOOTSTRAP.md + AGENT.md         │    │
+│  │  [qdrant]   Vector-DB fuer ARIAs Gedaechtnis     │    │
+│  │             Bind-Mount: aria-data/brain/qdrant/  │    │
+│  │                                                   │    │
+│  │  [brain]    ARIA Agent + Memory Container         │    │
+│  │             FastAPI auf Port 8080                 │    │
+│  │             Eigener Agent-Loop, Skills,           │    │
+│  │             Vector-Memory, SSH-Zugriff zur VM     │    │
+│  │             Bind-Mount: aria-data/brain/data/    │    │
 │  │                                                   │    │
 │  │  [bridge]   ARIA Voice Bridge Container           │    │
-│  │             Wake-Word (lokales Mikro auf VM)       │    │
-│  │             STT primaer remote (Gamebox-Whisper)   │    │
-│  │             Fallback: lokales faster-whisper (CPU) │    │
-│  │             TTS via F5-TTS auf Gamebox             │    │
-│  │             Bruecke: App <> RVS <> Bridge <> ARIA │    │
+│  │             Wake-Word, STT, TTS-Forwarding        │    │
+│  │             Spricht mit Brain via HTTP/8080       │    │
 │  │                                                   │    │
 │  │  [diagnostic] Selbstcheck-UI + Einstellungen      │    │
-│  │               Gateway + RVS + Proxy Status        │    │
-│  │               Chat, Sessions, Login, Logs         │    │
+│  │               Port 3001 (im Netzwerk der Bridge)  │    │
+│  │               Chat, Gehirn, Dateien, Logs         │    │
 │  └──────────────────┬──────────────────────────────┘    │
 │                     │ Volume Mount                       │
 │                     ▼                                    │
 │  ┌─────────────────────────────────────────────────┐    │
-│  │  ./aria-data/  — Ein tar = vollstaendiges Backup  │    │
+│  │  ./aria-data/  — Konfiguration + SSH-Keys         │    │
+│  │  ./aria-data/brain/ — Vector-DB + Skills (gitignored)│
+│  │  Backup via Diagnostic → "Gehirn-Export" (tar.gz) │    │
 │  └─────────────────────────────────────────────────┘    │
 └─────────────────────────────────────────────────────────┘
 ```
 
+> OpenClaw (frueher `aria-core`) ist abgerissen — ARIA laeuft jetzt mit eigenem Agent-Framework im
+> `aria-brain` Container. Eigene Tools, Skills, Vector-Memory statt Sessions. Letzter OpenClaw-Stand
+> ist als Git-Tag `v0.1.2.0` archiviert.
+
 **Vier separate Deployments:**
 
 | Was | Wo | Wie |
 |-----|----|-----|
 | RVS | Rechenzentrum | `cd rvs && docker compose up -d` |
-| ARIA Core | Debian 13 VM | `docker compose up -d && ./aria-setup.sh` |
+| ARIA Brain/Bridge/Diagnostic | Debian 13 VM | `./init.sh && ./aria-setup.sh && docker compose up -d` |
 | Gamebox-Stack (F5-TTS + Whisper) | Gamebox (GPU) | `cd xtts && docker compose up -d` |
 | Android App | Stefans Handy | APK installieren (Auto-Update via RVS) |
 
@@ -119,8 +125,7 @@ bash init.sh    # legt USER.md aus Vorlage an (idempotent, schadet nicht)
 
 `.env` Datei editieren (Details siehe `.env.example`):
 ```bash
-# Gateway-Auth: Alle Services die mit aria-core reden brauchen diesen Token
-# Diagnostic, Bridge, App nutzen ihn fuer den WebSocket-Handshake
+# Auth-Token: Alle ARIA-Services nutzen ihn fuer interne Auth
 ARIA_AUTH_TOKEN=        # openssl rand -hex 32
 
 # RVS-Verbindung: Hostname + Port deines Rendezvous-Servers
@@ -129,17 +134,18 @@ RVS_PORT=443
 RVS_TLS=true
 RVS_TLS_FALLBACK=true
 
-# Pairing-Token: Verbindet App, Bridge, Diagnostic und XTTS im gleichen RVS-Room
+# Pairing-Token: Verbindet App, Bridge, Diagnostic und Gamebox im gleichen RVS-Room
 # MUSS auf allen Geraeten identisch sein (ARIA-VM, Gaming-PC, App)
-# Wird von generate-token.sh automatisch generiert und eingetragen
 RVS_TOKEN=              # ./generate-token.sh
-
-# Optional: SSH-Host des RVS-Servers fuer Auto-Update (z.B. root@aria-rvs)
-RVS_UPDATE_HOST=
 ```
 
+Alle anderen Einstellungen (Stimmen, Modi, Wake-Word, F5-TTS-Tuning) leben in
+`/shared/config/runtime.json` und werden ueber die Diagnostic-UI gepflegt — nicht
+in der `.env`. Komplett-Reset jederzeit moeglich via "🗑 ALLES löschen" im
+Diagnostic-Einstellungen-Tab.
+
 **Zwei Tokens, zwei Zwecke:**
-- **ARIA_AUTH_TOKEN**: Authentifizierung am OpenClaw Gateway (aria-core). Wer diesen Token hat, kann ARIA Befehle geben.
+- **ARIA_AUTH_TOKEN**: Interner Auth-Token zwischen ARIAs Containern.
 - **RVS_TOKEN**: Pairing-Token fuer den Rendezvous-Server. Alle Geraete mit dem gleichen Token landen im gleichen "Room" und koennen kommunizieren. Die App bekommt diesen Token per QR-Code.
 
 ### 2. Claude CLI einloggen (Proxy-Auth)
@@ -157,48 +163,24 @@ claude login
 **Wichtig:** Der Ordner `~/.claude/` (nicht `~/.config/claude/`!) wird als Volume
 in den Proxy gemountet. Die Credentials ueberleben Container-Restarts.
 
-### 3. Voice Bridge konfigurieren
+### 3. SSH-Key fuer aria-wohnung generieren + RVS-Token + Container
 
 ```bash
-cp aria-data/config/aria.env.example aria-data/config/aria.env
-# Bei Bedarf anpassen (Whisper-Modell als Fallback, Sprache, Wake-Word)
-```
+# SSH-Key fuer den Zugriff von ARIA auf die VM (aria-wohnung)
+./aria-setup.sh
 
-STT laeuft primaer auf der Gamebox (faster-whisper auf GPU), TTS ausschliesslich
-ueber F5-TTS auf der Gamebox — siehe Abschnitt "Gamebox-Stack — F5-TTS + Whisper"
-weiter unten.
-
-### 5. RVS-Token generieren & Container starten
-
-```bash
-# Token generieren — schreibt RVS_TOKEN in .env, zeigt QR-Code
+# RVS-Token generieren — schreibt RVS_TOKEN in .env, zeigt QR-Code
 ./generate-token.sh
 
 # Alle Container starten
 docker compose up -d
 ```
 
-### 6. ARIA Setup ausfuehren (einmalig!)
+`aria-setup.sh` generiert den ed25519-Key in `aria-data/ssh/` und traegt den
+Public-Key in `/root/.ssh/authorized_keys` ein (Script laeuft als root auf der VM
+aria-wohnung). Brain + Proxy nutzen den gleichen Key.
 
-```bash
-./aria-setup.sh
-```
-
-Dieses Script ist **essentiell** — es macht:
-1. Wartet bis aria-core laeuft
-2. Fixt Volume-Permissions (Docker → node User)
-3. Schreibt `openclaw.json` (Proxy-Provider, Model-Config, Timeout 900s)
-4. Setzt exec-approvals Wildcard (Tool-Ausfuehrung im headless-Modus)
-5. Generiert SSH-Key fuer VM-Zugriff (`aria-data/ssh/`)
-6. Fixt SSH-Permissions im Container
-7. Startet aria-core neu
-
-**SSH-Key auf der VM eintragen** (wird vom Script angezeigt):
-```bash
-cat ~/ARIA-AGENT/aria-data/ssh/id_ed25519.pub >> /root/.ssh/authorized_keys
-```
-
-### 7. App verbinden
+### 4. App verbinden
 
 App oeffnen → QR-Code scannen → "ARIA, hoerst du mich?"
 
@@ -206,20 +188,19 @@ Der QR-Code enthaelt: Host, Port, Token, TLS-Flag — einmal scannen, nie wieder
 
 Bestehendes Token nochmal als QR anzeigen: `./generate-token.sh show`
 
-### 8. Diagnostic pruefen
+### 5. Diagnostic pruefen
 
 ```bash
 # Im Browser:
 http://<VM-IP>:3001
 ```
 
-Die Diagnostic-UI zeigt:
-- Gateway-Verbindung (gruener Punkt = OK)
-- RVS-Verbindung
-- Proxy-Status + Claude Login
-- Chat-Test (direkt an ARIA schreiben)
-- Session-Verwaltung
-- Container-Logs
+Die Diagnostic-UI hat vier Top-Tabs:
+
+- **Main** — Live-Chat-Test, Status (Brain / RVS / Proxy), End-to-End-Trace
+- **Gehirn** — Memory-Verwaltung (Vector-DB), Skills, Export/Import des kompletten Gehirns als tar.gz
+- **Dateien** — alle Dateien aus `/shared/uploads/` (von ARIA generiert oder hochgeladen) mit Download/Delete
+- **Einstellungen** — Reparatur (Container-Restart), Wipe, Sprachausgabe, Whisper, Runtime-Config, App-Onboarding (QR), Komplett-Reset
 
 ---
 
@@ -227,7 +208,7 @@ Die Diagnostic-UI zeigt:
 
 Der Proxy ist das Herzsttueck: Er macht aus der Claude Max Subscription eine lokale API.
 
-**Ablauf:** `OpenClaw (aria-core) → HTTP → claude-max-api-proxy → Claude Code CLI (--print) → Anthropic API`
+**Ablauf:** `aria-brain → HTTP → claude-max-api-proxy → Claude Code CLI (--print) → Anthropic API`
 
 Der Proxy-Container (`node:22-alpine`) installiert bei jedem Start:
 - `@anthropic-ai/claude-code` — Claude Code CLI
@@ -248,52 +229,34 @@ Danach werden per `sed` vier Patches angewendet:
 
 ## Konfigurationsdateien
 
-### aria-data/config/
+### aria-data/
 
-| Datei | Zweck | Gemountet als |
-|-------|-------|---------------|
-| `BOOTSTRAP.md` | ARIAs System-Prompt: Identitaet, Sicherheitsregeln, Tool-Freigaben, Infrastruktur | `BOOTSTRAP.md` + `CLAUDE.md` im Workspace |
-| `AGENT.md` | ARIAs Persoenlichkeit, Tool-Freigaben, Arbeitsprinzipien | `AGENT.md` im Workspace |
-| `USER.md` | Stefans Praeferenzen, Kommunikationsstil | `USER.md` im Workspace |
-| `openclaw.env` | OpenClaw Container-Environment | `.env` im Workspace |
-| `aria.env` | Voice Bridge Konfiguration (Whisper, Stimmen) | `/config/aria.env` in Bridge |
+| Pfad | Zweck |
+|------|-------|
+| `.env` | Tokens (ARIA_AUTH_TOKEN, RVS_TOKEN, RVS_HOST) — minimal, alles andere lebt in der DB |
+| `aria-data/ssh/` | SSH-Key fuer den Zugriff auf aria-wohnung (Brain + Proxy teilen den Key) |
+| `aria-data/brain/qdrant/` | Vector-DB-Storage (Bind-Mount, gitignored) |
+| `aria-data/brain/data/` | Skills, Embedding-Modell-Cache (Bind-Mount, gitignored) |
+| `aria-data/brain-import/` | `AGENT.md`, `USER.md.example`, `TOOLING.md.example` — Quelle fuer den initialen Memory-Import in die Vector-DB |
+| `aria-data/config/diag-state/` | Diagnostic State (z.B. zuletzt aktive Session) |
 
-**BOOTSTRAP.md** ist die wichtigste Datei — sie definiert:
-- Wer ARIA ist (Name, Rolle, Persoenlichkeit)
-- Sicherheitsregeln (kein ClawHub, Prompt Injection abwehren)
-- Tool-Freigaben (alle Claude Code Tools: WebFetch, Bash, etc.)
-- SSH-Zugriff auf aria-wohnung (VM)
-- Gedaechtnis-System
+### /shared/config/ (im aria-shared Volume)
 
-### openclaw.json (via aria-setup.sh)
+| Datei | Zweck |
+|-------|-------|
+| `voice_config.json` | TTS-Engine, geclonte Stimme, Whisper-Modell, F5-TTS-Tuning |
+| `runtime.json` | Token + RVS-Override + Whisper-Sprache (durch Diagnostic gepflegt) |
+| `highlight_triggers.json` | Highlight-Trigger-Woerter |
+| `chat_backup.jsonl` | Append-only Chat-Log (Quelle fuer die Chat-History in Diagnostic) |
 
-Wird von `aria-setup.sh` in den Container geschrieben:
-```json
-{
-  "agents": {
-    "defaults": {
-      "model": { "primary": "proxy/claude-sonnet-4" },
-      "timeoutSeconds": 900,
-      "maxConcurrent": 4
-    }
-  },
-  "models": {
-    "providers": {
-      "proxy": {
-        "api": "openai-completions",
-        "baseUrl": "http://proxy:3456/v1",
-        "apiKey": "not-needed"
-      }
-    }
-  },
-  "tools": { "profile": "full" },
-  "messages": { "ackReactionScope": "all" }
-}
-```
+`voice_config.json` + `highlight_triggers.json` lassen sich via Diagnostic →
+"Sprachausgabe" als Bundle exportieren/importieren.
 
-**timeoutSeconds: 900** (15 Min) — notwendig weil jede Anfrage einen neuen
-`claude --print` Prozess spawnt (Cold Start). Bei Tool-Nutzung (WebFetch, Bash)
-braucht ARIA mehrere API-Roundtrips.
+### Backup / Reset
+
+- **Gehirn-Backup**: Diagnostic → Gehirn → "⬇ Export herunterladen" — komplettes Brain (Memories + Skills + Qdrant-DB) als `.tar.gz`
+- **Stimmen-Backup**: pro Stimme ein `.tar.gz` (Diagnostic → Sprachausgabe → ⬇ pro Stimme); Import via Upload-Button
+- **Komplett-Reset**: Diagnostic → Einstellungen → "🗑 ALLES löschen" — Memory + Stimmen + Settings weg; `.env` + SSH-Keys bleiben
 
 ---
 
@@ -304,14 +267,14 @@ auf der Gamebox.
 
 **Nachrichtenfluss:**
 ```
-Text:   App → RVS → Bridge → chat.send → aria-core
+Text:   App → RVS → Bridge → aria-brain (HTTP)
 Audio:  App → RVS → Bridge → stt_request (RVS) → whisper-bridge (Gamebox)
-                          → stt_response → Bridge → chat.send → aria-core
+                          → stt_response → Bridge → aria-brain
         Fallback bei Timeout: lokales faster-whisper (CPU)
-Datei:  App → RVS → Bridge → /shared/uploads/ → chat.send (mit Pfad) → aria-core
+Datei:  App → RVS → Bridge → /shared/uploads/ → aria-brain (mit Pfad)
 
-aria-core → Antwort → Gateway → Diagnostic → RVS → App
-                              → Bridge → xtts_request (RVS) → f5tts-bridge
+aria-brain → Antwort → Bridge → RVS → App
+                              → xtts_request (RVS) → f5tts-bridge
                               → audio_pcm Stream → RVS → App AudioTrack
 ```
 
@@ -343,34 +306,23 @@ aria-core → Antwort → Gateway → Diagnostic → RVS → App
 
 ## Diagnostic — Selbstcheck-UI und Einstellungen
 
-Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit aria-core.
+Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 
-### Features
+### Tabs
 
-- **Status-Karten**: Gateway (Handshake), RVS (TLS-Fallback), Proxy (Auth)
-- **Disk-Voll Banner**: Rotes Overlay wenn die VM-Disk knapp wird, mit copy-baren Cleanup-Befehlen (safe + aggressiv)
-- **Chat-Test**: Nachrichten direkt an ARIA senden (Gateway oder via RVS), Vollbild-Modus
-- **"ARIA denkt..." Indikator**: Zeigt live was ARIA gerade tut (Denken, Tool, Schreiben)
-- **Abbrechen-Button**: Stoppt laufende Anfragen + doctor --fix
-- **Session-Verwaltung**: Sessions auflisten, wechseln, erstellen, loeschen, als Markdown exportieren (⬇ Button)
-- **Chat-History**: Wird beim Laden und Session-Wechsel angezeigt (read-only aus JSONL)
-- **TTS-Diagnose Tab**: Stimmen testen, Status pruefen, Fehler anzeigen
-- **Einstellungen**: TTS aktiv-Toggle, F5-TTS-Voice (gecloned), Betriebsmodi, Whisper-Modell (tiny…large-v3, Hot-Reload auf der Gamebox)
-- **Voice-Status**: Beim Wechsel der globalen Stimme zeigt ein Status-Text "Lade…" → "bereit (X.Ys)" — getriggert ueber `voice_preload`/`voice_ready`
-- **Voice Cloning**: Audio-Samples hochladen, Referenz-Text wird automatisch via Whisper transkribiert
+- **Main**: Brain/RVS/Proxy-Status, Chat-Test, "ARIA denkt..."-Indikator, End-to-End-Trace, Container-Logs
+- **Gehirn**: Memory-Browser (Vector-DB), Suche + Filter, Edit/Add/Delete, Gehirn-Export/Import (tar.gz), Skills (geplant)
+- **Dateien**: Browser fuer `/shared/uploads/` — von ARIA generierte oder hochgeladene Dateien herunterladen oder loeschen (Live-Update der Chat-Bubbles)
+- **Einstellungen**: Reparatur (Container-Restart fuer Brain/Bridge/Qdrant), Komplett-Reset, Betriebsmodi, Sprachausgabe + Voice-Cloning + F5-TTS-Tuning, Whisper, Onboarding-QR, App-Cleanup
+
+### Was zusaetzlich noch drin steckt
+
+- **Disk-Voll Banner** mit copy-baren Cleanup-Befehlen (safe + aggressiv)
+- **Voice Cloning**: Audio-Samples hochladen, Whisper transkribiert den Ref-Text automatisch
+- **Voice Export/Import**: einzelne Stimmen als `.tar.gz` zwischen Gameboxen mitnehmen
+- **Settings Export/Import**: `voice_config.json` + `highlight_triggers.json` als JSON-Bundle
 - **Claude Login**: Browser-Terminal zum Einloggen in den Proxy
-- **Core Terminal**: Shell in aria-core (openclaw CLI)
-- **Container-Logs**: Echtzeit-Logs aller Container (gefiltert nach Tab + Pipeline)
-- **SSH Terminal**: Direkter SSH-Zugang zu aria-wohnung
-- **Watchdog**: Erkennt stuck Runs (2min Warnung → 5min doctor --fix → 8min Container-Restart)
-
-### Session-Verwaltung
-
-Die in der Diagnostic gewaehlte Session gilt **global** — Bridge und App nutzen
-dieselbe Session. Die aktive Session wird unter `/data/active-session` persistiert
-und ueberlebt Container-Restarts.
-
-API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
+- **SSH Terminal**: direkter SSH-Zugang zu aria-wohnung
 
 ---
 
@@ -404,10 +356,7 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 - QR-Code Scanner fuer Token-Pairing
 - **ARIA-Dateien empfangen**: Wenn ARIA eine PDF/Bild/Markdown/ZIP fuer dich erstellt (Marker `[FILE: /shared/uploads/aria_*]` in der Antwort), erscheint sie als eigene Anhang-Bubble. Tippen → wird via RVS geladen + mit Android-Intent-Picker geoeffnet (PDF-Viewer, Bildbetrachter, Standard-App). Inline-Bilder aus Markdown-`![alt](url)`-Syntax werden direkt unter dem Text gerendert (PNG/JPG via Image, SVG via react-native-svg)
 - **Vollbild mit Pinch-Zoom**: Bilder im Vollbild-Modal sind pinch-zoombar (1x..5x), 1-Finger-Pan wenn gezoomt, Doppel-Tap toggelt 1x↔2.5x — alles ohne externe Lib
-- **ARIA-Reparatur-Buttons** (Settings → Reparatur und in der "ARIA denkt"-Bubble):
-  - 🔧 *Reparieren* → `openclaw doctor --fix` (stuck Runs aufloesen)
-  - 🚨 *Hart neu starten* → Container-Restart via Docker-API (15s Downtime)
-  - 🧹 *Konversation komprimieren* → Sessions weg + Restart (Auto-Trigger bei >140 Messages via `COMPACT_AFTER_MESSAGES`-Env in Bridge, schuetzt vor E2BIG-Crash)
+- **Container-Restart-Buttons** (Settings → Reparatur): aria-bridge / aria-brain / aria-qdrant gezielt neu starten (jeweils ~5s Downtime). Geht ueber RVS → Bridge → Diagnostic → Docker-Socket-API.
 - **Cache-Cleanup**: Beim App-Start werden orphane TTS-WAVs aus dem Cache geraeumt. Plus Settings-Buttons "TTS-Cache leeren", "Update-Cache leeren", "Anhang-Cache leeren"
 
 ### Wake-Word (openWakeWord, on-device)
@@ -516,9 +465,9 @@ Der Update-Flow:
 
 ```
 App (Mikrofon) → AAC/MP4 Aufnahme → Base64 → RVS → Bridge
-Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-core
+Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-brain
 Bridge: STT-Ergebnis → RVS → App (Placeholder wird durch transkribierten Text ersetzt)
-aria-core → Antwort → Bridge → F5-TTS (Gaming-PC) → PCM-Stream → RVS → App
+aria-brain → Antwort → Bridge → F5-TTS (Gaming-PC) → PCM-Stream → RVS → App
 App: AudioTrack MODE_STREAM (nahtlos), Cache als WAV pro Message
 ```
 
@@ -552,8 +501,8 @@ bleibt bis ARIA wirklich verstummt ist.
 
 ```
 App (Kamera/Dateimanager) → Base64 → RVS → Bridge
-Bridge: Speichert in /shared/uploads/ (Shared Volume, fuer aria-core sichtbar)
-Bridge: chat.send → "Stefan hat ein Bild geschickt: foto.jpg — liegt unter /shared/uploads/..."
+Bridge: Speichert in /shared/uploads/ (Shared Volume, fuer aria-brain sichtbar)
+Bridge: aria-brain → "Stefan hat ein Bild geschickt: foto.jpg — liegt unter /shared/uploads/..."
 ARIA: Kann Datei per Bash/Read-Tool oeffnen und analysieren
 ```
 
@@ -583,34 +532,34 @@ ist in den App-Einstellungen konfigurierbar.
 
 ## Datenverzeichnis — aria-data/
 
-Alles was ARIA weiss, kann und ist — liegt hier. Ein `tar` = vollstaendiges Backup.
-
 ```
 aria-data/
-├── brain/                          ← ARIAs Gedaechtnis (OpenClaw Memory)
-│   ├── MEMORY.md                   ← Langzeitgedaechtnis
-│   └── memory/                     ← Tageslogbuecher
+├── brain/                          ← ARIAs Gehirn — Bind-Mount, GITIGNORED
+│   ├── qdrant/                     ← Vector-DB Storage (Memories, Skills-Embeddings)
+│   └── data/                       ← Skills, Embedding-Modell-Cache
+│       └── skills/<name>/          ← Pro Skill ein Ordner mit Manifest, Code, venv
 │
-├── skills/                         ← ARIAs Faehigkeiten (selbst geschrieben!)
+├── brain-import/                   ← Quell-Dateien fuer den initialen Import in die DB
+│   ├── AGENT.md                    ← Persoenlichkeit (wird Memory-Punkte vom Typ identity/rule)
+│   ├── BOOTSTRAP.md
+│   ├── TOOLING.md.example
+│   └── USER.md.example
 │
 ├── config/
-│   ├── BOOTSTRAP.md                ← System-Prompt (Identitaet, Regeln, Tools)
-│   ├── AGENT.md                    ← Persoenlichkeit & Arbeitsprinzipien
-│   ├── USER.md                     ← Stefans Praeferenzen
-│   ├── openclaw.env                ← OpenClaw Environment
-│   ├── aria.env                    ← Voice Bridge Config
 │   └── diag-state/                 ← Diagnostic persistenter State
 │
-│   (im Shared Volume /shared/config/):
-│   ├── voice_config.json           ← TTS-Einstellungen (Stimme, Speed, F5-TTS-Tuning)
-│   └── chat_backup.jsonl           ← Nachrichten-Backup (on-the-fly)
-│
-└── ssh/                            ← SSH Keys fuer VM-Zugriff
-    ├── id_ed25519                  ← Private Key (generiert von aria-setup.sh)
-    ├── id_ed25519.pub              ← Public Key (muss in VM authorized_keys!)
-    └── config                      ← SSH Config (Host aria-wohnung)
+└── ssh/                            ← SSH Keys (Brain + Proxy teilen sich)
+    ├── id_ed25519
+    ├── id_ed25519.pub
+    └── config                      ← Host aria-wohnung
 ```
 
+`aria-data/brain/` (Vector-DB + Skills) ist gitignored — Backup laeuft ueber
+den Gehirn-Export-Button in der Diagnostic, nicht ueber Git.
+
+Settings im Shared Volume (`/shared/config/`): `voice_config.json`,
+`highlight_triggers.json`, `runtime.json`, `chat_backup.jsonl`.
+
 **Backup:**
 ```bash
 tar -czf aria-backup-$(date +%Y%m%d).tar.gz aria-data/
@@ -757,16 +706,15 @@ dem Cache wiederverwendet.
 
 ## Docker Volumes
 
-| Volume | Pfad im Container | Zweck |
-|--------|-------------------|-------|
-| `openclaw-config` | `/home/node/.openclaw` | OpenClaw Config, Sessions, Auth |
-| `claude-config` | `/home/node/.claude` | Claude Code Settings, Permissions |
-| `~/.claude` (bind) | `/root/.claude` (Proxy) | Claude CLI Credentials |
-| `./aria-data/ssh` (bind) | `/root/.ssh`, `/home/node/.ssh` | SSH Keys |
-| `./aria-data/brain` (bind) | `/home/node/.openclaw/workspace/memory` | Gedaechtnis |
-| `./aria-data/skills` (bind) | `/home/node/.openclaw/workspace/skills` | Skills |
-| `aria-shared` | `/shared` (Core + Bridge + Proxy + Diag) | Datei-Austausch, Config, Uploads |
-| `./aria-data/config/diag-state` (bind) | `/data` (Diagnostic) | Persistenter State (aktive Session) |
+| Volume / Bind | Pfad im Container | Zweck |
+|---------------|-------------------|-------|
+| `~/.claude` (bind) | `/root/.claude` (proxy) | Claude CLI Credentials |
+| `./aria-data/ssh` (bind) | `/root/.ssh` (proxy, brain) | SSH-Keys fuer aria-wohnung |
+| `./aria-data/brain/qdrant` (bind) | `/qdrant/storage` (qdrant) | Vector-DB Storage |
+| `./aria-data/brain/data` (bind) | `/data` (brain) | Skills + Embedding-Modell-Cache |
+| `./aria-data/brain` (bind) | `/brain` (diagnostic) | Brain-Export/Import-Endpoints |
+| `aria-shared` | `/shared` (brain, bridge, proxy, diagnostic) | Datei-Austausch, Config, Uploads |
+| `./aria-data/config/diag-state` (bind) | `/data` (diagnostic) | Diagnostic persistenter State |
 
 ---
 
@@ -795,22 +743,21 @@ docker compose down
 
 # Einzelnen Container neu bauen
 docker compose up -d --build diagnostic
-docker compose up -d --build bridge
+docker compose up -d --build bridge brain
 
 # Logs
-docker compose logs -f              # alle
-docker compose logs -f aria          # nur aria-core
-docker compose logs -f proxy         # nur proxy
+docker compose logs -f               # alle
+docker compose logs -f brain         # nur Agent + Memory
+docker compose logs -f qdrant        # nur Vector-DB
+docker compose logs -f bridge        # nur Voice-Bridge
+docker compose logs -f proxy         # nur Claude-Proxy
 
-# Setup wiederholen (nach Config-Aenderungen)
-./aria-setup.sh
+# SSH-Test (Brain zu aria-wohnung)
+docker exec aria-brain ssh aria-wohnung hostname
 
-# SSH-Test
-docker exec aria-core ssh aria-wohnung hostname
-
-# Tool-Test
-# Neue Session in Diagnostic anlegen, dann:
-# "Wie wird das Wetter in Bremen?"
+# Brain-API direkt testen
+docker exec aria-brain curl localhost:8080/health
+docker exec aria-brain curl localhost:8080/memory/stats
 ```
 
 ---
@@ -892,6 +839,20 @@ docker exec aria-core ssh aria-wohnung hostname
 - [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
 
+### Phase A — Refactor: OpenClaw raus, eigenes Brain rein
+
+- [x] aria-brain Container-Skeleton (FastAPI, Qdrant, sentence-transformers)
+- [x] Diagnostic: Gehirn-Tab (Memory Search/Filter, Add/Edit/Delete)
+- [x] Diagnostic: Gehirn-Export/Import als tar.gz
+- [x] Diagnostic: Datei-Manager (Liste, Suche, Download, Delete mit Live-Bubble-Update)
+- [x] App: Datei-Manager als Modal in den Einstellungen
+- [x] Diagnostic: Komplett-Reset (Wipe All)
+- [x] Voice Export/Import (einzelne Stimmen + F5/Whisper-Settings als Bundle)
+- [x] aria-core (OpenClaw) komplett abgerissen — Tag `v0.1.2.0` als Archiv
+- [ ] **Phase B Punkt 2:** Migration `aria-data/brain-import/` → atomare Memory-Punkte
+- [ ] **Phase B Punkt 3:** Brain Conversation-Loop (Single-Chat + Rolling Window + Memory-Destillat)
+- [ ] **Phase B Punkt 4:** Skills-System (Manifest, venv, README pro Skill, Diagnostic-Tab)
+
 ### Phase 2 — ARIA wird produktiv
 
 - [ ] Skills bauen (Bildgenerierung, etc.)
@@ -899,7 +860,6 @@ docker exec aria-core ssh aria-wohnung hostname
 - [ ] VM einrichten (Desktop, Browser, Tools)
 - [ ] Heartbeat (periodische Selbst-Checks)
 - [ ] Lokales LLM als Waechter (Triage vor Claude-Call)
-- [ ] Auto-Compacting / Memory-Verwaltung
 
 ### Phase 3 — Erweiterungen
 

issue.md

@@ -214,7 +214,20 @@ Wichtige Mechanismen:
 
 ## Offen
 
-### Bugs
+### Brain (Phase B — der grosse Refactor laeuft)
+
+- [x] aria-brain Container-Skeleton (FastAPI + Qdrant + sentence-transformers)
+- [x] Memory CRUD via Diagnostic-Gehirn-Tab (Add/Edit/Delete + Search + Filter)
+- [x] Gehirn-Export/Import als tar.gz (komplett: Memories + Skills + Qdrant)
+- [x] Voice-Bridge: aria-core-spezifische Logik raus (doctor_fix, aria_restart, aria_session_reset, compact_after)
+- [x] aria-core komplett aus docker-compose.yml raus, Watchdog raus
+- [x] Diagnostic: Wipe-All-Button (Memory + Stimmen + Settings)
+- [x] Voice Export/Import (Diagnostic + XTTS-Bridge auf Gaming-PC)
+- [x] F5/Whisper-Settings als JSON-Bundle Export/Import
+- [x] Datei-Manager (Diagnostic + App-Modal): /shared/uploads/ verwalten, Delete spiegelt sich live in den Chat-Bubbles
+- [ ] **Phase B Punkt 2:** Migration `aria-data/brain-import/` → atomare Memory-Punkte (Identity / Rules / Preferences / Tools)
+- [ ] **Phase B Punkt 3:** Brain Conversation-Loop (Single-Chat UI + Rolling Window + Memory-Destillat)
+- [ ] **Phase B Punkt 4:** Skills-System (Manifest, venv/local-bin, README pro Skill, Diagnostic-Skills-Tab, Export/Import)
 
 ### App Features
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
@@ -222,9 +235,6 @@ Wichtige Mechanismen:
 
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
-- [ ] Auto-Compacting und Memory/Brain Verwaltung (SQLite?)
 - [ ] Diagnostic: System-Info Tab (Container-Status, Disk, RAM, CPU)
 - [ ] RVS Zombie-Connections endgueltig loesen
-- [ ] Alle .env-Variablen ueber Diagnostic konfigurierbar machen (Fallback .env bleibt fuer initialen Bootstrap)
 - [ ] Gamebox: kleine Web-Oberflaeche fuer Credentials/Server-Config oder zentral aus Diagnostic per RVS push
-- [ ] Root-Cause OpenClaw Session-Reset: Herausfinden warum Sessions beim ersten chat.send nach Container-Restart verworfen werden