fix+docs: Bug-Fixes, vollstaendige Dokumentation v8

Bug-Fixes:
- hermes_agent.py: asyncio.get_event_loop() → get_running_loop() (Python 3.10+)
- routers/hermes.py: Thread-Lock fuer Whisper-Init, HERMES_WINDOWS_USER Import,
  Piper stderr logging, __import__ Anti-Pattern entfernt
- routers/memory.py: SQLite WAL-Mode, Kategorie-Enum-Validierung (user/instruction/stable/versioned/ephemeral)
- HermesPanel.svelte: findLast() → reverse().find() (Browser-Kompatibilitaet)
- ConnectPanel.svelte: Hardcoded Username durch Platzhalter ersetzt

Docs:
- CLAUDE.md: komplett aktualisiert (v7+v8, Hermes, Memory, alle Env-Vars)
- ROADMAP.md: v7+v8 als erledigt, naechste Features (v8.1-v9.1)
- README.md: komplett neu geschrieben (Agentic OS Konzept, alle Features)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

CLAUDE.md

@@ -1,127 +1,123 @@
 # Mission Control
 
 Web-Dashboard zur Verwaltung eines **lokalen LLM-Stacks (`llama-swap`)** auf dem Bosgame M5.
-FastAPI-Backend + Vanilla-JS-Dashboard. **Leitprinzip: KISS — kein Build-Schritt, kein Frontend-Framework, keine Datenbank.** Concerns sind getrennt (SoC) — aber *ohne* Build: native ES-Module im Frontend, FastAPI-`APIRouter` im Backend.
+FastAPI-Backend + Svelte 5-Frontend (Vite-Build). **Leitprinzip: KISS — SoC ohne Overhead.**
 
 ## Architektur
 
 **Backend** (Top-Level-Helfer + ein Router je Bereich):
-- **`app.py`** — dünner Einstieg: `FastAPI`, hängt die Router ein, liefert das statische UI aus, Exception-Handler + eine `Cache-Control: no-cache`-Middleware für `/` und `/static` (UI wirkt sofort nach rsync, kein Stale-JS im Browser).
+- **`app.py`** — dünner Einstieg: `FastAPI`, hängt die Router ein, liefert das statische UI aus, Exception-Handler + `Cache-Control: no-cache`-Middleware.
 - **`config.py`** — alle Env-Vars + die gemeinsame `ruamel.yaml`-Instanz. Auch `SOURCE_DIR`/`PROD_DIR` fürs Self-Update.
-- **`auth.py`** — optionale Token-Auth: Header `X-MC-Token` **oder** Query `?token=` (Query ist Pflicht für WebSockets, da Browser dort keine Header senden).
-- **`jobengine.py`** — In-Memory-Job-System (Threads + Subprocess) mit Live-Log. `start_job(..., stdin_data=, log_cmd=)`: Secrets (sudo-PW) gehen über **stdin**, die Log-Zeile wird sanitisiert (kein Passwort im Log/`ps`).
-- **`llamaswap.py`** — spricht `llama-swap` an (`/running`, `/v1/models`, unload) und liest/schreibt dessen `config.yaml` per `ruamel.yaml` (Kommentare bleiben erhalten).
-- **`hw_math.py`** — Odysseus-Fit-Mathe: VRAM/RAM-Bedarf, tps-Schätzung, **`max_ctx_for`** (optimaler Kontext aus Hardware), `extract_params_b`. Genutzt von cookbook + models.
-- **`recipes.py`** — kuratierte Use-Case-Stacks (Daten, kein Code) fürs Cookbook 2.0.
-- **`routers/*.py`** — ein Router je Bereich: `models.py` (`status` mit Meta/Caps/**optimal_ctx**, `download`, `register`, `update_model`, `unload`, `chat`), `jobs.py` (`jobs`), `maintenance.py` (`update` = **llama.cpp**, `self-update` = **MC selbst**, `os-update`, `service/{name}/restart`, `reboot`, `logs`-WebSocket), `system.py` (`status` + `stream`-WebSocket, Live-Metriken via psutil/sysfs), `cookbook.py` (`analyze`/`evaluate`/`recipes`/`install-recipe`), `integration.py` (`test` — Engine-Verbindung), `news.py` (`news` — RSS-Aggregation via stdlib). Alle unter `/api/*`.
+- **`auth.py`** — optionale Token-Auth: Header `X-MC-Token` **oder** Query `?token=` (Query ist Pflicht für WebSockets).
+- **`jobengine.py`** — In-Memory-Job-System (Threads + Subprocess) mit Live-Log. Secrets gehen über **stdin** (kein Leak in Log/`ps`).
+- **`llamaswap.py`** — spricht `llama-swap` an und liest/schreibt dessen `config.yaml` per `ruamel.yaml`.
+- **`hw_math.py`** — Odysseus-Fit-Mathe: VRAM/RAM-Bedarf, tps-Schätzung, `max_ctx_for`, `extract_params_b`.
+- **`recipes.py`** — kuratierte Use-Case-Stacks fürs Cookbook 2.0.
+- **`hermes_agent.py`** — Kern des Hermes-Agenten: Tool-Definitionen, Tool-Dispatcher, LLM-Loop (ReAct), Modell-Routing.
+- **`mcp_memory.py`** — stdio-MCP-Server: Gedächtnis-Tools für Cline/OpenCode/Claude Code.
+- **`routers/*.py`** — ein Router je Bereich:
+  - `models.py` — status/download/register/update_model/unload/chat
+  - `jobs.py` — Jobs-Liste
+  - `maintenance.py` — update/self-update/os-update/service-restart/reboot/logs-WebSocket
+  - `system.py` — status + stream-WebSocket (Live-Metriken psutil/sysfs)
+  - `cookbook.py` — analyze/evaluate/recipes/install-recipe/upgrades
+  - `integration.py` — test (Engine-Verbindungstest)
+  - `news.py` — RSS-Aggregation via stdlib
+  - `memory.py` — Gedächtnis-CRUD (SQLite, WAL-Mode), 5 Kategorien
+  - `hermes.py` — Chat-WebSocket/transcribe(Whisper)/tts(Piper)/status/pubkey
 
-**Frontend** (`static/`, dünne Hülle + ES-Module, kein Build):
-- **`index.html`** — nur Gerüst: Sidebar-Nav, Topbar, Alert-Banner, ein `.view`-Container je Bereich (Hash-Routing). Lädt `css/*` und `js/main.js` als Modul.
-- **Design-System (v3):** **EINE** Akzentfarbe (Teal `#2dd4bf`) für alles Klickbare; Grün/Gelb/Rot **nur** für Status. Dichtes Control-Plane-Layout, Monospace-Zahlen, Bento. **Keine Inline-Styles in Panels** — alles über Klassen aus `components.css` (`.card`, `.tile`, `.qa`, `.fit-badge`, `.modal-*`, `.badge`, `.bar`/`.meter`, `.chip` …). Tokens in `css/base.css` (`:root`).
-- **`js/core/*`** — `api.js` (Fetch + Token), `ui.js` (DOM-Helfer, Toast, Inline-Icon-Set, **`confirmModal`/`promptModal`** für Beginner-UX, `fmtBytes`/`fmtPct`), `nav.js` (beschrifteter View-Switch).
-- **`js/panels/*`** — ein Panel je Bereich (`overview`, `models`, `server`, `cookbook`, `connect`=Verbinden, `news`, `jobs`=Aktivität, `guides`). Panel-Vertrag: `{ id, mount?(), onStatus?(s), onJobs?(jobs), onSystem?(sys) }`.
-- **`js/main.js`** — bootet Panels, pflegt Topbar/Alert + **ehrlichen Security-Chip** (`status.secured`), WebSocket für Live-Metriken (`/api/system/stream`, 2 Hz), Polling (`/api/status` 3 s, `/api/jobs` 1.5 s).
-- **Leitprinzip UX:** verständlich/idiotensicher — Klartext-Microcopy, Fachbegriffe übersetzt (CPU→Prozessor, VRAM→Grafikspeicher), geführte Aktionen, heikle Aktionen mit `confirmModal` (Klartext-Konsequenz).
+**Frontend** (`frontend/src/`, Svelte 5 + Vite, Build → `static/dist/`):
+- **`index.html`** — Gerüst: Sidebar-Nav (10 Tabs), Topbar, Alert-Banner, View-Container je Bereich.
+- **`frontend/src/main.ts`** — bootet alle Svelte-Panels, Topbar/Alert, WebSocket Live-Metriken, Polling.
+- **`frontend/src/panels/`** — je ein Panel: Overview, Models, Jobs(Aktivität), Server, Cookbook, Connect(Verbinden), News, Guides, Memory(Gedächtnis), Hermes.
+- **`frontend/src/stores/`** — Svelte 5 Runes: `status.svelte.ts`, `jobs.svelte.ts`, `system.svelte.ts`.
+- **Design-System (v3):** EINE Akzentfarbe Teal `#2dd4bf`. Grün/Gelb/Rot nur für Status. Tokens in `css/base.css`.
 
-- **`mission-control.service`** — systemd-Unit (uvicorn auf Port 9000).
-- **Konfiguration** rein über Env-Vars: `MC_LLAMA_SWAP_URL`, `MC_CONFIG_PATH`, `MC_MODELS_DIR`, `MC_CMD_TEMPLATE`, `MC_UPDATE_CMD`, `MC_DEFAULT_TTL`, `MC_TOKEN`, `MC_SOURCE_DIR` (Self-Update-Quelle, Default `~/mission-control`).
+## Der Stack drumherum
 
-## Der Stack drumherum (Kontext)
-
-- **Bosgame M5**: AMD Strix Halo (gfx1151), Ubuntu 26.04, Kernel 7.0, ~124 GB GTT-Speicher. LAN-IP `192.168.178.151`.
-- **Inferenz**: vorgebaute llama.cpp-ROCm-Binaries → `llama-swap` auf **`*:8080` (LAN-offen**, mit `-watch-config`) → die Guides-Integrationen funktionieren von anderen Geräten. Engine-Update via `MC_UPDATE_CMD=/usr/local/bin/update-llamacpp` (lädt llama.cpp-ROCm für gfx1151).
-- **3 Modelle / 5 Rollen**: `coder`, `scout`, `vision` (Qwen3-Familie). Modelle werden geswappt, nicht parallel geladen.
-- **Mission Control**: Produktiv unter `/opt/mission-control` (als Dienst), Source-Repo unter `~/mission-control`.
+- **Bosgame M5**: AMD Strix Halo (gfx1151), Ubuntu 26.04, Kernel 7.0, ~124 GB GTT. LAN-IP `192.168.178.151`.
+- **Inferenz**: llama.cpp-ROCm-Binaries → `llama-swap` auf `*:8080` (LAN-offen, `-watch-config`).
+- **3 Modelle / 5 Rollen**: `coder` (Qwen3-30B-A3B), `scout` (Qwen3-8B), `vision` (Qwen3-VL).
+- **Mission Control**: Produktiv unter `/opt/mission-control`, Source unter `~/mission-control`.
+- **Gedächtnis**: SQLite unter `/srv/models/mission-control-memory.db` (5 Kategorien: user/instruction/stable/versioned/ephemeral).
+- **Hermes Agent**: läuft als Teil von Mission Control (kein separater Dienst), Voice via Whisper (CPU) + Piper TTS.
 
 ## Entwickeln & Deployen
 
-**Wo entwickelt wird:** primär auf einem **Windows-PC** (Repo z. B. `F:\Coding Stuff\mission-control`),
-Zielsystem ist der **Linux-Bosgame**. Lokal nur Smoke-Test (rendert/bootet sauber?), echter
-Funktionstest nur auf dem Bosgame (dort läuft llama-swap).
+**Wo entwickelt wird:** Windows-PC (`F:\Coding Stuff\mission-control`), Ziel: Linux-Bosgame.
+Lokal nur Smoke-Test (rendert/bootet?), echter Funktionstest auf dem Bosgame.
 
 **Lokaler Smoke-Test (Windows):**
 ```bash
 python -m venv .venv && .venv/Scripts/python -m pip install -r requirements.txt
 .venv/Scripts/python -m uvicorn app:app --port 9001
 ```
-Ohne llama-swap ist alles im Offline-Zustand (rote Pill, Warn-Banner) — das ist erwartet.
 
-**Bosgame-Zugang (SSH, key-basiert, passwortlos):**
+**Bosgame-Zugang:**
 ```bash
 ssh -i ~/.ssh/id_ed25519_hermes -o IdentitiesOnly=yes hitonabi@192.168.178.151
 ```
-User ist **`hitonabi`** (klein!). `sudo` braucht generell ein Passwort — **außer** einer engen NOPASSWD-Whitelist für genau `systemctl restart mission-control|llama-swap` und `journalctl` (dadurch laufen Self-Update, Dienst-Restarts und Log-Stream passwortlos). OS-Update/Reboot fragen das Passwort weiterhin ab.
+User: `hitonabi`. sudo NOPASSWD-Whitelist für `systemctl restart mission-control|llama-swap` und `journalctl`.
 
-**Self-Update statt manuellem Deploy:** Der Button „Mission Control aktualisieren" (`POST /api/self-update`) macht `git pull` (Source) → rsync → `systemctl restart` — der dokumentierte manuelle Weg unten ist nur noch Fallback/Erstinstallation.
-
-**Frontend-Build (Vite + Svelte 5, ab Phase C):**
+**Frontend-Build:**
 ```bash
-cd frontend && npm install   # einmalig
-npm run build                # vor jedem git push — Output: static/dist/main.js
+cd frontend && npm run build   # vor jedem git push
 ```
-Das Build-Ergebnis (`static/dist/`) wird committet → kein Build-Schritt auf dem Server.
-Beim Entwickeln: `npm run dev` in `frontend/` startet den Vite Dev-Server (Port 5173) für HMR.
-Neue Svelte-Panels kommen in `frontend/src/panels/`. Sobald ein Panel migriert ist,
-wird es in `frontend/src/main.ts` importiert und das alte `static/js/panels/<panel>.js` nicht mehr gebraucht.
+Output: `static/dist/main.js` + `static/dist/main.css` — wird committet (kein Build-Schritt auf dem Server).
 
-**Deploy-Kette (Windows → Gitea → Bosgame):**
-1. Frontend bauen: `cd frontend && npm run build` → `static/dist/main.js` aktualisiert.
-2. Lokal Smoke-Test → `git push` (origin = Gitea `http://192.168.178.153:3000/Hitonabi/mission-control.git`).
-3. Bosgame: `cd ~/mission-control && git pull --ff-only` (Source-Repo).
-4. Nach `/opt` ausrollen — **ohne sudo**, `node_modules` ausnehmen:
-   ```bash
-   rsync -a --exclude='.git' --exclude='.venv' --exclude='__pycache__' --exclude='*.pyc' --exclude='frontend/node_modules' ~/mission-control/ /opt/mission-control/
-   ```
-5. `sudo systemctl restart mission-control` (Passwort nötig). Prod = `:9000`, Dev-Spielwiese = `:9001`.
-6. **Niemals direkt in `/opt` arbeiten.** Logs: `journalctl -u mission-control -f`.
+**Deploy-Kette:**
+```
+npm run build → git push (Gitea :3000) → Bosgame: git pull → rsync → systemctl restart
+```
+Oder über den Self-Update-Button in Mission Control (empfohlen).
 
-Statische Dateien werden je Request frisch von Platte gelesen → UI-Änderungen wirken schon nach
-rsync; **Python-Code-Änderungen brauchen den Restart**.
+**Self-Update-Button** (`POST /api/self-update`): git pull → rsync → restart — alles in einem Klick.
+
+## Konfiguration (Env-Vars)
+
+| Variable | Default | Zweck |
+|---|---|---|
+| `MC_LLAMA_SWAP_URL` | `http://127.0.0.1:8080` | llama-swap URL |
+| `MC_CONFIG_PATH` | `/etc/llama-swap/config.yaml` | llama-swap Config |
+| `MC_MODELS_DIR` | `/srv/models` | GGUF-Ablageort |
+| `MC_TOKEN` | leer | Auth-Token (optional, LAN-only) |
+| `MC_UPDATE_CMD` | leer | Engine-Update-Befehl |
+| `MC_DEFAULT_TTL` | `300` | Sekunden bis Auto-Unload |
+| `MC_SOURCE_DIR` | `~/mission-control` | Self-Update Quelle |
+| `MC_MEMORY_DB` | `{MODELS_DIR}/mission-control-memory.db` | SQLite Gedächtnis |
+| `HERMES_SIMPLE_MODEL` | `scout` | Modell für einfache Tasks |
+| `HERMES_COMPLEX_MODEL` | `coder` | Modell für komplexe Tasks |
+| `HERMES_WINDOWS_HOST` | leer | Windows-PC IP für SSH |
+| `HERMES_WINDOWS_USER` | `TobisPC` | Windows SSH-Username |
+| `HERMES_SSH_KEY` | `~/.ssh/id_ed25519_hermes_agent` | SSH-Key für Hermes |
+| `PIPER_BIN` | `/opt/mission-control/piper/piper` | Piper TTS Binary |
+| `PIPER_VOICE` | `.../de_DE-kerstin-low.onnx` | Piper Stimm-Modell |
+| `WHISPER_MODEL` | `medium` | Whisper Modell-Größe |
 
 ## Konventionen
 
-- **Frontend: Vite + Svelte 5** (Phase C). Neuer Bereich = `frontend/src/panels/<Bereich>Panel.svelte` + `routers/<bereich>.py` + `initNav`-Eintrag in `index.html`. Danach `npm run build` in `frontend/` → `static/dist/main.js` wird committet.
-- Stores: `frontend/src/stores/status.svelte.ts`, `jobs.svelte.ts`, `system.svelte.ts` — Svelte 5 Runes (`$state`).
-- Statische Hilfsfunktionen in `static/js/core/` (api.js, ui.js, nav.js) bleiben als gemeinsame Basis — werden von Vite gebündelt, nicht direkt geladen.
-- **Backend SoC**: ein `routers/<bereich>.py` je Bereich, gemeinsame Logik in `config/auth/jobengine/llamaswap/hw_math`.
-- Endpoint-URLs bleiben unter `/api/*`; neue Bereiche degradieren sauber, wenn ihre Quelle (sysfs, `amd-smi`, `systemctl`) fehlt (z. B. beim Entwickeln auf Windows).
-- Funktion darf **nicht** von `localStorage` abhängen (nur das Token-Feld nutzt es, das ist ok).
-- **Sicherheit**: Das Backend führt Shell-Befehle aus → ausschließlich im vertrauenswürdigen LAN betreiben, niemals offen ins Internet.
+- **Neuer Bereich**: `routers/<bereich>.py` + `frontend/src/panels/<Bereich>Panel.svelte` + Nav/View in `index.html` + Import in `main.ts`. Danach `npm run build`.
+- **Backend SoC**: gemeinsame Logik in `config/auth/jobengine/llamaswap/hw_math`. Alles unter `/api/*`.
+- **Sicherheit**: Shell-Befehle → nur LAN. Secrets via stdin. Token optional.
+- **SQLite**: WAL-Mode aktiv, `check_same_thread=False` — ausreichend für Single-User.
+- **`asyncio.get_running_loop()`** statt `get_event_loop()` (Python 3.10+ kompatibel).
+- **Memory-Kategorien**: `user` | `instruction` | `stable` | `versioned` | `ephemeral` — Enum in `routers/memory.py`.
 
-## Gotchas (wichtig!)
+## Gotchas
 
-- **`${PORT}`** in der generierten `llama-swap`-Config muss **literal** stehen bleiben → beim Bauen des cmd-Strings `str.replace` benutzen, NICHT `.format` (sonst KeyError auf `PORT`).
-- `llama-swap` muss mit **`-watch-config`** laufen, sonst greift das Auto-Einpflegen neuer Modelle nicht.
-- HuggingFace-Downloads mit **`HF_HUB_DISABLE_XET=1`** (sonst reproduzierbarer Hänger bei ~6 MB).
-- Vision-Modelle in llama.cpp brauchen zusätzlich **`--mmproj <projektor>` und `--jinja`**.
+- **`${PORT}`** in llama-swap-Config → `str.replace` statt `.format` (KeyError sonst).
+- **`-watch-config`** bei llama-swap nötig für Auto-Einpflegen.
+- **`HF_HUB_DISABLE_XET=1`** bei HuggingFace-Downloads (Hänger bei ~6 MB).
+- **Vision-Modelle**: brauchen `--mmproj <projektor>` und `--jinja`.
+- **Gitea-Push** kann transient mit „Failed to authenticate" fehlschlagen → einfach nochmal.
+- **Piper TTS**: Binary + Stimm-Modell müssen separat installiert werden (nicht via pip).
+- **Whisper**: lädt beim ersten Aufruf ~1.4 GB Modell herunter (einmalig, dann gecacht).
+- **Hermes SSH-Key**: muss auf dem Bosgame generiert werden (`~/.ssh/id_ed25519_hermes_agent`).
 
-## Gotchas v3 (zusätzlich)
+## Projektstatus
 
-- **`.qa` ist ein `<button>`** → die globale `button.danger`-Regel (Vollrot) schlägt durch. Für gefährliche Aktionszeilen `.qa-danger` nutzen (rotes Icon), NICHT `.danger`.
-- **CSS rückwärtskompatibel halten:** Panels werden schrittweise migriert; beim Token-/Klassen-Umbau alte Klassennamen + Vars (`--hi`, `--red`, `--red-dim`) bedienen, sonst brechen noch nicht migrierte Panels.
-- **Browser-ESM-Cache:** Beim lokalen Testen bustet ein Soft-Reload den Modul-Cache nicht zuverlässig → Preview-Server neu starten oder cache-bustend dynamisch importieren. In Prod erledigt das die `no-cache`-Middleware (einmal Strg+Shift+R nach dem ersten Deploy).
-- **Gitea-Push** kann transient mit „Failed to authenticate user" fehlschlagen (Server kurz weg) → einfach erneut versuchen.
+**v7 (Memory Layer)**: SQLite-Gedächtnis mit 5 Kategorien + MCP-Server für alle Tools live.
+**v8 (Hermes Agent)**: Chat-Agent mit Voice (Whisper STT + Piper TTS), Tool Calling, WebSocket-Streaming live.
+Offene v8-Schritte: Piper-Binary installieren, Windows OpenSSH Server + SSH-Key einrichten.
 
-## Projektstatus & Roadmap
-
-**v3 ist umgesetzt & live** (siehe `ROADMAP.md`): einheitliches Design-System, Beginner-UX
-(Klartext/Führung), Security-Härtung (Passwort-Leak dicht, ehrlicher Chip), **Self-Update-Button**.
-
-**v4 ist umgesetzt & live** („Der Lotse" — siehe `ROADMAP.md`): (1) optimale Kontextfenster
-auto-ermittelt (`hw_math.max_ctx_for`, in Cookbook + Modelle-Konfig) → (2) Cookbook 2.0
-use-case-getrieben mit Stack-Empfehlungen (`recipes.py`, „Komplettes Setup installieren") →
-(3) „Verbinden"-Tab mit Connection-Test + Bild-/Vision-Flow → (4) News-Board (RSS via stdlib).
-Alles automatisch aus Modellen + Hardware; KISS/SoC blieb (keine DB, keine neue Lib).
-
-**v5 ist umgesetzt & live** („Anfänger-Lotse"): Klartext-Erklärungen (Swapping/Spitzenbedarf, Kontext-ⓘ,
-Guides-Neubau), aktuelle Juni-2026-Modelle (Rezepte + dynamische GGUF-Auflösung `_pick_gguf`),
-GGUF/MCP erklärt, empfohlene Tools + HF-Token (Einstellungen), News aus Qualitätsquellen +
-**Upgrade-Vorschläge** (`/api/cookbook/upgrades` + `/install-model`, `UPGRADES` in `recipes.py`).
-
-**v6 ist umgesetzt & live**: Stack zeigt echtes Modell; Top-News + Toolbar-Update-Badges
-(`/api/updates`); News-Magazin-Layout; Guide neu mit Tutorials/Workflows + Konzept-Karten;
-Cookbook-Modelle diversifiziert best-in-class (Qwen3/Gemma/Mistral/DeepSeek, neue Kategorie
-„Nachdenken & Logik") + „Beste Wahl für dein System" (`recommended_id`).
-Wir sind im **Feinschliff- und Wartungsmodus**.
-
-**Nordstern:** den Server nie wieder via SSH/Putty anfassen müssen — 100 % Automatisierung / Klicki-Bunti.
+**Nordstern:** Den Bosgame nie wieder via SSH/Putty anfassen — 100 % Automatisierung / Klicki-Bunti.

README.md

@@ -1,85 +1,111 @@
 # Mission Control
 
-Eine schlanke Steuerzentrale für deinen lokalen `llama-swap`-Stack auf dem Bosgame M5.
-Ein FastAPI-Backend + ein HTML-Dashboard. Kein Build-Schritt, keine Datenbank.
+Persönliche Steuerzentrale für einen lokalen LLM-Stack auf dem Bosgame M5.
+FastAPI-Backend + Svelte 5-Frontend. Kein Cloud-Zwang, keine Datenbank-Abhängigkeit.
 
-## Was sie kann
+## Was es kann
 
-- **Modelle & Ports** sehen — liest `llama-swap` (`/running`, `/v1/models`) + deine `config.yaml`
-- **Modell holen** — lädt eine GGUF-Datei von HuggingFace (`hf download`) als Hintergrund-Job mit Live-Log
-- **Einpflegen** — schreibt das Modell automatisch in deine `config.yaml`; `llama-swap` lädt mit `-watch-config` neu
-- **Wartung** — Container/Toolbox aktualisieren, Modelle aus dem Speicher werfen
-- **Schnelltest** — Chat-Box, um ein Modell zu wecken und zu prüfen
+**LLM-Stack verwalten**
+- Modelle & Status sehen (llama-swap `/running`, `/v1/models`, `config.yaml`)
+- Modelle von HuggingFace laden — als Hintergrund-Job mit Live-Log
+- Automatisch in llama-swap einpflegen (`-watch-config`)
+- Optimale Kontextfenster berechnen (hardware-aware, `hw_math`)
 
-Was sie **bewusst nicht** macht: Chat-Logs, Inferenz-Monitoring im Detail — dafür hat `llama-swap`
-schon `/ui` und `/log`. Mission Control ergänzt nur, was fehlt.
+**Cookbook**
+- Use-Case-getrieben: Coding · Chat · Vision · Agenten · Schnell & sparsam
+- Hardware-Ampel pro Setup, „Beste Wahl für dein System"
+- 1-Klick „Komplettes Setup installieren"
+
+**Wartung & Server**
+- OS-Updates, Dienste steuern (llama-swap, Mission Control), Reboot
+- Live-Logs (journalctl via WebSocket)
+- Self-Update-Button (git pull → rsync → restart)
+
+**Verbinden**
+- Copy-Paste-Configs für Cline, OpenCode, Zed, Continue, Jan AI, OpenWebUI
+- Gedächtnis-MCP: alle Tools teilen dasselbe persistente Gedächtnis
+
+**Gedächtnis** *(v7)*
+- SQLite-Datenbank mit 5 Kategorien: `user` · `instruction` · `stable` · `versioned` · `ephemeral`
+- MCP-Server (`mcp_memory.py`): Cline, OpenCode, Claude Code teilen dasselbe Gedächtnis
+- Temporäre Einträge (ephemeral) nach 7 Tagen automatisch gelöscht
+
+**Hermes Agent** *(v8)*
+- Lokaler KI-Assistent direkt im Browser — Text und Sprache
+- Whisper STT (lokal, ROCm-beschleunigt) + Piper TTS (weibliche Stimme Kerstin)
+- Tool Calling: Dateien lesen, Befehle ausführen, System abfragen, Web suchen
+- Gedächtnis-Integration: Hermes kennt dich und deinen Stack von Anfang an
+- Setup-Wizard für Piper + Windows SSH-Zugriff
 
 ## Voraussetzungen
 
 - Python 3.11+
-- `hf` CLI installiert (`pip install -U "huggingface_hub[cli]"`)
-- ein laufendes `llama-swap` — gestartet **mit `-watch-config`**, sonst greift das Auto-Einpflegen nicht
+- `llama-swap` laufend mit `-watch-config`
+- `hf` CLI (`pip install -U "huggingface_hub[cli]"`)
+- Für Voice: `faster-whisper` + Piper Binary (Anleitung im Hermes-Tab)
 
-## Installation
+## Schnellstart (Bosgame)
 
 ```bash
 sudo mkdir -p /opt/mission-control && sudo chown $USER /opt/mission-control
-cp -r *.py routers static /opt/mission-control/
+git clone http://192.168.178.153:3000/Hitonabi/mission-control.git ~/mission-control
+rsync -a --exclude='.git' ~/mission-control/ /opt/mission-control/
 cd /opt/mission-control
-python3 -m venv .venv && . .venv/bin/activate
-pip install -r requirements.txt
-uvicorn app:app --host 0.0.0.0 --port 9000
+python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
 ```
 
-Dann im Browser im LAN: `http://<bosgame-ip>:9000`
-
-### Als Dienst (Autostart)
-
-Pfade in `mission-control.service` anpassen, dann:
-
+Als Dienst:
 ```bash
 sudo cp mission-control.service /etc/systemd/system/
-sudo systemctl daemon-reload
-sudo systemctl enable --now mission-control
+sudo systemctl daemon-reload && sudo systemctl enable --now mission-control
 ```
 
-## Konfiguration (Umgebungsvariablen)
+Browser im LAN: `http://192.168.178.151:9000`
+
+## Konfiguration
+
+Alle Einstellungen über Umgebungsvariablen in der systemd-Unit:
 
 | Variable | Default | Zweck |
 |---|---|---|
-| `MC_LLAMA_SWAP_URL` | `http://127.0.0.1:8080` | wo `llama-swap` lauscht |
-| `MC_CONFIG_PATH` | `/etc/llama-swap/config.yaml` | die `llama-swap`-Config |
-| `MC_MODELS_DIR` | `/srv/models` | wohin GGUFs geladen werden |
-| `MC_CMD_TEMPLATE` | siehe unten | Startbefehl pro Modell |
-| `MC_UPDATE_CMD` | _(leer)_ | Befehl für „Container aktualisieren" |
-| `MC_DEFAULT_TTL` | `300` | Sekunden bis Auto-Unload |
-| `MC_TOKEN` | _(leer)_ | optionales Zugriffs-Token |
+| `MC_LLAMA_SWAP_URL` | `http://127.0.0.1:8080` | llama-swap URL |
+| `MC_CONFIG_PATH` | `/etc/llama-swap/config.yaml` | llama-swap Config |
+| `MC_MODELS_DIR` | `/srv/models` | GGUF-Ablageort |
+| `MC_TOKEN` | leer | Auth-Token (optional) |
+| `MC_UPDATE_CMD` | leer | Engine-Update-Befehl |
+| `MC_SOURCE_DIR` | `~/mission-control` | Self-Update Quelle |
+| `MC_MEMORY_DB` | `{MODELS_DIR}/mission-control-memory.db` | Gedächtnis-Datenbank |
+| `HERMES_SIMPLE_MODEL` | `scout` | Modell für einfache Tasks |
+| `HERMES_COMPLEX_MODEL` | `coder` | Modell für komplexe Tasks |
+| `HERMES_WINDOWS_HOST` | leer | Windows-PC IP für SSH-Zugriff |
+| `PIPER_BIN` | `/opt/mission-control/piper/piper` | Piper TTS Binary |
+| `PIPER_VOICE` | `.../de_DE-kerstin-low.onnx` | Piper Stimme |
+| `WHISPER_MODEL` | `medium` | Whisper Modell-Größe |
 
-### Wichtig: `MC_CMD_TEMPLATE` an deinen Start anpassen
+## Sicherheit
 
-Das ist der Befehl, der pro Modell in die `config.yaml` geschrieben wird. `{model}` und `{ctx}`
-werden von Mission Control ersetzt, **`${PORT}` bleibt stehen** (das ersetzt `llama-swap` selbst).
+- Ausschließlich im vertrauenswürdigen LAN betreiben
+- `MC_TOKEN` setzen für minimalen Schutz
+- Für Remote-Zugriff: SSH-Tunnel oder Tailscale, niemals direktes Port-Forwarding
+- Hermes-SSH-Key hat nur Zugriff auf explizit freigegebene Windows-Pfade
+
+## Architektur
 
-Direkt auf dem Host (llama-server im PATH):
 ```
-llama-server -m {model} --host 127.0.0.1 --port ${PORT} -c {ctx} -ngl 999 -fa 1 --no-mmap
+Browser (Windows PC)
+  ├── Svelte 5 UI (static/dist/main.js)
+  └── WebSocket (Live-Metriken, Hermes-Chat, Logs)
+
+FastAPI (Bosgame :9000)
+  ├── routers/models.py      LLM-Verwaltung
+  ├── routers/system.py      Live-Metriken (psutil/sysfs)
+  ├── routers/maintenance.py Updates, Logs, Neustart
+  ├── routers/cookbook.py    Modell-Empfehlungen
+  ├── routers/memory.py      Gedächtnis (SQLite)
+  ├── routers/hermes.py      Agent-Chat, Voice (Whisper/Piper)
+  └── ...
+
+llama-swap (:8080)          Inference (Qwen3-Familie)
+SQLite                      Gedächtnis (/srv/models/mission-control-memory.db)
+mcp_memory.py               MCP-Server für Cline/OpenCode/Claude Code
 ```
-
-Über den kyuz0-Container (distrobox) — Beispiel, an deinen Toolbox-Namen anpassen:
-```
-distrobox enter llama-vulkan-radv -- llama-server -m {model} --host 127.0.0.1 --port ${PORT} -c {ctx} -ngl 999 -fa 1 --no-mmap
-```
-
-> `-fa 1` (Flash Attention) und `--no-mmap` sind auf Strix Halo Pflicht, sonst drohen Crashes/Slowdowns.
-
-## ⚠️ Sicherheit
-
-Mission Control führt Shell-Befehle aus (Downloads, Updates) und schreibt deine Config.
-**Niemals offen ins Internet hängen.** Betrieb nur im vertrauenswürdigen LAN. Wenn du
-trotzdem etwas Schutz willst, setz `MC_TOKEN` und trag es oben rechts im Dashboard ein.
-Für echten Remote-Zugriff: per SSH-Tunnel oder Tailscale, nicht per Portfreigabe.
-
-## API (falls du es skripten willst)
-
-`GET /api/status` · `POST /api/download` · `POST /api/register` · `POST /api/unload[?model=]`
-· `POST /api/update` · `POST /api/chat` · `GET /api/jobs` · `GET /api/jobs/{id}`

ROADMAP.md

@@ -1,165 +1,82 @@
-# Mission Control - Roadmap v2
+# Mission Control — Roadmap
 
-**Nordstern:** Den Bosgame nie wieder via SSH/Putty bedienen müssen. **100 % Automatisierung oder Klicki-Bunti.**
+**Nordstern:** Den Bosgame nie wieder via SSH/Putty bedienen. **100 % Automatisierung oder Klicki-Bunti.**
+**Größeres Ziel:** Mission Control als persönliches **Agentic OS** — lokaler, privater KI-Assistent der das gesamte Setup kennt und steuert.
+
+---
+
+## v8 — Hermes Agent / Agentic OS Kern (✅ UMGESETZT & live, Stand 2026-06-23)
+
+**Hermes**: dauerhafter lokaler KI-Assistent auf dem Bosgame. Text + Voice, Tool Calling, Gedächtnis.
+
+- **`hermes_agent.py`**: ReAct-Agent mit Tool-Set (read_file, list_dir, run_command, system_status, memory r/w, web_search). Modell-Routing: scout für einfache Tasks, coder für komplexe.
+- **`routers/hermes.py`**: WS `/chat` (streaming), POST `/transcribe` (Whisper STT, CPU), POST `/tts` (Piper TTS, weibliche Stimme Kerstin), GET `/status`, GET `/pubkey`.
+- **HermesPanel.svelte**: Chat-UI mit Token-Streaming, Tool-Anzeige, Mikrofon-Button (MediaRecorder), TTS-Wiedergabe, Setup-Wizard (Windows SSH + Piper-Anleitung).
+- **Setup-Wizard**: zeigt Schritt-für-Schritt Einrichtung für Piper + Windows OpenSSH.
+
+**Offene Schritte (nicht Code, sondern Einrichtung):**
+- [ ] Piper Binary + Kerstin-Stimme auf dem Bosgame installieren (Befehle im Setup-Wizard)
+- [ ] Windows OpenSSH Server aktivieren (5 PowerShell-Befehle im Setup-Wizard)
+- [ ] SSH-Key auf Bosgame generieren: `ssh-keygen -t ed25519 -C "hermes-agent@bosgame" -f ~/.ssh/id_ed25519_hermes_agent -N ""`
+- [ ] `HERMES_WINDOWS_HOST` + `HERMES_WINDOWS_USER` in `mission-control.service` setzen
+
+---
+
+## v7 — Memory Layer / Gedächtnis (✅ UMGESETZT & live, Stand 2026-06-23)
+
+Persistentes, tool-übergreifendes Gedächtnis für alle KI-Tools via MCP.
+
+- **`routers/memory.py`**: SQLite CRUD + Export, WAL-Mode, 5 Kategorien mit Enum-Validierung.
+- **`mcp_memory.py`**: stdio-MCP-Server — Tools: get/add/search/update/delete_memory. Einmalig in Cline/OpenCode/Claude Code einbinden.
+- **MemoryPanel.svelte**: Gedächtnis-Tab mit Kategorie-Filter, Inline-Edit, Add-Formular.
+- **ConnectPanel.svelte**: Gedächtnis-MCP Setup-Guide mit Config-Snippets.
+- **5 Kategorien**: `user` (wer du bist) · `instruction` (Verhaltensregeln für alle Tools) · `stable` (Projektfakten) · `versioned` (Tech-Versionen) · `ephemeral` (7 Tage, dann weg).
 
 ---
 
 ## v6 — Workflow & Politur (✅ UMGESETZT & live, Stand 2026-06-21)
 
-- **Dashboard/Toolbar:** „Dein Stack" zeigt echtes Modell hinter dem Alias; Top-News-Karte;
-  Toolbar-Update-Badges (`/api/updates`: OS via apt + Modell-Upgrades).
-- **News & Guide entklobigt:** News als Magazin-Layout; Guide neu mit **Tutorials/Workflows**
-  (erster Workflow, Kontext leeren, „brauche ich einen Agenten?", Auto-Swap, Tools nutzen) +
-  kompakten Konzept-Karten.
-- **Cookbook smart:** Modelle **diversifiziert** best-in-class (Qwen3-Coder, Gemma 3, Mistral Small,
-  DeepSeek-R1, Qwen3-VL) + neue Kategorie „Nachdenken & Logik"; „**Beste Wahl für dein System**"
-  hervorgehoben (`recommended_id`); GGUF beim Install dynamisch aufgelöst.
-- **Erklärt:** Swapping/Spitzenbedarf-Klartext, „nur eins läuft gleichzeitig, kein Summieren".
+- Dashboard zeigt echtes Modell hinter dem Alias; Toolbar-Update-Badges (OS + Modell-Upgrades).
+- News als Magazin-Layout; Guide neu mit Tutorials/Workflows + Konzept-Karten.
+- Cookbook: Modelle diversifiziert (Qwen3/Gemma/Mistral/DeepSeek), „Beste Wahl für dein System".
 
 ---
 
-## v5 — „Anfänger-Lotse" (✅ UMGESETZT & live, Stand 2026-06-21)
+## v5 — „Anfänger-Lotse" (✅ UMGESETZT & live)
+## v4 — „Der Lotse" (✅ UMGESETZT & live)
+## v3 — Redesign + Beginner-UX + Security (✅ UMGESETZT & live)
 
-Wasserdicht erklären + aktualisieren + smart empfehlen (für blutige Anfänger).
-- **Erklären:** Swapping-Klartext + Spitzenbedarf pro Modell (nur eins läuft gleichzeitig, kein Summieren);
-  Kontext-ⓘ-Tooltips; **Guides-Tab neu** (LLM/GGUF/Quant/Kontext/Swapping/MCP/Skills/Agenten).
-- **Aktualisieren:** Rezepte auf Juni-2026-Modelle (Qwen3-Coder-30B-A3B, Qwen3-8B/30B, Qwen2.5-VL-7B);
-  GGUF-Datei beim Install **dynamisch aufgelöst** (`_pick_gguf`); „kein GGUF" entschärft + erklärt;
-  **Empfohlene Tools** in Verbinden (OpenCode/Cline/Continue + MCP); **HF-Token** in Einstellungen.
-- **Smart:** News-Quellen aufgeräumt (Qualitäts-RSS statt Git-Tags); **Upgrade-Vorschläge**
-  („Modell X ersetzt dein Y, weil …" → 1-Klick-Tausch via `/install-model`, `UPGRADES`-Map in recipes.py).
+Details in Git-History.
 
 ---
 
-## v4 — „Der Lotse" (✅ UMGESETZT & live, Stand 2026-06-21)
+## Nächste Features (Vorschläge)
 
-Sprung vom Modell-*Manager* zum geführten *Berater*. Alles **automatisch aus Modellen + Hardware**.
-KISS/SoC blieb: je Bereich ein `routers/<x>.py` + `js/panels/<x>.js` + Nav-Eintrag, keine DB, keine
-schwere Lib. **Alle 4 Schritte sind live** — Checklisten unten erledigt.
+### v8.1 — Hermes Windows-SSH (Phase C)
+- [ ] Hermes kann Dateien auf Windows-PC lesen/schreiben via paramiko SSH
+- [ ] Tool: `read_file_windows(path)`, `write_file_windows(path, content)`, `run_command_windows(cmd)`
+- [ ] Hermes updated opencode.json / Zed-Settings automatisch wenn neue Modelle verfügbar
+- [ ] Mission Control Setup-Wizard: SSH-Test-Button mit grünem Haken
 
-### 1. Optimale Kontextfenster (Fundament)
-- [x] `hw_math`: `max_ctx_for(params_b, quant, ram_gb)` — Umkehrfrage „welcher ctx passt noch?"
-      (KV-Cache-Bedarf vs. freier Speicher).
-- [x] Pro Modell empfohlener ctx + Klartext-Begründung; Ein-Klick „optimal setzen" (nutzt `update_model`).
-- [x] Speist Cookbook (2.) + Modelle-Tab.
+### v8.2 — `.well-known/opencode` Remote Config
+- [ ] `GET /.well-known/opencode` — vollständige, dynamisch generierte OpenCode-Config (provider + models + MCP)
+- [ ] OpenCode Desktop lädt beim Start automatisch alle Configs von Mission Control
+- [ ] Einmalig: `OPENCODE_REMOTE_CONFIG=http://192.168.178.151:9000/.well-known/opencode` setzen
 
-### 2. Cookbook 2.0 — Use-Case-getrieben
-- [x] Einstieg „Wofür?": Coding · Bilder verstehen · Allrounder/Chat · Lange Dokumente · Agenten/Tool-Use · Schnell & sparsam.
-- [x] Pro Use-Case ein kuratiertes **Setup/Stack** (mehrere Modelle/Rollen) statt Einzelmodell, mit
-      Hardware-**Ampel pro Setup** (via `hw_math`) + vorgeschlagenem ctx. Rezepte als Daten (`recipes.py`).
-- [x] „Komplettes Setup installieren" — download + register aller Modelle in einem Rutsch.
-- [x] Roh-Suche bleibt als „Profi-Modus".
+### v9 — Agentic OS Orchestrierung
+- [ ] Hermes kann geplante Tasks ausführen (Cron-artig, z.B. täglich Modell-Updates prüfen)
+- [ ] Task-Queue: Aufgaben übergeben, Ergebnis später abholen
+- [ ] Push-Notifications: Hermes meldet sich wenn er fertig ist
+- [ ] Multi-Step-Workflows: "Recherchiere X, schreibe Zusammenfassung, speichere ins Gedächtnis"
 
-### 3. Verbinden / Orchestrierung (neuer Tab, erweitert Guides)
-- [x] Geführter Assistent je Tool (OpenCode/Cline/Cursor/OpenWebUI) mit exakter Config.
-- [x] **„Verbindung testen"** — `routers/integration.py` `/api/integration/test` ruft llama-swap
-      `/v1/models` (LAN-URL) und meldet Erfolg + Modell-Liste zurück.
-- [x] Bild-Eingaben für Fehleranalyse: erkennt Vision-Modell (sonst Hinweis „Vision installieren") +
-      Copy-Snippet im OpenAI-Vision-Format. Auto-Swapping erklären.
+### v9.1 — Guides & Connect aktualisieren
+- [ ] Zed als primäre Editor-Empfehlung (Inline-Completion + Agent, lokal)
+- [ ] Antigravity entfernen oder als "Cloud-first, lokal wackelig" markieren
+- [ ] Continue als "unsichere Zukunft (Cursor-Akquisition)" markieren
+- [ ] `.well-known/opencode`-Snippet in Connect-Tab ergänzen
 
-### 4. News-Board (neuer Tab)
-- [x] `routers/news.py`: kuratierte RSS/Atom-Feeds (HuggingFace-Blog, r/LocalLLaMA, llama.cpp-Releases,
-      Ollama) via `httpx` + stdlib-`xml.etree` (kein neuer Dep), In-memory-Cache (~30 min TTL).
-- [x] `panels/news.js`: Karten (Titel/Quelle/Datum/Link), sanitisiert, LAN-only; Hardware-relevante
-      Releases (gfx1151/ROCm) hervorheben.
-
----
-
-## v3 — Redesign + Beginner-UX + Security (Stand 2026-06-21, live)
-
-Nach der funktional kompletten v2 (unten) umgesetzt — Fokus: **schick, selbsterklärend, wasserdicht.**
-
-- **Design-System:** EINE Akzentfarbe (Teal), Bento, Monospace-Zahlen, beschriftete Sidebar; Inline-Styles
-  raus → alles über `components.css`. Mockup-getrieben (Übersicht + Cookbook).
-- **Beginner-UX:** Klartext-Microcopy, Fachbegriffe übersetzt, menschliches Hero-Urteil, geführte Aktionen,
-  `confirmModal`/`promptModal` für heikle Aktionen, Fit-Ampel + Sortierung im Cookbook, Guides mit Kopier-Buttons.
-- **Security:** sudo-Passwort über **stdin** (kein Leak mehr im Job-Log/`ps`), ehrlicher Security-Chip
-  (`status.secured`), WS-Token (Query). Bind bleibt `0.0.0.0` (LAN-only), Token optional.
-- **Self-Update:** Button „Mission Control aktualisieren" (`/api/self-update`: git pull → rsync → restart) —
-  end-to-end verifiziert. `no-cache`-Middleware für sofortige UI-Wirkung nach Deploy.
-- **Infra geklärt:** llama-swap lauscht `*:8080` (LAN); `MC_UPDATE_CMD` = llama.cpp-Engine-Update (≠ MC selbst).
-
-Details/Konventionen: **CLAUDE.md**. Modus jetzt: Feinschliff & Bug-Hunting.
-
----
-
-## Projektstand v2 (Stand 2026-06-20)
-
-**✅ Schritt 1 erledigt & live auf `:9000`** — *SoC-Refactor + Design 2.0 als Fundament* (Commit `3649394`).
-Backend in Helfer + `routers/*` zerlegt, Frontend in ES-Module (`js/core` + `js/panels`) + ausgelagertes
-CSS, neues Dashboard-Layout (Sidebar-Nav, Topbar, Alert-Banner, Hero, KPI-Kacheln, Health-Signale,
-Modell-Listen, Aktivitäts-Stream) angelehnt an `docs/mission-control-overview.png`. Bestehende Funktionen
-1:1 migriert, Endpoint-URLs unverändert. Architektur + Deploy-Weg stehen in **CLAUDE.md**.
-
-**✅ Schritt 2 erledigt & live** — *Feature 3: Live-Auslastung*. `system.py` Router mit `psutil` und sysfs für CPU/RAM/Disk/GPU/Temp.
-
-**Reihenfolge (abgestimmt):** Design/Architektur zuerst (✅), dann Quick Wins, Security-Brocken zuletzt:
-`1 (✅) Fundament → 2 (✅) Feature 3 Live-Auslastung → 3 (✅) Feature 6 Mehr LLM-Metriken → 4 (✅) Feature 1 Server-Management → 5 (✅) Feature 4 Cookbook → 6 (✅) Feature 7 Integrations-Anleitungen → 7 (✅) Feature 2 Live-Terminal`.
-
-**Arbeitsweise je Schritt:** neuer `routers/<x>.py` + `js/panels/<x>.js` + Nav-Eintrag, sauber degradierend.
-Bauen + Smoke-Test auf Windows, dann push→pull→rsync→restart auf den Bosgame (CLAUDE.md „Entwickeln & Deployen").
-Ein Commit je Schritt. **Ich (KI) habe key-basierten SSH-Zugang zum Bosgame und kann selbst deployen+restarten.**
-
-**→ Letzte Errungenschaften:**
-- **WebSockets:** `/api/system/stream` für super-fluide 2Hz System-Metriken (CPU/RAM/GPU) ohne HTTP-Overhead.
-- **Cookbook 2.0:** Suchergebnisse laden Metriken asynchron ("Lazy Loading"), inklusive Hardware-Fit-Berechnung. UI ist auf Premium-Niveau angehoben (Hover-Effekte, Badge-Colors).
-- **Log-Streaming:** `GET /running`-Polls werden herausgefiltert, Live-Konsolen sind sauber.
-
-**→ Aktueller Modus = Wartung & Feinschliff.**
-- Die v2 Roadmap ist damit zu 100% umgesetzt.
-- Fokus liegt ab sofort auf Stabilität, Bug-Hunting und dem finalen "Polishing".
-
----
-
-## Features
-
-### 1. Server-Management ("Update-Panel 2.0") (✅ Erledigt)
-Aktuell gibt es nur "Container aktualisieren" + "Alles aus dem Speicher". Ziel: den kompletten Server aus der UI verwalten.
-- [x] OS-/Core-Updates (`apt update/upgrade`) per Knopf, mit Live-Output
-- [x] Dienste steuern (`llama-swap`, `mission-control`: Status, Restart)
-- [x] Reboot / Health-Übersicht
-- [x] Referenz: altes `ai-control`-Skript als Funktionsvorlage
-- ⚠️ **Scope-/Security-Sprung**: macht MC zum Server-Admin-Panel. Rechte minimal halten (sudoers-Whitelist für genau die erlaubten Befehle, statt Vollzugriff).
-
-### 2. Live-Terminal / Log via SSH (✅ Erledigt)
-- [x] Unter "Server" -> "Console" kann man das Journal verfolgen.
-- [x] Simpler "Log" Endpunkt in `maintenance.py` (`journalctl -u llama-swap -n 100 -f` über Websockets).
-- [x] UI: Schwarze Konsole, umschaltbar zwischen `llama-swap` und `mission-control`.
-- ⚠️ **Security-kritisch**: Authentifizierung via Token als Query-Parameter, da Browser keine Custom Websocket-Header senden können.
-
-### 3. Live-Auslastung im Dashboard (✅ Erledigt)
-- [x] CPU / RAM / GPU-VRAM+GTT / Temperatur live anzeigen
-- [x] Quellen: **sysfs + psutil** — `amd-smi`/`rocm-smi` sind auf dem Bosgame NICHT installiert!
-      GPU-Mem: `/sys/class/drm/card1/device/mem_info_*`; Temp: hwmon-`name` `amdgpu`/`k10temp`.
-
-### 4. Cookbook + "Modell holen" verschmelzen (✅ Erledigt)
-- Bisher: Textfelder für HuggingFace-Repo + Pfad unter "Modelle". Das ist super für Custom-Zeug.
-- [x] Neu: Ein Klick-Cookbook (Sidebar-Tab "Cookbook") mit kuratierter Liste (z.B. Qwen2.5-Coder 32B, Llama3 Vision, etc.) inkl. Hardware-Aware "What Fits" Logik (wie bei Odysseus).
-- [x] Klick auf Modellkarte im Cookbook triggert den Download via `/api/download`.
-- [x] UI-Aufräumen: "Modell holen" Panel wandert ins Cookbook, unter "Modelle" bleibt nur die Tabelle & Chat.
-
-### 5. Design 2.0
-- [x] **Grundgerüst + Design-Sprache in Schritt 1 umgesetzt** (Sidebar-Nav, Topbar, Hero, getönte
-      KPI-Kacheln, Health-Signale, Listen, Aktivitäts-Stream, Alert-Banner) — Tokens in `css/base.css`.
-- [x] Feinschliff pro Feature durchgeführt.
-
-### 6. Mehr LLM-Metriken (✅ Erledigt)
-- [x] Fähigkeiten pro Modell anzeigen (Text / Bild / Code)
-- [x] Tokens/Sek, Kontextgröße, Quant, Dateigröße auf Platte
-- [x] Status pro Modell: geladen / idle / Ladezeit
-
-### 7. Integrations-Anleitungen (Copy-Paste) (✅ Erledigt)
-- [x] Unter "Guides" (neuer Tab links) gibt es Copy-Paste Templates.
-- [x] Templates für die Integration von llama-swap/mission-control in:
-  - Cline / Cursor
-  - N8N / Zapier
-  - OpenWebUI
-  - LangChain / Python Code
-
----
-
-## Tech-Leitplanken
-
-- **KISS beibehalten** — kein schweres Framework, solange es ohne geht.
-- **Sicherheit zuerst** bei allem mit Shell-/SSH-Zugriff: LAN-only, Auth, minimale Rechte.
-- Backend-Logik in `app.py`, UI in `static/index.html` — Trennung sauber halten.
+### Langfristig
+- [ ] Hermes-Persönlichkeit konfigurierbar (Name, Tonalität) über Gedächtnis `instruction`-Einträge
+- [ ] Voice-to-Voice latency optimieren (Whisper ROCm wenn stable)
+- [ ] Mehrsprachige TTS-Stimmen (EN + DE umschaltbar)
+- [ ] Hermes kann Mission Control selbst weiterentwickeln (Agentic self-improvement)

frontend/src/panels/ConnectPanel.svelte

@@ -80,7 +80,7 @@
       : 'python'
     const scriptPath = tool === 'bosgame'
       ? '/opt/mission-control/mcp_memory.py'
-      : 'C:\\\\Users\\\\TobisPC\\\\mission-control\\\\mcp_memory.py'
+      : 'C:\\\\Users\\\\<DeinUsername>\\\\mission-control\\\\mcp_memory.py'
     return `{\n  "mcpServers": {\n    "mission-control-memory": {\n      "command": "${pyPath}",\n      "args": ["${scriptPath}"],\n      "env": {\n        "MC_URL": "http://192.168.178.151:9000"\n      }\n    }\n  }\n}`
   }
 </script>

frontend/src/panels/HermesPanel.svelte

@@ -48,7 +48,7 @@
         messages = [...messages, { role: 'tool', content: preview, tool: m.name }]
       } else if (m.type === 'tool_result') {
         // Tool-Result in letzten Tool-Eintrag schreiben
-        const last = messages.findLast(x => x.role === 'tool' && x.tool === m.name)
+        const last = [...messages].reverse().find(x => x.role === 'tool' && x.tool === m.name)
         if (last) last.content = m.content
         messages = [...messages]
       } else if (m.type === 'error') {

hermes_agent.py

@@ -375,7 +375,7 @@ async def run_agent(message: str, send: SendFn) -> None:
         await send({"type": "thinking"})
 
         try:
-            result = await asyncio.get_event_loop().run_in_executor(
+            result = await asyncio.get_running_loop().run_in_executor(
                 None, lambda: _call_llm(model, messages)
             )
         except Exception as exc:
@@ -411,7 +411,7 @@ async def run_agent(message: str, send: SendFn) -> None:
 
             await send({"type": "tool_call", "name": name, "args": args})
 
-            tool_out = await asyncio.get_event_loop().run_in_executor(
+            tool_out = await asyncio.get_running_loop().run_in_executor(
                 None, lambda n=name, a=args: execute_tool(n, a)
             )
 

routers/hermes.py

@@ -14,6 +14,7 @@ import hashlib
 import json
 import subprocess
 import tempfile
+import threading
 from pathlib import Path
 from typing import Optional
 
@@ -23,7 +24,7 @@ from fastapi.responses import Response, JSONResponse
 from auth import auth
 from config import (
     PIPER_BIN, PIPER_VOICE, WHISPER_MODEL_SIZE,
-    HERMES_WINDOWS_HOST, HERMES_SSH_KEY,
+    HERMES_WINDOWS_HOST, HERMES_WINDOWS_USER, HERMES_SSH_KEY,
 )
 from hermes_agent import run_agent
 
@@ -35,23 +36,28 @@ router = APIRouter(prefix="/api")
 
 _whisper_model = None
 _whisper_loading = False
+_whisper_lock = threading.Lock()
 
 
 def _get_whisper():
     global _whisper_model, _whisper_loading
-    if _whisper_model is not None:
-        return _whisper_model
-    if _whisper_loading:
-        return None
-    _whisper_loading = True
+    with _whisper_lock:
+        if _whisper_model is not None:
+            return _whisper_model
+        if _whisper_loading:
+            return None
+        _whisper_loading = True
     try:
         from faster_whisper import WhisperModel
-        _whisper_model = WhisperModel(WHISPER_MODEL_SIZE, device="cpu", compute_type="int8")
+        model = WhisperModel(WHISPER_MODEL_SIZE, device="cpu", compute_type="int8")
+        with _whisper_lock:
+            _whisper_model = model
+        return model
     except Exception:
-        _whisper_model = None
+        return None
     finally:
-        _whisper_loading = False
-    return _whisper_model
+        with _whisper_lock:
+            _whisper_loading = False
 
 
 # ---------------------------------------------------------------------------
@@ -75,6 +81,7 @@ def _tts(text: str) -> Optional[bytes]:
             input=text, capture_output=True, text=True, timeout=30
         )
         if result.returncode != 0:
+            print(f"[Piper] Fehler: {result.stderr or 'exit '+str(result.returncode)}")
             return None
         audio = Path(wav_path).read_bytes()
         if len(_tts_cache) >= 64:
@@ -190,7 +197,7 @@ def hermes_status():
             c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
             c.connect(
                 HERMES_WINDOWS_HOST,
-                username=__import__("config").HERMES_WINDOWS_USER,
+                username=HERMES_WINDOWS_USER,
                 key_filename=str(HERMES_SSH_KEY),
                 timeout=3,
             )

routers/memory.py

@@ -9,6 +9,7 @@ Alle MCP-Tools teilen denselben Speicher via mcp_memory.py-Wrapper.
 import sqlite3
 import uuid
 from datetime import datetime, timezone
+from enum import Enum
 from typing import Optional
 
 from fastapi import APIRouter, Depends, HTTPException
@@ -28,6 +29,7 @@ def _db() -> sqlite3.Connection:
         MEMORY_DB.parent.mkdir(parents=True, exist_ok=True)
         _db_conn = sqlite3.connect(str(MEMORY_DB), check_same_thread=False)
         _db_conn.row_factory = sqlite3.Row
+        _db_conn.execute("PRAGMA journal_mode=WAL")  # sicherer bei concurrent FastAPI-Threads
         _db_conn.execute("""
             CREATE TABLE IF NOT EXISTS memories (
                 id         TEXT PRIMARY KEY,
@@ -47,15 +49,23 @@ def _db() -> sqlite3.Connection:
     return _db_conn
 
 
+class _MemCategory(str, Enum):
+    user        = "user"
+    instruction = "instruction"
+    stable      = "stable"
+    versioned   = "versioned"
+    ephemeral   = "ephemeral"
+
+
 class _MemIn(BaseModel):
     content: str
-    category: str = "stable"   # stable | versioned | ephemeral
+    category: _MemCategory = _MemCategory.stable
     source: str = "manual"
 
 
 class _MemUp(BaseModel):
     content: Optional[str] = None
-    category: Optional[str] = None
+    category: Optional[_MemCategory] = None
 
 
 def _row(r: sqlite3.Row) -> dict: