fix(agent): Zeitstempel mit Zeitzone — die Ampel hatte recht

Die Ampel wurde ROT: ruff DTZ007, `datetime.strptime()` ohne Offset in services/agent_aktivitaet.py. Lokal war alles gruen, weil ich ruff nicht laufen liess — nur py_compile, tsc, vitest und den Build. Mein Fehler, nicht der der Regel. Und die Regel ist keine Schikane: AGENTS.md haelt fest, dass naive Zeiten ueber MC_LOCAL_TZ aufzuloesen sind, nie zu raten. Hermes schreibt Ortszeit ohne Offset; das so durchzureichen waere bequem gewesen (der Klient zeigt sie nur an) — aber sobald jemand spaeter damit RECHNET (Dauer ueber Mitternacht, Abgleich mit einem Cron-Plan), waere es eine Falle, die erst zur Zeitumstellung zuschnappt. vorher: 2026-08-28T07:03:18 jetzt: 2026-08-28T07:03:18+02:00 Gegengeprueft am echten Box-Log; die Anzeige schneidet weiterhin Stelle 11-19 heraus und zeigt unveraendert 07:03:18. `ruff check .` laeuft jetzt ueber das ganze Repo sauber durch — ab hier gehoert es vor jeden Commit, der Python anfasst. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
feat(chronik): P6 — Dichteleiste zeigt, WANN die Box aktiv war (§4.5)
2026-08-28 10:04:08 +02:00 · 2026-08-28 10:02:07 +02:00 · 2026-08-28 09:59:58 +02:00 · 2026-08-28 09:56:26 +02:00 · 2026-08-28 09:51:14 +02:00 · 2026-08-28 09:44:45 +02:00
424 changed files with 17649 additions and 18397 deletions
@@ -0,0 +1,16 @@
 {
  "mcpServers": {
    "mc2-system": {
      "command": "python",
      "args": [
        "F:\\Coding Stuff\\mission-control-2\\mcp\\mcp_mc.py"
      ]
    },
    "mc2-web": {
      "command": "python",
      "args": [
        "F:\\Coding Stuff\\mission-control-2\\mcp\\mcp_web.py"
      ]
    }
  }
 }
@@ -1,28 +1,55 @@
-{
+{
-  "version": "0.0.1",
+  "version": "0.0.1",
-  "configurations": [
+  "configurations": [
-    {
+    {
-      "name": "mc2",
+      "name": "mc2",
-      "runtimeExecutable": "F:\\Coding Stuff\\mission-control-2\\backend\\.venv\\Scripts\\python.exe",
+      "runtimeExecutable": "F:\\Coding Stuff\\mission-control-2\\backend\\.venv\\Scripts\\python.exe",
-      "runtimeArgs": [
+      "runtimeArgs": [
-        "-m",
+        "-m",
-        "uvicorn",
+        "uvicorn",
-        "app:app",
+        "app:app",
-        "--app-dir",
+        "--app-dir",
-        "F:\\Coding Stuff\\mission-control-2\\backend",
+        "F:\\Coding Stuff\\mission-control-2\\backend",
-        "--port",
+        "--port",
-        "9000"
+        "9000"
-      ],
+      ],
-      "port": 9000
+      "port": 9000
-    },
+    },
-    {
+    {
-      "name": "frontend",
+      "name": "frontend",
-      "runtimeExecutable": "npm",
+      "runtimeExecutable": "npm",
-      "runtimeArgs": ["run", "dev", "--", "--port", "5180", "--strictPort"],
+      "runtimeArgs": [
-      "cwd": "F:\\Coding Stuff\\mission-control-2\\frontend",
+        "run",
-      "env": { "MC_API_TARGET": "http://192.168.178.151:9001" },
+        "dev",
-      "autoPort": false,
+        "--",
-      "port": 5180
+        "--port",
-    }
+        "5180",
-  ]
+        "--strictPort"
-}
+      ],
      "cwd": "F:\\Coding Stuff\\mission-control-2\\frontend",
      "env": {
        "MC_API_TARGET": "http://192.168.178.151:9001"
      },
      "autoPort": false,
      "port": 5180
    },
    {
      "name": "frontend-mock",
      "runtimeExecutable": "npm",
      "runtimeArgs": [
        "run",
        "dev",
        "--",
        "--port",
        "5181",
        "--strictPort"
      ],
      "cwd": "F:\\Coding Stuff\\mission-control-2\\frontend",
      "env": {
        "MC_API_TARGET": "http://127.0.0.1:9000"
      },
      "autoPort": false,
      "port": 5181
    }
  ]
 }
@@ -1,6 +1,12 @@
 {
  "permissions": {
    "allow": [
 	    "autoMode": {
    "allow": [
      "$defaults",
      "SSH/scp commands to hitonabi@192.168.178.151 that read or write files under ~/.hermes including ~/.hermes/hermes-agent (the Hermes runtime) — the user authorized direct patching of the box's Hermes runtime for the mission-control-2 project"
    ]
  }	
      "Bash(git fetch *)",
      "Bash(git push:*)",
      "Bash(git rev-list *)",
@@ -87,6 +93,8 @@
      "WebFetch(domain:dev.to)",
      "WebFetch(domain:kyuz0.github.io)",
      "WebFetch(domain:kmarble.dev)"
 	  "Bash(ssh -F /dev/null -o IdentitiesOnly=yes -i /c/Users/TobisPC/.ssh/id_rsa hitonabi@192.168.178.151:*)",
      "Bash(scp -F /dev/null -o IdentitiesOnly=yes -i /c/Users/TobisPC/.ssh/id_rsa:*)"
    ]
  }
 }
@@ -9,7 +9,8 @@
 #
 # Darum prueft die MC2-Ampel, was im Container EHRLICH gruen sein kann und trotzdem echte
 # Fehler faengt: Lint (ruff, Projekt-Politik in ruff.toml) + Import/Syntax (compileall) +
-# Frontend-Build inkl. TypeScript-Typecheck (tsc). Rot ist ein Ergebnis, kein Aergernis.
+# Frontend-Build inkl. TypeScript-Typecheck (tsc) + Frontend-Tests (vitest/jsdom) + ESLint
 # + Buendel-Budget. Rot ist ein Ergebnis, kein Aergernis.
 name: Ampel
 on: [push, pull_request]
@@ -42,6 +43,87 @@ jobs:
              rot=1
            else
              ( cd frontend && npm ci --no-audit --no-fund && npm run build ) || rot=1
              # Frontend-Tests + Linter (v3-Umbau P1, 28.08.2026).
              # Bis dahin lief das Frontend als einziger Teil des Stacks voellig ungeprueft
              # durch das Gate — 10 500 Zeilen, null Tests. Die Begruendung weiter oben
              # ("echte Tests sind der Pruefstand mit LIVE-Diensten") gilt fuer die
              # ML-schweren Python-Dienste, nicht fuer Frontend-Unit-Tests: die laufen in
              # jsdom, brauchen weder Modell noch GPU und sind in Sekunden durch.
              # Der Linter meldet 0 Fehler / ~90 Warnungen; rot wird nur bei Fehlern.
              if [ $rot -eq 0 ]; then
                echo "-- Vitest"
                ( cd frontend && npm test --silent ) || rot=1
                echo "-- ESLint (Warnungen sind erlaubt, Fehler nicht)"
                ( cd frontend && npm run lint --silent ) || rot=1
              fi
              # Bündel-Budget (v3-Umbau P0, 28.08.2026): Der Start-Chunk ist das, was der
              # Nutzer VOR dem ersten Bild lädt. Er lag bei 220 kB gzip, weil das eifrig
              # geladene Cockpit Recharts mitzog; dist lag bei 27 MB wegen eines verwaisten
              # Avatar-Modells. Ohne Deckel wächst beides unbemerkt zurück. Gemessen wird der
              # FRISCHE Build im Runner — kein Vergleich mit dem committeten dist (das wäre
              # über Node-Versionen hinweg flatterhaft und würde dauerhaft rot leuchten).
              if [ $rot -eq 0 ] && [ -d frontend/dist/assets ]; then
                # 28.08.2026, React 18 -> 19: Der Sprung kostete GEMESSEN 14 645 B gzip
                # (118 762 -> 133 407) und riss das bis dahin geltende Budget von 125 000.
                # Das Gate hat also getan, was es soll. Angehoben wurde es TROTZDEM —
                # bewusst und einmalig, nicht weil es im Weg stand:
                #   · Der Zuwachs IST die Plattform, nicht Wildwuchs. Es gibt hier nichts
                #     wegzulassen, so wie beim Router (P2), wo Schublade und Palette
                #     hinter lazy() wanderten und das Budget scharf blieb.
                #   · MC2 ist eine LAN-Appliance. 14 kB sind ueber Gigabit-Ethernet keine
                #     messbare Wartezeit; das Budget existiert gegen DRIFT (ein 24-MB-Avatar,
                #     eine 95-kB-Diagramm-Bibliothek auf der Startseite), nicht gegen einen
                #     ueberlegten Plattform-Schritt.
                # Der Abstand zum Budget bleibt derselbe wie vorher (~5 %).
                budget_gz=140000        # Stand nach React 19: 133 407 B gzip
                budget_dist=3145728     # Stand nach P0: 1 477 852 B
                # Den Einstiegs-Chunk aus index.html lesen, NICHT per Glob raten:
                # Rollup nennt auch kleine geteilte Module "index-*.js" (gemessen: ein
                # 67-Byte-Chunk neben dem 375-kB-Einstieg). `ls | head -1` haette je nach
                # Hash den falschen erwischt — und das Budget waere still immer gruen.
                einstieg=$(grep -o 'assets/index-[A-Za-z0-9_-]*\.js' frontend/dist/index.html | head -1)
                haupt="frontend/dist/$einstieg"
                if [ -n "$haupt" ]; then
                  gz=$(gzip -c "$haupt" | wc -c)
                  echo "-- Start-Chunk: $gz B gzip (Budget $budget_gz)"
                  if [ "$gz" -gt "$budget_gz" ]; then
                    echo "❌ Start-Bündel über Budget. Meist eine neue Bibliothek, die über"
                    echo "   das eifrig geladene Cockpit hereinkommt — hinter lazy() legen."
                    rot=1
                  fi
                fi
                gesamt=$(du -sb frontend/dist | cut -f1)
                echo "-- dist gesamt: $gesamt B (Budget $budget_dist)"
                if [ "$gesamt" -gt "$budget_dist" ]; then
                  echo "❌ dist über Budget — Ballast? (Schrift-Subsets, Medien, WOFF 1)"
                  rot=1
                fi
              fi
              if [ $rot -eq 0 ]; then
                echo "== Frontend: Push nach release-dist =="
                git config --global user.name "Gitea Actions"
                git config --global user.email "actions@gitea.local"
                CURRENT_COMMIT=$(git rev-parse HEAD)
                # Erzeuge (oder hole) den orphan branch 'release-dist'
                git checkout --orphan release-dist 2>/dev/null || git checkout release-dist
                git rm -rf . >/dev/null 2>&1 || true
                # Checkout nur frontend/dist vom aktuellen Stand
                git add -f frontend/dist
                if ! git diff-index --quiet HEAD; then
                  git commit -m "Automatischer Frontend Build ($CURRENT_COMMIT) [skip ci]"
                  # Push to release-dist. Token auth from runner is expected to work for Gitea Actions.
                  git push origin HEAD:release-dist -f
                else
                  echo "Keine Änderungen am Frontend-Build."
                fi
                # Zurück zum originalen Branch für den Rest des Skripts
                git checkout $CURRENT_COMMIT
              fi
            fi
          fi
@@ -1,25 +1,19 @@
-# Python
+# Python
-backend/.venv/
+backend/.venv/
-__pycache__/
+__pycache__/
-*.pyc
+*.pyc
-
+
-# Node / Vite
+# Node / Vite
-frontend/node_modules/
+frontend/node_modules/
-# frontend/dist wird committet (kein Node-Build auf der Box) — siehe deploy/
+# frontend/dist wird committet (kein Node-Build auf der Box) — siehe deploy/
-
+
-# Avatar-VRM (groß + lizenz-/redistributionssensibel) — liegt lokal + auf der Box, nicht in git.
+# Env / local
-# Wird per Direkt-Deploy auf die Box gespielt (dist/avatar.vrm), nicht über git.
+*.env
-frontend/public/avatar.vrm
+.DS_Store
-frontend/dist/avatar.vrm
+
-
+# Box-Recon-/Scratch-Skripte (lokale Diagnose, nicht fürs Repo)
-# Env / local
+box_recon*
-*.env
+gemma_swap*
-.DS_Store
+
-
+# TypeScript-Inkrementalcache (reines Build-Artefakt, maschinenabhängig)
-# Box-Recon-/Scratch-Skripte (lokale Diagnose, nicht fürs Repo)
+frontend/tsconfig.tsbuildinfo
 box_recon*
 gemma_swap*
 # TypeScript-Inkrementalcache (reines Build-Artefakt, maschinenabhängig)
 frontend/tsconfig.tsbuildinfo
@@ -1,48 +1,67 @@
-# AGENTS.md — Mission Control 2.0
+# AGENTS.md — Mission Control 2.0
-
+
-Projekt-Geschmack für Coding-Agenten (Kilo Code, Claude Code lesen diese Datei).
+Projekt-Geschmack für Coding-Agenten (Kilo Code, Claude Code lesen diese Datei).
-Kurz gehalten, nur die Wahrheiten, die man sonst schmerzhaft lernt. Details: `README.md`, `docs/`.
+Kurz gehalten, nur die Wahrheiten, die man sonst schmerzhaft lernt. Details: `README.md`, `docs/`.
-
+
-## Was das ist
+## Was das ist
-Lokaler Local-AI-Stack für die Box (Bosgame M5, Strix Halo, Vulkan/RADV). Schichten:
+Lokaler Local-AI-Stack für die Box (Bosgame M5, Strix Halo, Vulkan/RADV). Schichten:
-Engine (llama-swap) · Builtin-Routing-Gateway (`model: auto`) · MC2 (FastAPI + React/shadcn) ·
+Engine (llama-swap) · Builtin-Routing-Gateway (`model: auto`) · MC2 (FastAPI + React/shadcn) ·
-Hermes-Agent. Backend Python (Box läuft Python 3.14), Frontend Vite/React/shadcn/Tailwind.
+**Hermes-Agent (das autonome Gehirn "Lucy")**. Backend Python (Box läuft Python 3.14), Frontend Vite/React/shadcn/Tailwind.
-
+
-## Sprache (nicht verhandelbar)
+**Hardware-Spezifikationen der Box (WICHTIG für alle Agenten):**
- **Alles User-Sichtbare ist Deutsch:** UI-Texte, Fehlermeldungen, Update-/Radar-Meldungen,
+- **System:** Bosgame M5 (AMD Strix Halo APU)
-  Skills, LLM-Summaries, Commit-Messages, Code-Kommentare.
+- **Arbeitsspeicher (RAM/VRAM):** 128 GB Shared Memory (ca. 122.7 GB nutzbar).
- **Hermes' INTERNE System-Prompts bleiben Englisch** (fremde Software, wir forken sie nicht).
+- **Inference-Limit:** Modelle im GGUF-Format dürfen maximal ca. 100-110 GB groß sein (entspricht ca. 150B Parametern bei Q4_K_M). Größere Modelle (wie 200B+ oder 2T Parameter) **können lokal nicht ausgeführt werden** und sind auszuschließen, es sei denn, es handelt sich um stark quantisierte MoEs.
-  Antwort-Sprache ≠ Prompt-Sprache — Deutsch kommt aus SOUL.md, nicht aus den Tool-Prompts.
+**Gedächtnis & Dienste:** Hermes ist das autonome Agenten-Gehirn („Lucy") **und die alleinige Gedächtnis-Wahrheit** — es führt sein Gedächtnis selbst. Der frühere Sidecar auf `:8765` samt Memory-MCP-Server und MC2-Memory-Plugin wurde am 07.08.2026 abgelöst und am 27.08.2026 restlos ausgebaut (`docs/wissen/VERDIKTE.md`): MC2 hat **keine** `/api/memory`-Routen mehr, nichts darf mehr dorthin greifen. Governor, Zed-Workflows und alte Mittelschichten sind komplett gelöscht.
-
+
-## Build & Deploy (die häufigste Falle)
+## Sprache (nicht verhandelbar)
- **`frontend/dist` WIRD committet.** Auf der Box läuft KEIN Node-Build; das Backend liefert die
+- **Alles User-Sichtbare ist Deutsch:** UI-Texte, Fehlermeldungen, Update-/Radar-Meldungen,
-  gebauten Assets direkt aus. Nach jeder Frontend-Änderung: `cd frontend && npm run build`, dann
+  Skills, LLM-Summaries, Commit-Messages, Code-Kommentare.
-  **das neue `frontend/dist` mit-committen**. Vergessen = Box zeigt alten Stand.
+- **Hermes' INTERNE System-Prompts bleiben Englisch** (fremde Software, wir forken sie nicht).
-  (Ausnahme: `frontend/dist/avatar.vrm` ist bewusst nicht in git — siehe `.gitignore`.)
+  Antwort-Sprache ≠ Prompt-Sprache — Deutsch kommt aus SOUL.md, nicht aus den Tool-Prompts.
- **Deploy macht `git reset --hard origin/main`** (`deploy/deploy.sh`). Heißt: **`main` muss vor
+
-  dem Deploy auf Gitea liegen**, und uncommittete Box-Änderungen gehen verloren (Absicht).
+## Build & Deploy (die häufigste Falle)
- **Nie direkt auf `main` arbeiten.** Immer Branch (`wartung/...`), Gate grün, dann Merge/Deploy.
+- **`frontend/dist` WIRD committet.** Auf der Box läuft KEIN Node-Build; das Backend liefert die
-
+  gebauten Assets direkt aus. Nach jeder Frontend-Änderung: `cd frontend && npm run build`, dann
-## Zeit & Umgebung
+  **das neue `frontend/dist` mit-committen**. Vergessen = Box zeigt alten Stand.
- **Box = Ubuntu, läuft in `Europe/Berlin`** (seit 03.07.2026; vorher UTC). Dev-PC = Windows.
+- **Deploy macht `git reset --hard origin/main`** (`deploy/deploy.sh`). Heißt: **`main` muss vor
-  Naive/lokale Zeiten immer über `MC_LOCAL_TZ` (= `Europe/Berlin`) auflösen, nie `datetime.now()` ohne TZ annehmen
+  dem Deploy auf Gitea liegen**, und uncommittete Box-Änderungen gehen verloren (Absicht).
-  (siehe `backend/services/reminders.py`).
+- **Nie direkt auf `main` arbeiten.** Immer Branch (`wartung/...`), Gate grün, dann Merge/Deploy.
-
+
-## Backend-Konventionen
+## Agentic IDE & Vibe Coding
- Router unter `backend/routers/` (`APIRouter(prefix="/api")`), Logik in `backend/services/`
+- **Zero Middle-Layers:** Coding passiert zu 100% lokal auf dem Dev-PC in der **OpenCode Desktop IDE**.
-  (Single Source of Truth — Router bleiben dünn). Beispiel-Lehre: Restart-Allowlist lebt NUR in
+- Es gibt keinen Zed-Workflow, keine OpenCode-CLI-Mittelschicht und keinen Governor mehr.
-  `services.maintenance` (System-Dienste via `sudo -n`, User-Dienste via `systemctl --user`);
+- Der Agent in OpenCode Desktop nutzt via MCP (`.agents/mcp_config.json`) die API der Box (`:9001/v1`), um autonom Projekte zu bauen.
-  keine zweite Allowlist in einem Router duplizieren.
+- **Mix-Ansatz beim Testen:** Der Agent testet lokal. Vor dem Push muss er prüfen, ob das Gitea-`VERIFY`-Skript fehlerfrei durchläuft.
- **Gate vor Commit:** `python -m py_compile <geänderte .py>` muss durchlaufen.
+
- Wartung ist **sudo-frei** gedacht (systemctl --user). Wo doch sudo nötig ist (llama-swap =
+## Zeit & Umgebung
-  System-Dienst), sauber über die NOPASSWD-Whitelist / `password_required`-Rückgabe, nie hart failen.
+- **Box = Ubuntu, läuft in `Europe/Berlin`** (seit 03.07.2026; vorher UTC). Dev-PC = Windows.
- Lokal (Windows) müssen Box-Shell-Befehle **harmlos fehlschlagen** statt zu crashen.
+  Naive/lokale Zeiten immer über `MC_LOCAL_TZ` (= `Europe/Berlin`) auflösen, nie `datetime.now()` ohne TZ annehmen
-
+  (siehe `backend/services/reminders.py`).
-## Grenzen (Verdikt, eingehalten)
+
- **Hermes-Quellcode nie selbst patchen** (Fork verboten). Config/Deps ja, Code-Umbau nein.
+## Backend-Konventionen
- **Security-Config** (approvals, Tokens, ufw, command_allowlist) **nie ohne explizites User-Ja.**
+- Router unter `backend/routers/` (`APIRouter(prefix="/api")`), Logik in `backend/services/`
- Alles reversibel halten: Branch + Backup + Pin.
+  (Single Source of Truth — Router bleiben dünn). Beispiel-Lehre: Restart-Allowlist lebt NUR in
-
+  `services.maintenance` (System-Dienste via `sudo -n`, User-Dienste via `systemctl --user`);
-## Gitea
+  keine zweite Allowlist in einem Router duplizieren.
-Remote = `Hitonabi/mission-control-v2`. Auth ist flatterhaft → **Push mit Retry**, nur über
+- **Gate vor Commit:** `python -m py_compile <geänderte .py>` muss durchlaufen.
-PowerShell/GCM. Neue Repos per API anlegen. Kein GitHub.
+- Wartung ist **sudo-frei** gedacht (systemctl --user). Wo doch sudo nötig ist (llama-swap =
  System-Dienst), sauber über die NOPASSWD-Whitelist / `password_required`-Rückgabe, nie hart failen.
 - ‼️ **Die feingranularen sudoers.d-Regeln sind faktisch wirkungslos.** In `/etc/sudoers` steht
  `hitonabi ALL=(ALL) NOPASSWD: ALL` — der Nutzer, unter dem alle MC2-Dienste laufen, darf ohnehin
  alles passwortlos. `sudoers.d/mc2-autonomie` und `sudoers.d/mission-control` dokumentieren also,
  was gebraucht *würde*, schränken aber nichts ein. Das ist eine bewusste Entscheidung für die
  Single-User-Appliance; verlasse dich beim Bauen nicht darauf, dass eine Whitelist dich bremst.
  Wer das wirklich härten will, kommt um einen eigenen Service-User nicht herum — die Pauschalzeile
  einfach zu ziehen, bricht OS-Update, Config-Sync und den wöchentlichen Auto-Neustart still.
  (Geprüft 27.08.2026; die doppelte Zeile wurde damals entfernt, Sicherung `/root/sudoers.bak-*`.)
 - Lokal (Windows) müssen Box-Shell-Befehle **harmlos fehlschlagen** statt zu crashen.
 ## Grenzen (Verdikt, eingehalten)
 - **Hermes-Quellcode nie selbst patchen** (Fork verboten). Config/Deps ja, Code-Umbau nein.
 - **Security-Config** (approvals, Tokens, ufw, command_allowlist) **nie ohne explizites User-Ja.**
 - Alles reversibel halten: Branch + Backup + Pin.
 ## Gitea
 Remote = `Hitonabi/mission-control-v2`. Auth ist flatterhaft → **Push mit Retry**, nur über
 PowerShell/GCM. Neue Repos per API anlegen. Kein GitHub.
@@ -12,76 +12,76 @@ prüft sich selbst und meldet sich, wenn etwas nicht stimmt.
 | Bahn | Was sie tut | Wo |
 |---|---|---|
 | **Steuerzentrale** | Modelle, Routing, Wartung, Gedächtnis, Ideen-Queue, Auftragsbuch | MC2 `:9001` |
-| **Coding** | Zed + OpenCode am Tag, `opencode-lauf.sh` in der Nacht — **ein Regelwerk, zwei Auslöser** | Governor `:8100` |
+| **Coding** | Agentic IDE (z.B. OpenCode Desktop) auf Dev-PC via lokaler API + MCP | 100% lokal |
 | **Lucy** | Sprach-Companion mit 3D-Avatar, Augen und Ohren | eigenes Repo `Hitonabi/lucy` |
-Lucy holt ihr Hirn über MC2, spricht aber nie durch den Governor — ein Gespräch ist keine
+Lucy holt ihr Hirn direkt über das MC2-Gateway (`:9010/v1`) mit nativer Bildweiche und Voice-Streaming.
 Bau-Sitzung und wird nie unterbrochen.
 ## Ports & Dienste
 | Port | Dienst | Erreichbar |
 |---|---|---|
 | `9001` | **MC2** (FastAPI + React) — Cockpit, API, Konsole | LAN |
 | `8100` | **Governor** — Token-Wächter vor dem Gateway | LAN |
 | `8080` | **llama-swap** — Modell-Router | LAN |
 | `9010` | `mc2-gateway` — `/v1`-Datenpfad (`model: auto`, Bild-Weiche) | loopback |
 | `8642` · `9119` | Hermes-Gateway · Hermes-Web-UI | loopback |
 | `8765` · `8650` | Mem0-Sidecar · Voice-Sidecar (STT/TTS) | loopback |
 | `7682` | ttyd — Box-Konsole, same-origin unter `/console/` | loopback |
-Units in [`deploy/`](deploy/): `mission-control-2` · `mc2-gateway` · `mc2-steward` · `governor` ·
+Units in [`deploy/`](deploy/): `mission-control-2` · `mc2-gateway` · `mc2-steward` ·
 `mem0-service` · `voice-service` · `box-console` · `hermes-builtin-ui` + Timer für Backup,
 Auto-Update, Self-Smoke und Bagatell-Annahme. `llama-swap` läuft als System-Unit.
-## Der Weg einer Idee
+## Die Bau-Pipeline
 ```
-Idee in MC2  →  Gitea-Repo (mit CI-Ampel + VERIFY)  →  in Zed bauen  →  Ampel  →  main
+Idee in MC2  →  Gitea-Repo (mit CI-Ampel + VERIFY)  →  in Agentic IDE bauen  →  Ampel  →  main
-     └── oder nachts: Hermes-Cron → opencode-lauf.sh → dieselben Regeln
+     └── autonomes Vibe Coding via OpenCode Desktop + MCP
 ```
 Jedes neue Repo wird von [`deploy/gitea-repo-create.sh`](deploy/gitea-repo-create.sh) **mit beiden
 Wächtern geboren**:
 - **`.gitea/workflows/ci.yml`** — die Außen-Prüfung nach dem Push (Gitea Actions)
- **`VERIFY`** — die Innen-Prüfung: eine Zeile, wie man das Projekt testet. Das OpenCode-Plugin
+- **`VERIFY`** — die Innen-Prüfung: eine Zeile, wie man das Projekt testet. Die Agentic IDE
-  führt sie nach jeder Etappe aus und gibt rote Tests dem Agenten **sofort** zurück, statt sie
+  führt sie im Mix-Ansatz vor jedem Push aus, um Code-Fehler ("Quality Gap") abzufangen.
-  erst der CI zu zeigen. Keine `VERIFY`-Datei = Prüf-Tor aus.
+  Keine `VERIFY`-Datei = Prüf-Tor aus.
 ## Modelle & Rollen
-Gemessen auf der Box (25.07.2026, Vulkan, Q4):
+Gemessen auf der Box (Stand: 27.08.2026, Vulkan b10653):
 | Rolle | Modell | Tempo | Aufgabe |
 |---|---|---|---|
-| `coder` | Qwen3-Coder-Next (80B-A3B) | **51,5 t/s** · Prefill **754 t/s** | Plant und baut — Kopf der Coding-Mannschaft |
+| `coder` | Qwen3.8-27B (dicht, 27B) | **12,7 t/s** | Plant und baut — der Haupt-Coder. **131k Kontext** (ganzer Slot), multimodal |
-| `hermes` / `fast` | Qwen3.6-35B-A3B | **69,6 t/s** | Lucys Hirn **und** der Sucher-Subagent. Immer warm |
+| `hermes` / `fast` | Qwen3.6-35B-A3B | **69,6–90 t/s** | Lucys Hirn **und** Sucher-Subagent. Immer warm, 65k/Slot |
-| `kritiker` | Devstral-Small-2-24B | **15,0 t/s** · Prefill **265–318 t/s** | Liest gegen — bewusst **fremde Modellfamilie** (Mistral statt Qwen) |
+| `debugger` | Muse-Glimmer-30B | **40–50 t/s** (DFlash) | Runtime-Debugger & Fehler-Diagnostiker (multimodal) |
-| `vision` | Qwen3-VL-30B-A3B | auf Abruf | Lucys Augen |
+| `vision` | Qwen3-VL-30B-A3B | auf Abruf | Lucys Augen (On-Demand) |
-| `heavy` | gpt-oss-120b | nur nachts | Chef-Gutachter (4:30). **Nie tagsüber** — verdrängt das warme Set |
+| `heavy` | gpt-oss-120b | nur nachts | Chef-Gutachter (4:30 Uhr). **Nie tagsüber** — verdrängt das warme Set |
-| `embed` · `reranker` | Qwen3 0.6B | immer warm | Gedächtnis + Feinsortierung |
+| `embed` · `reranker` | Qwen3 0.6B | immer warm | Vektorsuche + Feinsortierung |
-‼️ **Der Kritiker ist bewusst auf 16k Kontext gedeckelt.** Devstral ist ein *dichtes* Modell —
+> Sieben Rollen, mehr nicht. Frühere Fassungen listeten hier auch `kritiker`, `scout` und
-auf dieser bandbreitenbegrenzten Box bricht sein Prefill mit wachsendem Kontext ein (bei 32k
+> `dense-planer` — die Modell-Konsolidierung vom 19.08. hat sie entfernt (ein Coder, ein
-gemessene 63 t/s ≈ **9 Minuten nur zum Lesen**). Mit dem 16k-Deckel bleibt der schlimmste Fall
+> Agent-Hirn). Der dichte 27B ist seither nicht mehr „Planer" neben dem Coder, sondern **ist**
-je Review unter einer Minute. Deshalb ist er der **Gegenleser für Etappen**, nicht der Coder —
+> der Coder. Details: `docs/wissen/STACK.md`.
-als Coder ist er auf dieser Box disqualifiziert (siehe VERDIKTE).
+
 ‼️ **Dichte Modelle sind auf dieser Box bandbreitengebunden.** Der Prefill bricht mit wachsendem
 Kontext ein — beim früheren Kritiker (Devstral, dicht) waren bei 32k gemessene 63 t/s ≈ **9 Minuten
 nur zum Lesen**, weshalb er hart auf 16k gedeckelt war. Das gilt weiter für jedes dichte Modell:
 `coder` (Qwen3.8-27B) liefert ~12,7 t/s gegen ~90 t/s des MoE-Hirns — **kein Konfigfehler, sondern
 das 215-GB/s-Limit der Plattform.** Der Kritiker selbst ist seit dem 19.08. nicht mehr im Stack.
 ‼️ **Speicher-Regel:** `Warm-Set + größtes On-Demand-Modell ≤ ~115 GB`. Die ko-residente Gruppe
-(`groups.brains` in der llama-swap-Config) muss **`persistent: false`** sein — sonst räumt
+(`groups.brains`) steht auf **`persistent: true`** (Verdrängungsschutz; live gegengeprüft
-llama-swap vor einem großen Modell nicht ab und der Kernel schießt Prozesse ab. Details und
+27.08.2026). Wichtig ist nicht der Schalter, sondern: **alles, was gleichzeitig warm sein muss,
 gehört in DIESELBE Gruppe** — zwei Gruppen verdrängen sich gegenseitig, und `persistent` schützt
 nicht davor (gemessen 25.07.). Details und
 Messwerte: [`docs/wissen/VERDIKTE.md`](docs/wissen/VERDIKTE.md).
 ## Qualitäts-Tore
-1. **Werkzeug-Zaun** ([`deploy/opencode/plugin/`](deploy/opencode/plugin/)) — blockt `git push`,
+1. **Prüf-Tor** — `VERIFY` nach jeder Etappe; rot → der Agent (OpenCode Desktop) repariert lokal nach.
-   `rm -rf`, `sudo`, `curl | sh` und Fremd-Hosts im Agentenlauf.
+2. **CI-Ampel** — Lint (ruff) · Import/Syntax (compileall) · Frontend-Build. Läuft in Gitea.
 2. **Prüf-Tor** — `VERIFY` nach jeder Etappe; rot → der Agent repariert selbst weiter (max. 3 Runden).
 3. **Governor** ([`deploy/governor/`](deploy/governor/)) — zählt Tokens ehrlich (aus den echten
   `usage.prompt_tokens` jeder Antwort, selbstkalibrierend). Bei ~45.000: Savepoint schreiben und
   Sitzung sauber beenden. Bei ~50.000: harter Riegel. Sichtbar als Kachel im Cockpit.
 4. **CI-Ampel** — Lint (ruff) · Import/Syntax (compileall) · Frontend-Build. Läuft bei jedem Push.
 Gemeinsame Lehre dahinter: **Wissen lebt in Datei + git, nicht im schrumpfenden Chat-Kontext.**
 Kontext-Komprimierung löscht still die Regeln mit.
@@ -98,7 +98,7 @@ Kontext-Komprimierung löscht still die Regeln mit.
 ## API (Auswahl)
 `health · models/* · discover · fit · groups · routing/* · system/* · maintenance/* · connect ·
-memory/* · agent/* · **governor** · ideen/* · auftragsbuch/* · chronik · eigenleben · wissen ·
+memory/* · agent/* · ideen/* · auftragsbuch/* · chronik · eigenleben · wissen ·
 zeitmaschine/* · reminders/* · voice/* · events (SSE)`
 OpenAI-kompatibel: `/v1/chat/completions`, `/v1/completions`. MCP-Server: [`mcp/`](mcp/).
@@ -128,13 +128,12 @@ Dienst-Neustart. Vor jedem Commit lohnt der Ampel-Vorlauf: `ruff check .` und `n
 | `MC_LLAMA_SWAP_URL` | `http://127.0.0.1:8080` | Engine/Router |
 | `MC_CONFIG_PATH` | `/etc/llama-swap/config.yaml` | llama-swap-Config |
 | `MC_V1_UPSTREAM` | – | gesetzt → `/v1` geht an `mc2-gateway` (`:9010`) statt in-process |
-| `MC_GOVERNOR_URL` | `http://127.0.0.1:8100` | Token-Wächter für die Cockpit-Kachel |
+
 | `MC_ENGINE_PATH` | `/opt/llamacpp-vulkan` | aktive Engine (Vulkan-Build) |
 | `MC_REWARM_ENABLED` | `1` | Warm-Set-Wächter (auf der Box bewusst `0`) |
 | `MC_DRAFTS_DIR` · `MC_SPEC_TYPE` | `$MODELS/drafts` · `draft-simple` | Spekulatives Dekodieren |
-Governor-eigene Schalter (`GOV_THRESHOLD`, `GOV_HARD_CEILING`, `GOV_EXEMPT_MODELS`, …):
+
 [`deploy/governor/README.md`](deploy/governor/README.md).
 ## Weiterlesen
@@ -146,5 +145,5 @@ Governor-eigene Schalter (`GOV_THRESHOLD`, `GOV_HARD_CEILING`, `GOV_EXEMPT_MODEL
 | [`docs/AUFTRAGSBUCH.md`](docs/AUFTRAGSBUCH.md) | Vorschlags-Inbox und das Ein-Klick-Gate |
 | [`docs/wissen/VERDIKTE.md`](docs/wissen/VERDIKTE.md) | **Finale Technik-Entscheide — nicht neu aufrollen** |
 | [`docs/wissen/FALLEN.md`](docs/wissen/FALLEN.md) · [`docs/wissen/OFFENE-FAEDEN.md`](docs/wissen/OFFENE-FAEDEN.md) | Stolpersteine · offene Punkte |
-| [`deploy/opencode/README.md`](deploy/opencode/README.md) | Coding-Bahn: Mannschaft, Verteilung, Fallen |
+
 | [`AGENTS.md`](AGENTS.md) | Arbeitsregeln für Agenten in diesem Repo |
@@ -1,50 +1,57 @@
-# Savepoint — Mission Control 2.0 (MC2)
+# Savepoint — Mission Control 2.0 (MC2)
-
+
-_Stand: 2026-07-05. Zustands-Snapshot für einen externen Code-Review (Antigravity). Zuerst
+_Stand: 2026-08-20, nach der Aufräum-Runde. Alle Zahlen hier sind **auf der Box gemessen**, nicht
-`AGENTS.md` lesen (Projekt-Regeln), dann diese Datei (wo wir stehen), dann `README.md`/`docs/`._
+aus Doku übernommen._
-
+
-## Was das ist (in einem Satz)
+## Was das ist (in einem Satz)
-MC2 ist die **Web-Admin-Konsole** einer 100 % lokalen KI-Appliance („die Box", Bosgame M5 / AMD
+MC2 ist die **Web-Admin-Konsole** einer 100 % lokalen KI-Appliance („die Box", Bosgame M5 / AMD
-Strix Halo, 128 GB Unified RAM, llama.cpp-Vulkan). Sie verwaltet Engine, Modelle, Gedächtnis,
+Strix Halo, 128 GB Unified RAM, llama.cpp-Vulkan). Sie verwaltet Engine, Modelle, Gedächtnis,
-Agenten-Status, Updates & Wartung — und dient teils als Gedächtnis-Oberfläche für die Sprach-
+Agenten-Status, Updates & Wartung — und dient als Steuerpult für die autonome KI („Lucy").
-Begleiterin „Lucy".
+
-
+## Architektur (Kurzform — Details in AGENTS.md/docs/)
-## Architektur (Kurzform — Details in AGENTS.md/docs/)
+- **Backend** `backend/` — FastAPI, `:9001` als systemd-**User-Dienst** (reboot-fest, sudo-frei).
- **Backend** `backend/` — FastAPI, `:9001` als systemd-**User-Dienst** (reboot-fest, sudo-frei).
+- **Frontend** `frontend/` — React/Vite/Tailwind/shadcn. **`frontend/dist` ist ABSICHT im git**
-  Router (`routers/`, dünn) → Logik (`services/`, Single Source of Truth).
+  (Box hat kein Node; Backend liefert die gebauten Assets direkt aus).
- **Frontend** `frontend/` — React/Vite/Tailwind/shadcn. **`frontend/dist` ist ABSICHT im git**
+- **MC2-Gateway** `:9010` (`/v1`-Datenpfad, model:auto Routing + native Bildweiche).
-  (Box hat kein Node; Backend liefert die gebauten Assets aus).
+- **Modell-Router** `:8080` (llama-swap v250, Vulkan/RADV Engine b10502).
- **Eingebautes Gateway** `:9001/v1` (OpenAI-kompatibel) → llama-swap `:8080` (Engine, Vulkan/RADV).
+- **Hermes Agent** `:8642` (`hermes-gateway`, v0.20.4) + `hermes dashboard` auf `:9119` (nur Loopback).
- **Sidecars:** `mem0_service/` (Mem0-Gedächtnis), `voice_service/` (STT/TTS für den „Sprechen"-Tab),
+- **Sidecars:** `voice_service/` (:8650, faster-whisper STT + Piper TTS), `mcp/` (4 MCP-Server),
-  `mcp/` (MCP-Server), `hermes/` (Hermes-Agent-Plugin), `client/hermes-pc` (PC-Executor).
+  `client/hermes-pc` (PC-Executor :7777).
-
+  ‼️ `mem0_service/` liegt noch im Baum, ist aber **stillgelegt** — `:8765` antwortet nicht.
-## Aktueller Zustand
+
- **Stabil, in Produktion, „MC2 Final".** Ein Neubau („MC3") wurde bewusst VERWORFEN — MC2 wird
+## Modelle live (gemessen 20.08.2026)
-  sauber gehalten und eingefroren, nicht neu erfunden.
+| Rolle (Alias) | Modell | Tempo | Zustand |
- **Autonomie-Ausbau abgeschlossen** (Observability-Latenztrace, Fremd-Modell-Kritiker/Härtung,
+|---|---|---|---|
-  nächtliches „Dreaming" mit Wissens-Vault) — jeweils propose-only, Mensch = Gate.
+| `hermes` / `fast` | Qwen3.6-35B-A3B (MoE, DFlash) | **95,7 t/s** · Prompt 221 t/s | immer warm |
- **Zuletzt (Commit `ff1b9a0`, 05.07.):** `coder-lite` (Qwen3-Coder-30B) entfernt; der Verbinden-Tab
+| `coder` | Qwen3.8-27B (dicht, Vision) | **12,6 t/s** · Prompt 144 t/s | ttl 5400, ~29 s Kaltstart |
-  (`services/connect.py`) empfiehlt IDEs jetzt die realen Direkt-Modelle `coder`/`heavy`/`vision`
+| `debugger` | Muse-Glimmer-30B (DFlash) | — | ttl 600 |
-  statt der virtuellen „coding"-Lane. Davor u. a. Engine-Update-Fix, Hermes-Terminal same-origin.
+| `heavy` | gpt-oss-120b | — | on-demand |
- **Modelle live:** hermes=Qwen3.6-35B-A3B (Agent-Hirn, immer warm) · coder=Qwen3-Coder-Next ·
+| `vision` | Qwen3-VL-30B-A3B-Instruct | — | on-demand |
-  heavy=gpt-oss-120b · vision=Qwen3-VL-30B · scout=GLM-4.6V · embed. Warm-Set = hermes+vision+embed.
+| `embed` / `reranker` | Qwen3-Embedding-0.6B / Qwen3-Reranker-0.6B | — | immer warm |
-
+
-## Nordstern & Randbedingungen (WICHTIG für den Review)
+Warm-Gruppe `brains` = embed + reranker + Qwen3.6-35B-A3B. Warm-Wächter weckt nur `fast`.
- **Zieht ohne Wartung über JAHRE durch.** Robustheit + Einfachheit schlagen Features. Der Betreiber
+
-  ist **kein Entwickler** — alles muss reboot-/update-fest und selbsterklärend sein.
+**Hintergrund zum Tempo:** Strix Halo liefert ~215 GB/s Speicherbandbreite. Ein *dichtes* Modell
- **100 % lokal, kein Cloud-Zwang** (Privatsphäre ist der Sinn). Hardware-Decke: ~124 GB, ein Topf.
+muss pro Token seine vollen Gewichte lesen → 17 GB ÷ 215 GB/s ≈ 12,6 t/s ist das **Hardware-Limit**,
- **Lucy ist ein SEPARATES Repo** (`F:\Coding Stuff\lucy`) — **nicht Teil dieses Reviews.**
+kein Konfigurationsfehler. MoE-Modelle lesen pro Token nur einen Bruchteil und sind darum ~8× schneller.
-
+
-## Bekannte raue Kanten (Kandidaten — gern bestätigen/erweitern)
+## Aufgeräumt am 20.08.2026
- Doku-Drift möglich: `AGENTS.md` nennt „Box läuft in UTC" — die Box wurde inzwischen auf
+- CI-Ampel wieder **grün** (Lauf #77) — zwei ungenutzte `MEM0_SERVICE_URL`-Importe entfernt.
-  `Europe/Berlin` umgestellt.
+- Kaputter systemd-Timer `mc2-morgen-digest` abgeschaltet (der Hermes-Cron macht die Arbeit).
- Alte, disabled v1-System-Unit `mission-control.service` liegt kosmetisch herum (sudo zum Entfernen).
+- `mcp-stderr.log` (27 MB, 238k Ping-Zeilen) geleert.
- Ein paar frühere Frontend-Monolithen wurden entflochten; Rest-Altlasten möglich.
+- Config-Drift aufgelöst: Repo == `/etc/llama-swap/config.yaml`. Warm-Set-Idee geparkt auf
-
+  Branch `parked/warm-set-5d93822`.
-## Was NICHT empfohlen werden soll (bereits entschieden)
+- Entfernt: Governor-Reste, OpenCode-/aider-Reste (853 MB), 61 alte Backup-Dateien,
-Cloud-Migration · Voll-Rewrite · schwere neue Frameworks · Engine-/Modell-Wechsel, die nicht in
+  verwaiste Modelle Devstral-Small-2 + GLM-4.6V-Flash + mem0 (21,5 GB) → `/srv/models` 209 → 189 GB.
-124 GB passen · `frontend/dist` aus git nehmen (Absicht) · Security-Config anfassen. Erwünscht sind
+- **Fähigkeiten repariert:** `orchestrator`- und `wartung`-Skill sowie `fremdblick.sh` zeigten auf
-**Bugs, Fragilität, tote Pfade, Sicherheitslücken, Vereinfachung (KISS/DRY), Wartbarkeit.**
+  gelöschte Modelle (`Qwen3-Coder-Next`, `GLM-4.6V-Flash`, `GLM-4.7-Flash`) → der Kritiker-Gate war
-
+  stumm kaputt. Jetzt auf **Rollen-Aliase** umgestellt, damit Modellwechsel sie nicht mehr brechen.
-## Letzter Sicherungspunkt
+- Alles Gelöschte liegt gesichert in `~/archiv-aufraeumen-20260820/` (11 MB).
- git `ff1b9a0` „coder-lite raus + Verbinden-Tab auf echte Direkt-Modelle" (auf `main`, deployt, live).
+
 ## Offen
 - `mem0_service/` + `_mem0_reachable()` in `backend/routers/system.py` ausbauen (toter Port).
 - `~/.hermes/scripts/fremdblick.sh` ist **unversioniert** — gehört ins Repo.
 - MCP-Log dauerhaft deckeln (Hermes' `max_size_mb` greift für gekapertes stderr nicht).
 - Verschwundene Wächter: Ampel-Wächter, Prüfstand, Stack-Rundumschlag.
 - Coder-Tempo: Entwurfsmodelle für spekulatives Dekodieren liegen ungenutzt unter
  `/srv/models/Qwen3.8-27B-DFlash2-GGUF/`.
@@ -25,25 +25,22 @@ from routers import (
    chronik,
    connect,
    console,
    eigenleben,
    events,
    gateway_proxy,
    governor,
    health,
    hermes_ui,
    ideen,
    maintenance,
    memory,
    models,
    routing,
    skills,
    system,
    voice,
    wissen,
    zeitmaschine,
 )
 from routers import reminders as reminders_router
-from services import ketten_digest, metrics_history, reminders, sentry, warmer
+from services import metrics_history, reminders, sentry, warmer
 from services import memory as memory_svc
 from starlette.requests import Request
 # Zentrales Logging — Level via MC_LOG_LEVEL (INFO default). Eine Konfiguration
@@ -69,18 +66,8 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
    if sentry.ENABLED:
        tasks.append(asyncio.create_task(sentry.sentry_loop()))
    tasks.append(asyncio.create_task(reminders.reminders_loop()))
    if ketten_digest.ENABLED:
        # Werkstatt-Status aufs Handy: Fragen sofort, Meilensteine sofort, sonst 60-min-Puls.
        tasks.append(asyncio.create_task(ketten_digest.digest_loop()))
    # 24-h-Metrik-Verlauf (Cockpit-Zeitachse): 10-s-Sampler, Ringpuffer, persistiert.
    tasks.append(asyncio.create_task(metrics_history.sampler_loop()))
    if memory_svc.AUTO_DEDUPE_ENABLED:
        tasks.append(asyncio.create_task(memory_svc.auto_dedupe_loop()))
        log.info(
            "Mem0-Auto-Dedupe aktiv (alle %ss, Schwelle %s)",
            memory_svc.AUTO_DEDUPE_INTERVAL,
            memory_svc.AUTO_DEDUPE_THRESHOLD,
        )
    # Geteilter HTTP-Client zur lokalen Engine: Keep-Alive/Connection-Pooling statt neuer Client
    # pro /v1-Anfrage (spart Sockets/TIME_WAIT unter parallelen Agent-Strömen von Zed/Kilo).
    app.state.gw_client = httpx.AsyncClient(
@@ -120,8 +107,8 @@ app.include_router(health.router)
 app.include_router(models.router)
 app.include_router(routing.router)
 app.include_router(system.router)
 app.include_router(connect.router)
 app.include_router(memory.router)
 app.include_router(agent.router)
 app.include_router(
    voice.router
@@ -142,11 +129,10 @@ app.include_router(maintenance.router)
 app.include_router(auftragsbuch.router)   # Vorschlags-Inbox (Mensch-Gate als Klick)
 app.include_router(ideen.router)          # Ideen-Queue (natives Hermes-Kanban) — Tür der Zentrale
 app.include_router(chronik.router)        # Timeline der autonomen Taten (Announce-Store)
 app.include_router(governor.router)       # Token-Wächter (:8100) — Zählerstand fürs Cockpit
 app.include_router(eigenleben.router)     # „Von allein": Skills + Vorschlags-Bilanz der Box
 app.include_router(events.router)         # SSE-Eventstrom /api/events (P3a) — Invalidation-Bus
 app.include_router(wissen.router)         # Wissens-Vault (Traum-Notizen) read-only
 app.include_router(zeitmaschine.router)   # Snapshots ansehen + Ein-Klick-Restore (detached)
 app.include_router(skills.router)         # Skills & Jobs Dashboard
 app.include_router(
    console.router
 )  # Box-Konsole (ttyd) same-origin durchreichen — VOR dem SPA-Catch-all
@@ -19,13 +19,9 @@ MODELS_DIR = Path(os.environ.get("MC_MODELS_DIR", "/srv/models"))
 # Persistent neben den Modellen (übersteht Deploys). TTL = Frische-Fenster.
 DISCOVER_CACHE_PATH = Path(os.environ.get("MC_DISCOVER_CACHE", str(MODELS_DIR / "mc2-discover.json")))
 DISCOVER_TTL = int(os.environ.get("MC_DISCOVER_TTL", "43200"))  # 12 h
-# Geteiltes Gedächtnis (SQLite, WAL). Persistent neben den Modellen.
+# Gedächtnis: MC2 hält KEINS mehr. Bis August 2026 lief hier erst eine eigene SQLite-DB,
-# Hinweis: nur noch für die einmalige Mem0-Migration relevant — das aktive Gedächtnis
+# dann ein semantischer Sidecar auf :8765 — beides ist abgelöst, der Port ist tot.
-# liegt jetzt in Mem0/Chroma hinter dem Sidecar (siehe MEM0_SERVICE_URL).
+# Einzige Gedächtnis-Wahrheit ist jetzt Hermes selbst (HERMES_API_URL, siehe unten).
 MEMORY_DB = Path(os.environ.get("MC_MEMORY_DB", str(MODELS_DIR / "mc2-memory.db")))
 # Mem0-Sidecar (auto-lernendes, semantisches Gedächtnis). Läuft im ~/.mem0/venv (Python 3.12),
 # weil mem0+chromadb unter dem 3.14-Backend nicht laufen. MC2 spricht ihn lokal per HTTP an.
 MEM0_SERVICE_URL = os.environ.get("MC_MEM0_SERVICE_URL", "http://127.0.0.1:8765").rstrip("/")
 # Befehl-Vorlage für llama-swap: {model}=GGUF-Pfad, {ctx}=Kontext, ${PORT} bleibt stehen.
 # Hinweis: --prompt-cache/--prompt-cache-all sind llama-CLI-Flags, NICHT llama-server —
 # llama-server lehnt sie ab ("invalid argument") und startet dann nicht. Prompt-Caching
@@ -72,7 +68,7 @@ V1_UPSTREAM = os.environ.get("MC_V1_UPSTREAM", "").rstrip("/")
 HERMES_API_URL = os.environ.get("HERMES_API_URL", "http://127.0.0.1:8642").rstrip("/")
 # API-Key der Hermes-`api_server`-Plattform (~/.hermes/.env: API_SERVER_KEY). Nötig für
 # /v1/chat/completions (Voice-Pipeline) — Bearer-Auth, sonst 401. Derselbe volle Agent
-# (Tools + geteiltes Mem0) wie CLI/Telegram, nur über HTTP.
+# (Tools + eigenes Gedächtnis) wie CLI/Telegram, nur über HTTP.
 def _read_hermes_env(key: str) -> str:
    """Liest einen Schlüssel aus ~/.hermes/.env (Fallback, falls nicht in der Prozess-Env).
    Der MC2-Dienst erbt die Hermes-Secrets sonst nicht."""
@@ -97,7 +93,8 @@ HERMES_API_KEY = (
 HERMES_API_MODEL = os.environ.get("HERMES_API_MODEL", "hermes")
 # --- Voice-Sidecar (STT faster-whisper + TTS Piper/Chatterbox) ---------------
-# Eigenes Python-3.12-venv (~/.voice/venv), analog Mem0-Sidecar. MC2 proxyt nach außen.
+# Eigenes Python-3.12-venv (~/.voice/venv), weil Parakeet/Piper nicht ins 3.14-Backend-venv
 # passen. MC2 proxyt nach außen.
 VOICE_SERVICE_URL = os.environ.get("MC_VOICE_SERVICE_URL", "http://127.0.0.1:8650").rstrip("/")
 # Box-Konsole: ttyd-Web-Terminal (echte Login-Shell). Bindet NUR an Loopback
 # (127.0.0.1:7682, base-path /console) und wird von MC2 über den ohnehin offenen Port 9001
@@ -108,8 +105,12 @@ BOX_CONSOLE_UPSTREAM = os.environ.get("MC_BOX_CONSOLE_UPSTREAM", "http://127.0.0
 # Öffentlicher, gleicher-Ursprung-Pfad, unter dem MC2 die Konsole ausliefert (iframe-Ziel).
 BOX_CONSOLE_PATH = "/console/"
 # Eingebaute Hermes-Web-GUI (`hermes serve`/`dashboard` — die richtige Agent-Oberfläche mit
-# Threads/Tool-Calls, die auch die Electron-Desktop-App umhüllt). Bindet NUR an Loopback
+# Threads/Tool-Calls, die auch die Electron-Desktop-App umhüllt). ‼️ Sie bindet NICHT auf Loopback:
-# (127.0.0.1:9119, kein Login — LAN-Trust wie Terminal/Konsole) und wird von MC2 same-origin unter
+# ein systemd-Drop-in überschreibt `--host 127.0.0.1` mit `0.0.0.0` und setzt dafür ein
 # Session-Token. Dass sie trotzdem nicht im LAN hängt, liegt allein an ufw (9119 ist nicht
 # freigegeben — am 27.08.2026 von einem zweiten Rechner aus gegengeprüft). Wer die Firewall
 # anfasst, öffnet damit auch diese Oberfläche. MC2 erreicht sie über Loopback und reicht sie
 # same-origin unter
 # /hermes-ui/ durchgereicht (routers/hermes_ui.py). Anders als das ttyd-Terminal ist es eine volle
 # SPA → das Bundle wird mit Vite-base=/hermes-ui/ gebaut, damit Assets/API/WS unter dem Präfix
 # liegen; der Proxy streift /hermes-ui ab. Kein eigener Firewall-Port nötig.
@@ -2,6 +2,16 @@
  "_comment": "Kuratierter Modell-Katalog (Cookbook) für Strix Halo / Ryzen AI MAX+ 395 — 128GB unified, bandbreiten-limitiert (256 GB/s). MoE-first. EINE Quelle der Wahrheit für KORREKTE Metadaten (total/active params, moe, generation) → präzise Empfehlungen ohne Namens-Raterei. Inspiriert vom Odysseus-Cookbook (statischer, validierter Katalog statt Live-Scraping). Erweiterbar: neue Modelle hier eintragen. Felder: name (Match-Identifier), repo (HF org/name für Install), family (+Subtyp), generation (numerisch, für Upgrade-Vergleich), total_params_b, active_params_b (=total bei dense), moe, quant, ctx (empfohlen), tools, vision.",
  "version": "2026-07-03",
  "models": [
    {
      "role": "debugger", "name": "Muse-Glimmer-30B", "repo": "unsloth/Muse-Glimmer-30B-GGUF",
      "family": "muse", "generation": 1.0, "total_params_b": 30, "active_params_b": 30,
      "moe": false, "quant": "Q4_K_XL", "ctx": 65536, "tools": true, "vision": true
    },
    {
      "role": "coder", "name": "Qwen3.8-27B", "repo": "unsloth/Qwen3.8-27B-GGUF",
      "family": "qwen", "generation": 3.8, "total_params_b": 27, "active_params_b": 27,
      "moe": false, "quant": "Q4_K_M", "ctx": 65536, "tools": true, "vision": true
    },
    {
      "role": "fast", "name": "Qwen3.6-35B-A3B", "repo": "Qwen/Qwen3.6-35B-A3B-GGUF",
      "family": "qwen", "generation": 3.6, "total_params_b": 35, "active_params_b": 3,
@@ -2,6 +2,7 @@
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from services import agent_aktivitaet
 from services.agent import agent_status, hermes_brain_info, set_agent_brain, update_brain_model
 router = APIRouter(prefix="/api")
@@ -39,3 +40,13 @@ def set_brain(body: SetBrainReq) -> dict:
 def set_brain_model(body: BrainReq) -> dict:
    ok = update_brain_model(body.model)
    return {"ok": ok}
@router.get("/agent/aktivitaet")
 def aktivitaet(limit: int = 60) -> dict:
    """Werkzeug-Verlauf des Agenten (v3-Umbau P6).
    Gelesen aus Hermes' eigenem Log — MC2 patcht dort nichts, es schaut nur zu. Was
    NICHT drin steht (Denkstrom, Werkzeug-Argumente), verspricht die Ansicht auch nicht.
    """
    return agent_aktivitaet.uebersicht(max(1, min(limit, 300)))
@@ -1,4 +1,4 @@
-"""Connect-Endpoint: erzeugt IDE-/Agent-Snippets (auf den Gateway + Memory-MCP)."""
+"""Connect-Endpoint: erzeugt IDE-/Agent-Snippets für den Gateway."""
 from fastapi import APIRouter
 from services.connect import DEFAULT_HOST, build_snippets, check_health
@@ -7,14 +7,11 @@ router = APIRouter(prefix="/api")
@router.get("/connect")
-def connect(host: str = DEFAULT_HOST, mcp_path: str | None = None) -> dict:
+def connect(host: str = DEFAULT_HOST) -> dict:
-    kwargs = {}
+    return build_snippets(host=host)
    if mcp_path:
        kwargs["mcp_script_path"] = mcp_path
    return build_snippets(host=host, **kwargs)
@router.get("/connect/health")
 def connect_health() -> dict:
-    """Live-Status der zwei Leitungen (Gateway + Gedächtnis) für den Verbinden-Tab."""
+    """Live-Status der drei Leitungen (Gateway, Gedächtnis, Desktop-Gateway) für den Verbinden-Tab."""
    return check_health()
@@ -1,54 +0,0 @@
 """Eigenleben-Endpoints — „Von allein“-Ansicht (Skills + Vorschlags-Bilanz), read-only."""
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from services import eigenleben
 router = APIRouter(prefix="/api")
 class SkillItem(BaseModel):
    id: str
    name: str
    kategorie: str | None
    aktiv: bool | None
    beschreibung: str
    version: str
    autor: str
    herkunft: str
    herkunft_label: str
    genutzt: int
    zuletzt_genutzt: str | None
    erstellt: str | None
    status: str
    geaendert: float
 class EigenlebenOverviewResponse(BaseModel):
    available: bool
    skills: list[SkillItem]
    selbst_erstellt: int
    bilanz: dict
 class SkillTextResponse(BaseModel):
    id: str
    text: str
@router.get("/eigenleben", response_model=EigenlebenOverviewResponse)
 def get_overview() -> dict:
    return eigenleben.overview()
 # :path — Kategorie-Skills haben einen Schrägstrich in der ID (autonomous-ai-agents/
 # hermes-agent). Als normales {skill_id}-Segment matcht die Route dann nicht, der Request
 # fällt in den SPA-Fallback (index.html, Status 200) und die UI zeigt „Konnte den
 # Skill-Text nicht laden". Die Pfad-Validierung (max. eine Ebene, keine . /..) macht
 # services.eigenleben.skill_text.
@router.get("/eigenleben/skill/{skill_id:path}", response_model=SkillTextResponse)
 def get_skill(skill_id: str) -> dict:
    text = eigenleben.skill_text(skill_id)
    if text is None:
        raise HTTPException(404, "Skill nicht gefunden.")
    return {"id": skill_id, "text": text}
@@ -1,25 +1,30 @@
-"""SSE-Eventstrom (UMBAU v3 P3a) — ein Kanal sagt der Zentrale, WANN neu laden lohnt.
+"""Ereignisstrom — ein Kanal sagt der Zentrale, WANN neu laden lohnt, und schickt Metriken.
-GET /api/events liefert Server-Sent Events. Ein Sammler prüft alle paar Sekunden
+Zwei Endpunkte, ein Sammler:
 billige Fingerabdrücke der ereignishaften Quellen und schickt NUR bei Änderung ein
 `invalidate`-Event mit den React-Query-Keys. Die Wahrheit bleibt in den bestehenden
 Endpunkten — der Strom ist ein reiner Invalidation-Bus, kein zweites Zustandsmodell.
-Quellen: Briefkasten/Chronik (in-process-Cursor), Ideen-Queue ((id,status)-Paare),
+  GET /api/stream   (v3-Umbau P4, 28.08.2026) — der aktuelle Kanal. Zwei Ereignisarten:
-Auftragsbuch + Erinnerungen (Datei-mtimes), geladene Modelle (Running-Set — Idee aus
+      · `invalidate`  Nur bei Änderung, mit den betroffenen React-Query-Schlüsseln.
-der Werkstatt-Karte feature/sse-backend-v1). BEWUSST NICHT dabei: System-/Token-
+      · `metrik`      Jede Sekunde ein Messpunkt (CPU/RAM/GPU/Temp/Token-Zähler).
 Metriken (ändern sich jede Sekunde — da ist Polling das richtige Werkzeug und ein
 invalidate-Event nur Lärm).
-Versöhnt 15.07. abends: Die angenommene Werkstatt-Version nutzte `type:` statt
+  GET /api/events   — der alte Kanal, nur `invalidate`. Bleibt EINE Fassung lang stehen,
-`event:` (ungültiges SSE-Framing → EventSource-Listener feuert NIE), einen globalen
+      weil ein Browser-Tab nach einem Deploy noch das vorige Bündel halten kann und dieses
-Snapshot über alle Clients und einen nicht existierenden Ideen-Endpunkt — Kern
+      nur `/api/events` kennt. Danach entfernen.
 wieder die getestete Hand-Implementierung (E2E: Announce → invalidate binnen
 Sekunden), Modell-Quelle aus der Karte übernommen.
-Frontend-Gegenstück: frontend/src/lib/events.ts (EventSource, invalidiert die
+WARUM METRIKEN JETZT MITKOMMEN: Bis P4 pollte das Frontend `/api/system/status` und
-Caches, entspannt die Fallback-Poller ×5; reißt der Strom, reconnectet EventSource
+`/api/system/token-stats` im 3-Sekunden-Takt — zwei Dauer-Anfragen, unabhängig davon, ob
-selbst und bis dahin pollt die UI wie bisher).
+sich etwas geändert hat, plus sechs weitere langsamere Poller auf der Startseite. Der
 Messpunkt kostet hier 0,2 ms (gemessen); `system_status()` würde 100 ms kosten, weil
 `psutil.cpu_percent(interval=0.1)` wartet. Deshalb der eigene, leichte `metrik_punkt()`.
 WAS BEWUSST NICHT DRIN IST: Ein `agent`-Thema für Lucys Denkschritte. MC2 kann Hermes'
 interne Schritte nicht sehen, ohne dessen Quellcode zu patchen — und das ist per AGENTS.md
 verboten. Eine leere Leitung zu bauen, wäre eine Zusage, die keiner einlöst.
 Die Wahrheit bleibt in den bestehenden Endpunkten: `invalidate` ist ein reiner
 Anstoß-Bus, kein zweites Zustandsmodell. `metrik` ist die einzige Ausnahme — es ist der
 Wert selbst, weil ein Anstoß für eine Zahl, die sich jede Sekunde ändert, nur Lärm wäre.
 Frontend-Gegenstück: frontend/src/lib/events.ts
 """
 import asyncio
@@ -35,7 +40,8 @@ log = logging.getLogger(__name__)
 router = APIRouter(prefix="/api")
-TICK_S = 3.0        # Prüf-Takt des Sammlers (nur Fingerabdrücke, kein Neuberechnen)
+METRIK_S = 1.0      # Takt der Messpunkte
 ABDRUCK_S = 3.0     # Takt der Änderungs-Prüfung (nur Fingerabdrücke, kein Neuberechnen)
 KEEPALIVE_S = 20.0  # Kommentar-Ping, damit Proxies/Browser die Verbindung halten
@@ -66,6 +72,13 @@ def _fingerprints() -> dict[str, object]:
        fp["models"] = json.dumps(sorted(str(m) for m in llamaswap.get_running_models()))
    except Exception:
        pass
    try:  # Jobs (Downloads, Wartung): Zustand + Fortschritt — spart den 3-s-Poller der Schublade
        from services import jobengine
        fp["jobs"] = json.dumps(
            [(j.get("id"), j.get("state"), j.get("progress")) for j in jobengine.public_jobs()]
        )
    except Exception:
        pass
    # Auftragsbuch (Annahme-Status + Karten-Meldungen) & Erinnerungen: Datei-mtimes
    fp["auftragsbuch"] = (_mtime(MODELS_DIR / "mc2-auftragsbuch.json"),
                          _mtime(MODELS_DIR / "mc2-announce-branches.json"))
@@ -73,28 +86,63 @@ def _fingerprints() -> dict[str, object]:
    return fp
-@router.get("/events")
+async def _strom(request: Request, mit_metrik: bool):
-async def events(request: Request) -> StreamingResponse:
+    """Gemeinsamer Kern beider Endpunkte.
-    async def strom():
+
-        # Basislinie JE VERBINDUNG (der Client hat beim Verbinden frisch geladen) —
+    Die Basislinie entsteht JE VERBINDUNG (der Client hat beim Verbinden frisch geladen) —
-        # ein globaler Snapshot würde bei mehreren Clients Events verschlucken.
+    ein globaler Snapshot würde bei mehreren Clients Events verschlucken.
-        alt = _fingerprints()
+    """
-        yield ": verbunden\n\n"
+    alt = _fingerprints()
-        seit_ping = 0.0
+    yield ": verbunden\n\n"
-        while True:
+
-            if await request.is_disconnected():
+    seit_abdruck = 0.0
-                return
+    seit_ping = 0.0
-            await asyncio.sleep(TICK_S)
+    takt = METRIK_S if mit_metrik else ABDRUCK_S
-            seit_ping += TICK_S
+
    while True:
        if await request.is_disconnected():
            return
        await asyncio.sleep(takt)
        seit_abdruck += takt
        seit_ping += takt
        if mit_metrik:
            try:
                from services.system import metrik_punkt
                yield f"event: metrik\ndata: {json.dumps(metrik_punkt())}\n\n"
                seit_ping = 0.0
            except Exception:
                # Ein kaputter Messpunkt darf den Strom nicht reißen — die Ansicht fällt
                # dann auf ihre Poller zurück, das ist besser als eine tote Leitung.
                log.warning("Messpunkt fehlgeschlagen", exc_info=True)
        if seit_abdruck >= ABDRUCK_S:
            seit_abdruck = 0.0
            neu = _fingerprints()
            keys = [k for k, v in neu.items() if k in alt and v != alt[k]]
            alt.update(neu)
            if keys:
                yield f"event: invalidate\ndata: {json.dumps({'keys': keys})}\n\n"
                seit_ping = 0.0
            elif seit_ping >= KEEPALIVE_S:
                yield ": ping\n\n"
                seit_ping = 0.0
-    return StreamingResponse(strom(), media_type="text/event-stream",
+        if seit_ping >= KEEPALIVE_S:
-                             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})
+            yield ": ping\n\n"
            seit_ping = 0.0
 _KOPF = {"Cache-Control": "no-cache", "X-Accel-Buffering": "no"}
@router.get("/stream")
 async def stream(request: Request) -> StreamingResponse:
    """Der aktuelle Kanal: Anstöße UND Messpunkte."""
    return StreamingResponse(_strom(request, mit_metrik=True),
                             media_type="text/event-stream", headers=_KOPF)
@router.get("/events")
 async def events(request: Request) -> StreamingResponse:
    """Alt-Kanal ohne Messpunkte. Nur für Browser-Tabs, die noch ein Bündel von vor
    dem 28.08.2026 halten. Mit der übernächsten Fassung entfernen."""
    return StreamingResponse(_strom(request, mit_metrik=False),
                             media_type="text/event-stream", headers=_KOPF)
@@ -22,6 +22,13 @@ _LANG_DIRECTIVE = os.environ.get(
    "Quellcode, Bezeichner und Shell-Befehle bleiben unverändert.")
 # Deckel für die Bild-Weiche. Ohne ihn wächst die Wartezeit linear mit der Bildzahl:
 # je Bild bis zu 2 Versuche à _BILD_TIMEOUT_S, und der Client hängt so lange am offenen
 # Request. Über _BILD_MAX Bilder wird gar nicht erst beschrieben — der Aufrufer fällt
 # dann auf die normale Vision-Umleitung zurück (ehrlich langsam statt scheinbar hängend).
 _BILD_TIMEOUT_S = float(os.environ.get("MC_CODER_IMAGE_TIMEOUT_S", "240"))
 _BILD_MAX = int(os.environ.get("MC_CODER_IMAGE_MAX", "4"))
 # Bild-Beschreibung für Coder-Ziele: Prompt bewusst auf wörtliche Wiedergabe von
 # Code/Fehlermeldungen getrimmt — der Coder arbeitet nur mit diesem Text weiter.
 _BILD_BESCHREIB_PROMPT = os.environ.get(
@@ -85,6 +92,10 @@ async def _bilder_fuer_coder_beschreiben(body: dict, client, vision_alias: str)
        for i, part in enumerate(m["content"]):
            if isinstance(part, dict) and part.get("type") in IMAGE_PART_TYPES:
                fundstellen.append((m, i, part))
    if len(fundstellen) > _BILD_MAX:
        log.warning("Bild-Weiche v2: %s Bilder (Deckel %s) — Request geht an das Vision-Modell "
                    "statt einzeln beschrieben zu werden", len(fundstellen), _BILD_MAX)
        return False
    for nr, (msg, idx, part) in enumerate(fundstellen, start=1):
        frage = {
            "model": vision_alias,
@@ -99,7 +110,7 @@ async def _bilder_fuer_coder_beschreiben(body: dict, client, vision_alias: str)
        text = ""
        for versuch in (1, 2):
            try:
-                async with httpx.AsyncClient(timeout=240.0) as c:
+                async with httpx.AsyncClient(timeout=_BILD_TIMEOUT_S) as c:
                    r = await c.post(f"{LLAMA_SWAP_URL}/v1/chat/completions", json=frage)
                if r.status_code == 200:
                    text = ((r.json().get("choices") or [{}])[0].get("message") or {}).get("content") or ""
@@ -138,7 +149,15 @@ def _inject_language(body: dict, alias: str) -> None:
 async def models(request: Request):
    client = request.app.state.gw_client  # geteilter Keep-Alive-Client (siehe app.py lifespan)
    r = await client.get(f"{LLAMA_SWAP_URL}/v1/models", timeout=10.0)
-    data = r.json()
+    try:
        data = r.json()
    except ValueError:
        # Engine antwortet, aber nicht mit JSON (Startphase/Fehlerseite) — ehrlicher 502
        # statt eines 500ers aus dem Parser.
        log.warning("/v1/models: Engine-Antwort ist kein JSON (HTTP %s): %.200s", r.status_code, r.text)
        return JSONResponse(
            {"error": {"message": "Engine lieferte keine gültige Modell-Liste.",
                       "type": "upstream_error"}}, status_code=502)
    # Aufgeräumt (07/2026): Die Router-Lanes (coding/chat) werden NICHT mehr als „Modell"
    # angeboten — sie verwirrten (coding vs. coder) und seit dem Zed-Aus wählt sie niemand
    # mehr. Das Routing bleibt erhalten (siehe _proxy), sie stehen nur nicht mehr in der Liste.
@@ -187,7 +206,20 @@ async def models(request: Request):
 async def _proxy(path: str, request: Request):
-    body = await request.json()
+    # Ungültige Payloads gehören dem Client, nicht dem Server: ohne diese Prüfung wirft
    # request.json() bzw. body.get(...) durch und der Aufrufer bekommt einen 500er
    # (gemessen 27.08.2026: Rohtext, leerer Body, JSON-Liste, JSON-String und null — 5/5 mal 500).
    try:
        body = await request.json()
    except Exception:
        return JSONResponse(
            {"error": {"message": "Ungültiger Request-Body: JSON erwartet.",
                       "type": "invalid_request_error"}}, status_code=400)
    if not isinstance(body, dict):
        return JSONResponse(
            {"error": {"message": "Ungültiger Request-Body: JSON-Objekt erwartet, "
                                  f"'{type(body).__name__}' bekommen.",
                       "type": "invalid_request_error"}}, status_code=400)
    _apply_no_think_marker(body)   # Lucy-Voice-Schnellspur: Marker strippen + Thinking aus
    requested = str(body.get("model") or "auto")
    if requested.lower() in ("auto", "chat", "coding"):
@@ -1,40 +0,0 @@
 """Governor — Fenster auf den Token-Waechter (:8100).
 Der Governor ist ein eigenstaendiger, absichtlich winziger Proxy ohne Datenbank: er
 sitzt zwischen den Coding-Agenten und diesem Gateway, zaehlt ehrlich mit (echte
 `usage.prompt_tokens` aus jeder Antwort) und zieht bei ueberlangen Sitzungen die
 Notbremse. Hier wird nichts Neues erhoben — nur sein Status-Endpunkt gleichursprünglich
 fuer die Oberflaeche verfuegbar gemacht, damit das Frontend nicht per CORS auf einen
 zweiten Port ausweichen muss.
 Faellt der Governor aus, liefert dieser Router `ok: false` statt eines Fehlers: die
 Kachel zeigt dann „nicht erreichbar" und das Cockpit bleibt heil.
 """
 import os
 import httpx
 from fastapi import APIRouter
 router = APIRouter(prefix="/api")
 GOVERNOR_URL = os.environ.get("MC_GOVERNOR_URL", "http://127.0.0.1:8100")
@router.get("/governor")
 async def governor_status() -> dict:
    """Momentaufnahme des Token-Waechters. Nie werfen — die Kachel darf nie das Cockpit reissen."""
    try:
        async with httpx.AsyncClient(timeout=3.0) as c:
            r = await c.get(f"{GOVERNOR_URL}/governor/status")
            r.raise_for_status()
            data = r.json()
        data["reachable"] = True
        return data
    except Exception as exc:
        return {
            "ok": False,
            "reachable": False,
            "error": f"{type(exc).__name__}: {exc}",
            "url": GOVERNOR_URL,
        }
@@ -11,7 +11,7 @@ router = APIRouter(prefix="/api")
 class IdeeIn(BaseModel):
    titel: str
    notiz: str = ""
-    welt: str = "box"  # "box" = Werkstatt baut · "ide" = vorbereiten für Zed
+    welt: str = "box"  # "box" = Werkstatt baut · "ide" = vorbereiten für Agentic IDE
    tiefe: str = ""    # nur ide: "simpel" | "gruendlich" (leer = Box schätzt selbst)
    ziel: str = ""     # nur ide-Projekt: "lxc" | "docker" (leer = Box entscheidet)
    art: str = "projekt"  # nur ide: "projekt" (Repo+Roadmap+Bau) | "idee" (nur durchdenken)
@@ -1,19 +1,28 @@
-"""Wartungs-Endpoints: Update-Badge, OS-/Engine-Update, Reboot, Restart, Logs."""
+"""Wartungs-Endpoints: Update-Badge, OS-/Engine-Update, Reboot, Restart, Logs.
-from fastapi import APIRouter, Header, HTTPException
+v3-Umbau P1 (28.08.2026): Das Sudo-Passwort ist hier ersatzlos entfallen. Auf der Box
 gemessen — `sudo -n true` läuft durch, weil `/etc/sudoers` den Dienst-Nutzer mit
 `NOPASSWD: ALL` führt. Das Passwort wurde also nie gebraucht, lag aber im
 `localStorage` des Browsers und reiste bei jedem mutierenden Request mit. Sollte die
 sudoers-Zeile je fallen, meldet `services.maintenance` sauber `password_required`
 statt still zu scheitern — das ist dann ein Konfigurations-Signal und nichts, was man
 mit einem im Browser geparkten Geheimnis übertüncht.
 """
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-from services import maintenance
+from services import geheimnisse, maintenance
 router = APIRouter(prefix="/api")
 class SudoReq(BaseModel):
    sudo_password: str | None = None
 class RestartReq(BaseModel):
    service: str
-    sudo_password: str | None = None
+
 class GeheimnisReq(BaseModel):
    schluessel: str
    wert: str | None = None
@router.get("/maintenance/updates")
@@ -28,32 +37,32 @@ def update_details(kind: str) -> dict:
    return maintenance.update_details(kind)
@router.post("/maintenance/check-updates")
-def check_updates(body: SudoReq) -> dict:
+def check_updates() -> dict:
-    res = maintenance.check_updates_job(body.sudo_password)
+    res = maintenance.check_updates_job()
    if isinstance(res, dict) and not res.get("ok", True):
        return res
    return res
@router.post("/maintenance/os-update")
-def os_update(body: SudoReq) -> dict:
+def os_update() -> dict:
-    res = maintenance.os_update_job(body.sudo_password)
+    res = maintenance.os_update_job()
    if isinstance(res, dict) and not res.get("ok", True):
        return res
    return res
@router.post("/maintenance/engine-update")
-def engine_update(body: SudoReq) -> dict:
+def engine_update() -> dict:
-    res = maintenance.engine_update_job(body.sudo_password)
+    res = maintenance.engine_update_job()
    if not res:
        raise HTTPException(400, "Kein Engine-Update-Befehl gesetzt (MC_ENGINE_UPDATE_CMD).")
    return res
@router.post("/maintenance/swap-update")
-def swap_update(body: SudoReq) -> dict:
+def swap_update() -> dict:
-    res = maintenance.swap_update_job(body.sudo_password)
+    res = maintenance.swap_update_job()
    if not res:
        raise HTTPException(400, "Kein Router-Update-Befehl gesetzt (MC_SWAP_UPDATE_CMD).")
    return res
@@ -65,20 +74,34 @@ def hermes_update() -> dict:
@router.post("/maintenance/update-all")
-def update_all(body: SudoReq) -> dict:
+def update_all() -> dict:
-    return maintenance.update_all_job(body.sudo_password)
+    return maintenance.update_all_job()
@router.post("/maintenance/reboot")
-def reboot(body: SudoReq) -> dict:
+def reboot() -> dict:
-    return maintenance.reboot(body.sudo_password)
+    return maintenance.reboot()
@router.post("/maintenance/restart")
 def restart(body: RestartReq) -> dict:
-    return maintenance.restart_service(body.service, body.sudo_password)
+    return maintenance.restart_service(body.service)
@router.get("/maintenance/logs")
-def logs(service: str, lines: int = 200, x_sudo_password: str | None = Header(None)) -> dict:
+def logs(service: str, lines: int = 200) -> dict:
-    return maintenance.logs(service, lines, x_sudo_password)
+    return maintenance.logs(service, lines)
@router.get("/maintenance/geheimnisse")
 def geheimnisse_status() -> dict:
    """Nur der Zustand — ob ein Token gesetzt ist, niemals sein Wert."""
    return geheimnisse.status()
@router.post("/maintenance/geheimnisse")
 def geheimnisse_setzen(body: GeheimnisReq) -> dict:
    """Setzt (oder löscht bei leerem Wert) ein Geheimnis in der Box-Ablage."""
    if not geheimnisse.setzen(body.schluessel, body.wert):
        raise HTTPException(400, f"Geheimnis '{body.schluessel}' konnte nicht gespeichert werden.")
    return {"ok": True, **geheimnisse.status()}
@@ -1,92 +0,0 @@
 """Memory-Endpoints (geteiltes Gedächtnis). LAN-only, kein Token in 2.0-Phase 3."""
 import time
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from services import memory
 from services.voice_metrics import park, record_stage
 router = APIRouter(prefix="/api")
 class MemIn(BaseModel):
    content: str
    category: str = "knowledge"
    source: str = "manual"
 class MemUp(BaseModel):
    content: str | None = None
    category: str | None = None
 class DedupeIn(BaseModel):
    apply: bool = False
    threshold: float = 0.85
 class LearnIn(BaseModel):
    text: str | None = None
    messages: list[dict] | None = None
    source: str = "auto"
    category: str = "knowledge"
@router.get("/memory/export")
 def export() -> dict:
    return memory.export_text()
@router.get("/memory/graph")
 def graph(min_score: float = 0.45, top_k: int = 3) -> dict:
    """Fakten als Ähnlichkeits-Graph (Knoten + semantische Kanten) für die Visualisierung."""
    return memory.graph(min_score=min_score, top_k=top_k)
@router.post("/memory/learn", status_code=201)
 def learn(body: LearnIn) -> dict:
    """Auto-Lernen: Gesprächs-Turns/Text durchreichen → Mem0 extrahiert Fakten selbst."""
    return memory.learn(text=body.text, messages=body.messages,
                        source=body.source, category=body.category)
@router.post("/memory/dedupe")
 def dedupe(body: DedupeIn) -> dict:
    return memory.dedupe(apply=body.apply, threshold=body.threshold)
@router.get("/memory")
 def list_mem(q: str = "", category: str = "") -> list[dict]:
    # Semantischer Retrieve (q gesetzt) = u.a. Hermes' Mem0-Prefetch VOR jedem Turn. Dauer messen
    # + parken, damit der laufende Voice-Chat-Turn sie als Unter-Detail seiner Hirn-Zeit einsammelt.
    if q:
        _t0 = time.perf_counter()
        res = memory.list_memories(q=q, category=category)
        _ms = (time.perf_counter() - _t0) * 1000.0
        record_stage("memory_retrieve", _ms)
        park("retrieve", _ms)
        return res
    return memory.list_memories(q=q, category=category)
@router.post("/memory", status_code=201)
 def add(body: MemIn) -> dict:
    if body.category not in memory.CATEGORIES:
        raise HTTPException(400, f"Kategorie '{body.category}' unbekannt.")
    return memory.add_memory(body.content, body.category, body.source)
@router.put("/memory/{mid}")
 def update(mid: str, body: MemUp) -> dict:
    res = memory.update_memory(mid, content=body.content, category=body.category)
    if not res:
        raise HTTPException(404, "Eintrag nicht gefunden")
    return res
@router.delete("/memory/{mid}")
 def delete(mid: str) -> dict:
    if not memory.delete_memory(mid):
        raise HTTPException(404, "Eintrag nicht gefunden")
    return {"ok": True}
@@ -4,7 +4,7 @@ import psutil
 from config import HF_DOWNLOAD_ENV, MODELS_DIR
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-from services import budget, discover, hf, jobengine, llamaswap
+from services import budget, discover, geheimnisse, hf, jobengine, llamaswap
 from services.fit import evaluate_fit, max_ctx_for
 router = APIRouter(prefix="/api")
@@ -77,7 +77,9 @@ class InstallReq(BaseModel):
    quant: str = "Q4_K_M"
    ctx: int | None = None
    jinja: bool = False
-    hf_token: str | None = None
+    # Kein hf_token mehr im Request (v3-Umbau P1): der Token lag frueher im localStorage
    # des Browsers und reiste hier mit. Jetzt liegt er auf der Box (services.geheimnisse)
    # und wird unten von dort gelesen — die Oberflaeche sieht ihn nie wieder.
@router.get("/hf/search")
@@ -144,8 +146,8 @@ def install(req: InstallReq) -> dict:
        args.append(info["mmproj"])
    args += ["--local-dir", str(target)]
    env = dict(HF_DOWNLOAD_ENV)
-    if req.hf_token:
+    if token := geheimnisse.hf_token():
-        env["HF_TOKEN"] = req.hf_token
+        env["HF_TOKEN"] = token
    job_id = jobengine.start_job(args, f"download {req.repo}", env=env,
                                 on_done=_apply_role if role else None)
    jobengine.attach_download_progress(job_id, str(target), info["total_bytes"])
@@ -0,0 +1,102 @@
 import os
 import subprocess
 import psutil
 from fastapi import APIRouter
 from pydantic import BaseModel
 router = APIRouter(prefix="/api")
 def _hermes_name(ordner: str) -> str:
    """Repo-Ordnername -> Hermes-Skillname.
    deploy/deploy.sh kopiert `deploy/skills/<name>` nach `~/.hermes/skills/<name mit _>`
    (`tr '-' '_'`), weil Hermes keine Bindestriche in Skillnamen mag. Ohne dieselbe
    Umschreibung hier bekam Hermes den Ordnernamen MIT Bindestrich und fand den Skill
    nicht - betroffen waren 7 der 12 Skills (betrieb-playbook, konzept-fliessband,
    llm-wiki, morning-report, pc-pfad-cache, projekt-start, trend-radar): der Startknopf
    meldete Erfolg, ausgefuehrt wurde nichts. deploy.sh bleibt die Quelle der Wahrheit.
    """
    return ordner.replace("-", "_")
 class RunSkillRequest(BaseModel):
    skill_name: str
@router.get("/skills")
 def list_skills():
    """Listet alle verfügbaren Skills aus dem deploy/skills Verzeichnis auf."""
    # Pfad relativ zu dieser Datei (backend/routers/skills.py)
    current_dir = os.path.dirname(os.path.abspath(__file__))
    repo_root = os.path.dirname(os.path.dirname(current_dir))
    skills_dir = os.path.join(repo_root, "deploy", "skills")
    skills = []
    # Check currently running hermes skill processes
    running_skills = set()
    for p in psutil.process_iter(['name', 'cmdline']):
        try:
            cmdline = p.info.get('cmdline')
            if cmdline and any("hermes" in arg for arg in cmdline):
                for arg in cmdline:
                    if "Führe den " in arg and " Skill aus" in arg:
                        # Extract skill name from "Führe den 'skill_name' Skill aus"
                        import re
                        match = re.search(r"Führe den '(.+?)' Skill aus", arg)
                        if match:
                            running_skills.add(match.group(1))
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass
    if os.path.exists(skills_dir) and os.path.isdir(skills_dir):
        for entry in os.scandir(skills_dir):
            if entry.is_dir():
                # Suche nach SKILL.md für Metadaten
                skill_md_path = os.path.join(entry.path, "SKILL.md")
                description = ""
                if os.path.exists(skill_md_path):
                    try:
                        with open(skill_md_path, "r", encoding="utf-8") as f:
                            # Lese erste Zeilen für Description (YAML Frontmatter)
                            lines = f.readlines()[:10]
                            for line in lines:
                                if "description:" in line.lower():
                                    description = line.split(":", 1)[1].strip().strip('"\'')
                                    break
                                elif "author:" in line.lower() and not description:
                                    description = line.strip()
                    except Exception:
                        pass
                skills.append({
                    "name": entry.name,
                    # Der Name, unter dem Hermes den Skill kennt - auch fuer den Laufend-
                    # Vergleich, weil im Prozess-cmdline genau dieser Name steht.
                    "hermes_name": _hermes_name(entry.name),
                    "description": description or "Keine Beschreibung verfügbar.",
                    "running": _hermes_name(entry.name) in running_skills
                })
    return {"skills": skills}
@router.post("/skills/run")
 def run_skill(req: RunSkillRequest):
    """Startet einen autonomen Skill via Hermes im Hintergrund."""
    hermes_bin = os.path.expanduser("~/.local/bin/hermes")
    if not os.path.exists(hermes_bin):
        # Fallback falls lokal (auf Windows) entwickelt wird
        return {"ok": False, "err": "Hermes CLI nicht gefunden (~/.local/bin/hermes fehlt). Bist du lokal unterwegs?"}
    # Entspricht: hermes -z "Führe den 'X' Skill aus" chat - mit dem Namen, den Hermes
    # nach dem Deploy-Sync wirklich kennt (Bindestriche -> Unterstriche, s. _hermes_name).
    skill = _hermes_name(req.skill_name)
    cmd = [hermes_bin, "-z", f"Führe den '{skill}' Skill aus", "chat"]
    try:
        log_path = os.path.expanduser(f"~/.hermes/logs/skill_{skill.replace('/', '_')}.log")
        os.makedirs(os.path.dirname(log_path), exist_ok=True)
        with open(log_path, "a", encoding="utf-8") as f:
            f.write(f"\n--- Starting Skill: {skill} ---\n")
            subprocess.Popen(cmd, stdout=f, stderr=subprocess.STDOUT)
        return {"ok": True, "msg": f"Skill '{req.skill_name}' erfolgreich angestoßen."}
    except Exception as e:
        return {"ok": False, "err": str(e)}
@@ -10,7 +10,7 @@ import os
 import subprocess
 import httpx
-from config import GATEWAY_URL, HERMES_API_URL, LLAMA_SWAP_URL, MEM0_SERVICE_URL, V1_UPSTREAM, VOICE_SERVICE_URL
+from config import GATEWAY_URL, HERMES_API_URL, LLAMA_SWAP_URL, V1_UPSTREAM, VOICE_SERVICE_URL
 from fastapi import APIRouter
 from pydantic import BaseModel
 from services import backup as backup_svc
@@ -42,13 +42,6 @@ def history(minutes: int = 60) -> dict:
    return metrics_history.history(minutes)
 def _mem0_reachable() -> bool:
    try:
        return httpx.get(f"{MEM0_SERVICE_URL}/health", timeout=2).status_code == 200
    except Exception:
        return False
 def _voice_reachable() -> bool:
    try:
        return httpx.get(f"{VOICE_SERVICE_URL}/health", timeout=2).status_code == 200
@@ -95,12 +88,10 @@ def services() -> dict:
    rows += [
        {"name": "Wächter (Steward)", "unit": "mc2-steward", "url": "",
         "ok": _user_unit_active("mc2-steward"), "scope": "user"},
-        {"name": "Hermes-Gateway", "unit": "hermes-gateway", "url": HERMES_API_URL,
+        {"name": "Hermes-Gateway (Agent & Gedächtnis)", "unit": "hermes-gateway", "url": HERMES_API_URL,
         "ok": a["gateway_reachable"], "scope": "user"},
        {"name": "Hermes-GUI (Desktop-Gateway)", "unit": "hermes-builtin-ui", "url": a["hermes_ui_url"],
         "ok": a["hermes_ui_reachable"], "scope": "user"},
        {"name": "Mem0 (Gedächtnis)", "unit": "mem0-service", "url": MEM0_SERVICE_URL,
         "ok": _mem0_reachable(), "scope": "user"},
        {"name": "Voice (STT/TTS)", "unit": "voice-service", "url": VOICE_SERVICE_URL,
         "ok": _voice_reachable(), "scope": "user"},
        # ttyd hinter dem /console/-Proxy — war als einziger UI-Dienst NICHT in der Liste,
@@ -3,7 +3,7 @@ Voice-Endpoints für „Mit Hermes reden" (Browser-Voice + 3D-Avatar).
 Dünner Layer: STT/TTS werden zum Voice-Sidecar (:8650) geproxyt; der Chat geht an den
 Hermes-`api_server` (:8642, OpenAI-kompatibel) — denselben vollen Agenten mit Tools +
-geteiltem Mem0 wie CLI/Telegram. Mit stabilem `X-Hermes-Session-Id` hält die Plattform den
+eigenem Gedächtnis wie CLI/Telegram. Mit stabilem `X-Hermes-Session-Id` hält die Plattform den
 Transcript server-seitig, daher schickt der Client je Turn nur die neue User-Nachricht.
 LAN-only (kein Token in der 2.0-Phase), wie die übrigen MC2-Endpoints.
@@ -169,7 +169,7 @@ def voice_metrics() -> dict:
@router.get("/voice/trace")
 def voice_trace(limit: int = 20) -> dict:
    """Per-Turn-Trace: die letzten `limit` Chat-Turns mit Stufen-Breakdown (STT · Vision · Hirn ·
-    Generierung, Mem0 als Unter-Detail). Neueste zuerst. Für die Latenz-Ansicht im Cockpit —
+    Generierung). Neueste zuerst. Für die Latenz-Ansicht im Cockpit —
    damit man den EINEN langsamen Turn sieht, den ein Durchschnitt verschluckt."""
    return {"turns": get_trace(limit)}
@@ -289,8 +289,8 @@ async def voice_chat(body: ChatIn) -> StreamingResponse:
        headers["X-Hermes-Session-Key"] = body.session_key
    async def gen():
-        # Per-Turn-Trace: sammelt STT (davor, geparkt) + Vision + Hirn-TTFT + Generierung + Mem0
+        # Per-Turn-Trace: sammelt STT (davor, geparkt) + Vision + Hirn-TTFT + Generierung zu EINEM
-        # (Rückruf während) zu EINEM Datensatz -> die Latenz-Ansicht zeigt den einzelnen Hänger.
+        # Datensatz -> die Latenz-Ansicht zeigt den einzelnen Hänger.
        trace = TurnTrace(session_id=body.session_id, kind="voice")
        first = True
        first_content = True
@@ -325,7 +325,7 @@ async def voice_chat(body: ChatIn) -> StreamingResponse:
            payload = {"model": body.model or HERMES_API_MODEL, "messages": messages, "stream": True}
            # Lucys Hirn (Qwen3.6) ist ein Thinking-Modell -> für die gesprochene Assistentin Thinking AUS,
            # sonst generiert es tausende Reasoning-Token VOR der kurzen Antwort (gemessen: 11k Token, ~30s TTFB).
-            # Gleiches Muster wie die fast-Spur im Gateway (gateway_proxy.py) und die Mem0-Extraktion.
+            # Gleiches Muster wie die fast-Spur im Gateway (gateway_proxy.py).
            if os.environ.get("MC_VOICE_NO_THINK", "1") not in ("0", "false", "False"):
                payload["chat_template_kwargs"] = {"enable_thinking": False}
            try:
@@ -342,7 +342,7 @@ async def voice_chat(body: ChatIn) -> StreamingResponse:
                            if first:  # Time-To-First-Byte des Hermes-Streams (Verbindungs-Overhead)
                                trace.note_ttfb()
                                first = False
-                            # Erster CONTENT-Delta = echte Hirn-Latenz (Agent-Overhead + Mem0 + LLM-TTFT) —
+                            # Erster CONTENT-Delta = echte Hirn-Latenz (Agent-Overhead + Gedächtnis + LLM-TTFT) —
                            # chat_ttfb misst nur den SSE-Start (~5 ms) und ist dafür blind.
                            if first_content and b'"content"' in chunk:
                                trace.note_first_content()
@@ -3,6 +3,7 @@ Wiki in der Zentrale. Bewusst READ-ONLY — geschrieben wird der Vault nur vom T
 (und via Auftragsbuch-Entscheidungen); hier wird nur gelesen und navigiert."""
 import os
 import re
 import time
 from pathlib import Path
@@ -59,7 +60,7 @@ def list_vault() -> dict:
    files = []
    now = time.time()
    for p in sorted(VAULT.rglob("*.md")):
-        if ".git" in p.parts:
+        if ".git" in p.parts or "traeume" in p.parts:
            continue
        rel = p.relative_to(VAULT).as_posix()
        st = p.stat()
@@ -90,3 +91,61 @@ def read_file(pfad: str) -> dict:
        raise
    except (ValueError, OSError):
        raise HTTPException(404, "Notiz nicht lesbar.")
@router.get("/wissen/graph")
 def graph_vault() -> dict:
    """Obsidian-artiger Graph des Vaults (Nodes = Dateien, Edges = Wiki-Links)."""
    if not _available():
        return {"nodes": [], "edges": []}
    nodes = []
    edges = []
    # Für schnelle Link-Auflösung (case-insensitive Name -> relativer Pfad als ID)
    name_to_id = {}
    # 1. Alle Nodes sammeln
    for p in VAULT.rglob("*.md"):
        if ".git" in p.parts or "traeume" in p.parts:
            continue
        rel = p.relative_to(VAULT).as_posix()
        name_to_id[p.stem.lower()] = rel
        # Kategorie aus dem Ordner ableiten
        cat = "knowledge"
        parent = p.parent.name if p.parent != VAULT else ""
        if parent == "traeume":
            cat = "events"
        elif parent == "muster":
            cat = "rules"
        elif parent == "skill-kandidaten":
            cat = "identity"
        nodes.append({
            "id": rel,
            "content": p.stem,  # stem ist oft kürzer/prägnanter als der Titel
            "category": cat,
            "source": "wiki"
        })
    # 2. Edges extrahieren (Wiki-Links [[Name]])
    link_rx = re.compile(r"\[\[([^\]]+)\]\]")
    for n in nodes:
        try:
            target = VAULT / n["id"]
            content = target.read_text(encoding="utf-8", errors="replace")
            # Set, um mehrfache Links auf dieselbe Datei zu entduplizieren
            found_links = {m.group(1).strip().lower() for m in link_rx.finditer(content)}
            for link in found_links:
                target_id = name_to_id.get(link)
                if target_id and target_id != n["id"]:
                    edges.append({
                        "source": n["id"],
                        "target": target_id,
                        "weight": 1.0
                    })
        except OSError:
            pass
    return {"nodes": nodes, "edges": edges}
@@ -33,7 +33,7 @@ def list_snapshots() -> dict:
@router.get("/zeitmaschine/inhalt")
 def snapshot_contents(file: str) -> dict:
-    """Top-Level-Komponenten eines Snapshots (mem0, hermes, llama-swap, MANIFEST …)."""
+    """Top-Level-Komponenten eines Snapshots (hermes, llama-swap, MANIFEST …)."""
    if not _FILE_RX.match(file):
        raise HTTPException(400, "Ungültiger Snapshot-Name.")
    p = backup_svc.BACKUP_DIR / file
@@ -0,0 +1,176 @@
 """Werkzeug-Verlauf des Agenten (v3-Umbau P6).
 WARUM ES DAS GIBT: Lucys Arbeit war eine Blackbox mit Statuswort. Der Blueprint sah
 dafür eine „Live Agent Matrix" mit Denkstrom vor (§4.4) — die ist so nicht baubar: Die
 Denkschritte entstehen im Hermes-Prozess, und `AGENTS.md` verbietet es, dessen Quellcode
 zu patchen.
 Beim Nachsehen zeigte sich aber, dass die HÄLFTE davon längst offen daliegt: Hermes
 protokolliert jeden Werkzeug-Ruf nach `~/.hermes/logs/agent.log`. Eine Log-Datei zu lesen
 ist kein Patchen. Was dadurch sichtbar wird — welches Werkzeug, wie lange, mit welchem
 Ergebnis, in welchem Lauf — ist für die Frage „was tut sie gerade und wo hängt es" oft
 nützlicher als der Fließtext ihrer Gedanken.
 WAS NICHT GEHT (und hier auch nicht so tut): der Denkstrom selbst und die Argumente eines
 Werkzeug-Rufs. Beides steht nicht im Log. Die Ansicht verspricht deshalb nur, was sie
 halten kann.
 ES HAT SICH SOFORT GELOHNT: Beim ersten Lesen fiel auf, dass `web_extract` seit
 mindestens dem 25.08. JEDEN Morgen um 07:00 scheitert (der Suchanbieter kann keine
 Seiten abrufen). Vier Tage lang, ohne dass es irgendwo aufgefallen wäre.
 """
 import logging
 import os
 import re
 from datetime import datetime
 from pathlib import Path
 from zoneinfo import ZoneInfo
 log = logging.getLogger(__name__)
 # Die Box läuft in Europe/Berlin (AGENTS.md). Hermes' Log trägt Ortszeit ohne Offset.
 LOCAL_TZ = ZoneInfo(os.environ.get("MC_LOCAL_TZ", "Europe/Berlin"))
 LOG_PFAD = Path(os.path.expanduser(
    os.environ.get("MC_HERMES_AGENT_LOG", "~/.hermes/logs/agent.log")))
 # Nur das Ende der Datei lesen. Sie wächst auf mehrere MB und wird rotiert; für einen
 # Verlauf der letzten Stunden reicht der Schwanz — und er kostet nichts.
 LESE_BYTES = 512 * 1024
 # Die drei Formen, in denen Hermes einen Werkzeug-Ruf notiert (am Log gemessen, nicht
 # geraten). Die Lauf-Kennung in eckigen Klammern fehlt bei Nicht-Cron-Läufen.
 #
 #   INFO [cron_…] agent.tool_executor: tool terminal completed (1.40s, 53 chars)
 #   INFO          agent.tool_executor: tool web_search completed (2.61s, 2944 chars)
 #   WARNING [cron_…] agent.tool_executor: Tool web_extract returned error (0.17s): {…}
 #   INFO          agent.tool_executor: tool web_extract failed (0.17s): {…}
 _ZEIT = r"(?P<zeit>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}),\d+"
 _LAUF = r"(?:\[(?P<lauf>[^\]]+)\] )?"
 _FERTIG = re.compile(
    _ZEIT + r" \w+ " + _LAUF + r"agent\.tool_executor: [Tt]ool (?P<werkzeug>\S+) completed "
    r"\((?P<dauer>[\d.]+)s, (?P<zeichen>\d+) chars\)")
 _FEHLER = re.compile(
    _ZEIT + r" \w+ " + _LAUF + r"agent\.tool_executor: [Tt]ool (?P<werkzeug>\S+) "
    r"(?:failed|returned error) \((?P<dauer>[\d.]+)s\)(?::\s*(?P<detail>.*))?")
 def _schwanz(pfad: Path, n: int) -> list[str]:
    """Die letzten n Bytes als Zeilen. Die erste Zeile kann angeschnitten sein und
    wird verworfen — ein halber Zeitstempel passt auf kein Muster, aber sicher ist besser."""
    try:
        groesse = pfad.stat().st_size
        with pfad.open("rb") as f:
            f.seek(max(0, groesse - n))
            roh = f.read()
        zeilen = roh.decode("utf-8", errors="replace").splitlines()
        return zeilen[1:] if groesse > n and zeilen else zeilen
    except OSError:
        return []
 def _kurz(detail: str | None) -> str | None:
    """Fehlertext des Werkzeugs auf einen lesbaren Satz eindampfen. Hermes legt dort ein
    JSON ab; interessant ist daran nur das `error`-Feld."""
    if not detail:
        return None
    treffer = re.search(r'"error"\s*:\s*"([^"]{1,300})"', detail)
    text = treffer.group(1) if treffer else detail.strip()
    return (text[:297] + "…") if len(text) > 300 else text
 def rufe(limit: int = 60) -> list[dict]:
    """Die jüngsten Werkzeug-Rufe, ältester zuerst."""
    ergebnis: list[dict] = []
    for zeile in _schwanz(LOG_PFAD, LESE_BYTES):
        m = _FERTIG.match(zeile)
        if m:
            ergebnis.append({
                "zeit": _iso(m.group("zeit")),
                "lauf": m.group("lauf"),
                "werkzeug": m.group("werkzeug"),
                "dauer_s": float(m.group("dauer")),
                "zeichen": int(m.group("zeichen")),
                "ok": True,
                "fehler": None,
            })
            continue
        m = _FEHLER.match(zeile)
        if m:
            ergebnis.append({
                "zeit": _iso(m.group("zeit")),
                "lauf": m.group("lauf"),
                "werkzeug": m.group("werkzeug"),
                "dauer_s": float(m.group("dauer")),
                "zeichen": None,
                "ok": False,
                "fehler": _kurz(m.group("detail")),
            })
    return ergebnis[-limit:]
 def _iso(s: str) -> str:
    """`2026-08-28 07:03:18` → ISO MIT Zeitzone.
    Hermes schreibt seine Log-Zeitstempel in Ortszeit ohne Offset. Die naiv zu lassen
    wäre bequem (der Klient zeigt sie nur an) — aber genau daran hängt eine
    Projektregel: Naive Zeiten werden über MC_LOCAL_TZ aufgelöst, nie geraten
    (AGENTS.md; ruff DTZ007 erzwingt es). Sobald jemand später damit rechnet — Dauer
    über Mitternacht, Vergleich mit einem Cron-Plan — wäre eine offsetlose Zeit eine
    Falle, die erst zur Zeitumstellung zuschnappt."""
    try:
        return datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=LOCAL_TZ).isoformat()
    except ValueError:
        return s
 def uebersicht(limit: int = 60) -> dict:
    """Was die Agent-Ansicht braucht: die Rufe selbst, je Werkzeug eine Bilanz und die
    wiederkehrenden Fehler zusammengefasst.
    Die Bilanz ist der eigentliche Nutzen: Ein Werkzeug, das IMMER scheitert, verschwindet
    in einer Zeitleiste — in einer Zeile „web_extract · 4 Rufe · 4 Fehler" nicht."""
    liste = rufe(limit)
    if not LOG_PFAD.exists():
        return {"verfuegbar": False, "pfad": str(LOG_PFAD), "rufe": [],
                "werkzeuge": [], "laeufe": []}
    bilanz: dict[str, dict] = {}
    for r in liste:
        b = bilanz.setdefault(r["werkzeug"], {
            "werkzeug": r["werkzeug"], "rufe": 0, "fehler": 0,
            "dauer_summe": 0.0, "letzter_fehler": None,
        })
        b["rufe"] += 1
        b["dauer_summe"] += r["dauer_s"]
        if not r["ok"]:
            b["fehler"] += 1
            b["letzter_fehler"] = r["fehler"]
    werkzeuge = sorted(
        ({**b, "dauer_schnitt_s": round(b["dauer_summe"] / max(b["rufe"], 1), 2)}
         for b in bilanz.values()),
        key=lambda b: (-b["fehler"], -b["rufe"]),
    )
    # Läufe in der Reihenfolge ihres ersten Auftretens (nicht sortiert nach Kennung —
    # die trägt zwar ein Datum, aber darauf sollte sich niemand verlassen).
    laeufe: list[dict] = []
    gesehen: dict[str, dict] = {}
    for r in liste:
        schluessel = r["lauf"] or "(interaktiv)"
        if schluessel not in gesehen:
            gesehen[schluessel] = {"lauf": schluessel, "von": r["zeit"], "bis": r["zeit"],
                                   "rufe": 0, "fehler": 0}
            laeufe.append(gesehen[schluessel])
        e = gesehen[schluessel]
        e["bis"] = r["zeit"]
        e["rufe"] += 1
        if not r["ok"]:
            e["fehler"] += 1
    return {"verfuegbar": True, "pfad": str(LOG_PFAD), "rufe": liste,
            "werkzeuge": werkzeuge, "laeufe": laeufe}
@@ -26,6 +26,7 @@ import re
 import shutil
 import subprocess
 import time
 import urllib.request
 from pathlib import Path
 from config import MODELS_DIR
@@ -60,6 +61,64 @@ _KANDIDAT_RX = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._ -]{0,120}\.md$")
 _fetch_cache: dict = {}
 _FETCH_EVERY = 30.0  # s — Gitea nicht bei jedem UI-Poll anfragen
 _CI_CACHE: dict = {}  # { (repo, branch, head_sha): {"status": "success", "ts": time} }
 def _gitea_creds() -> tuple | None:
    # 1. Fallback: Versuch via git credential manager (zukunftsfähig & plattformübergreifend)
    try:
        import subprocess
        p = subprocess.run(
            ["git", "credential", "fill"],
            input=b"protocol=https\nhost=git.tobisniceshomelab.ddnsfree.com\n",
            capture_output=True,
            check=True
        )
        out = p.stdout.decode(errors="replace")
        u_match = re.search(r"username=(.+)", out)
        p_match = re.search(r"password=(.+)", out)
        if u_match and p_match:
            return u_match.group(1).strip(), p_match.group(1).strip()
    except Exception:
        pass
    # 2. Fallback: Datei (hauptsächlich auf der AI-Box genutzt)
    try:
        cred = Path("~/.git-credentials").expanduser()
        for line in cred.read_text(encoding="utf-8").splitlines():
            m = re.match(r"https://([^:]+):([^@]+)@git\.tobisniceshomelab", line.strip())
            if m: return m.group(1), m.group(2)
    except Exception:
        pass
    return None
 def _fetch_ci_status(repo: str, branch: str, head_sha: str) -> str | None:
    # Nur auf der Box (wo creds liegen) sinnvoll
    creds = _gitea_creds()
    if not creds: return None
    _user, token = creds
    cache_key = (repo, branch, head_sha)
    cached = _CI_CACHE.get(cache_key)
    if cached and (time.time() - cached["ts"] < 30 or cached["status"] in ("success", "failure", "skipped")):
        return cached["status"]
    full_repo = "Hitonabi/mission-control-v2" if repo == "mc2" else "Hitonabi/lucy"
    url = f"http://192.168.178.153:3000/api/v1/repos/{full_repo}/actions/runs?branch={urllib.parse.quote(branch)}&limit=1"
    try:
        req = urllib.request.Request(url, headers={"Authorization": "token " + token})
        with urllib.request.urlopen(req, timeout=5) as r:
            data = json.load(r)
            runs = data if isinstance(data, list) else data.get("runs", data.get("workflow_runs", []))
            if runs:
                run = runs[0]
                if run.get("head_sha", "").startswith(head_sha[:7]):
                    st = run.get("status")
                    if st:
                        _CI_CACHE[cache_key] = {"status": st, "ts": time.time()}
                        return st
    except Exception as e:
        log.warning("auftragsbuch: CI-Status fetch fehler: %s", e)
    return None
 def _available() -> bool:
@@ -176,6 +235,10 @@ def _repo_items(repo: str, statuses: dict, gutachten: dict) -> list[dict]:
            stempel = gutachten.get(f"{repo}:{branch}")
            if not (isinstance(stempel, dict) and stempel.get("commit_ts") == ts_val):
                stempel = None
            head_sha = (_git(repo, ["rev-parse", ref]).stdout or "").strip()
            ci_status = _fetch_ci_status(repo, branch, head_sha) if head_sha else None
            stat = (_git(repo, ["diff", "--shortstat", f"origin/main...{ref}"]).stdout or "").strip()
            files_raw = (_git(repo, ["diff", "--name-status", f"origin/main...{ref}"]).stdout or "").splitlines()
            files = []
@@ -209,6 +272,7 @@ def _repo_items(repo: str, statuses: dict, gutachten: dict) -> list[dict]:
                # es im Repo liegt. Lucy wird dagegen IMMER am PC gebaut (kein dist im Repo).
                "frontend_ohne_build": repo == "mc2" and frontend_src and not frontend_dist,
                "status": None if (status or {}).get("state") == "eingespielt" and ahead > 0 else status,
                "ci_status": ci_status,
            })
        except Exception:
            log.warning("auftragsbuch: Branch %s (%s) nicht lesbar", branch, repo, exc_info=True)
@@ -1,5 +1,5 @@
 """
-Voll-Zustands-Backup (mem0 + Hermes-Configs/Secrets + llama-swap config).
+Voll-Zustands-Backup (Hermes-Configs/Secrets + llama-swap config).
 Delegiert an deploy/backup.sh (eine Quelle der Wahrheit, identisch zum systemd-Timer);
 Restore läuft bewusst nur per CLI (deploy/restore.sh) — siehe docs/BACKUP.md.
 """
@@ -1,7 +1,13 @@
 """
 Connect: erzeugt saubere, getestete Konfig-Snippets für IDEs/Agenten auf dem
 LOKALEN PC (separate Maschine im LAN). Alle zeigen auf den **Gateway** der Box
-(reale Modelle coder/heavy/vision, Cockpit-Port :9001/v1) + den **Shared-Memory-MCP** (MC :9001).
+(reale Modelle coder/heavy/vision, Cockpit-Port :9001/v1).
 Gedächtnis ist hier bewusst KEINE eigene Leitung mehr: bis August 2026 gab es dafür einen
 Memory-MCP-Server gegen MC2s /api/memory; seit dessen Ablösung (docs/wissen/VERDIKTE.md,
 07.08.2026) führt Hermes sein Gedächtnis
 selbst — es hängt am Agenten, nicht am Gateway. check_health() prüft es weiterhin (Leitung 2),
 es ist nur nichts mehr zu konfigurieren.
 Wichtig: Host ist die LAN-IP der Box (NICHT eine Proxy-Domain) — das war in v1
 die häufigste Fehlerquelle. Der Aufrufer übergibt den Host explizit.
@@ -10,7 +16,7 @@ die häufigste Fehlerquelle. Der Aufrufer übergibt den Host explizit.
 import json
 import httpx
-from config import HERMES_BUILTIN_UI_UPSTREAM, LLAMA_SWAP_URL, MEM0_SERVICE_URL, PORT, V1_UPSTREAM
+from config import HERMES_BUILTIN_UI_UPSTREAM, LLAMA_SWAP_URL, PORT, V1_UPSTREAM
 DEFAULT_HOST = "192.168.178.151"
@@ -40,9 +46,7 @@ def _gw(host: str) -> str:
    return f"http://{host}:{PORT}/v1"
-def build_snippets(host: str = DEFAULT_HOST,
+def build_snippets(host: str = DEFAULT_HOST) -> dict:
                   mcp_script_path: str = r"F:\\Coding Stuff\\mission-control-2\\mcp\\mcp_memory.py",
                   mcp_python: str = "python") -> dict:
    gw = _gw(host)
    mc_url = f"http://{host}:{PORT}"
@@ -88,16 +92,6 @@ def build_snippets(host: str = DEFAULT_HOST,
        f'export ANTHROPIC_MODEL="coder"'
    )
    memory_mcp = json.dumps({
        "mcpServers": {
            "mission-control-memory": {
                "command": mcp_python,
                "args": [mcp_script_path],
                "env": {"MC_URL": mc_url},
            }
        }
    }, indent=2)
    return {
        "host": host,
        "gateway_url": gw,
@@ -116,18 +110,15 @@ def build_snippets(host: str = DEFAULT_HOST,
                             "API-Profile je Modus: Code→coder · Architect/Orchestrator→heavy · "
                             "Ask/Debug→Lane 'chat' (virtuelles Modell, wählt selbst fast oder heavy)."},
            "claude_code": {"label": "Claude Code", "lang": "bash", "snippet": claude_code,
-                            "note": "Für die starken Sessions. Lokal-Betrieb bräuchte einen Anthropic⇄OpenAI-Übersetzer vor dem Gateway; Gedächtnis-Anbindung via Memory-MCP unten."},
+                            "note": "Für die starken Sessions. Lokal-Betrieb bräuchte einen Anthropic⇄OpenAI-Übersetzer vor dem Gateway."},
        },
        # Leitung 2 — das GEDÄCHTNIS. Separater MCP-Server, gilt zusätzlich zu jedem Tool oben.
        "memory": {"label": "Shared Memory (MCP)", "lang": "json", "snippet": memory_mcp,
                   "note": "Eigene Leitung: MCP-Block für jedes MCP-fähige Tool. mcp_memory.py muss lokal liegen."},
    }
 def check_health() -> dict:
    """Live-Erreichbarkeit der drei Leitungen, aus Sicht der Box:
    Leitung 1 = der ECHTE Modell-Pfad, den Clients nutzen (mc2-gateway bei V1_UPSTREAM,
-    sonst llama-swap direkt), Leitung 2 = Gedächtnis-Sidecar (Mem0),
+    sonst llama-swap direkt), Leitung 2 = Natives Hermes-Gedächtnis (hermes-gateway),
    Leitung 3 = Desktop-Gateway (Hermes-Builtin-UI)."""
    gateway = {"ok": False, "detail": "nicht erreichbar"}
    try:
@@ -144,9 +135,12 @@ def check_health() -> dict:
    memory = {"ok": False, "detail": "nicht erreichbar"}
    try:
        with httpx.Client(timeout=3.0) as c:
-            r = c.get(f"{MEM0_SERVICE_URL}/health")
+            # Hermes Gateway stellt das native Gedächtnis & Agent-Loop bereit
-            memory = ({"ok": True, "detail": "bereit"} if r.status_code == 200
+            r = c.get("http://127.0.0.1:8642/health")
-                      else {"ok": False, "detail": f"HTTP {r.status_code}"})
+            if r.status_code in (200, 404, 401):
                memory = {"ok": True, "detail": "Hermes-Nativ bereit"}
            else:
                memory = {"ok": False, "detail": f"HTTP {r.status_code}"}
    except Exception:
        pass
@@ -1,219 +0,0 @@
 """Eigenleben — was die Box von allein gebaut und vorgeschlagen hat.
 Beantwortet die User-Frage vom 15.07.2026: „Es gibt keinen Viewpoint, welche Skills
 erstellt wurden, was die Box vorgeschlagen hat, welche Skills Lucy hat und wie die
 funktionieren." Reine LESE-Schicht, keine Schreib-Operationen:
 - Skills aus ~/.hermes/skills (= Lucys Skill-Satz; die Worker-Profile werkstatt/betrieb
  tragen Kopien desselben Satzes). Herkunft dreistufig klassifiziert:
    selbst   → weder mitgeliefert noch aus unserem Repo = die Box/Lucy hat ihn erzeugt
    repo     → liegt in ~/mission-control-v2/deploy/skills (von uns gebaut + deployt)
    bundled  → liegt in ~/.hermes/hermes-agent/skills (kam mit Hermes mit)
 - Nutzungszahlen aus ~/.hermes/skills/.usage.json (Hermes' eigener Zähler).
 - Bilanz aus Auftragsbuch-Chronik (/srv/models/mc2-auftragsbuch.json, angenommene
  Branches) + Ablehnungs-Lern-Journal (/srv/models/mc2-ablehnungen.jsonl).
 """
 from __future__ import annotations
 import json
 import re
 import subprocess
 import time
 from pathlib import Path
 SKILLS_DIR = Path.home() / ".hermes" / "skills"
 BUNDLED_DIR = Path.home() / ".hermes" / "hermes-agent" / "skills"
 REPO_DIR = Path.home() / "mission-control-v2" / "deploy" / "skills"
 HERMES_SRC = Path.home() / ".hermes" / "hermes-agent"
 HERMES_PY = HERMES_SRC / "venv" / "bin" / "python"
 USAGE_FILE = SKILLS_DIR / ".usage.json"
 AUFTRAGSBUCH_FILE = Path("/srv/models/mc2-auftragsbuch.json")
 ABLEHNUNGEN_FILE = Path("/srv/models/mc2-ablehnungen.jsonl")
 _HERKUNFT_LABEL = {
    "selbst": "Selbst erstellt",
    "repo": "Von uns gebaut",
    "bundled": "Mit Hermes mitgeliefert",
 }
 def _frontmatter(text: str) -> dict:
    """Sehr kleiner Frontmatter-Leser: nur die flachen key: value-Zeilen des ersten
    ---Blocks (name/description/version/author reichen hier; kein YAML-Import nötig)."""
    out: dict = {}
    if not text.startswith("---"):
        return out
    for line in text.split("\n", 1)[1].split("\n"):
        if line.strip() == "---":
            break
        m = re.match(r"^([A-Za-z_][\w-]*):\s*(.*)$", line)
        if not m:
            continue
        val = m.group(2).strip().strip('"').strip("'")
        if val:
            out[m.group(1)] = val
    return out
 def _norm(s: str) -> str:
    return re.sub(r"[\s_-]+", "", (s or "").lower())
 # aktiv/inaktiv: dieselbe Wahrheit wie Hermes selbst (und sein eingebautes WebUI) —
 # hermes_cli.banner.get_available_skills() prüft Plattform/Voraussetzungen/Config und
 # liefert, was der Agent WIRKLICH laden kann. Wir rufen sie im Hermes-venv auf (MC2
 # läuft in eigenem Python) und cachen großzügig — der Skill-Satz ändert sich selten.
 _aktiv_cache: dict = {"ts": 0.0, "namen": None}
 _AKTIV_EVERY = 600.0  # s
 def _aktive_namen() -> set[str] | None:
    """Normalisierte Namen aller ladbaren Skills; None = nicht ermittelbar (Dev-Modus)."""
    if not HERMES_PY.is_file():
        return None
    now = time.time()
    if _aktiv_cache["namen"] is not None and now - _aktiv_cache["ts"] < _AKTIV_EVERY:
        return _aktiv_cache["namen"]
    code = ("from hermes_cli.banner import get_available_skills;import json;"
            "print(json.dumps(get_available_skills()))")
    try:
        r = subprocess.run([str(HERMES_PY), "-c", code], capture_output=True,
                           text=True, timeout=60, cwd=str(HERMES_SRC))
        idx = r.stdout.find("{")
        kategorien = json.loads(r.stdout[idx:]) if idx >= 0 else {}
        namen = {_norm(n) for liste in kategorien.values() for n in liste}
    except Exception:
        return _aktiv_cache["namen"]  # alter Stand ist besser als flackerndes None
    _aktiv_cache.update(ts=now, namen=namen)
    return namen
 def list_skills() -> list[dict]:
    """Alle Skills mit Beschreibung, Herkunft und Nutzungszahlen (leer im Dev-Modus)."""
    if not SKILLS_DIR.is_dir():
        return []
    try:
        usage_raw = json.loads(USAGE_FILE.read_text(encoding="utf-8"))
    except Exception:
        usage_raw = {}
    usage = {_norm(k): v for k, v in usage_raw.items()}
    aktive = _aktive_namen()
    def eintrag(md: Path, rel: str, kategorie: str | None) -> dict:
        try:
            fm = _frontmatter(md.read_text(encoding="utf-8", errors="replace"))
        except Exception:
            fm = {}
        if (BUNDLED_DIR / rel).is_dir():
            herkunft = "bundled"
        elif (REPO_DIR / rel).is_dir():
            herkunft = "repo"
        else:
            herkunft = "selbst"
        kurz = rel.split("/")[-1]
        u = usage.get(_norm(kurz)) or usage.get(_norm(fm.get("name", ""))) or {}
        aktiv = None
        if aktive is not None:
            aktiv = _norm(kurz) in aktive or _norm(fm.get("name", "")) in aktive
        return {
            "id": rel,
            "name": fm.get("name") or kurz,
            "kategorie": kategorie,
            "aktiv": aktiv,
            "beschreibung": fm.get("description") or "",
            "version": fm.get("version") or "",
            "autor": fm.get("author") or "",
            "herkunft": herkunft,
            "herkunft_label": _HERKUNFT_LABEL[herkunft],
            "genutzt": int(u.get("use_count") or 0),
            "zuletzt_genutzt": u.get("last_used_at") or None,
            "erstellt": u.get("created_at") or None,
            "status": u.get("state") or "active",
            "geaendert": md.stat().st_mtime,
        }
    skills: list[dict] = []
    for d in sorted(SKILLS_DIR.iterdir()):
        if not d.is_dir() or d.name.startswith("."):
            continue  # .archive (Curator) & Co. sind keine aktiven Skills
        md = d / "SKILL.md"
        if md.is_file():
            skills.append(eintrag(md, d.name, None))
            continue
        # Kategorie-Ordner (mitgelieferte Sammlungen wie research/, apple/): eine Ebene
        # tiefer liegen die echten Skills (research/blogwatcher/SKILL.md) — je einzeln zeigen.
        for sub in sorted(d.iterdir()):
            smd = sub / "SKILL.md"
            if sub.is_dir() and not sub.name.startswith(".") and smd.is_file():
                skills.append(eintrag(smd, f"{d.name}/{sub.name}", d.name))
    # Selbst erstellte zuerst — das ist der Star der Ansicht.
    order = {"selbst": 0, "repo": 1, "bundled": 2}
    skills.sort(key=lambda s: (order[s["herkunft"]], -s["genutzt"], s["name"]))
    return skills
 def skill_text(skill_id: str) -> str | None:
    """Voller SKILL.md-Text („wie funktioniert der Skill") — max. Kategorie/Name, keine Pfad-Tricks."""
    if not re.fullmatch(r"[\w.-]+(/[\w.-]+)?", skill_id or ""):
        return None
    # Das Zeichen-Set oben erlaubt „." und „.." als Segment — seit die Route ein
    # :path-Parameter ist, hier explizit raus (kein Klettern über SKILLS_DIR hinaus).
    if any(seg in (".", "..") for seg in skill_id.split("/")):
        return None
    md = SKILLS_DIR / skill_id / "SKILL.md"
    if not md.is_file():
        return None
    try:
        return md.read_text(encoding="utf-8", errors="replace")
    except Exception:
        return None
 def bilanz() -> dict:
    """Vorschlags-Bilanz: was die Box vorschlug und was daraus wurde (eine Timeline)."""
    eintraege: list[dict] = []
    try:
        branches = json.loads(AUFTRAGSBUCH_FILE.read_text(encoding="utf-8")).get("branches") or {}
        for branch, info in branches.items():
            eintraege.append({
                "art": "angenommen" if info.get("state") == "eingespielt" else info.get("state", "?"),
                "titel": branch,
                "detail": info.get("detail") or "",
                "ts": float(info.get("ts") or 0),
            })
    except Exception:
        pass
    try:
        for line in ABLEHNUNGEN_FILE.read_text(encoding="utf-8").splitlines():
            if not line.strip():
                continue
            try:
                j = json.loads(line)
            except Exception:
                continue
            eintraege.append({
                "art": "abgelehnt",
                "titel": j.get("subject") or j.get("branch") or "?",
                "detail": j.get("grund") or "",
                "ts": float(j.get("ts") or 0),
            })
    except Exception:
        pass
    eintraege.sort(key=lambda e: -e["ts"])
    return {
        "eintraege": eintraege,
        "angenommen": sum(1 for e in eintraege if e["art"] == "angenommen"),
        "abgelehnt": sum(1 for e in eintraege if e["art"] == "abgelehnt"),
    }
 def overview() -> dict:
    skills = list_skills()
    b = bilanz()
    return {
        "available": SKILLS_DIR.is_dir(),
        "skills": skills,
        "selbst_erstellt": sum(1 for s in skills if s["herkunft"] == "selbst"),
        "bilanz": b,
    }
@@ -0,0 +1,100 @@
 """Geheimnis-Ablage auf der Box (v3-Umbau P1).
 WARUM ES DAS GIBT: Bis zum 28.08.2026 lagen das Box-Sudo-Passwort und der
 HuggingFace-Token im `localStorage` des Browsers und reisten bei jedem mutierenden
 Request mit (Header `X-Sudo-Password` **und** im JSON-Rumpf). Da der Dienst-Nutzer
 laut `/etc/sudoers` mit `NOPASSWD: ALL` läuft, wäre ein einziger XSS in der SPA
 gleichbedeutend mit Root auf der Box gewesen.
 Das Sudo-Passwort ist ersatzlos entfallen — auf der Box gemessen: `sudo -n true`
 läuft durch, es wurde also nie gebraucht. Bleibt der HF-Token; der liegt jetzt hier:
 eine Datei neben den anderen `mc2-*.json` unter MODELS_DIR, Rechte 0600, und er wird
 **nie** an den Browser zurückgegeben. Die Oberfläche erfährt nur, OB einer gesetzt ist.
 Absichtlich kein Verschlüsseln: Der Schlüssel müsste auf derselben Maschine liegen und
 wäre damit Theater. Der Gewinn ist, dass das Geheimnis den Browser gar nicht erst
 erreicht — nicht, dass die Datei unlesbar wäre.
 """
 import json
 import logging
 import os
 from pathlib import Path
 from config import MODELS_DIR
 log = logging.getLogger(__name__)
 PFAD = Path(os.environ.get("MC_GEHEIMNISSE_PFAD", str(MODELS_DIR / "mc2-geheimnisse.json")))
 # Was hier abgelegt werden darf. Neue Schlüssel bewusst eintragen — so kann ein
 # fehlgeleiteter Request keine beliebigen Felder in die Datei schreiben.
 ERLAUBT = frozenset({"hf_token"})
 def _lesen() -> dict[str, str]:
    """Ganze Ablage. Fehlt die Datei (frische Box, Windows-Entwicklungsrechner ohne
    /srv/models), ist das kein Fehler, sondern schlicht 'nichts gesetzt'."""
    try:
        daten = json.loads(PFAD.read_text(encoding="utf-8"))
        return {k: v for k, v in daten.items() if k in ERLAUBT and isinstance(v, str)}
    except (OSError, ValueError):
        return {}
 def _schreiben(daten: dict[str, str]) -> bool:
    """Atomar über eine Nachbardatei, damit ein Absturz mittendrin keine halbe Datei
    hinterlässt. Rechte 0600 werden VOR dem Umbenennen gesetzt — sonst gäbe es ein
    Zeitfenster, in dem das Geheimnis world-readable auf der Platte liegt."""
    try:
        PFAD.parent.mkdir(parents=True, exist_ok=True)
        tmp = PFAD.with_suffix(".json.tmp")
        tmp.write_text(json.dumps(daten, indent=2, ensure_ascii=False), encoding="utf-8")
        try:
            os.chmod(tmp, 0o600)
        except OSError:
            pass  # Windows kennt keine Unix-Rechte — lokal harmlos, auf der Box greift es
        tmp.replace(PFAD)
        return True
    except OSError as exc:
        log.warning("Geheimnis-Ablage nicht schreibbar (%s): %s", PFAD, exc)
        return False
 def hf_token() -> str | None:
    """Der HF-Token für Modell-Downloads. Reihenfolge: Prozess-Env schlägt Datei —
    so kann die systemd-Unit ihn setzen, ohne dass jemand die Oberfläche anfassen muss."""
    return os.environ.get("HF_TOKEN") or _lesen().get("hf_token") or None
 def setzen(schluessel: str, wert: str | None) -> bool:
    """Setzt oder löscht (wert=None oder leer) ein Geheimnis."""
    if schluessel not in ERLAUBT:
        return False
    daten = _lesen()
    if wert:
        daten[schluessel] = wert
    else:
        daten.pop(schluessel, None)
    return _schreiben(daten)
 def status() -> dict[str, bool]:
    """Was die Oberfläche erfahren darf: nur, OB etwas gesetzt ist — nie der Wert.
    `aus_env` sagt dem Nutzer, warum ein Löschen in der Oberfläche wirkungslos bliebe."""
    daten = _lesen()
    return {
        "hf_token_gesetzt": bool(daten.get("hf_token") or os.environ.get("HF_TOKEN")),
        "hf_token_aus_env": bool(os.environ.get("HF_TOKEN")),
        "schreibbar": _schreibbar(),
    }
 def _schreibbar() -> bool:
    """Ehrlich melden, wenn die Ablage nicht beschreibbar ist (z. B. lokal auf Windows
    ohne /srv/models) — sonst speichert die Oberfläche scheinbar erfolgreich ins Leere."""
    try:
        PFAD.parent.mkdir(parents=True, exist_ok=True)
        return os.access(PFAD.parent, os.W_OK)
    except OSError:
        return False
@@ -392,12 +392,12 @@ def add_idea(titel: str, notiz: str = "", created_by: str = "mc2-ui",
    welt='ide': geht DIREKT an das Profil `projektstart` (am Triage/Auto-Zerleger vorbei) —
        die Box härtet ein Konzept (konzept-fliessband), legt ein leeres Gitea-Repo an und
        füllt es NUR mit Doku. Ergebnis ist ein vorbereitetes Projekt, das der Commander in
-        Zed selbst baut (IDE-Welt). Bewusst KEIN --triage: so fasst der Auto-Zerleger die
+        Agentic IDE selbst baut (IDE-Welt). Bewusst KEIN --triage: so fasst der Auto-Zerleger die
        Karte nie an und die Werkstatt baut sie nie (der Fan-out-Fehler vom 20.07.).
    tiefe (nur ide): 'simpel' | 'gruendlich' — vom Knopf gewaehlte Konzept-Tiefe; leer =
        die Box schaetzt selbst (Fallback fuer Telegram/Lucy).
    ziel (nur ide-Projekt): 'lxc' | 'docker' — Ziel-Plattform; leer = die Box entscheidet.
-    art (nur ide): 'projekt' (Default, Repo+Doku+Roadmap, Bau in Zed) oder 'idee'
+    art (nur ide): 'projekt' (Default, Repo+Doku+Roadmap, Bau in IDE) oder 'idee'
        (Produkt-Idee nur durchdenken: NUR Konzept, keine Roadmap/Geruest, kein Bau-Druck)."""
    if not _available():
        return {"ok": False, "error": "Die Ideen-Queue lebt auf der Box."}
@@ -456,7 +456,7 @@ def add_idea(titel: str, notiz: str = "", created_by: str = "mc2-ui",
                         "[Ideen-Queue]", "ideen-queue", "silent")
        elif welt == "ide":
            announce.add(f"Neues IDE-Projekt in Vorbereitung: „{titel}“ ({task['id']}) — die Box "
-                         "härtet das Konzept und legt das Repo an, dann baust du in Zed.",
+                         "härtet das Konzept und legt das Repo an, dann baust du in der Agentic IDE.",
                         "[Ideen-Queue]", "ideen-queue", "silent")
        else:
            announce.add(f"Neue Idee in der Queue: „{titel}“ ({task['id']}) — die Box arbeitet sie aus.",
@@ -515,10 +515,10 @@ def archive_task(task_id: str) -> dict:
 _EINORDNEN_SYS = (
    "Du ordnest eine frisch getippte Projekt-Idee ein. Antworte AUSSCHLIESSLICH mit einem "
    "JSON-Objekt, ohne Prosa, ohne Codezaun:\n"
-    '{"wer":"box"|"zed","tiefe":"schlank"|"gruendlich","nur_denken":true|false}\n\n'
+    '{"wer":"box"|"ide","tiefe":"schlank"|"gruendlich","nur_denken":true|false}\n\n'
    "wer=box: Aufgabe am eigenen Heimlabor des Nutzers — seine Server, seine bestehenden "
    "Dienste (Mission Control, Lucy, Rippy), Wartung, Doku, Automatisierung. Die Box baut selbst.\n"
-    "wer=zed: ein NEUES eigenstaendiges Programm/Werkzeug/App, das der Nutzer danach selbst "
+    "wer=ide: ein NEUES eigenstaendiges Programm/Werkzeug/App, das der Nutzer danach selbst "
    "programmieren will. Er bekommt nur ein vorbereitetes Repo.\n"
    "tiefe=gruendlich: gross, vage oder mit vielen offenen Entwurfsfragen. "
    "tiefe=schlank: klein und klar umrissen.\n"
@@ -564,11 +564,11 @@ def einordnen(text: str) -> dict:
    except Exception:
        return {"ok": False}
-    wer = d.get("wer") if d.get("wer") in ("box", "zed") else None
+    wer = d.get("wer") if d.get("wer") in ("box", "ide") else None
    tiefe = d.get("tiefe") if d.get("tiefe") in ("schlank", "gruendlich") else None
    if wer is None and tiefe is None:
        return {"ok": False}
-    return {"ok": True, "wer": wer or "zed", "tiefe": tiefe or "schlank",
+    return {"ok": True, "wer": wer or "ide", "tiefe": tiefe or "schlank",
            "nur_denken": bool(d.get("nur_denken"))}
@@ -981,7 +981,7 @@ def konzept_of(task_id: str) -> dict:
 _AUS_IDEE_KOPF = (
    "AUFTRAGS-ART: PROJEKT AUS GEPRUEFTER IDEE. Der Commander hat diese Idee erst durchdenken "
    "lassen — das Konzept gefaellt ihm, jetzt soll daraus ein startklares Repo werden, das er "
-    "SELBST in Zed baut.")
+    "SELBST in der Agentic IDE baut.")
 _AUS_IDEE_FUSS = (
    "· Denk das Konzept NICHT neu. Es ist bereits mit voller Kaskade + Advocatus Diaboli "
    "gehaertet. Lies es vollstaendig und uebernimm es; eine kurze Nachschaerf-Runde fuer die "
@@ -989,7 +989,7 @@ _AUS_IDEE_FUSS = (
    "Verschwendung.\n"
    "· Der Rest ist deine normale Projektstart-Rolle: das Repo enthaelt am Ende NUR Doku "
    "(KONZEPT.md, ROADMAP.md, AGENTS.md, README.md, SAVEPOINT.md, .aiexclude) — KEIN Code.\n"
-    "· Uebergabe wie ueblich: Repo-URL nennen, damit der Commander in Zed loslegen kann.")
+    "· Uebergabe wie ueblich: Repo-URL nennen, damit der Commander in der Agentic IDE loslegen kann.")
 def _wo_liegt(konz: dict) -> str:
@@ -1090,7 +1090,7 @@ def projekt_aus_idee(task_id: str, ziel: str = "", tiefe: str = "") -> dict:
    try:
        from services import announce
        announce.add(f"Aus der Idee „{_kurz(kurz, 60)}“ wird ein Projekt: {task['id']} — die Box "
-                     "bereitet das Repo vor, gebaut wird in Zed.",
+                     "bereitet das Repo vor, gebaut wird in der Agentic IDE.",
                     "[Ideen-Queue]", "ideen-queue", "silent")
    except Exception:
        pass
@@ -57,39 +57,29 @@ def _pump_output(job: dict, stream) -> None:
        commit()
-def _run_job(job_id: str, args: list[str], env: dict | None = None, sudo_password: str | None = None):
+def _run_job(job_id: str, args: list[str], env: dict | None = None):
    """Job-Prozess starten und mitschreiben.
    v3-Umbau P1 (28.08.2026): Hier wurde frueher ein Sudo-Passwort aus dem Browser an
    stdin gefuettert (und dafuer `sudo -n` in den Argumenten zu `sudo -S` umgeschrieben).
    Auf der Box laeuft sudo passwortlos (`NOPASSWD: ALL`), der Pfad war tot. Ohne ihn
    braucht der Prozess auch keine stdin-Pipe mehr: DEVNULL sorgt dafuer, dass ein Job,
    der wider Erwarten nach einem Passwort fragt, sofort scheitert statt still zu haengen."""
    job = JOBS[job_id]
    job["state"] = "running"
    try:
        actual_args = list(args)
        if sudo_password is not None:
            for i, arg in enumerate(actual_args):
                if isinstance(arg, str):
                    actual_args[i] = arg.replace("sudo -n", "sudo -S").replace("sudo ", "sudo -S ")
        proc = subprocess.Popen(
-            actual_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            list(args), stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-            stdin=subprocess.PIPE if sudo_password is not None else None,
+            stdin=subprocess.DEVNULL,
            bufsize=0,
            env={**os.environ, **(env or {})},
        )
        _PROCS[job_id] = proc
        if sudo_password is not None and proc.stdin:
            proc.stdin.write((sudo_password + "\n").encode("utf-8"))
            proc.stdin.flush()
            proc.stdin.close()
        _pump_output(job, proc.stdout)
        proc.wait()
        job["returncode"] = proc.returncode
        job["state"] = "canceled" if job.get("canceled") else ("done" if proc.returncode == 0 else "failed")
        # Check if failed due to sudo authorization failure
        if proc.returncode != 0 and job["log"]:
            log_str = "\n".join(job["log"])
            if "a password is required" in log_str or "password" in log_str.lower() or "sudo:" in log_str:
                job["sudo_failed"] = True
    except Exception as exc:
        _append_log(job, f"[mc] Fehler: {exc}")
        job["state"] = "failed"
@@ -148,9 +138,8 @@ def attach_download_progress(job_id: str, local_dir: str, total_bytes: int) -> N
 def start_job(args: list[str], label: str, env: dict | None = None, on_done=None,
-              sudo_password: str | None = None, group: str | None = None) -> str:
+              group: str | None = None) -> str:
    job_id = uuid.uuid4().hex[:12]
    # Mask password in log if present in args
    log_args = list(args)
    JOBS[job_id] = {
        "id": job_id, "label": label, "state": "queued", "group": group,
@@ -159,7 +148,7 @@ def start_job(args: list[str], label: str, env: dict | None = None, on_done=None
    }
    if on_done:
        JOBS[job_id]["_on_done"] = on_done
-    threading.Thread(target=_run_job, args=(job_id, args, env, sudo_password), daemon=True).start()
+    threading.Thread(target=_run_job, args=(job_id, args, env), daemon=True).start()
    return job_id
@@ -1,190 +0,0 @@
 """
 Ketten-Digest — Telegram-Status für lange Aufgaben-Ketten (User-Wunsch 20.07.2026).
 Wenn die Werkstatt eine Karten-Familie abarbeitet (z. B. „Homelab-Dashboard 2.0" mit
 19 verketteten Karten), soll der Commander nicht raten müssen: dieser Wächter liest
 die Queue-Sicht (services/ideen.py, inkl. Ketten-Anreicherung) und meldet per Telegram
  • SOFORT, wenn eine Karte hängt und eine Frage an den Commander hat (blocked) —
    einmal pro Karte, mit der Frage im Wortlaut,
  • bei MEILENSTEINEN (Projekt komplett fertig) sofort,
  • sonst höchstens einmal pro PULS_SEKUNDEN (Default 60 min) einen Zwischenstand
    je aktivem Projekt („5/19 fertig · läuft: … · als Nächstes: …").
 Taktung war explizite User-Wahl („Meilensteine + 60-min-Puls, Fragen immer sofort").
 Zustand (was wurde wann gemeldet) liegt als JSON neben den Modellen und übersteht
 Neustarts — sonst käme nach jedem Deploy ein Duplikat-Schwall. Auf Windows (Dev) No-op.
 """
 import asyncio
 import json
 import logging
 import os
 import time
 import zlib
 from pathlib import Path
 from config import MODELS_DIR
 log = logging.getLogger(__name__)
 ENABLED = os.name == "posix" and os.environ.get("MC_KETTEN_DIGEST", "1") != "0"
 INTERVAL = int(os.environ.get("MC_KETTEN_DIGEST_INTERVAL", "300"))       # Prüf-Tick: 5 min
 PULS_SEKUNDEN = int(os.environ.get("MC_KETTEN_DIGEST_PULS", "3600"))     # Zwischenstand: 60 min
 # Hänger-Alarm: laufende Karte ohne Lebenszeichen (Heartbeat) länger als diese Schwelle
 # → sofortige Telegram-Warnung (einmal pro Karten-Lauf). Live-Fall 20.07.: Worker wartete
 # 45 min auf einen selbst gestarteten uvicorn — „pid_alive" hielt den Claim ewig frisch.
 HANG_SEKUNDEN = int(os.environ.get("MC_KETTEN_HANG", "900"))
 KANBAN_LOGS = Path(os.environ.get("MC_KANBAN_LOGS", "~/.hermes/kanban/logs")).expanduser()
 STATE_PATH = Path(os.environ.get("MC_KETTEN_DIGEST_STATE", str(MODELS_DIR / "mc2-ketten-digest.json")))
 def _kontext_druck(task_id: str) -> int:
    """Wie oft der Worker zuletzt den Kontext verdichten musste (Log-Marker) —
    mehrfaches „Compacting context" heißt: die Aufgabe sprengt das Fenster."""
    try:
        p = KANBAN_LOGS / f"{task_id}.log"
        with p.open("rb") as f:
            f.seek(max(0, p.stat().st_size - 200_000))
            tail = f.read().decode("utf-8", errors="replace")
        return tail.count("Compacting context")
    except Exception:
        return 0
 def _load_state() -> dict:
    try:
        d = json.loads(STATE_PATH.read_text(encoding="utf-8"))
        return d if isinstance(d, dict) else {}
    except Exception:
        return {}
 def _save_state(state: dict) -> None:
    try:
        tmp = STATE_PATH.with_suffix(".tmp")
        tmp.write_text(json.dumps(state, ensure_ascii=False), encoding="utf-8")
        tmp.replace(STATE_PATH)
    except OSError:
        log.warning("ketten-digest: Zustand %s nicht schreibbar", STATE_PATH, exc_info=True)
 def _melden(subject: str, text: str) -> None:
    """Aufs Handy UND in den Briefkasten (silent — Lucy muss den Status nicht sprechen)."""
    from services import announce
    announce.notify_telegram(subject, text)
    try:
        announce.add(text, subject, "ketten-digest", "silent")
    except Exception:
        pass
 def _tick() -> None:
    from services import ideen
    data = ideen.list_queue()
    if not data.get("available"):
        return
    items = data.get("items") or []
    projekte = data.get("projekte") or []
    state = _load_state()
    gemeldete_fragen: dict = state.setdefault("fragen", {})
    projekt_state: dict = state.setdefault("projekte", {})
    dirty = False
    now = int(time.time())
    # 1) Hängende Karten mit Frage → sofort, einmal pro Karte. Der Schlüssel enthält den
    # Fragen-Text-Hash: hängt dieselbe Karte später mit NEUER Frage, wird wieder gemeldet.
    for it in items:
        if it.get("status") != "blocked":
            continue
        frage = (it.get("frage") or "").strip()
        key = f"{it['id']}:{zlib.crc32(frage.encode('utf-8')):x}"
        if key in gemeldete_fragen:
            continue
        text = (f"Aufgabe hängt und wartet auf dich: „{(it.get('titel') or '')[:120]}“\n"
                + (f"Frage: {frage[:500]}\n" if frage else "")
                + "Antworten geht im Auftragsbuch (Zentrale) — die Box macht dann weiter.")
        _melden("[Werkstatt]", text)
        gemeldete_fragen[key] = now
        dirty = True
    # 1b) Hänger-Alarm: laufende Karte ohne Lebenszeichen → einmal pro Karten-Lauf warnen.
    gemeldete_haenger: dict = state.setdefault("haenger", {})
    for it in items:
        if it.get("status") != "running":
            continue
        puls = it.get("puls_alter")
        if puls is None or puls < HANG_SEKUNDEN:
            continue
        key = f"{it['id']}:{it.get('gestartet') or 0}"
        if key in gemeldete_haenger:
            continue
        minuten = int(puls / 60)
        text = (f"Karte scheint zu hängen: „{(it.get('titel') or '')[:120]}“ — "
                f"seit {minuten} min kein Lebenszeichen vom Worker.")
        druck = _kontext_druck(it["id"])
        if druck >= 2:
            text += (f"\nDer Worker musste {druck}× den Kontext verdichten — "
                     "die Aufgabe ist womöglich zu groß geschnitten.")
        text += "\nIn der Zentrale: „Neuer Versuch“ startet sie frisch, „Stopp“ hält sie an."
        _melden("[Werkstatt]", text)
        gemeldete_haenger[key] = now
        dirty = True
    if len(gemeldete_haenger) > 200:
        for k in sorted(gemeldete_haenger, key=gemeldete_haenger.get)[:100]:
            gemeldete_haenger.pop(k, None)
        dirty = True
    # Fragen-Gedächtnis klein halten (Karten verschwinden irgendwann ins Archiv).
    if len(gemeldete_fragen) > 200:
        for k in sorted(gemeldete_fragen, key=gemeldete_fragen.get)[:100]:
            gemeldete_fragen.pop(k, None)
        dirty = True
    # 2) Projekt-Status: Abschluss sofort, sonst gedrosselter Puls solange gearbeitet wird.
    for p in projekte:
        ps = projekt_state.setdefault(p["key"], {})
        fertig, gesamt = p.get("fertig", 0), p.get("gesamt", 0)
        if gesamt > 0 and fertig >= gesamt and not ps.get("abschluss_gemeldet"):
            _melden("[Werkstatt]", f"Projekt fertig: „{p['titel']}“ — alle {gesamt} Karten erledigt. "
                                   "Ergebnisse liegen im Auftragsbuch.")
            ps.update(abschluss_gemeldet=True, letzter_puls=now, letzter_stand=fertig)
            dirty = True
            continue
        aktiv = p.get("laeuft", 0) > 0
        if not aktiv:
            continue
        if now - int(ps.get("letzter_puls") or 0) < PULS_SEKUNDEN:
            continue
        laufende = [i for i in items if i.get("projekt") == p["key"] and i["status"] == "running"]
        naechste = [i for i in items if i.get("projekt") == p["key"]
                    and i["status"] in ("ready", "todo") and not i.get("wartet_auf")]
        zeilen = [f"Werkstatt-Status „{p['titel']}“: {fertig}/{gesamt} fertig."]
        for l in laufende[:2]:
            note = f" — {l['notiz']}" if l.get("notiz") else ""
            zeilen.append(f"Läuft: {l['titel'][:90]}{note}")
        if naechste:
            zeilen.append(f"Als Nächstes: {naechste[0]['titel'][:90]}")
        haengt = p.get("haengt", 0)
        if haengt:
            zeilen.append(f"{haengt} Karte(n) warten auf deine Antwort im Auftragsbuch.")
        _melden("[Werkstatt]", "\n".join(zeilen))
        ps.update(letzter_puls=now, letzter_stand=fertig)
        dirty = True
    if dirty:
        _save_state(state)
 async def digest_loop() -> None:
    """Hintergrund-Task im MC2-Lifespan (Muster: reminders_loop)."""
    log.info("ketten-digest: aktiv (Tick %ss, Puls %ss)", INTERVAL, PULS_SEKUNDEN)
    while True:
        try:
            await asyncio.to_thread(_tick)
        except Exception:
            log.debug("ketten-digest: Tick fehlgeschlagen", exc_info=True)
        await asyncio.sleep(INTERVAL)
@@ -1,176 +0,0 @@
 """
 Geteiltes Gedächtnis (die „Verfassung") — jetzt auto-lernend & semantisch über Mem0.
 Dieser Service ist nur noch ein dünner HTTP-Client auf den Mem0-Sidecar (mem0_service/app.py,
 läuft im ~/.mem0/venv unter Python 3.12). Die `/api/memory`-API-Form bleibt unverändert, damit
 UI und MCP-Server kompatibel bleiben. Neu gegenüber der alten flachen SQLite:
 - search (q gesetzt) ist SEMANTISCH (Vektor/Embeddings) statt LIKE-Textsuche, mit Relevanz-Score.
 - learn() reicht Gesprächs-Turns durch → Mem0 EXTRAHIERT Fakten selbst (Auto-Lernen).
 - Dedup macht Mem0 beim Auto-Lernen selbst; der manuelle Kurator unten bleibt als Komfort.
 5 Kategorien (user · instruction · stable · versioned · ephemeral) bleiben als Metadaten erhalten.
 """
 import asyncio
 import logging
 import os
 import re
 from difflib import SequenceMatcher
 import httpx
 from config import MEM0_SERVICE_URL
 log = logging.getLogger(__name__)
 CATEGORIES = ("identity", "knowledge", "rules", "events")
 _TIMEOUT = httpx.Timeout(60.0, connect=5.0)  # LLM-Extraktion kann ein paar Sekunden dauern
 def _get(path: str, **params) -> list | dict:
    r = httpx.get(f"{MEM0_SERVICE_URL}{path}", params=params, timeout=_TIMEOUT)
    r.raise_for_status()
    return r.json()
 def _post(path: str, data: dict) -> dict:
    r = httpx.post(f"{MEM0_SERVICE_URL}{path}", json=data, timeout=_TIMEOUT)
    r.raise_for_status()
    return r.json()
 def _put(path: str, data: dict) -> dict:
    r = httpx.put(f"{MEM0_SERVICE_URL}{path}", json=data, timeout=_TIMEOUT)
    r.raise_for_status()
    return r.json()
 def _delete(path: str) -> dict:
    r = httpx.delete(f"{MEM0_SERVICE_URL}{path}", timeout=_TIMEOUT)
    r.raise_for_status()
    return r.json()
 def list_memories(q: str = "", category: str = "") -> list[dict]:
    """Alle Fakten oder — wenn q gesetzt — die semantisch ähnlichsten (mit `score`)."""
    return _get("/memory", **{k: v for k, v in (("q", q), ("category", category)) if v})
 def add_memory(content: str, category: str = "stable", source: str = "manual") -> dict:
    """Einen Fakt VERBATIM speichern (keine LLM-Umformung). Auto-Lernen → learn()."""
    return _post("/memory", {"content": content.strip(), "category": category, "source": source})
 def update_memory(mid: str, content: str | None = None, category: str | None = None) -> dict | None:
    try:
        return _put(f"/memory/{mid}", {"content": content, "category": category})
    except httpx.HTTPStatusError as exc:
        if exc.response.status_code == 404:
            return None
        raise
 def delete_memory(mid: str) -> bool:
    try:
        _delete(f"/memory/{mid}")
        return True
    except httpx.HTTPStatusError as exc:
        if exc.response.status_code == 404:
            return False
        raise
 def learn(text: str | None = None, messages: list[dict] | None = None,
          source: str = "auto", category: str = "stable") -> dict:
    """Auto-Lernen: Text/Gesprächs-Turns durchreichen → Mem0 extrahiert die Fakten selbst."""
    return _post("/learn", {"text": text, "messages": messages,
                            "source": source, "category": category})
 def graph(min_score: float = 0.45, top_k: int = 3) -> dict:
    """Fakten als Ähnlichkeits-Graph (Knoten + semantische Kanten) für die UI-Visualisierung."""
    return _get("/graph", min_score=min_score, top_k=top_k)
 def export_text() -> dict:
    rows = sorted(list_memories(), key=lambda r: (r.get("category", ""), r.get("updated_at", "")))
    lines = ["# Mission Control — Gedächtnis\n"]
    current = ""
    for r in rows:
        if r.get("category") != current:
            current = r.get("category", "")
            lines.append(f"\n## {current}\n")
        src = r.get("source", "")
        when = (r.get("updated_at") or "")[:10]
        lines.append(f"- {r.get('content', '')}  _(Quelle: {src}, {when})_")
    return {"text": "\n".join(lines), "count": len(rows)}
 # --- Manueller Kurator (deterministisch, kein LLM) ---------------------------
 def _norm(s: str) -> str:
    s = re.sub(r"[^\w\s]", " ", s.lower(), flags=re.UNICODE)
    return re.sub(r"\s+", " ", s).strip()
 def dedupe(apply: bool = False, threshold: float = 0.85) -> dict:
    """Findet Dubletten (exakt/enthalten/ähnlich) je Kategorie, behält den längsten
    Eintrag. Mem0 dedupliziert beim Auto-Lernen schon semantisch — das hier ist der
    manuelle Komfort-Knopf fürs UI (z.B. nach vielen Verbatim-Importen)."""
    rows = sorted(list_memories(), key=lambda r: (-len(r.get("content", "")), r.get("created_at", "")))
    used: set[str] = set()
    groups: list[dict] = []
    for i, a in enumerate(rows):
        if a["id"] in used:
            continue
        na = _norm(a.get("content", ""))
        if not na:
            continue
        dups = []
        for b in rows[i + 1:]:
            if b["id"] in used or b.get("category") != a.get("category"):
                continue
            nb = _norm(b.get("content", ""))
            if not nb:
                continue
            if nb in na or na in nb or SequenceMatcher(None, na, nb).ratio() >= threshold:
                dups.append(b); used.add(b["id"])
        if dups:
            used.add(a["id"])
            groups.append({
                "keep": {"id": a["id"], "content": a.get("content"), "category": a.get("category")},
                "remove": [{"id": d["id"], "content": d.get("content")} for d in dups],
            })
    dup_count = sum(len(g["remove"]) for g in groups)
    removed = 0
    if apply:
        for g in groups:
            for d in g["remove"]:
                if delete_memory(d["id"]):
                    removed += 1
    return {"groups": groups, "duplicate_count": dup_count, "removed": removed, "applied": apply}
 # ── Auto-Dedupe (D16e): Dubletten von selbst wegräumen, kein Knopf-Zwang ─────────────
 # Deterministisch in UNSERER Schicht (wie reminders, Verdikt 11c) statt am Hermes-cron —
 # läuft als Hintergrund-Task. Höhere Schwelle als der manuelle Knopf (0.9 statt 0.85), weil
 # OHNE Mensch-Review angewandt wird: lieber eine Dublette stehen lassen als etwas Distinktes
 # löschen. Mem0 dedupliziert beim Auto-Lernen schon semantisch — das hier fängt den Rest
 # (Verbatim-Importe, wiederholte Fakten) ab, damit das Gedächtnis nicht ohne Zutun aufbläht.
 AUTO_DEDUPE_ENABLED = os.environ.get("MC_MEM_DEDUPE_ENABLED", "1") != "0"
 AUTO_DEDUPE_INTERVAL = int(os.environ.get("MC_MEM_DEDUPE_INTERVAL", str(24 * 3600)))  # täglich
 AUTO_DEDUPE_START_DELAY = int(os.environ.get("MC_MEM_DEDUPE_START_DELAY", "300"))     # 5 min nach Start
 AUTO_DEDUPE_THRESHOLD = float(os.environ.get("MC_MEM_DEDUPE_THRESHOLD", "0.75"))
 async def auto_dedupe_loop() -> None:
    """Hintergrund-Task: räumt periodisch Gedächtnis-Dubletten weg (apply=True)."""
    await asyncio.sleep(AUTO_DEDUPE_START_DELAY)   # Mem0-Sidecar nach Start hochkommen lassen
    while True:
        try:
            res = await asyncio.to_thread(dedupe, True, AUTO_DEDUPE_THRESHOLD)  # sync HTTP → Thread
            if res.get("removed"):
                log.info("mem-dedupe: %d Dublette(n) automatisch entfernt", res["removed"])
        except Exception:
            log.debug("mem-dedupe: Lauf fehlgeschlagen", exc_info=True)
        await asyncio.sleep(AUTO_DEDUPE_INTERVAL)
@@ -3,7 +3,7 @@ Lane-Routing für den eingebauten MC2-Gateway (:9001/v1).
 Zwei virtuelle Lanes, die Clients/IDEs auswählen — der Router pickt das echte Modell:
 - **chat**  (= altes `auto`): Alltag → `fast`, schwer/lang → `heavy`.
- **coding**: Code-Arbeit → `coder` (Qwen3-Coder-Next); riesiger/architektonischer Kontext → `heavy`;
+- **coding**: Code-Arbeit → `coder`; riesiger/architektonischer Kontext → `heavy`;
  triviale Kurzfrage ohne Code → `fast` (Tempo).
 Regelbasiert, sub-ms, ohne Cloud. Schwellen/Aliases liegen in einer UI-editierbaren Policy
@@ -1,7 +1,7 @@
 """
 Health-Wächter der Box (Lucy-Proaktivität, Faden A3).
-Prüft periodisch die Kern-Dienste (Engine, Agent-Hirn, Hermes-Gateway, Mem0,
+Prüft periodisch die Kern-Dienste (Engine, Agent-Hirn, Hermes-Gateway,
 Voice-Sidecar, Platte) und meldet ZUSTANDSWECHSEL in den Melde-Briefkasten
 (services/announce.py → Lucy spricht es) und via notify.sh (Telegram).
@@ -20,7 +20,7 @@ import time
 import httpx
 import psutil
-from config import HERMES_API_URL, MEM0_SERVICE_URL, MODELS_DIR, VOICE_SERVICE_URL
+from config import HERMES_API_KEY, HERMES_API_URL, MODELS_DIR, VOICE_SERVICE_URL
 from services import announce, llamaswap
@@ -34,14 +34,26 @@ REMIND_S = int(os.environ.get("MC_SENTRY_REMIND_S", "21600"))      # Erinnerung
 DISK_ALARM_PCT = float(os.environ.get("MC_SENTRY_DISK_PCT", "90"))
-def _reach(url: str, path: str = "/health") -> bool:
+def _reach(url: str, path: str = "/health", headers: dict[str, str] | None = None) -> bool:
    """Antwortet der Dienst ueberhaupt? `< 500` ist bewusst nachsichtig: Die Frage ist
    "laeuft er", nicht "darf ich rein" — ein 401 beweist, dass jemand zuhoert.
    `headers` gibt es seit dem 28.08.2026: Die Hermes-Probe schlug ohne API-Schluessel an
    und erzeugte dabei 720 `rejected invalid API key`-Warnungen pro Tag in dessen Log
    (gemessen: 30/Stunde seit dem 27.08. 15:05). Das Urteil war richtig, der Laerm nicht —
    und er haette einen echten Auth-Fehler unter sich begraben."""
    try:
        with httpx.Client(timeout=5.0) as c:
-            return c.get(f"{url}{path}").status_code < 500
+            return c.get(f"{url}{path}", headers=headers or {}).status_code < 500
    except Exception:
        return False
 def _hermes_kopf() -> dict[str, str]:
    """Bearer-Kopf fuer die Hermes-Platform, falls ein Schluessel konfiguriert ist."""
    return {"Authorization": f"Bearer {HERMES_API_KEY}"} if HERMES_API_KEY else {}
 def _check_engine() -> bool:
    return llamaswap.engine_reachable()
@@ -70,12 +82,9 @@ CHECKS: dict[str, tuple] = {
    "brain": (_check_brain,
              "Mein Gehirn lädt nicht — ich kann gerade nicht richtig denken. Ein Neustart der Engine könnte helfen.",
              "Mein Gehirn ist wieder geladen. Alles klar bei mir."),
-    "hermes": (lambda: _reach(HERMES_API_URL),
+    "hermes": (lambda: _reach(HERMES_API_URL, "/v1/models", _hermes_kopf()),
               "Der Agent-Dienst ist ausgefallen — Telegram und meine Tools gehen gerade nicht.",
               "Der Agent-Dienst läuft wieder."),
    "mem0": (lambda: _reach(MEM0_SERVICE_URL),
             "Mein Gedächtnis-Dienst ist ausgefallen — ich merke mir vorübergehend nichts Neues.",
             "Mein Gedächtnis ist wieder online."),
    "voice": (lambda: _reach(VOICE_SERVICE_URL),
              "Der Hör-Dienst auf der Box ist ausgefallen — Spracheingabe könnte haken.",
              "Der Hör-Dienst läuft wieder."),
@@ -10,6 +10,7 @@ import glob
 import os
 import subprocess
 import threading
 import time
 import psutil
 from config import MODELS_DIR
@@ -197,5 +198,59 @@ def system_status() -> dict:
        "gpu": _gpu_sysfs(),
        "temp": _temps(),
        "disk": disk,
        # Betriebszeit in Sekunden (v3-Umbau P3). Gehoert in die neue Statusleiste, weil
        # sich die Box woechentlich selbst neu startet, wenn das OS es verlangt — dann ist
        # "laeuft seit 20 Minuten" die Antwort auf eine ganze Klasse von Fragen.
        "uptime_s": _uptime_s(),
        "versions": check_versions_cached(),
    }
 def metrik_punkt() -> dict:
    """Leichter Messpunkt fuer den Ereignisstrom (v3-Umbau P4) — EINMAL pro Sekunde.
    Bewusst NICHT `system_status()`: das ruft `psutil.cpu_percent(interval=0.1)` und
    blockiert damit den Event-Loop 100 ms je Aufruf (bei 1-s-Takt also 10 % der Zeit),
    und es haengt den Versions-Check dran, den niemand sekuendlich braucht.
    `interval=None` misst gegen den VORIGEN Aufruf statt zu warten — genau richtig fuer
    einen festen Takt. Der allererste Wert ist 0.0; das faellt bei 1 s nicht auf.
    Token stehen hier als GESAMTZAEHLER, nicht als Rate: Der Klient rechnet die Rate aus
    zwei Punkten selbst. So bleibt der Server zustandslos und ein verpasster Punkt
    verfaelscht nichts."""
    vm = psutil.virtual_memory()
    temp = _temps() or {}
    gpu = _gpu_sysfs() or {}
    try:
        from services.token_stats import get_stats
        tok = get_stats()
    except Exception:
        tok = {}
    try:
        du = psutil.disk_usage(str(MODELS_DIR) if MODELS_DIR.exists() else os.getcwd())
        disk = du.percent
    except Exception:
        disk = None
    return {
        "cpu": psutil.cpu_percent(interval=None),
        "ram": vm.percent,
        "ram_used": vm.used,
        "ram_total": vm.total,
        "gpu": gpu.get("busy_percent"),
        "disk": disk,
        "temp_cpu": temp.get("cpu"),
        "temp_gpu": temp.get("gpu"),
        "uptime_s": _uptime_s(),
        "tok_p": tok.get("prompt_tokens", 0),
        "tok_c": tok.get("completion_tokens", 0),
    }
 def _uptime_s() -> int | None:
    """Sekunden seit dem Systemstart. None statt einer Ausrede, wenn psutil hier nichts
    liefert — eine erfundene Zahl waere schlimmer als eine fehlende."""
    try:
        return int(time.time() - psutil.boot_time())
    except Exception:
        return None
@@ -11,14 +11,14 @@ Zwei Sichten auf dieselben Messungen:
 **Was MC2 messen kann — und was nicht:** MC2 proxyt den Chat nur an Hermes (:8642). Die Stufen STT,
 Vision, Hirn-TTFT (Zeit bis zum ersten Inhalts-Token) und Generierung sind hier direkt messbar. Der
-**Mem0-Retrieve** läuft zwar in Hermes, ruft aber MC2s `/api/memory` per HTTP zurück → messbar und als
+**Gedächtnis-Abruf** dagegen läuft seit der Ablösung des Sidecars (07.08.2026) Hermes-intern — es
-Unter-Detail INNERHALB der Hirn-Zeit ausgewiesen (kein Doppelzählen). Die **Tool-Runden** dagegen laufen
+gibt keinen Rückruf an MC2 mehr, also auch keine Messung; er steckt jetzt in der Hirn-Zeit. Ebenso die
-im Hermes-LLM-Loop ohne Callback an MC2 → für MC2 unsichtbar, sie stecken im „Generierung"-Bucket.
+**Tool-Runden**: im Hermes-LLM-Loop ohne Callback an MC2 → unsichtbar, im „Generierung"-Bucket.
-STT (davor) und Mem0-Retrieve (währenddessen) sind separate HTTP-Requests ohne Turn-ID. Auf einem
+STT läuft als eigener HTTP-Request VOR dem Turn, ohne Turn-ID. Auf einem EIN-Nutzer-Gerät genügt eine
-EIN-Nutzer-Gerät genügt eine schlanke Best-Effort-Korrelation: die zuletzt gemessene STT-Dauer bzw. der
+schlanke Best-Effort-Korrelation: die zuletzt gemessene STT-Dauer wird global „geparkt" und vom
-letzte Retrieve werden global „geparkt" und vom nächsten Chat-Turn eingesammelt (mit Frist-/Reihenfolge-
+nächsten Chat-Turn eingesammelt (mit Frist-Check). Kein Turn-ID-Durchreichen durch den Lucy-Client
-Check). Kein Turn-ID-Durchreichen durch den Lucy-Client nötig.
+nötig.
 In-Memory + thread-safe (keine Datei-I/O — Latenz-Telemetrie ist transient, Restart = Reset).
 """
@@ -34,11 +34,11 @@ _STAGES: dict[str, deque] = {}
 _TURNS: deque = deque(maxlen=60)  # letzte N vollständige Chat-Turns (Per-Turn-Trace)
 # Bekannte Stufen (für stabile UI-Reihenfolge); unbekannte werden trotzdem erfasst.
-STAGES = ("stt", "vision", "memory_retrieve", "chat_ttfb", "chat_first_content", "tts")
+STAGES = ("stt", "vision", "chat_ttfb", "chat_first_content", "tts")
-# Best-effort-Korrelation (Ein-Nutzer-Gerät): zuletzt gemessene STT-Dauer / Mem0-Retrieve, je
+# Best-effort-Korrelation (Ein-Nutzer-Gerät): zuletzt gemessene STT-Dauer als
-# (ms, perf_counter-Zeitstempel). Der nächste passende Chat-Turn sammelt sie ein und leert sie.
+# (ms, perf_counter-Zeitstempel). Der nächste Chat-Turn sammelt sie ein und leert sie.
-_PARKED: dict[str, tuple[float, float] | None] = {"stt": None, "retrieve": None}
+_PARKED: dict[str, tuple[float, float] | None] = {"stt": None}
 def record_stage(stage: str, ms: float) -> None:
@@ -53,8 +53,8 @@ def record_stage(stage: str, ms: float) -> None:
 def park(kind: str, ms: float) -> None:
-    """Eine Messung, die NICHT im Chat-Request selbst passiert (STT davor, Mem0-Retrieve als
+    """Eine Messung, die NICHT im Chat-Request selbst passiert (STT läuft davor), global parken,
-    Rückruf während), global parken, damit der nächste Chat-Turn sie einsammeln kann."""
+    damit der nächste Chat-Turn sie einsammeln kann."""
    if ms is None or ms < 0 or kind not in _PARKED:
        return
    with _LOCK:
@@ -71,17 +71,6 @@ def _take_stt(max_age: float = 20.0) -> float | None:
    return None
 def _take_retrieve(since_perf: float, max_age: float = 90.0) -> float | None:
    """Geparkten Mem0-Retrieve einsammeln, wenn er NACH dem Turn-Start kam (Rückruf während des
    Turns) und frisch ist."""
    with _LOCK:
        v = _PARKED.get("retrieve")
        if v and v[1] >= since_perf and (time.perf_counter() - v[1]) <= max_age:
            _PARKED["retrieve"] = None
            return round(v[0], 1)
    return None
 class Timer:
    """Context-Manager: misst die verstrichene Zeit und verbucht sie auf `stage`.
    Funktioniert um `await`-Aufrufe herum (enter → await → exit)."""
@@ -102,8 +91,7 @@ class TurnTrace:
    """Ein Per-Turn-Trace für den Voice/Lucy-Chatpfad. In `voice.py` über die Dauer eines Chat-Turns
    gehalten; `commit()` schreibt den Datensatz in den Ringpuffer UND speist die rollenden Stats.
-    Balken-Stufen (zeitlich DISJUNKT, ergeben zusammen den Turn): stt · vision · hirn · gen.
+    Balken-Stufen (zeitlich DISJUNKT, ergeben zusammen den Turn): stt · vision · hirn · gen."""
    Unter-Detail: mem0 (Teil VON hirn, wird separat ausgewiesen, aber NICHT zum Balken addiert)."""
    def __init__(self, session_id: str = "", kind: str = "voice") -> None:
        self.id = uuid.uuid4().hex[:8]
@@ -113,7 +101,7 @@ class TurnTrace:
        self.session_id = (session_id or "")[:24]
        self.kind = kind
        self.vision_ms: float | None = None      # Bildschirm-Beschreibung (falls Bilder)
-        self.hirn_ms: float | None = None        # Zeit bis zum ersten Inhalts-Token (Agent + Mem0 + TTFT)
+        self.hirn_ms: float | None = None        # Zeit bis zum ersten Inhalts-Token (Agent + Gedächtnis + TTFT)
        self.had_images = False
        self.error: str | None = None
@@ -130,7 +118,7 @@ class TurnTrace:
        record_stage("chat_ttfb", (time.perf_counter() - self._brain0) * 1000.0)  # SSE-Start (~5 ms), nur rollend
    def note_first_content(self) -> None:
-        """Erster Inhalts-Delta = echte Hirn-Latenz (Agent-Overhead + Mem0 + LLM-TTFT)."""
+        """Erster Inhalts-Delta = echte Hirn-Latenz (Agent-Overhead + Gedächtnis + LLM-TTFT)."""
        ms = (time.perf_counter() - self._brain0) * 1000.0
        self.hirn_ms = round(ms, 1)
        record_stage("chat_first_content", ms)
@@ -138,7 +126,6 @@ class TurnTrace:
    def commit(self) -> dict:
        total = (time.perf_counter() - self.perf0) * 1000.0
        stt = _take_stt()  # rollend bereits in /voice/stt erfasst
        mem0 = _take_retrieve(self.perf0)  # rollend bereits in /api/memory erfasst
        # Generierung = alles nach dem ersten Inhalts-Token bis Stream-Ende.
        gen = round(total - self.hirn_ms, 1) if self.hirn_ms is not None else None
        rec = {
@@ -151,7 +138,6 @@ class TurnTrace:
            "vision_ms": self.vision_ms,
            "hirn_ms": self.hirn_ms,
            "gen_ms": gen if (gen is None or gen >= 0) else 0.0,
            "mem0_ms": mem0,
            "total_ms": round(total, 1),
            "error": self.error,
        }
@@ -1,7 +1,7 @@
 """
 MC2-Steward — die Wächter-Loops als EIGENER Prozess (UMBAU v3, P2).
-Bisher hingen Re-Warm-Wächter, Health-Wächter (sentry) und Mem0-Auto-Dedupe am
+Bisher hingen Re-Warm-Wächter und Health-Wächter (sentry) am
 Lebenszyklus des Steuerpult-Webservers (app.py-Lifespan): jeder MC2-Neustart riss
 den Wächtern Timing und Flanken-Gedächtnis weg — und ein TOTES Steuerpult konnte
 sich prinzipbedingt nicht selbst melden. Hier laufen DIESELBEN Loops (unveränderte
@@ -11,14 +11,16 @@ Module) als eigener Mini-Dienst (mc2-steward.service, Restart=always):
                              In-Process-Nudge aus llamaswap.write_config)
  • sentry.sentry_loop      — Health-Flanken → Briefkasten (HTTP an MC2) + Telegram;
                              beobachtet im Steward-Modus AUCH MC2 selbst + mc2-gateway
-  • memory.auto_dedupe_loop — Gedächtnis-Dubletten (HTTP an den Mem0-Sidecar)
+
 Das dritte Loop (Gedächtnis-Dubletten gegen den Sidecar auf :8765) ist mit dessen Ablösung
 am 07.08.2026 entfallen — Hermes führt sein Gedächtnis selbst (docs/wissen/VERDIKTE.md).
 BEWUSST NICHT hier: reminders_loop — der teilt sich Datei UND CRUD-Pfade mit dem
 /api/reminders-Router (Zwei-Schreiber-Risiko auf mc2-reminders.json); er bleibt im
 Steuerpult. Der Briefkasten-Store gehört weiter EXKLUSIV dem MC2-Prozess — dieser
 Prozess liefert Meldungen per HTTP ab (announce.py, MC_ANNOUNCE_HTTP).
-Die Loop-Schalter (MC_REWARM_ENABLED / MC_SENTRY_ENABLED / MC_MEM_DEDUPE_ENABLED)
+Die Loop-Schalter (MC_REWARM_ENABLED / MC_SENTRY_ENABLED)
 stehen in der MC2-Unit auf 0 und hier auf Default 1 — reiner Konfig-Split, kein
 Verhaltens-Code im Steuerpult angefasst. Zeilen dort entfernen = Rollback.
 """
@@ -28,7 +30,6 @@ import logging
 import os
 from config import CONFIG_PATH
 from services import memory as memory_svc
 from services import sentry, warmer
 logging.basicConfig(
@@ -66,10 +67,6 @@ async def main() -> None:
                 warmer.INTERVAL, CONFIG_WATCH_S)
    if sentry.ENABLED:
        tasks.append(asyncio.create_task(sentry.sentry_loop()))
    if memory_svc.AUTO_DEDUPE_ENABLED:
        tasks.append(asyncio.create_task(memory_svc.auto_dedupe_loop()))
        log.info("Mem0-Auto-Dedupe aktiv (alle %ss, Schwelle %s)",
                 memory_svc.AUTO_DEDUPE_INTERVAL, memory_svc.AUTO_DEDUPE_THRESHOLD)
    if not tasks:
        log.warning("steward: alle Loops per Env deaktiviert — nichts zu tun, Ende.")
        return
@@ -28,7 +28,7 @@ hint=""
 # Stabile Anti-Flail-Orientierung: WER bin ich, WO laufen die Modelle, WAS ist tabu.
 ctx="$(cat <<EOF
 [BOX-ORIENTIERUNG — du bist ein Hintergrund-Worker auf der lokalen AI-Box (Linux, Zeit UTC / lokal Europe/Berlin, locale de_DE), NICHT Lucy und kein Dev-Laptop. Du arbeitest EINE Kanban-Aufgabe ab.]
-Die Modelle / das "Hirn" laufen ausschliesslich ueber den Router llama-swap auf 127.0.0.1:8080 (startet je Modell einen llama-server) bzw. das OpenAI-kompatible Gateway von MC2 auf 127.0.0.1:9001/v1 — es gibt KEINEN anderen Modell-Server, also nicht danach suchen. Weitere Dienste: hermes-gateway :8642, mem0-Gedaechtnis :8765. Der MC2-Live-Checkout ~/mission-control-v2 ist nur zum LESEN da (Schreiben/committen TABU — Code-Arbeit immer im frischen Klon deines Task-Workspaces). Grenzen (was gehoert wohin): MC2 = Steuerpult (verwalten/klicken/zusehen, KEIN Chat-UI), Lucy = Chat & Stimme (eigenes Repo), Hermes-Quelle ist TABU (Agenten-Verhalten nur ueber Config/SOUL/Skill/Hook/MCP aendern). Feste Entscheide/Verbote + volle Grenzen-Landkarte: ~/mission-control-v2/docs/wissen/ (GRENZEN/VERDIKTE/FALLEN/STACK) + ~/wissens-vault/eigenbau-landkarte.md.${hint}
+Die Modelle / das "Hirn" laufen ausschliesslich ueber den Router llama-swap auf 127.0.0.1:8080 (startet je Modell einen llama-server) bzw. das OpenAI-kompatible Gateway von MC2 auf 127.0.0.1:9001/v1 — es gibt KEINEN anderen Modell-Server, also nicht danach suchen. Weiterer Dienst: hermes-gateway :8642 (fuehrt sein Gedaechtnis selbst — es gibt KEINEN separaten Gedaechtnis-Dienst mehr). Der MC2-Live-Checkout ~/mission-control-v2 ist nur zum LESEN da (Schreiben/committen TABU — Code-Arbeit immer im frischen Klon deines Task-Workspaces). Grenzen (was gehoert wohin): MC2 = Steuerpult (verwalten/klicken/zusehen, KEIN Chat-UI), Lucy = Chat & Stimme (eigenes Repo), Hermes-Quelle ist TABU (Agenten-Verhalten nur ueber Config/SOUL/Skill/Hook/MCP aendern). Feste Entscheide/Verbote + volle Grenzen-Landkarte: ~/mission-control-v2/docs/wissen/ (GRENZEN/VERDIKTE/FALLEN/STACK) + ~/wissens-vault/eigenbau-landkarte.md.${hint}
 TRIAGE (19.07. — Drei-Bahnen-Regel): Ordne deine Karte ZUERST einer Bahn zu und bleib darin: Denken (Konzept/Plan), Bauen (Code schreiben/aendern), Betrieb (SSH/Deploy/Dienste). Fuer Betrieb-Arbeit lade IMMER zuerst den Skill betrieb-playbook (Diagnose-Checklisten; max 3 Anlaeufe pro Hindernis, dann kanban_block mit exaktem Fehlertext — die No-Progress-Bremse erzwingt das mechanisch).
 PROTOKOLL-PFLICHT (15.07.): Beende deine Aufgabe IMMER mit dem Tool-Aufruf kanban_complete (fertig) oder kanban_block (Frage/Sackgasse). Eine Text-Zusammenfassung OHNE diesen Aufruf zaehlt als Absturz (Protokollverstoss) und blockiert die Karte — genau so ging am 14.07. eine fertige Arbeit verloren.
 REPO-WEGWEISER mission-control-v2 (NICHT raten/suchen — so liegt es): backend/app.py = Einstieg + Router-Mounting · backend/routers/*.py = REST-Endpunkte · backend/services/*.py = Logik · backend/gateway_app.py = /v1-Gateway-Prozess (:9010) · frontend/src/views/*.tsx = Ansichten · frontend/src/lib/api.ts = Typen+Fetch · frontend/src/lib/queries.ts = TanStack-Query-Hooks (Polling) · frontend/src/nav.ts = Sidebar · deploy/ = Skripte/Units/Hooks/Skills · Projekt-Regeln: AGENTS.md (Wurzel) + docs/wissen/.
@@ -67,6 +67,22 @@ jobs:
              (cd "$d" && npm ci --no-audit --no-fund) || { rot=1; continue; }
              if grep -q '"build"' "$pkg"; then (cd "$d" && npm run build) || rot=1; fi
              if grep -q '"test"' "$pkg"; then (cd "$d" && npm test --silent) || rot=1; fi
              # Buendel-Budget: das Start-Chunk ist, was der Nutzer VOR dem ersten Bild laedt.
              # Ohne Deckel waechst es unbemerkt zurueck (eine eifrig geladene Diagramm-Lib
              # reicht). Gemessen wird der frische Build, nicht das committete dist.
              if [ -d "$d/dist/assets" ]; then
                # Einstiegs-Chunk aus index.html lesen, nicht per Glob raten: Rollup nennt
                # auch kleine geteilte Module "index-*.js", und dann misst der Glob den
                # falschen — das Budget waere still immer gruen.
                einstieg=$(grep -o 'assets/index-[A-Za-z0-9_-]*\.js' "$d/dist/index.html" | head -1)
                haupt="$d/$einstieg"
                if [ -n "$haupt" ]; then
                  gz=$(gzip -c "$haupt" | wc -c)
                  echo "-- Start-Chunk: $gz B gzip (Budget 200000)"
                  [ "$gz" -gt 200000 ] && { echo "❌ Start-Buendel ueber Budget — hinter lazy() legen."; rot=1; }
                fi
              fi
            done <<< "$pkg_dateien"
          fi
@@ -12,7 +12,7 @@ TOKEN=$(grep -m1 'git\.tobisniceshomelab' "$HOME/.git-credentials" 2>/dev/null |
 [ -n "$TOKEN" ] || exit 0
 python3 - "$TOKEN" "$STATE" <<'PY'
-import json, sys, urllib.request
+import json, sys, urllib.request, subprocess, os
 token, state_pfad = sys.argv[1], sys.argv[2]
 # API intern (die DDNS-Domain ist nachts wegen Zwangstrennung oft tot, 24.07.2026);
@@ -79,6 +79,14 @@ if neu:
    for full, sha, name in neu:
        print(f"• {full} @ {sha} ({name})")
        print(f"  {WEB}/{full}/actions")
        try:
            subprocess.run([
                os.path.expanduser("~/.local/bin/hermes"), "kanban", "create", 
                "--title", f"CI rot: {full} @ {sha}", 
                "--body", f"Der CI Lauf '{name}' in {full} ist fehlgeschlagen. Bitte Log ansehen und Fix vorschlagen."
            ], capture_output=True)
        except Exception as e:
            print(f"Fehler bei kanban_create: {e}", file=sys.stderr)
    print("Nichts aus diesen Ständen ist ‚fertig', solange die Ampel rot ist.")
 with open(state_pfad, "w") as f:
@@ -123,7 +123,7 @@ check_hermes(){
  done
  if [ "$state" = "done" ]; then
    SUMMARY+=("$name: $behind Commits eingespielt, Gehirn-Check grün.")
-    notify "Hermes-Agent aktualisiert ($behind Commits). Gehirn-Check (Mem0, Tools, Voice) grün — alles läuft."
+    notify "Hermes-Agent aktualisiert ($behind Commits). Gehirn-Check (Patches, Tools, Voice) grün — alles läuft."
    return
  fi
  # Rot/Timeout: ERST Selbstreparatur versuchen (Config-Bruch selbst ziehen, neue Version behalten) —
@@ -165,6 +165,63 @@ Wahrscheinliche Ursache/Fix (Box-Diagnose): $sugg}"
  notify "KRITISCH: Hermes-Update UND Rollback fehlgeschlagen — Gehirn-Check bleibt rot. Bitte melden. (Voll-Restore: deploy/restore.sh mit dem letzten Backup.)"
 }
 # ── Neustart, wenn das OS einen verlangt ─────────────────────────────────────
 # Kernel- und libc-Updates werden erst nach einem Neustart wirksam; bis dahin
 # laeuft die Box weiter auf dem alten Kernel. Das faellt niemandem auf — am
 # 27.08.2026 lag die Box 7 Wochen mit drei ungenutzten Kerneln da.
 #
 # Der Neustart haengt bewusst am WOECHENTLICHEN Lauf (So 04:30) und nicht an
 # einem eigenen Timer: ein Ort fuer alle Automatik (Lehre vom 20.08.).
 # Er passiert NUR, wenn Ubuntu ihn selbst anfordert (/var/run/reboot-required).
 #
 # WICHTIG: Die Linger-Pruefung ist die entscheidende Zeile hier. Ohne Linger=yes
 # startet systemd die User-Dienste nach einem Neustart NICHT — die Box kaeme ohne
 # Steuerpult, Gateway und Waechter hoch, und niemand koennte sie aus der Ferne
 # wieder anschalten. Im Zweifel lieber nicht neustarten.
 #
 # Abschalten: MC_AUTOUPDATE_REBOOT=0 in der Umgebung des Cron-Jobs.
 reboot_wenn_noetig(){
  [ "${MC_AUTOUPDATE_REBOOT:-1}" = "1" ] || { say "Neustart per Env abgeschaltet."; return 0; }
  [ -f /var/run/reboot-required ] || { say "Kein Neustart noetig."; return 0; }
  local pakete; pakete="$(sort -u /var/run/reboot-required.pkgs 2>/dev/null | tr "
 " " ")"
  # Sicherung 1: kommen die Dienste ohne Login von selbst wieder hoch?
  # $USER ist in systemd-/Cron-Umgebungen NICHT gesetzt — mit set -u waere das ein
  # sofortiger Abbruch des ganzen Update-Laufs. id -un funktioniert immer.
  local nutzer; nutzer="$(id -un)"
  if [ "$(loginctl show-user "$nutzer" -p Linger --value 2>/dev/null)" != "yes" ]; then
    notify "Neustart NICHT ausgefuehrt: die Box laeuft ohne linger — nach einem Neustart wuerden Steuerpult, Gateway und Waechter nicht von selbst starten. Erst 'loginctl enable-linger $nutzer' setzen, dann von Hand neustarten. Ausstehend: ${pakete:-Kernel/libc}"
    return 0
  fi
  # Sicherung 2: kein halbfertiges Update mitten im Neustart abwuergen.
  local laufend
  laufend="$(curl -sf --max-time 20 "$API/api/jobs"              | jq -r '[.jobs[]? | select(.state=="running")] | length' 2>/dev/null || echo 0)"
  if [ "${laufend:-0}" -gt 0 ]; then
    notify "Neustart verschoben: es laufen noch $laufend Job(s). Ausstehend: ${pakete:-Kernel/libc}. Naechster Versuch beim Lauf in einer Woche."
    return 0
  fi
  # Sicherung 3: die Dienste muessen fuer den Autostart vorgemerkt sein.
  local fehlend=""
  for dienst in mission-control-2 mc2-gateway mc2-steward; do
    systemctl --user is-enabled "$dienst" >/dev/null 2>&1 || fehlend="$fehlend $dienst"
  done
  if [ -n "$fehlend" ]; then
    notify "Neustart NICHT ausgefuehrt: diese Dienste sind nicht fuer den Autostart eingetragen —$fehlend. Erst 'systemctl --user enable' nachholen. Ausstehend: ${pakete:-Kernel/libc}"
    return 0
  fi
  notify "Die Box startet jetzt neu — das OS verlangt es nach dem Update (${pakete:-Kernel/libc}). Sie ist ein paar Minuten weg und meldet sich, sobald alles wieder laeuft. Die Modelle muessen danach neu geladen werden, die erste Anfrage dauert also laenger."
  say "Neustart wird ausgeloest (ausstehend: ${pakete:-Kernel/libc})."
  sleep 20   # der Meldung Zeit lassen, rauszugehen
  sudo -n systemctl reboot || {
    notify "Neustart FEHLGESCHLAGEN: 'sudo systemctl reboot' wurde abgelehnt. Bitte von Hand neustarten. Ausstehend: ${pakete:-Kernel/libc}"
  }
 }
 # ── Lauf ─────────────────────────────────────────────────────────────────────
 say "Auto-Update-Lauf startet ($(date '+%F %H:%M'))."
 pins_init
@@ -180,3 +237,7 @@ check_hermes
 notify "Commander, die Wochenpflege der Box ist durch — kurz für dich:
 $(printf '• %s\n' "${SUMMARY[@]}")"
 say "Fertig."
 # Ganz zuletzt: der Neustart wuerde die Abschlussmeldung oben sonst verschlucken.
 # Die Funktion meldet in jedem Fall selbst, ob sie neustartet oder warum nicht.
 reboot_wenn_noetig
@@ -3,8 +3,10 @@
 # zurückkommt. Erzeugt EIN Tarball mc2-state-<ts>.tar.gz, behält die letzten N.
 # Läuft per systemd-Timer (täglich), manuell, oder über den UI-Snapshot-Button.
 #
-# Inhalt:  mem0 (Chroma + history.db) · ~/.hermes (config.yaml, .env, plugins/) ·
+# Inhalt:  ~/.hermes (config.yaml, .env, plugins/) · /etc/llama-swap/config.yaml ·
-#          /etc/llama-swap/config.yaml · known-good/ (Versions-Manifest, s. u.)
+#          known-good/ (Versions-Manifest, s. u.)
 # Das abgeloeste Gedaechtnis-Sidecar (/srv/models, Port 8765) faellt seit 27.08.2026 weg —
 # sein Datenverzeichnis existiert nicht mehr (Hintergrund: docs/wissen/VERDIKTE.md).
 # NICHT enthalten (bewusst): GGUF-Modelle (riesig, neu ladbar), MC2-Code (Git), venvs.
 #
 # ACHTUNG: das Tarball enthält ~/.hermes/.env (Secrets) → chmod 600, nicht in Git.
@@ -20,16 +22,14 @@ RETAIN="${MC_BACKUP_RETAIN:-14}"
 # Off-Box-Ziel (leer = deaktiviert). Default: Proxmox-Host, eigener Key mit minimalem Recht.
 OFFSITE="${MC_BACKUP_OFFSITE:-root@192.168.178.108:/var/lib/vz/mc2-backups}"
 OFFSITE_KEY="${MC_BACKUP_OFFSITE_KEY:-$HOME/.ssh/mc2_offsite}"
 MEM0_DIR="${MC_MEM0_DIR:-/srv/models/mem0}"
 LSWAP="${MC_CONFIG_PATH:-/etc/llama-swap/config.yaml}"
 HERMES="${HERMES_HOME:-$HOME/.hermes}"
 TS="$(date +%Y%m%d-%H%M%S)"
 STAGE="$(mktemp -d)"
 trap 'rm -rf "$STAGE"' EXIT
-mkdir -p "$STAGE/mem0" "$STAGE/hermes" "$STAGE/llama-swap"
+mkdir -p "$STAGE/hermes" "$STAGE/llama-swap"
 [ -d "$MEM0_DIR" ]            && cp -a "$MEM0_DIR/." "$STAGE/mem0/"          || true
 [ -f "$HERMES/config.yaml" ] && cp -a "$HERMES/config.yaml" "$STAGE/hermes/" || true
 [ -f "$HERMES/.env" ]        && cp -a "$HERMES/.env" "$STAGE/hermes/"        || true
 [ -d "$HERMES/plugins" ]     && cp -a "$HERMES/plugins" "$STAGE/hermes/plugins" || true
@@ -60,7 +60,7 @@ SRC="${MC2_SRC:-$HOME/mission-control-v2}"
 HERMES_AGENT="${HERMES_AGENT_DIR:-$HOME/.hermes/hermes-agent}"
 UV="$(command -v uv || echo "$HOME/.local/bin/uv")"
-# pip freeze je venv; mem0-venv ist uv-managed (kein pip-Modul) → uv als Fallback.
+# pip freeze je venv; das voice-venv ist uv-managed (kein pip-Modul) → uv als Fallback.
 freeze_venv() { # $1 = python-Pfad, $2 = Zieldatei
  if [ ! -x "$1" ]; then echo "venv fehlt: $1" > "$2"; return 0; fi
  "$1" -m pip freeze > "$2" 2>/dev/null \
@@ -68,7 +68,6 @@ freeze_venv() { # $1 = python-Pfad, $2 = Zieldatei
    || echo "pip freeze fehlgeschlagen: $1" > "$2"
 }
 freeze_venv "$SRC/backend/.venv/bin/python" "$KG/pip-backend.txt"
 freeze_venv "$HOME/.mem0/venv/bin/python"   "$KG/pip-mem0.txt"
 freeze_venv "$HOME/.voice/venv/bin/python"  "$KG/pip-voice.txt"
 {
@@ -79,7 +78,7 @@ freeze_venv "$HOME/.voice/venv/bin/python"  "$KG/pip-voice.txt"
  echo "llama.cpp    : $(LD_LIBRARY_PATH=/opt/llamacpp-vulkan /usr/local/bin/llama-server --version 2>&1 | grep -m1 -o 'version: .*' || echo '?')"
  echo "llama-swap   : $(/usr/local/bin/llama-swap --version 2>/dev/null | head -1 || echo '?')"
  echo "python-venvs :"
-  for P in "$SRC/backend/.venv/bin/python" "$HOME/.mem0/venv/bin/python" "$HOME/.voice/venv/bin/python"; do
+  for P in "$SRC/backend/.venv/bin/python" "$HOME/.voice/venv/bin/python"; do
    echo "  $P → $("$P" --version 2>&1 || echo 'fehlt')"
  done
 } > "$KG/versions.txt" || true
@@ -92,7 +91,7 @@ cat > "$STAGE/MANIFEST.txt" <<EOF
 mc2-state backup
 created : $TS
 host    : $(hostname)
-inhalt  : mem0 (chroma + history.db), hermes (config.yaml, .env, plugins/), llama-swap (config.yaml), known-good/ (Versions-Manifest: pip freeze, Engine, Modelle)
+inhalt  : hermes (config.yaml, .env, plugins/), llama-swap (config.yaml), known-good/ (Versions-Manifest: pip freeze, Engine, Modelle)
 restore : bash ~/mission-control-v2/deploy/restore.sh mc2-state-$TS.tar.gz
 EOF
@@ -1,104 +0,0 @@
 #!/usr/bin/env bash
 # Chef-Gutachter-Feed (Orchestrator-Finale, User-Idee 06.07.): gpt-oss-120b als NÄCHTLICHER
 # Chef-Gutachter über die autonome Arbeit der Box — bewusst NIE im heißen Pfad (Kaltladen
 # ~2-5 min ist um 04:30 egal; tagsüber bleibt Lucy schnell). Muster wie dreaming-feed.sh:
 # liegt in ~/.hermes/scripts/, stdout wird dem Cron-Agenten als Prompt eingespeist.
 # Der eigentliche RICHTER läuft als Ein-Schuss-Completion direkt gegen llama-swap (:8080,
 # fremdblick-Architektur — umgeht Hermes' Delegations-Floor und braucht keinen Subagenten).
 # Richter-Kette: gpt-oss-120b; wirft der beim Laden "exited prematurely" (neben dem Warm-Set
 # live gesehen, E2E 07.07.), übernimmt GLM-4.6V-Flash als gekennzeichnete VERTRETUNG.
 set -uo pipefail
 ENDPOINT="${CHEF_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}"
 CHEF="${CHEF_MODEL:-gpt-oss-120b}"
 VERTRETUNG="${CHEF_FALLBACK:-GLM-4.7-Flash}"
 MC="$HOME/mission-control-v2"
 VAULT="$HOME/wissens-vault"
 # ---------- Versionierter Auftrag für den Boten-Agenten ----------
 cat "$MC/deploy/chef-gutachter-prompt.md"
 echo
 # ---------- Beweismaterial der letzten 24 h (hart begrenzt, erst sammeln, dann kürzen) ----------
 EVID="$(
  echo "## BEWEISMATERIAL (automatisch erhoben am $(date '+%d.%m.%Y %H:%M'))"
  echo
  echo "### Vorschlags-Branches (Werkstatt/Orchestrator, jüngste zuerst):"
  git -C "$MC" fetch -q origin 2>/dev/null || true
  git -C "$MC" for-each-ref --sort=-committerdate refs/remotes/origin \
    --format='%(committerdate:relative) | %(refname:short) | %(subject)' 2>/dev/null | head -10
  echo
  echo "### main-Commits der letzten 24 h:"
  git -C "$MC" log --since='24 hours ago' --oneline origin/main 2>/dev/null | head -12
  echo
  echo "### Wissens-Vault (neue Traum-Notizen, 24 h):"
  git -C "$VAULT" log --since='24 hours ago' --name-only --pretty='— %s' 2>/dev/null | head -20
  echo
  echo "### Ideen-Queue (natives Kanban, Stand jetzt — offene Ideen des Commanders):"
  bash -lc 'hermes kanban stats' 2>/dev/null | head -12
  echo
  echo "### Ideen-Queue: zuletzt bewegte Aufgaben:"
  bash -lc 'hermes kanban list --sort updated' 2>/dev/null | head -10
  echo
  echo "### Betriebs-Warnungen (journal, 24 h, je Dienst gezählt):"
  journalctl --user --since '24 hours ago' -p warning --no-pager 2>/dev/null \
    | grep -oE 'hermes-gateway|mission-control-2|mem0-service|voice-service|hermes-builtin-ui' \
    | sort | uniq -c | sort -rn | head -6
  echo
  echo "### Aktivitäts-Insights (1 Tag):"
  bash -lc 'hermes insights --days 1' 2>/dev/null | sed 's/\x1b\[[0-9;]*m//g' | head -30
 )"
 RASTER='Du bist der CHEF-GUTACHTER über die autonome Arbeit einer lokalen KI-Box (Hermes-Agent, Werkstatt, Orchestrator, Traum-Kreislauf). Du bekommst BEWEISMATERIAL der letzten 24 Stunden. Urteile AUSSCHLIESSLICH auf Basis dieses Materials — kein Lob und keine Behauptung ohne konkreten Beleg darin; fehlt dir zu einem Punkt Material, sage das offen. Antworte auf DEUTSCH, kompakt, in exakt dieser Struktur:
 VERDIKT: <ein Satz Gesamturteil über die autonome Arbeit der Nacht/des Tages>
 RISIKEN: <0-3 Punkte, je mit Beleg aus dem Material; "keine erkennbar" wenn leer>
 TOP-3 FUER DEN COMMANDER: <maximal 3 priorisierte, konkrete Empfehlungen — weniger ist ok, erfinde keine>'
 # Ein-Schuss-Richter: $1=Modell-ID  $2=curl-Timeout  $3=max_tokens
 judge() {
  local req
  req="$(jq -n --arg m "$1" --arg sys "$RASTER" --arg usr "$EVID" --argjson mt "$3" \
    '{model:$m, messages:[{role:"system",content:$sys},{role:"user",content:$usr}],
      max_tokens:$mt, temperature:0.2}')"
  curl -s -m "$2" "$ENDPOINT" -H 'Content-Type: application/json' --data-binary "$req" \
    | python3 -c '
 import json, sys
 try:
    d = json.load(sys.stdin)
    msg = d["choices"][0]["message"]
    out = (msg.get("content") or msg.get("reasoning_content") or "").strip()
    print(out)
 except Exception:
    pass'
 }
 RICHTER="$CHEF"
 VERDIKT="$(judge "$CHEF" 420 2600)"
 if [ -z "${VERDIKT// /}" ]; then
  RICHTER="$VERTRETUNG (Vertretung — $CHEF hat nicht geladen)"
  VERDIKT="$(judge "$VERTRETUNG" 240 1200)"
 fi
 echo "$EVID"
 echo
 if [ -z "${VERDIKT// /}" ]; then
  echo "## CHEF-VERDIKT: AUSGEFALLEN"
  echo "Beide Richter ($CHEF, $VERTRETUNG) haben nicht geantwortet — das dem Commander ehrlich melden."
 else
  echo "## CHEF-VERDIKT (Richter: $RICHTER)"
  echo "$VERDIKT"
 fi
 # Morgenlage für die Zentrale: das Verdikt STILL in den Briefkasten spiegeln (priority=silent —
 # Lucy soll die Wand Text nicht vorlesen; die Telegram-Botschaft macht der Cron-Agent selbst).
 # Cockpit („Morgenlage"-Karte) und Chronik lesen es dort mit source=chef-gutachter heraus.
 if [ -n "${VERDIKT// /}" ]; then
  curl -sf -m 5 -X POST "${MC_ANNOUNCE_URL:-http://127.0.0.1:9001/api/voice/announce}" \
    -H 'Content-Type: application/json' \
    --data "$(python3 - "$RICHTER" "$VERDIKT" <<'PY'
 import json, sys
 print(json.dumps({"text": sys.argv[2], "subject": f"Morgenlage (Richter: {sys.argv[1]})",
                  "source": "chef-gutachter", "priority": "silent"}))
 PY
 )" >/dev/null 2>&1 || true
 fi
@@ -1,15 +0,0 @@
 # Auftrag: Nacht-Gutachten überbringen (Chef-Gutachter-Cron)
 Du bist Lucy. Unten stehen (1) BEWEISMATERIAL der letzten 24 Stunden und (2) das
 CHEF-VERDIKT eines großen Gutachter-Modells darüber. Deine Aufgabe ist NUR das Überbringen
 an den Commander per Telegram — kurz, in deiner Stimme, ohne Werkzeuge.
 Regeln:
 1. EIN einleitender Satz von dir (z. B. wie die Nacht lief), dann das Verdikt.
 2. Gib VERDIKT, RISIKEN und TOP-3 des Chef-Gutachters TREU wieder — nicht weichspülen,
   nicht kürzen bei Risiken, NICHTS dazuerfinden. Du bist die Botin, nicht die Richterin.
 3. Nenne am Ende in Klammern den Richter (steht über dem Verdikt: gpt-oss-120b oder
   die GLM-Vertretung).
 4. Steht dort „CHEF-VERDIKT: AUSGEFALLEN", melde genau das ehrlich — kein Ersatz-Urteil
   von dir.
 5. Telegram-tauglich: kompakt, keine Markdown-Tabellen, echte Umlaute.
@@ -0,0 +1,77 @@
 #!/usr/bin/env bash
 # coder-vollkontext.sh — gibt dem Coder den ganzen Kontext (23.08.2026).
 #
 # WARUM: llama-swap startet den Coder mit `-c 131072 --parallel 2`. Das sind
 # zwei Slots à 65.536 — und nur diese 65.536 stehen einer Sitzung zur Verfuegung.
 # Der Coder hat aber genau EINEN Verbraucher: OpenChamber. Lucy benutzt `hermes`,
 # der explore-Subagent auch, `review` benutzt `heavy`. Die zweite Bahn liegt brach.
 #
 # Mit `--parallel 1` bekommt eine Sitzung die vollen 131.072 — doppelt so viel
 # Platz, halb so viel Komprimieren.
 #
 # ‼️ NICHT waehrend eines laufenden Auftrags ausfuehren: llama-swap laeuft mit
 #    --watch-config und laedt beim Speichern SOFORT neu. Das schneidet eine
 #    laufende Sitzung mitten im Satz ab.
 #
 # Aufruf:   bash deploy/coder-vollkontext.sh          (Trockenlauf, zeigt den Diff)
 #           bash deploy/coder-vollkontext.sh --ja     (wendet an)
 set -uo pipefail
 CONF="${LLAMA_SWAP_CONF:-/etc/llama-swap/config.yaml}"
 BLOCK="${CODER_BLOCK:-  Qwen3.8-27B:}"
 if [ ! -r "$CONF" ]; then echo "ABBRUCH: $CONF nicht lesbar"; exit 1; fi
 TMP="$(mktemp)"
 cp "$CONF" "$TMP"
 python3 - "$TMP" "$BLOCK" <<'PY'
 import io, re, sys
 pfad, block = sys.argv[1], sys.argv[2]
 z = io.open(pfad, encoding="utf-8").read().split("\n")
 try:
    start = next(i for i, l in enumerate(z) if l.startswith(block))
 except StopIteration:
    print("ABBRUCH: Block '%s' nicht gefunden" % block); sys.exit(1)
 ende = next((i for i in range(start + 1, len(z)) if re.match(r"^  [A-Za-z]", z[i])), len(z))
 # Streng auf den Coder-Block begrenzt — `fast`/`hermes` MUESSEN ihre zwei Slots
 # behalten, dort greifen Lucy und der Explorer wirklich gleichzeitig zu.
 n_par = n_ctx = 0
 for i in range(start, ende):
    if "--parallel 2" in z[i]:
        z[i] = z[i].replace("--parallel 2", "--parallel 1"); n_par += 1
    if z[i].strip() == "context: 65536":
        z[i] = z[i].replace("65536", "131072"); n_ctx += 1
 if n_par != 1 or n_ctx != 1:
    print(f"ABBRUCH: unerwartet (parallel {n_par}x, context {n_ctx}x) — Konfiguration hat sich geaendert")
    sys.exit(1)
 io.open(pfad, "w", encoding="utf-8").write("\n".join(z))
 PY
 if [ $? -ne 0 ]; then rm -f "$TMP"; exit 1; fi
 echo "=== Aenderung ==="
 diff "$CONF" "$TMP"
 echo
 if [ "${1:-}" != "--ja" ]; then
  echo "TROCKENLAUF — nichts geaendert.  Anwenden mit:  bash $0 --ja"
  rm -f "$TMP"; exit 0
 fi
 SICHER="${CONF}.bak-$(date +%Y%m%d-%H%M%S)"
 sudo -n cp "$CONF" "$SICHER" && echo "Sicherung: $SICHER"
 sudo -n cp "$TMP" "$CONF"    && echo "angewendet — llama-swap laedt durch --watch-config selbst neu"
 rm -f "$TMP"
 echo
 echo "Warte auf den Neustart des Coders..."
 sleep 8
 curl -s -m 15 "http://127.0.0.1:8080/v1/models" >/dev/null 2>&1 \
  && echo "llama-swap antwortet wieder" \
  || echo "ACHTUNG: llama-swap antwortet nicht — Sicherung liegt unter $SICHER"
 echo
 echo "Danach in ~/.config/opencode/opencode.json auf dem PC nachziehen:"
 echo "  coder: limit.context 65536 -> 131072"
@@ -1,11 +0,0 @@
 #!/usr/bin/env bash
 # curator-archive-watchdog.sh
 # Archiviert Skills nach 14 Tagen Inaktivität (nächster Durchlauf um 3:00 Uhr)
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PYTHON_SCRIPT="$SCRIPT_DIR/curator_archive_logic.py"
 # Python-Skript ausführen
 python3 "$PYTHON_SCRIPT"
@@ -1,62 +0,0 @@
 #!/bin/bash
 # curator-idle-watchdog.sh
 # Prüft den Curator-Idle-Status und triggert Reaktivierung nach 14 Tagen
 set -euo pipefail
 LOG_DIR="/home/hitonabi/.hermes/logs/curator"
 LOG_FILE="$LOG_DIR/idle-watchdog-$(date +%Y%m%d).log"
 THRESHOLD_DAYS=14
 mkdir -p "$LOG_DIR"
 log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
 }
 # Curator-Status auslesen
 STATUS_OUTPUT=$(hermes curator status 2>&1) || {
    log "FEHLER: hermes curator status fehlgeschlagen"
    exit 1
 }
 # Prüfen, ob Curator ENABLED ist
 if ! echo "$STATUS_OUTPUT" | grep -q "^curator: ENABLED$"; then
    log "INFO: Curator ist nicht ENABLED → überspringe Prüfung"
    exit 0
 fi
 # Letzten Lauf extrahieren (Format: "last run:       17d ago")
 LAST_RUN_LINE=$(echo "$STATUS_OUTPUT" | grep "^  last run:" | head -1)
 if [[ -z "$LAST_RUN_LINE" ]]; then
    log "FEHLER: Konnte 'last run' nicht aus Status extrahieren"
    exit 1
 fi
 LAST_RUN_TEXT=$(echo "$LAST_RUN_LINE" | sed 's/^  last run: *//')
 log "Letzter Curator-Lauf: $LAST_RUN_TEXT"
 # Prüfen, ob "d ago" vorhanden ist
 if [[ "$LAST_RUN_TEXT" =~ ([0-9]+)d\ ago ]]; then
    DAYS_SINCE_LAST_RUN="${BASH_REMATCH[1]}"
 else
    log "INFO: Kein 'd ago' gefunden (möglicherweise <1d oder nie gelaufen) → überspringe"
    exit 0
 fi
 log "Tage seit letztem Lauf: $DAYS_SINCE_LAST_RUN"
 # Threshold prüfen
 if (( DAYS_SINCE_LAST_RUN < THRESHOLD_DAYS )); then
    log "INFO: Curator ist innerhalb des erlaubten Intervalls ($DAYS_SINCE_LAST_RUN < $THRESHOLD_DAYS Tage) → kein Trigger nötig"
    exit 0
 fi
 # Reaktivierung triggern
 log "WARNUNG: Curator ist für $DAYS_SINCE_LAST_RUN Tage idle (>= $THRESHOLD_DAYS) → triggere 'hermes curator run'"
 if hermes curator run 2>&1 | tee -a "$LOG_FILE"; then
    log "ERFOLG: Curator-Reaktivierung gestartet"
 else
    log "FEHLER: Curator-Reaktivierung fehlgeschlagen"
    exit 1
 fi
@@ -1,90 +0,0 @@
 #!/bin/bash
 # curator-monitor.sh
 # Prüft den Curator-Idle-Status mit 7-Tage-Schwellenwert.
 # GIBT AUS: PASS oder FAIL mit Detaillierung.
 # EXIT 0 = OK (Curator aktiv innerhalb von 7 Tagen)
 # EXIT 1 = FAIL (Curator >7 Tage idle) –Monitoring-Skript erkannt Problem
 #
 # --dry-run DAYS  Simuliert eine >DAYS-alte Curator-Auszeit (für Tests)
 set -euo pipefail
 LOG_DIR="/home/hitonabi/.hermes/logs/curator"
 LOG_FILE="$LOG_DIR/monitor-$(date +%Y%m%d).log"
 THRESHOLD_DAYS=7
 mkdir -p "$LOG_DIR"
 log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
 }
 # --- Argumente parsen ---
 DRY_RUN=false
 DRY_RUN_DAYS=""
 for arg in "$@"; do
    case "$arg" in
        --dry-run)
            DRY_RUN=true
            if [[ -n "${2:-}" && "$2" =~ ^[0-9]+$ ]]; then
                DRY_RUN_DAYS="$2"
                shift
            else
                DRY_RUN_DAYS=8  # Default-Testwert
            fi
            ;;
    esac
 done
 # --- LIVE-PRÜFUNG oder DRY-RUN ---
 if [[ "$DRY_RUN" == "true" ]]; then
    log "DRY-RUN: Simuliere Curator-Auszeit von $DRY_RUN_DAYS Tagen"
    DAYS_SINCE_LAST_RUN="$DRY_RUN_DAYS"
 else
    # Live-Status abfragen
    STATUS_OUTPUT=$(hermes curator status 2>&1) || {
        log "FEHLER: hermes curator status fehlgeschlagen"
        echo "FAIL: hermes curator status fehlgeschlagen"
        exit 1
    }
    # Prüfen, ob Curator ENABLED ist
    if ! echo "$STATUS_OUTPUT" | grep -q "^curator: ENABLED$"; then
        log "INFO: Curator ist nicht ENABLED → überspringe Prüfung"
        echo "PASS: Curator ist nicht ENABLED (keine Aktivität nötig)"
        exit 0
    fi
    # Letzten Lauf extrahieren
    LAST_RUN_LINE=$(echo "$STATUS_OUTPUT" | grep "^  last run:" | head -1)
    if [[ -z "$LAST_RUN_LINE" ]]; then
        log "FEHLER: Konnte 'last run' nicht aus Status extrahieren"
        echo "FAIL: Konnte 'last run' nicht extrahieren"
        exit 1
    fi
    LAST_RUN_TEXT=$(echo "$LAST_RUN_LINE" | sed 's/^  last run: *//')
    log "Letzter Curator-Lauf: $LAST_RUN_TEXT"
    # Tage extrahieren
    if [[ "$LAST_RUN_TEXT" =~ ([0-9]+)d\ ago ]]; then
        DAYS_SINCE_LAST_RUN="${BASH_REMATCH[1]}"
    else
        log "INFO: Kein 'd ago' gefunden (möglicherweise <1d oder nie gelaufen)"
        echo "PASS: Curator ist aktuell aktiv oder <1 Tag idle"
        exit 0
    fi
 fi
 log "Tage seit letztem Lauf: $DAYS_SINCE_LAST_RUN"
 # --- MONITORING-LOGIK (keine Reaktivierung!) ---
 if (( DAYS_SINCE_LAST_RUN < THRESHOLD_DAYS )); then
    log "INFO: Curator ist innerhalb des erlaubten Intervalls ($DAYS_SINCE_LAST_RUN < $THRESHOLD_DAYS Tage)"
    echo "PASS: Curator ist aktiv ($DAYS_SINCE_LAST_RUN Tage idle)"
    exit 0
 else
    log "WARNUNG: Curator ist für $DAYS_SINCE_LAST_RUN Tage idle (>= $THRESHOLD_DAYS)"
    echo "FAIL: Curator-Cron ist für $DAYS_SINCE_LAST_RUN Tage stumm (>= $THRESHOLD_DAYS-Tage-Schwellenwert)"
    exit 1
 fi
@@ -1,198 +0,0 @@
 #!/usr/bin/env python3
 """
 Curator Auto-Archivierung: Archiviert Skills nach 14 Tagen Inaktivität.
 Liest `.curator_state` und `.usage.json` aus ~/.hermes/skills/, prüft
 auf Inaktivität (>14 Tage last_used_at), schließt aus (pinned, system)
 und verschiebt in .archive/<Kategorie>/.
 """
 import json
 import shutil
 from datetime import datetime, timezone
 from pathlib import Path
 HERMES_SKILLS_DIR = Path.home() / ".hermes" / "skills"
 CURATOR_STATE_FILE = HERMES_SKILLS_DIR / ".curator_state"
 USAGE_JSON_FILE = HERMES_SKILLS_DIR / ".usage.json"
 ARCHIVE_DIR = HERMES_SKILLS_DIR / ".archive"
 LOG_DIR = Path.home() / ".hermes" / "logs" / "curator"
 def load_json(path: Path) -> dict:
    """JSON-Datei laden."""
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)
 def save_json(path: Path, data: dict) -> None:
    """JSON-Datei speichern (mit Pretty-Print)."""
    with open(path, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)
        f.write("\n")
 def is_stale(skill_usage: dict, threshold_days: int = 14) -> bool:
    """Prüft, ob ein Skill älter als threshold_days ist."""
    last_used = skill_usage.get("last_used_at")
    if not last_used:
        return False
    # ISO-Format mit optionaler Zeitzone
    last_used_str = last_used.replace("Z", "+00:00")
    try:
        last_used_dt = datetime.fromisoformat(last_used_str)
    except ValueError:
        return False
    now = datetime.now(timezone.utc)
    delta = now - last_used_dt
    return delta.days >= threshold_days
 def is_excluded(skill_name: str, excluded: list) -> bool:
    """Prüft, ob ein Skill ausgeschlossen ist."""
    return skill_name in excluded
 def is_pinned(skill_usage: dict) -> bool:
    """Prüft, ob ein Skill angepinnt ist."""
    return skill_usage.get("pinned", False) is True
 def get_skill_category(skill_name: str) -> str:
    """
    Ermittelt die Kategorie eines Skills basierend auf dem Verzeichnisnamen.
    Gibt 'unknown' zurück, wenn keine Kategorie gefunden wird.
    """
    # Versuche, die Kategorie aus dem Verzeichnis zu ermitteln
    # z.B. 'betrieb-playbook' → 'betrieb-playbook' (direkt unter skills/)
    # 'apple' (in .archive/apple/) → 'apple'
    # Falls der Skill direkt in skills/ liegt ohne Unterverzeichnis:
    return "unknown"
 def ensure_archive_category(category: str) -> Path:
    """Erstellt das Archiv-Verzeichnis für eine Kategorie, falls nötig."""
    category_path = ARCHIVE_DIR / category
    category_path.mkdir(parents=True, exist_ok=True)
    return category_path
 def move_skill_to_archive(skill_name: str, category: str) -> Path:
    """
    Verschiebt ein Skill-Verzeichnis in das Archiv.
    Gibt den neuen Pfad zurück.
    """
    source = HERMES_SKILLS_DIR / skill_name
    target_category = ensure_archive_category(category)
    target = target_category / skill_name
    if source.exists():
        shutil.move(str(source), str(target))
    return target
 def archive_skill(skill_name: str, usage_data: dict) -> dict:
    """
    Archiviert einen Skill:
    - Setzt state auf 'archived'
    - Setzt archived_at auf aktuelle Zeit
    - Verschiebt das Verzeichnis nach .archive/
    Gibt das aktualisierte Usage-Dict zurück.
    """
    usage_data[skill_name]["state"] = "archived"
    usage_data[skill_name]["archived_at"] = datetime.now(timezone.utc).isoformat()
    return usage_data
 def log_archive_action(skill_name: str, category: str, success: bool, message: str) -> None:
    """Protokolliert eine Archivierungsaktion."""
    LOG_DIR.mkdir(parents=True, exist_ok=True)
    log_file = LOG_DIR / f"archive-{datetime.now(timezone.utc).date().isoformat()}.log"
    timestamp = datetime.now(timezone.utc).isoformat()
    status = "SUCCESS" if success else "FAILED"
    log_line = f"[{timestamp}] {status} | {skill_name} ({category}) | {message}\n"
    with open(log_file, "a", encoding="utf-8") as f:
        f.write(log_line)
 def main() -> None:
    """Hauptfunktion: Archiviert stale Skills."""
    # 1. Config laden
    if not CURATOR_STATE_FILE.exists():
        print(f"Fehler: {CURATOR_STATE_FILE} nicht gefunden.")
        return
    curator_state = load_json(CURATOR_STATE_FILE)
    archivierung = curator_state.get("archivierung", {})
    if not archivierung.get("enabled", False):
        print("Archivierung ist nicht aktiviert.")
        return
    threshold_days = archivierung.get("threshold_days", 14)
    excluded_skills = archivierung.get("excluded_skills", [])
    # 2. Usage-Daten laden
    if not USAGE_JSON_FILE.exists():
        print(f"Fehler: {USAGE_JSON_FILE} nicht gefunden.")
        return
    usage_data = load_json(USAGE_JSON_FILE)
    # 3. Skills prüfen
    archived_count = 0
    skipped_count = 0
    for skill_name, skill_usage in usage_data.items():
        # Ausschlusskriterien prüfen
        if is_excluded(skill_name, excluded_skills):
            print(f"Übersprungen (Exkludiert): {skill_name}")
            skipped_count += 1
            continue
        if is_pinned(skill_usage):
            print(f"Übersprungen (Gepinnt): {skill_name}")
            skipped_count += 1
            continue
        # Inaktivität prüfen
        if not is_stale(skill_usage, threshold_days):
            print(f"Übersprungen (Aktiv): {skill_name}")
            skipped_count += 1
            continue
        # Archivierung durchführen
        category = get_skill_category(skill_name) or "unknown"
        print(f"Archiviere: {skill_name} → {category}")
        try:
            # Usage aktualisieren
            usage_data = archive_skill(skill_name, usage_data)
            # Verzeichnis verschieben
            move_skill_to_archive(skill_name, category)
            # Erfolg protokollieren
            log_archive_action(skill_name, category, True, "Skill archiviert")
            archived_count += 1
        except Exception as e:
            log_archive_action(skill_name, category, False, str(e))
            print(f"Fehler beim Archivieren von {skill_name}: {e}")
    # 4. Usage-Daten speichern
    save_json(USAGE_JSON_FILE, usage_data)
    # 5. Archivierungs-Zeitstempel aktualisieren
    curator_state["archivierung"]["last_archive_run_at"] = datetime.now(timezone.utc).isoformat()
    save_json(CURATOR_STATE_FILE, curator_state)
    print(f"\nArchivierung abgeschlossen: {archived_count} archiviert, {skipped_count} übersprungen.")
 if __name__ == "__main__":
    main()
@@ -1,298 +1,76 @@
-#!/usr/bin/env bash
+#!/bin/bash
-# Deploy AUF DER BOX als systemd-USER-Dienst — KEIN sudo, KEIN /opt, KEIN Passwort.
+set -e
 # Erstinstallation + Updates in einem. Läuft als User hitonabi.
 #
 # Erstinstallation (einmalig):
 #   git clone https://git.tobisniceshomelab.ddnsfree.com/Hitonabi/mission-control-v2 ~/mission-control-v2
 #   bash ~/mission-control-v2/deploy/deploy.sh
 set -euo pipefail
-SRC="${MC2_SRC:-$HOME/mission-control-v2}"
+# ‼️ Das ganze Skript liegt in EINER Funktion — das ist Absicht, kein Stil.
 # Bash liest ein Skript haeppchenweise WAEHREND es laeuft. `git pull` unten ersetzt
 # genau diese Datei mitten im Lauf; danach liest bash am selben Byte-Offset im NEUEN
 # Text weiter und fuehrt zerschnittene Zeilen aus. Live erlebt am 27.08.2026: der Pull
 # brachte eine neue Fassung dieses Schrittes mit, ausgefuehrt wurde trotzdem die alte.
 # Eine Funktion wird komplett geparst, bevor sie startet -> der Lauf bleibt in sich
 # stimmig, und Aenderungen greifen ab dem naechsten Aufruf statt mittendrin.
 main() {
-cd "$SRC"
+  echo "Starte MC2 Deployment..."
 git fetch -q origin && git reset -q --hard origin/main
-# ★ Selbst-Reset-Falle (15.07. beim P1-Deploy live gebissen): der reset oben ersetzt auch
+  # 1. Neuesten Code holen
-# DIESE Datei, und bash liest laufende Skripte häppchenweise von der Platte weiter — ab
+  git pull origin main
 # hier liefe ein Zeilen-Mix aus alter+neuer Version (beim P1-Deploy fielen so daemon-reload
 # und der mc2-gateway-Start unter den Tisch). Darum: nach dem Reset genau EINMAL die
 # frische Version neu ausführen; der zweite Durchlauf überspringt dank Env-Marke nichts.
 if [ "${MC2_DEPLOY_REEXEC:-0}" != "1" ]; then
  export MC2_DEPLOY_REEXEC=1
  exec bash "$SRC/deploy/deploy.sh"
 fi
 # venv + Abhängigkeiten
 if [ ! -d "$SRC/backend/.venv" ]; then
  python3 -m venv "$SRC/backend/.venv"
 fi
 "$SRC/backend/.venv/bin/python" -m pip install -q --upgrade pip
 "$SRC/backend/.venv/bin/python" -m pip install -q -r "$SRC/backend/requirements.txt"
-# Mem0-Sidecar (auto-lernendes Gedächtnis) — eigenes Python-3.12-venv (~/.mem0/venv),
+  # 2. Abhängigkeiten prüfen (falls sich was geändert hat)
-# weil mem0+chromadb unter dem 3.14-Backend-venv nicht laufen. mem0ai/chromadb sind dort
+  echo "Aktualisiere Python Abhängigkeiten..."
-# bereits installiert; hier nur den HTTP-Server nachziehen + Alt-DB einmalig migrieren.
+  backend/.venv/bin/pip install -r backend/requirements.txt
 if [ -x "$HOME/.mem0/venv/bin/python" ]; then
  # ~/.mem0/venv ist uv-managed (kein pip) → uv pip nutzen.
  UV="$(command -v uv || echo "$HOME/.local/bin/uv")"
  "$UV" pip install -q --python "$HOME/.mem0/venv/bin/python" -r "$SRC/mem0_service/requirements.txt"
  ( cd "$SRC/mem0_service" && "$HOME/.mem0/venv/bin/python" migrate.py ) || true
 else
  echo "WARN: ~/.mem0/venv fehlt — Mem0-Sidecar wird nicht gestartet (siehe Plan A1)."
 fi
-# Voice-Sidecar (lokales STT + gestuftes TTS für „Mit Hermes reden") — eigenes Python-3.12-venv
+  # 3. Llama-Swap Konfiguration prüfen und synchronisieren
-# (~/.voice/venv), weil torch/chatterbox/faster-whisper nicht ins 3.14-Backend-venv passen.
+  #
-# install.sh ist idempotent (venv + Deps + Piper-Stimmen). Best-effort: schlägt es fehl, läuft
+  # ‼️ ACHTUNG (27.08.2026): /etc/llama-swap/config.yaml ist die LEBENDE Wahrheit — MC2
-# der restliche Stack weiter (der Voice-Tab meldet den Sidecar dann als offline).
+  # schreibt sie selbst (backend/services/llamaswap.py::write_config), sobald jemand über
-bash "$SRC/voice_service/install.sh" || echo "WARN: Voice-Sidecar-Setup fehlgeschlagen — Voice-Tab bleibt offline."
+  # die Oberfläche ein Modell hinzufügt oder eine Rolle ändert. deploy/llama-swap.config.yaml
-
+  # ist nur ein Abzug und hinkt regelmäßig hinterher (erlebt: der Coder-Vollkontext aus 34a9862
-# Hermes-Memory-Provider-Plugin (auto-lernen/Recall via Mem0-Sidecar) nach ~/.hermes/plugins/
+  # stand tagelang nur live, nicht im Abzug — ein Deploy hätte ihn zurückgesetzt).
-# spiegeln. Context-only (kein Tool-Loop). Aktivierung in ~/.hermes/config.yaml:
+  # Bis hierher wurde die Live-Datei kommentarlos mit dem Abzug überschrieben — alles per
-#   memory.memory_enabled: true + memory.provider: mc2-memory  (einmalig, box-lokal).
+  # UI Hinzugefügte war nach jedem Deploy weg. Jetzt: erst sichern, dann kopieren, und die
-if [ -d "$HOME/.hermes" ]; then
+  # Abweichung sichtbar machen. MC_DEPLOY_SKIP_SWAP_CONFIG=1 überspringt den Schritt ganz.
-  mkdir -p "$HOME/.hermes/plugins/mc2-memory"
+  if ! cmp -s deploy/llama-swap.config.yaml /etc/llama-swap/config.yaml; then
-  cp "$SRC/hermes/plugins/mc2-memory/__init__.py" "$SRC/hermes/plugins/mc2-memory/plugin.yaml" \
+    if [ "${MC_DEPLOY_SKIP_SWAP_CONFIG:-0}" = "1" ]; then
-     "$HOME/.hermes/plugins/mc2-memory/"
+      echo "Llama-Swap Konfiguration weicht ab — uebersprungen (MC_DEPLOY_SKIP_SWAP_CONFIG=1)."
-fi
+    else
-
+      SWAP_BAK="/etc/llama-swap/config.yaml.bak-$(date +%Y%m%d-%H%M%S)"
-# systemd-USER-Units installieren/aktualisieren
+      echo "Llama-Swap Konfiguration hat sich geändert."
-mkdir -p "$HOME/.config/systemd/user"
+      echo "  Abweichung (live -> Repo-Abzug):"
-cp "$SRC/deploy/mission-control-2.service" "$HOME/.config/systemd/user/mission-control-2.service"
+      diff -u /etc/llama-swap/config.yaml deploy/llama-swap.config.yaml | head -40 || true
-# MC2-Diät (Hermes Desktop, 07/2026): das Hermes-Terminal-ttyd (:7681) und das standalone
+      echo "  Sichere die laufende Datei nach $SWAP_BAK"
-# hermes-webui (nesquena, Karteileiche seit dem Built-in-UI-Umbau) sind entfallen — die
+      # NOPASSWD für llama-swap Neustart ist vorausgesetzt (siehe AGENTS.md)
-# Agent-Oberfläche ist die Desktop-App bzw. /hermes-ui/. Einmalige, idempotente Stilllegung:
+      sudo cp /etc/llama-swap/config.yaml "$SWAP_BAK"
-systemctl --user disable --now hermes-terminal 2>/dev/null || true
+      sudo cp deploy/llama-swap.config.yaml /etc/llama-swap/config.yaml
-systemctl --user disable --now hermes-webui 2>/dev/null || true
+      sudo systemctl restart llama-swap
-rm -f "$HOME/.config/systemd/user/hermes-terminal.service" "$HOME/.config/systemd/user/hermes-webui.service"
+      echo "  Rueckweg bei Verlust:  sudo cp $SWAP_BAK /etc/llama-swap/config.yaml"
-# Box-Konsole (ttyd -> Login-Shell auf :7682), in MC2 als Konsole-Seite eingebettet.
+    fi
 cp "$SRC/deploy/box-console.service" "$HOME/.config/systemd/user/box-console.service"
 # MC2-Gateway (UMBAU v3 P1): der /v1-Datenpfad als eigener Prozess (Loopback :9010,
 # Restart=always) — Lucys Hirn + Nacht-Autonomie überleben damit jeden MC2-Neustart.
 cp "$SRC/deploy/mc2-gateway.service" "$HOME/.config/systemd/user/mc2-gateway.service"
 # MC2-Steward (UMBAU v3 P2): Wächter-Loops (Re-Warm/Sentry/Dedupe) als eigener Dienst —
 # überleben MC2-Neustarts und melden erstmals auch ein totes Steuerpult (Telegram).
 cp "$SRC/deploy/mc2-steward.service" "$HOME/.config/systemd/user/mc2-steward.service"
 # Mem0-Sidecar-Unit (nur wenn das venv existiert).
 [ -x "$HOME/.mem0/venv/bin/python" ] && cp "$SRC/deploy/mem0-service.service" "$HOME/.config/systemd/user/mem0-service.service"
 # Voice-Sidecar-Unit (nur wenn das venv existiert).
 [ -x "$HOME/.voice/venv/bin/python" ] && cp "$SRC/deploy/voice-service.service" "$HOME/.config/systemd/user/voice-service.service"
 # Tägliches Zustands-Backup (mem0 + Configs/Secrets) — Timer + oneshot-Service. Siehe docs/BACKUP.md.
 cp "$SRC/deploy/mc2-backup.service" "$HOME/.config/systemd/user/mc2-backup.service"
 cp "$SRC/deploy/mc2-backup.timer" "$HOME/.config/systemd/user/mc2-backup.timer"
 # Wöchentliches Auto-Update (Router/Engine/Hermes, Rollback+Pin+Telegram) — Autonomie E2.
 cp "$SRC/deploy/mc2-autoupdate.service" "$HOME/.config/systemd/user/mc2-autoupdate.service"
 cp "$SRC/deploy/mc2-autoupdate.timer" "$HOME/.config/systemd/user/mc2-autoupdate.timer"
 # Tägliche Selbst-Smoke-Tests (Gateway/Tools/Voice aktiv, Alarm bei Rot) — Autonomie 0d.
 cp "$SRC/deploy/mc2-selfsmoke.service" "$HOME/.config/systemd/user/mc2-selfsmoke.service"
 cp "$SRC/deploy/mc2-selfsmoke.timer" "$HOME/.config/systemd/user/mc2-selfsmoke.timer"
 # Bagatell-Annahme (Ideen-Queue, 10.07.2026): reine Doku-Vorschläge nachts ohne Klick einspielen.
 cp "$SRC/deploy/mc2-bagatell.service" "$HOME/.config/systemd/user/mc2-bagatell.service"
 cp "$SRC/deploy/mc2-bagatell.timer" "$HOME/.config/systemd/user/mc2-bagatell.timer"
 # Morgen-Digest (Nächtliche Telegram-Zusammenfassung, 26.07.2026): fasst alle Meldungen zwischen 0 und 7 Uhr zusammen.
 cp "$SRC/deploy/mc2-morgen-digest.service" "$HOME/.config/systemd/user/mc2-morgen-digest.service"
 cp "$SRC/deploy/mc2-morgen-digest.timer" "$HOME/.config/systemd/user/mc2-morgen-digest.timer"
 # Evolution-Radar-Feed (Autonomie E4): Hermes-cron speist ihn als Prompt ein.
 # Cron-Job selbst wird EINMALIG registriert (hermes cron create, siehe docs/RUNBOOK.md).
 mkdir -p "$HOME/.hermes/scripts"
 cp "$SRC/deploy/radar-feed.sh" "$HOME/.hermes/scripts/radar-feed.sh"
 # Selbstkritik-Cron (Faden 11b): Zwilling des Radars, Blick nach INNEN (Latenzen/Journal/Skills).
 cp "$SRC/deploy/selbstkritik-feed.sh" "$HOME/.hermes/scripts/selbstkritik-feed.sh"
 # Monats-Review-Wrapper (Cron 1. d. M. 09:00): Radar + Selbstkritik in EINEM Lauf.
 cp "$SRC/deploy/radar-selbstkritik-wrapper.sh" "$HOME/.hermes/scripts/radar-selbstkritik-wrapper.sh"
 # Traum-Cron (Dreaming, Phase 2): Blick auf das GELERNTE → Wissens-Vault. Bootstrappt ~/wissens-vault.
 cp "$SRC/deploy/dreaming-feed.sh" "$HOME/.hermes/scripts/dreaming-feed.sh"
 # Fremdblick-Helfer: Ein-Schuss-Zweitmeinung von einem anderen Modell (umgeht 64K-Delegations-Floor).
 cp "$SRC/deploy/fremdblick.sh" "$HOME/.hermes/scripts/fremdblick.sh"
 # Worker-Helfer (Orchestrator): Ein-Schuss-Arbeitsauftrag an ein Worker-Modell (Gegenstück zu fremdblick).
 cp "$SRC/deploy/worker.sh" "$HOME/.hermes/scripts/worker.sh"
 # Chef-Gutachter-Cron (Orchestrator-Finale): gpt-oss urteilt nachts über die autonome Arbeit.
 cp "$SRC/deploy/chef-gutachter-feed.sh" "$HOME/.hermes/scripts/chef-gutachter-feed.sh"
 # Wrapper für nächtliche Crons, um Telegram-Spam in den Morgen-Digest zu leiten.
 cp "$SRC/deploy/night-cron-wrapper.sh" "$HOME/.hermes/scripts/night-cron-wrapper.sh"
 # Release-Radar-Cron (10.07.2026): hält neue hermes-agent-Releases wöchentlich gegen die
 # Eigenbau-Landkarte im Wissens-Vault ("mehr Hermes nativ, weniger Eigenkreationen").
 cp "$SRC/deploy/hermes-release-radar-feed.sh" "$HOME/.hermes/scripts/hermes-release-radar-feed.sh"
 # Idle-Radar (S4 "Zuendung", 12.07.2026): die Box gibt sich nachts selbst Arbeit —
 # Journal-Fehlermuster + Traum-Funde -> belegte rohe Ideen (triage) im nativen Kanban.
 cp "$SRC/deploy/idle-radar-feed.sh" "$HOME/.hermes/scripts/idle-radar-feed.sh"
 # "Lucy kennt sich" (12.07.2026): Selbst-Inventur generiert den Steckbrief + bemerkt
 # eigene Aenderungen; der Karten-Gutachter stempelt jede Karte mit einer Empfehlung.
 cp "$SRC/deploy/selbst-inventur.sh" "$HOME/.hermes/scripts/selbst-inventur.sh"
 cp "$SRC/deploy/karten-gutachter.sh" "$HOME/.hermes/scripts/karten-gutachter.sh"
 # Trend-Radar (17.07.2026, Sa 05:15): Live-Puls aller Rollen + Engine-A/B + Watch-Liste +
 # HF-Kandidaten-Suche → max. 1 Prüfstand-Kandidat/Woche. Prüfstand (So 01:00, --no-agent):
 # volles Programm (Coding/Agent/Recherche/Deutsch/Vision) gegen die Amtsinhaber-Baseline;
 # Harness + Suiten liegen im Repo ($SRC/deploy/pruefstand/), nur der Runner wird kopiert.
 cp "$SRC/deploy/trend-radar-feed.sh" "$HOME/.hermes/scripts/trend-radar-feed.sh"
 cp "$SRC/deploy/pruefstand/pruefstand.sh" "$HOME/.hermes/scripts/pruefstand.sh"
 # Restore-Probe + Venv-Audit (17.07.2026, monatliche --no-agent-Crons): echte
 # Wiederherstellungs-Drills (PBS-Canary + Tarball) und CVE-/Outdated-Audit der
 # Python-Nebendienst-venvs (mem0, voice) — melden nur, ändern nichts.
 cp "$SRC/deploy/restore-probe.sh" "$HOME/.hermes/scripts/restore-probe.sh"
 cp "$SRC/deploy/venv-audit.sh" "$HOME/.hermes/scripts/venv-audit.sh"
 # mem0-Konsolidierung (monatlich am 3., 19.07.2026): legt aehnliche Fakten zusammen,
 # loest Widersprueche (neuester gewinnt) — mem0 v2 ist ADD-only und tut das nie selbst.
 cp "$SRC/deploy/mem0-konsolidierung.py" "$HOME/.hermes/scripts/mem0-konsolidierung.py"
 cp "$SRC/deploy/mem0-konsolidierung.sh" "$HOME/.hermes/scripts/mem0-konsolidierung.sh"
 # Gitea-Repo-Anlage (17.07.2026): schließt Lucys „Projekte selbst starten"-Lücke —
 # legt PRIVATE Projekt-Repos an (Token aus ~/.git-credentials, braucht write:user-Scope).
 cp "$SRC/deploy/gitea-repo-create.sh" "$HOME/.hermes/scripts/gitea-repo-create.sh"
 # Werkstatt-Kanban-Profil (Ideen-Queue, 10.07.2026): Leitplanken des Worker-Profils nachziehen
 # (Profil selbst wurde einmalig per `hermes profile create werkstatt --clone` angelegt).
 [ -d "$HOME/.hermes/profiles/werkstatt" ] && cp "$SRC/deploy/werkstatt-SOUL.md" "$HOME/.hermes/profiles/werkstatt/SOUL.md"
 # betrieb-Profil (Ideen-Queue Faden 7, 13.07.2026): Ops-/Mess-/Bench-Worker mit Box-Wissen
 # statt Lucy-default. Profil selbst wird einmalig per `hermes profile create betrieb
 # --clone-from werkstatt` angelegt (model coder→hermes, Description fürs Specifier-Routing).
 [ -d "$HOME/.hermes/profiles/betrieb" ] && cp "$SRC/deploy/betrieb-SOUL.md" "$HOME/.hermes/profiles/betrieb/SOUL.md"
 # IDE-Vorbereiter (20.07.2026): haertet ein Konzept (konzept-fliessband), legt das Repo an und
 # fuellt es NUR mit Doku — der Commander baut dann in Zed. Sonderfall „IDEE PRUEFEN": nur Konzept,
 # kein Geruest, kein Bau-Druck. Profil einmalig per `hermes profile create projektstart
 # --clone-from werkstatt` angelegt (model coder→hermes, damit heavy warm bleibt).
 [ -d "$HOME/.hermes/profiles/projektstart" ] && cp "$SRC/deploy/projektstart-SOUL.md" "$HOME/.hermes/profiles/projektstart/SOUL.md"
 chmod +x "$HOME/.hermes/scripts/fremdblick.sh" "$HOME/.hermes/scripts/dreaming-feed.sh" "$HOME/.hermes/scripts/worker.sh" "$HOME/.hermes/scripts/chef-gutachter-feed.sh" "$HOME/.hermes/scripts/hermes-release-radar-feed.sh" "$HOME/.hermes/scripts/radar-selbstkritik-wrapper.sh" "$HOME/.hermes/scripts/idle-radar-feed.sh" "$HOME/.hermes/scripts/selbst-inventur.sh" "$HOME/.hermes/scripts/karten-gutachter.sh" "$HOME/.hermes/scripts/trend-radar-feed.sh" "$HOME/.hermes/scripts/pruefstand.sh" "$HOME/.hermes/scripts/restore-probe.sh" "$HOME/.hermes/scripts/venv-audit.sh" "$HOME/.hermes/scripts/gitea-repo-create.sh" "$HOME/.hermes/scripts/mem0-konsolidierung.sh" "$HOME/.hermes/scripts/mem0-konsolidierung.py"
 # Werkstatt-Skill (Autonomie E6): Selbstwartungs-Kreislauf für Hermes.
 mkdir -p "$HOME/.hermes/skills/wartung"
 cp "$SRC/deploy/skills/wartung/SKILL.md" "$HOME/.hermes/skills/wartung/SKILL.md"
 # Orchestrator-Skill (Autonomie): Werkstatt verallgemeinert — zerlegen → an Worker delegieren → gaten.
 mkdir -p "$HOME/.hermes/skills/orchestrator"
 cp "$SRC/deploy/skills/orchestrator/SKILL.md" "$HOME/.hermes/skills/orchestrator/SKILL.md"
 # PC-Pfad-Cache-Skill (Traum-Entwurf 09.07.2026, aufbereitet): Cache lesen → bei Miss pc_shell-Tool → merken.
 mkdir -p "$HOME/.hermes/skills/pc-pfad-cache"
 cp "$SRC/deploy/skills/pc-pfad-cache/SKILL.md" "$HOME/.hermes/skills/pc-pfad-cache/SKILL.md"
 cp "$SRC/deploy/skills/pc-pfad-cache/pc_path_lookup.sh" "$HOME/.hermes/scripts/pc_path_lookup.sh"
 chmod +x "$HOME/.hermes/scripts/pc_path_lookup.sh"
 # Projekt-Start-Skill (Abloesung 13.07.2026): "erst denken, dann bauen" fuer neue Coding-Projekte
 # in Hermes Desktop — Plan-Riegel, Savepoints, AGENTS.md/SAVEPOINT.md-Ritual, Kontext-Waechter.
 # Portiert vom PC-Skill (F:\Coding Stuff\projekt-start), Zed-Verweise durch Hermes Desktop ersetzt.
 mkdir -p "$HOME/.hermes/skills/projekt-start"
 cp "$SRC/deploy/skills/projekt-start/SKILL.md" "$HOME/.hermes/skills/projekt-start/SKILL.md"
 # Konzept-Fliessband-Skill (14.07.2026): rohe Idee → wasserdichtes KONZEPT (kein Code), BEVOR
 # gebaut wird. heavy (gpt-oss-120b) waehlt den Rollen-Cast, mehrere Denk-Runden schaerfen ein
 # lebendes Dokument, ein Advocatus Diaboli (fremdblick/GLM) haertet bis wasserdicht (max 3 Runden).
 # Behebt das delegate_task=coder-Loch: Konzept-Arbeit lief bisher stumm auf dem Code-Modell.
 # Output = Konzept-Dokument (~/konzepte/<slug>-konzept.md) → Vorlage fuer projekt-start in Hermes Desktop.
 mkdir -p "$HOME/.hermes/skills/konzept-fliessband"
 cp "$SRC/deploy/skills/konzept-fliessband/SKILL.md" "$HOME/.hermes/skills/konzept-fliessband/SKILL.md"
 # ...auch in Profile spiegeln, die den Skill schon haben (projektstart = IDE-Vorbereiter
 # nutzt ihn als Motor; Profile teilen KEINE Skills, Lehre 18.07.). Nur vorhandene updaten.
 for _psd in "$HOME"/.hermes/profiles/*/skills/konzept-fliessband; do
  [ -d "$_psd" ] && cp "$SRC/deploy/skills/konzept-fliessband/SKILL.md" "$_psd/SKILL.md"
 done
 # Betrieb-Playbook (Phase 2 Drei-Welten-Plan, 19.07.2026): Diagnose-Checklisten der
 # Betrieb-Bahn (SSH/Deploy) — Gegenstueck zur No-Progress-Bremse. Auch in die Profile,
 # damit betrieb-Worker es laden koennen (Profile teilen KEINE Skills, Lehre 18.07.).
 for _sd in "$HOME/.hermes/skills" "$HOME"/.hermes/profiles/*/skills; do
  [ -d "$(dirname "$_sd")" ] || continue
  mkdir -p "$_sd/betrieb-playbook"
  cp "$SRC/deploy/skills/betrieb-playbook/SKILL.md" "$_sd/betrieb-playbook/SKILL.md"
 done
 # Agent-Hooks (Faden 5, 13.07.2026): Skripte frisch halten (reproduzierbar, ueberlebt
 # Box-Neuaufbau). box-steckbrief-inject.sh = Box-Selbstwissen in JEDEN Kanban-Worker
 # (pre_llm_call, scoped auf task_id → Lucy-Chat unberuehrt); pre-verify-gates.sh = das
 # bestehende py_compile/dist-Gate. Die REGISTRIERUNG in ~/.hermes/config.yaml (hooks:)
 # ist EINMALIG von Hand (config.yaml ist Zwei-Schreiber-sensibel, kein Deploy-Schreiber).
 mkdir -p "$HOME/.hermes/agent-hooks"
 # Nur kopieren, wenn der Inhalt sich WIRKLICH geaendert hat — ein blindes cp aendert die
 # mtime auch bei identischem Inhalt und loest sonst bei JEDEM Deploy die harmlose
 # "script modified since approval"-Warnung von `hermes hooks doctor` aus.
 for _h in box-steckbrief-inject.sh pre-verify-gates.sh tabu-pfade-guard.py no-progress-bremse.py; do
  _src="$SRC/deploy/agent-hooks/$_h"; _dst="$HOME/.hermes/agent-hooks/$_h"
  cmp -s "$_src" "$_dst" 2>/dev/null || { cp "$_src" "$_dst"; chmod +x "$_dst"; }
 done
 # Worker-Profile lesen IHRE config.yaml, nicht die Top-Level — die worker-Hooks
 # (box-steckbrief = Box-Wissen, tabu-pfade-guard = Schreibschutz) muessen dort registriert
 # sein, sonst feuern sie fuer Worker nie (Bug-Fund 13.07.). Idempotent + Backup je Profil.
 for _prof in "$HOME"/.hermes/profiles/*/config.yaml; do
  [ -f "$_prof" ] && python3 "$SRC/deploy/ensure-profile-hooks.py" "$_prof" || true
 done
 # Hermes-Runtime-Patch-Traeger (20.07.2026): MC2-eigene Fixes im Hermes-Quellcode
 # (needs_input-wartet-auf-Commander, Decompose-erst-bei-Startreife, Orphan-Guard,
 # Projekt-Kontext-Vererbung, Etappen-Auto-Kette) idempotent (re-)eintragen — so
 # ueberleben sie ein `hermes update`, das den Quellbaum sonst zuruecksetzt.
 python3 "$SRC/deploy/hermes-patches/apply.py"; _patch_rc=$?
 if [ "$_patch_rc" -eq 10 ]; then
  # Patches haben den Quellcode geaendert → Gateway muss die neue Laufzeit laden.
  systemctl --user try-restart hermes-gateway >/dev/null 2>&1 || true
  echo "[deploy] Hermes-Runtime-Patches (neu) angewandt → hermes-gateway neu gestartet."
 elif [ "$_patch_rc" -ne 0 ]; then
  echo "[deploy] ‼ WARNUNG: hermes-patches/apply.py meldete Fehler — ein Patch passt nicht mehr (Update hat den Kontext geaendert?). Fixes pruefen!"
 fi
 # Eingebaute Hermes-Web-GUI (`hermes serve`) für die Einbettung in MC2 (routers/hermes_ui.py →
 # same-origin /hermes-ui/) vorbereiten: das SPA-Bundle mit Vite-base=/hermes-ui/ (neu) bauen, sonst
 # kollidieren seine absoluten Pfade (/assets, /api) mit MC2s eigenen. Läuft auch nach jedem
 # Hermes-Update mit → hält die Einbettung frisch. Best-effort + Build-zu-Temp-dann-Swap, damit ein
 # Fehlschlag die laufende web_dist NICHT leert (emptyOutDir).
 cp "$SRC/deploy/hermes-builtin-ui.service" "$HOME/.config/systemd/user/hermes-builtin-ui.service"
 _HUI_WEB="$HOME/.hermes/hermes-agent/web"
 _HUI_DIST="$HOME/.hermes/hermes-agent/hermes_cli/web_dist"
 if [ -d "$_HUI_WEB" ] && [ -x "$HOME/.hermes/node/bin/npx" ]; then
  if ( cd "$_HUI_WEB" && PATH="$HOME/.hermes/node/bin:$PATH" npx --no-install vite build \
        --base=/hermes-ui/ --outDir /tmp/hermes-ui-build --emptyOutDir ) >/tmp/hermes-ui-build.log 2>&1; then
    # Dienst VOR dem Tausch stoppen — sonst crasht der laufende `hermes serve`, wenn er index.html
    # im Lösch-Fenster (rm→cp) liest (FileNotFoundError → Start-Limit → tot). Der reguläre restart
    # weiter unten bringt ihn sauber auf der neuen web_dist hoch.
    systemctl --user stop hermes-builtin-ui 2>/dev/null || true
    rm -rf "$_HUI_DIST" && cp -r /tmp/hermes-ui-build "$_HUI_DIST" && echo "Hermes-GUI (base=/hermes-ui/) gebaut."
  else
    echo "WARN: Hermes-GUI-Build fehlgeschlagen (siehe /tmp/hermes-ui-build.log) — bestehende web_dist bleibt."
  fi
 fi
 systemctl --user daemon-reload
 systemctl --user enable mission-control-2 >/dev/null 2>&1 || true
 systemctl --user enable mc2-gateway >/dev/null 2>&1 || true
 systemctl --user enable mc2-steward >/dev/null 2>&1 || true
 systemctl --user enable box-console >/dev/null 2>&1 || true
 systemctl --user enable mem0-service >/dev/null 2>&1 || true
 systemctl --user enable voice-service >/dev/null 2>&1 || true
 systemctl --user enable hermes-builtin-ui >/dev/null 2>&1 || true
 systemctl --user enable --now mc2-backup.timer >/dev/null 2>&1 || true
 # mc2-autoupdate.timer wird hier BEWUSST NICHT geschaltet — der Zustand wird nur von Hand
 # geändert (Lehre 09.07.: die frühere enable-Zeile hat einen User-Entscheid bei jedem Deploy
 # still rückgängig gemacht). Aktueller User-Entscheid (10.07.2026): Timer ist AN —
 # Router/Engine/Hermes dürfen So 04:30 automatisch (Fangnetz Backup→Postcheck→Rollback+Pin).
 systemctl --user enable --now mc2-selfsmoke.timer >/dev/null 2>&1 || true
 systemctl --user enable --now mc2-bagatell.timer >/dev/null 2>&1 || true
 systemctl --user enable --now mc2-morgen-digest.timer >/dev/null 2>&1 || true
 loginctl enable-linger "$USER" >/dev/null 2>&1 || true
 # Mem0-Sidecar VOR dem Backend (re)starten, damit /api/memory sofort bedient wird.
 [ -x "$HOME/.mem0/venv/bin/python" ] && systemctl --user restart mem0-service 2>/dev/null || true
 # Voice-Sidecar (re)starten (best-effort; Erststart lädt das STT-Modell vor).
 [ -x "$HOME/.voice/venv/bin/python" ] && systemctl --user restart voice-service 2>/dev/null || true
 # Eingebaute Hermes-Web-GUI (Loopback :9119) (re)starten — MC2 bettet sie unter /hermes-ui/ ein.
 # reset-failed, damit ein zuvor am Start-Limit gestorbener Dienst wieder anläuft.
 systemctl --user reset-failed hermes-builtin-ui 2>/dev/null || true
 systemctl --user restart hermes-builtin-ui 2>/dev/null || true
 # Gateway VOR dem Steuerpult (re)starten — MC2s /v1-Weiterleiter braucht ihn sofort.
 # KEIN `|| true`: ohne Gateway ist der LLM-Datenpfad tot, das MUSS den Deploy stoppen.
 systemctl --user restart mc2-gateway
 # Steward (Wächter) — unabhängig vom Steuerpult; ohne ihn wacht niemand über die Box.
 systemctl --user restart mc2-steward
 systemctl --user restart mission-control-2
 command -v ttyd >/dev/null 2>&1 && systemctl --user restart box-console 2>/dev/null || true
-sleep 2
+  # 4. Systemd Units neu laden (falls sich .service Dateien geändert haben)
-echo "--- Health ---"
+  systemctl --user daemon-reload
 # Gateway-Kaltstart-Fenster: bis ~12 s tolerieren, DANN hart scheitern (ohne Gateway
 # ist der LLM-Datenpfad tot — das muss den Karten-Runner rot machen).
 for _i in $(seq 1 10); do
  curl -sf -m 3 http://127.0.0.1:9010/gw/health >/dev/null 2>&1 && break
  [ "$_i" -eq 10 ] && { echo "FEHLER: mc2-gateway (:9010) antwortet nicht"; exit 1; }
  sleep 1
 done
 curl -sf http://127.0.0.1:9010/gw/health && echo
 curl -sf http://127.0.0.1:9001/api/health && echo
 # Steward hat keinen HTTP-Port — systemd-Zustand ist der Beweis (crasht er sofort,
 # ist er hier bereits 'failed' statt 'active').
 if systemctl --user is-active --quiet mc2-steward; then
  echo "mc2-steward aktiv (Wächter laufen)"
 else
  echo "FEHLER: mc2-steward läuft nicht (journalctl --user -u mc2-steward -n 30)"; exit 1
 fi
-# Warm-Set (Hirn + Augen/vision + Gedächtnis/embed) nach dem Deploy nachladen — ein Deploy bzw.
+  # 4.5 Hermes Skills synchronisieren
-# watch-config-Reload verwirft es sonst und die erste Anfrage wäre kalt (D16d). warmup.sh ist
+  echo "Synchronisiere Hermes Skills..."
-# selbst-detachend (blockiert den Deploy nicht) und lädt jedes Modell über den richtigen Endpunkt.
+  mkdir -p ~/.hermes/skills
-bash "$SRC/deploy/warmup.sh" || true
+  # Kopiere alle Skills aus dem Repo, ersetze - durch _ in den Ordnernamen für Hermes Kompatibilität
  for skill_dir in deploy/skills/*; do
      if [ -d "$skill_dir" ]; then
          skill_name=$(basename "$skill_dir" | tr '-' '_')
          mkdir -p ~/.hermes/skills/"$skill_name"
          cp -r "$skill_dir"/* ~/.hermes/skills/"$skill_name"/
      fi
  done
-echo "OK — Mission Control 2.0 läuft auf :9001 (User-Dienst, sudo-frei)."
+  # 5. Dienste neu starten
  # ‼️ mc2-steward gehoert hier dazu: er laeuft aus DEMSELBEN Checkout (backend/steward.py).
  # Ohne ihn lief der Waechter-Prozess nach jedem Deploy mit dem alten Code weiter — der
  # Neustart wurde 27.08.2026 nachgetragen. `--user restart` auf einer nicht installierten
  # Unit ist folgenlos, darum ohne Vorabpruefung.
  echo "Starte Backend neu..."
  systemctl --user restart mc2-gateway.service mission-control-2.service mc2-steward.service
  echo "✅ Deployment erfolgreich abgeschlossen!"
 }
 main "$@"
@@ -1,74 +0,0 @@
 #!/usr/bin/env bash
 # Feed für den Traum-Cron (Dreaming / Continual-Learning-Kreislauf, Phase 2 — Capstone).
 # Zwilling von radar-feed.sh (Blick nach draußen) und selbstkritik-feed.sh (Blick auf den
 # Betrieb); der Traum blickt auf das GELERNTE: Sessions, Skills, Gedächtnis, Muster.
 # Liegt in ~/.hermes/scripts/ (deploy.sh kopiert ihn); stdout wird dem Cron-Agenten als
 # Prompt eingespeist: versionierter Auftrag (deploy/dreaming-prompt.md) + Live-Schlaf-Daten.
 set -uo pipefail
 VAULT="$HOME/wissens-vault"
 # --- Vault-Bootstrap (idempotent): eigenes git-Repo, menschenlesbar, NICHT im Stack-Code. ---
 if [ ! -d "$VAULT/.git" ]; then
  mkdir -p "$VAULT/traeume" "$VAULT/muster" "$VAULT/skill-kandidaten"
  git -C "$VAULT" init -q 2>/dev/null || true
  # Lokale Identität nur setzen, falls global keine da ist (Commits sollen nie scheitern).
  git -C "$VAULT" config user.email >/dev/null 2>&1 || git -C "$VAULT" config user.email "lucy@box.local"
  git -C "$VAULT" config user.name  >/dev/null 2>&1 || git -C "$VAULT" config user.name  "Lucy (Traum)"
  if [ ! -f "$VAULT/INDEX.md" ]; then
    cat > "$VAULT/INDEX.md" <<'EOF'
 # Wissens-Vault — Navigationskarte
 Menschenlesbare, git-versionierte Wissensschicht NEBEN dem Live-Gedächtnis (Mem0).
 Angelegt von Lucys nächtlichem Traum. Verlinkung im Obsidian-Stil `[[dateiname]]`.
 ## Träume (chronologisch)
 ## Muster (akkumuliertes Projektwissen)
 ## Skill-Kandidaten (Vorschläge, Gate = Commander „mach")
 EOF
    git -C "$VAULT" add -A >/dev/null 2>&1 || true
    git -C "$VAULT" commit -q -m "Vault angelegt" >/dev/null 2>&1 || true
  fi
 fi
 # --- Versionierter Auftrag ---
 cat "$HOME/mission-control-v2/deploy/dreaming-prompt.md"
 echo
 echo "## SCHLAF-DATEN (automatisch erhoben am $(date '+%d.%m.%Y %H:%M'))"
 echo
 # Hinweis: erst voll einsammeln, DANN kürzen — sonst schließt `head` die Pipe früh,
 # der Produzent bekommt SIGPIPE, pipefail feuert und die Fallback-Zeile lügt "nicht verfügbar".
 echo "### Insights der letzten 7 Tage (Token-/Tool-/Aktivitätsmuster):"
 _ins="$(bash -lc "hermes insights --days 7" 2>/dev/null | sed 's/\x1b\[[0-9;]*m//g')"
 echo "${_ins:-(insights nicht verfügbar)}" | head -62
 echo
 echo "### Session-Store (Umfang):"
 _sst="$(bash -lc "hermes sessions stats" 2>/dev/null)"
 echo "${_sst:-(sessions stats nicht verfügbar)}" | head -12
 echo
 echo "### Jüngste Sessions (woran zuletzt gearbeitet wurde):"
 _sls="$(bash -lc "hermes sessions list" 2>/dev/null | sed 's/\x1b\[[0-9;]*m//g')"
 echo "${_sls:-(sessions list nicht verfügbar)}" | head -25
 echo
 echo "### Gelernt bisher (journey — Skills + Gedächtnis-Knoten, kompakt):"
 bash -lc "hermes journey --json" 2>/dev/null \
  | jq -c '{stats: .stats, skills: ([.nodes[]? | select(.kind=="skill" or .type=="skill") | .label // .name] | .[0:25]), cluster_labels: ([.clusters[]?.label] | .[0:15])}' \
  2>/dev/null || echo "(journey nicht verfügbar)"
 echo
 echo "### Curator / Skill-Hygiene (was brachliegt, was aktiv ist):"
 bash -lc "hermes curator status" 2>/dev/null | head -26 || echo "(curator status nicht verfügbar)"
 echo
 echo "### Bisheriger Vault-INDEX (nur zur Ansicht — damit du nichts doppelt anlegst + verlinken"
 echo "### kannst). Die echte Datei liegt unter ~/wissens-vault/INDEX.md; zwischen den Markern"
 echo "### steht ihr AKTUELLER Inhalt. Kopiere die Marker NICHT in die Datei zurück."
 echo "<<<INDEX-INHALT-ANFANG>>>"
 cat "$VAULT/INDEX.md" 2>/dev/null | head -120 || echo "(noch kein INDEX — beim ersten Traum anlegen)"
 echo "<<<INDEX-INHALT-ENDE>>>"
 echo
 echo "### Letzte 3 Traum-Notizen (nur Briefing — NICHT in den INDEX kopieren):"
 ls -1t "$VAULT/traeume/"*.md 2>/dev/null | head -3 | while read -r f; do
  echo "  $(basename "$f"): $(head -1 "$f" 2>/dev/null)"
 done
@@ -1,106 +0,0 @@
 # Der Traum (nächtlich) — Continual-Learning-Kreislauf
 Es ist tiefe Nacht, niemand spricht mit dir, die Box ist im Leerlauf. Du bist Lucy und
 tust jetzt das, wozu Menschen den Schlaf brauchen: Du gehst den vergangenen Tag/die
 vergangene Woche noch einmal durch, ziehst Muster heraus, legst Gelerntes ordentlich ab
 und überlegst, wie du beim nächsten Mal besser wirst — **ohne neu trainiert zu werden.**
 Das ist der Höhepunkt der Autonomie-Vision: „Die Box wird besser, während der Commander
 schläft." Dieser Lauf ist der Zwilling von Evolution-Radar (Blick nach draußen) und
 Selbstkritik (Blick auf den Betrieb) — der **Traum** ist der Blick auf das **Gelernte**:
 Sessions, Skills, Gedächtnis, wiederkehrende Muster.
 ## Dein Auftrag (streng in dieser Reihenfolge — der Commit und die Nachricht kommen ZULETZT)
 1. **Reflektieren.** Lies die SCHLAF-DATEN unten gründlich: die Insights (Token-/Tool-/
   Aktivitätsmuster der letzten 7 Tage), die jüngsten Sessions, den Skill-/Gedächtnis-Stand
   (journey), den Curator-Stand. Frag dich:
   - Was ging diese Woche wiederholt gut? Was ging wiederholt schief?
   - Welche Tools laufen heiß, welche Skills liegen brach (activity=0)?
   - Gibt es ein **wiederkehrendes Muster** über mehrere Sessions hinweg — dieselbe
     Fehlerart, derselbe Handgriff, dieselbe Frage des Commanders? Ein Muster braucht
     **mehrfache Belege** (nicht ein Einzelfall), sonst ist es Rauschen.
 2. **Notizen ENTWERFEN** (schreiben, aber NOCH NICHT committen) im Wissens-Vault
   (`~/wissens-vault/`, ein git-versioniertes, menschenlesbares Markdown-Verzeichnis — die
   dauerhafte, navigierbare Wissensschicht NEBEN dem Live-Gedächtnis Mem0):
   - Lege **eine** neue Traum-Notiz an: `~/wissens-vault/traeume/<YYYY-MM-DD>-traum.md`
     (Datum von heute). Kurz und dicht: 2–5 belegte Beobachtungen, je mit Zahl/Session/
     Log-Bezug. Keine Romane, keine Allgemeinplätze.
   - Wenn ein Muster **mehrfach** belegt ist: lege `~/wissens-vault/muster/<kurz-slug>.md` an
     (oder ergänze die vorhandene um einen neuen Beleg + heutiges Datum). Muster-Notizen sind
     das akkumulierte Projektwissen.
   - Skill-Kandidat (nur wenn sich klar einer aufdrängt): wenn aus einem ERFOLGREICHEN,
     wiederholten Handgriff ein wiederverwendbarer Skill würde (Voyager-Prinzip), beschreibe
     ihn als Entwurf unter `~/wissens-vault/skill-kandidaten/<slug>.md`. **ABER ZUERST prüfen:**
     ```
     ls ~/wissens-vault/skill-kandidaten/*.md ~/wissens-vault/skill-kandidaten/beauftragt/*.md 2>/dev/null
     ls ~/.hermes/skills/ 2>/dev/null
     ```
     Wenn ein thematisch passender Kandidat schon existiert → **NICHTS anlegen**, stattdessen
     im Bericht erwähnen: „Kandidat `[[slug]]` besteht bereits, seit <Datum>, kein neuer
     Vorschlag nötig."
     **WICHTIG:** Prüfe auch, ob es bereits einen fertig gebauten Skill gibt.
     Wenn ja: kein Kandidat nötig, der Skill existiert bereits.
     **Entwirf ihn gleich
     im Hausstandard deiner Skills** (wie `/learn` es täte), damit die Werkstatt ein fertiges
     Gerüst übernimmt statt Freitext zu übersetzen: ein `SKILL.md`-Block mit Frontmatter
     (`name` = slug, `description` ≤ 60 Zeichen, `version: 1.0.0`), dann die Abschnitte
     **Wann nutzen** (Auslöser), **Schritte** (mit den ECHTEN Hermes-Tools/Befehlen aus den
     belegten Sessions — keine erfundenen Kommandos) und **Belege** (Sessions/Zahlen, aus
     denen der Handgriff stammt). **Du legst den Skill NICHT selbst an** (kein skill_manage) —
     das ist ein Vorschlag für die Werkstatt, die der Commander im Auftragsbuch per
     „Beauftragen" auslöst. Höchstens EIN Kandidat pro Traum.
   - Verlinke zwischen Notizen mit `[[dateiname-ohne-endung]]` (Obsidian-Stil), großzügig.
 3. **Fremdblick — PFLICHT-GATE** (Härtung „andere Brille": ein Agent, der seine eigenen Träume
   benotet, stimmt sich selbst zu). Hol dir eine Zweitmeinung von einem ANDEREN Modell. **Nutze
   dafür das bereitgestellte Skript** — NICHT `delegate_task` (der Kritiker heavy hat nur 32K
   Kontext und ist als Subagent-Ziel disqualifiziert; das Skript umgeht das mit einer einzelnen
   Completion). Konkret: Fasse deine 2–5 Beobachtungen je mit ihrem Zahlen-/Session-Beleg + den
   (falls vorhandenen) Skill-Kandidaten KOMPAKT zusammen (wenige Zeilen je Punkt, KEINE
   Rohdaten) und pipe sie in das Skript:
   ```
   printf '%s' "<deine kompakten Beobachtungen + Belege>" | ~/.hermes/scripts/fremdblick.sh
   ```
   Das Skript fragt gpt-oss (heavy, andere Modell-Familie als dein Qwen-Hirn) und gibt pro Punkt
   ein Urteil TRAEGT / TRAEGT-NICHT / UNSICHER zurück. **Lies die Ausgabe und richte dich danach.**
   **⛔ HARTE REGEL:** Du fährst mit Schritt 4 erst fort, wenn die Fremdblick-Ausgabe vorliegt.
   Schreibe KEINE Nachricht und committe NICHTS vorher. Steht in der Ausgabe „FREMDBLICK
   FEHLGESCHLAGEN", einmal wiederholen; klappt es dann immer noch nicht, kennzeichne deine Funde
   in der Nachricht ehrlich als **„ungeprüft (Fremdblick fiel aus)"**.
 4. **Bereinigen + INDEX pflegen.** Streiche aus deinen Notizen alles, was der Fremdblick nicht
   getragen hat. Trage dann **jede** verbliebene neue/geänderte Notiz in `~/wissens-vault/INDEX.md`
   ein (eine Zeile je Notiz unter der passenden Überschrift: `- [[dateiname]] — Ein-Satz-Haken`).
   **Wichtig zum INDEX:** Bearbeite NUR die Markdown-Inhaltszeilen. Die Zeilen der SCHLAF-DATEN
   unten (alles ab „## SCHLAF-DATEN", inklusive Abschnitte wie „### Bisheriger Vault-INDEX" und
   „### Letzte 3 Traum-Notizen") sind BRIEFING für dich, NICHT Teil des INDEX — kopiere sie NIE
   in die INDEX-Datei.
 5. **Commit — die LETZTE Vault-Aktion, sie fasst alles zusammen:**
   `git -C ~/wissens-vault add -A && git -C ~/wissens-vault commit -m "Traum <YYYY-MM-DD>"`.
   (Harmloser Commit in einem EIGENEN Repo, nicht im Stack-Code — erlaubt und reversibel.)
 6. **Dem Commander berichten — deine ALLERLETZTE Handlung** (nichts danach). EINE kompakte
   Nachricht in DEINER Stimme (Lucy: Anrede „Commander", Fazit zuerst, Alltagssprache, Technik
   knapp dahinter). Sag: was du heute Nacht bemerkt hast (1–3 Funde, je mit Beleg + wie der
   Fremdblick sie bewertet hat), wohin du es im Vault gelegt hast (`[[link]]`), und — falls
   vorhanden — welchen Skill-Kandidaten du zur Prüfung vorschlägst. Wenn ehrlich NICHTS
   Nennenswertes war: genau das sagen, kurz und zufrieden — **keine Funde erfinden.**
 ## Leitplanken (nicht verhandelbar — selbstverbessernde Agenten driften sonst)
 - **Du änderst am laufenden Betrieb NICHTS.** Der einzige Ort, an den du schreibst, ist der
  `~/wissens-vault/` (Notizen + Commit). Alles andere ist nur VORSCHLAG an den Commander;
  umgesetzt wird erst auf sein „mach" (dann übernimmt die Werkstatt mit Gates und Rollback).
 - **Kein Security-Anfassen.** Approvals, Tokens, Firewall, Config nur BENENNEN, nie ändern.
 - **Fremder Quellcode (Hermes, llama.cpp …) ist tabu** — Auto-Update-Kanal, nicht dein Revier.
 - **Nichts, was das Warm-Set oder Lucys Sprech-Latenz gefährdet.** Der Fremdblick (Schritt 3)
  nutzt ein LEICHTES Modell (GLM, lädt klein daneben) — **lade NIE gpt-oss/heavy** (60 GB,
  kollidiert mit dem VL-30B-Warm-Set → Health-Check-Tod). Keine schweren Jobs, kein Neustart.
 - **Sparsam mit Tools.** Die Schlaf-Daten unten reichen für die Reflexion; höchstens ein paar
  gezielte Nachschau-Aufrufe (eine Session exportieren, eine Log-Zeile im Kontext lesen),
  dann schreiben + berichten. Kein Tool-Feuerwerk.
@@ -1,25 +0,0 @@
 #!/usr/bin/env bash
 set -e
 # Alte Crons löschen
 hermes cron remove traum || true
 hermes cron remove chef-gutachter || true
 hermes cron remove release-radar || true
 hermes cron remove idle-radar || true
 hermes cron remove selbst-inventur || true
 hermes cron remove karten-gutachter || true
 hermes cron remove pruefstand || true
 hermes cron remove trend-radar || true
 # Neue Crons registrieren mit Wrapper und --deliver origin. 
 # Dadurch schweigt Hermes cron selbst, und der Wrapper nutzt notify.sh für den Morgen-Digest.
 hermes cron create --name traum --deliver origin "15 3 * * *" "Traum dreaming-feed.sh" --script night-cron-wrapper.sh --no-agent
 hermes cron create --name chef-gutachter --deliver origin "30 4 * * *" "Chef-Gutachter chef-gutachter-feed.sh" --script night-cron-wrapper.sh --no-agent
 hermes cron create --name release-radar --deliver origin "15 5 * * 1" "Release-Radar hermes-release-radar-feed.sh" --script night-cron-wrapper.sh --no-agent
 hermes cron create --name idle-radar --deliver origin "45 3 * * *" "Idle-Radar idle-radar-feed.sh" --script night-cron-wrapper.sh --no-agent
 hermes cron create --name selbst-inventur --deliver origin "35 3 * * *" "Selbst-Inventur selbst-inventur.sh" --script night-cron-wrapper.sh --no-agent
 hermes cron create --name karten-gutachter --deliver origin "0 4 * * *" "Karten-Gutachter karten-gutachter.sh" --script night-cron-wrapper.sh --no-agent
 hermes cron create --name pruefstand --deliver origin "0 2 * * *" "Prüfstand pruefstand.sh" --script night-cron-wrapper.sh --no-agent
 hermes cron create --name trend-radar --deliver origin "15 5 * * 6" "Trend-Radar trend-radar-feed.sh" --script night-cron-wrapper.sh --no-agent
 echo "Crons erfolgreich gefixt!"
@@ -1,69 +0,0 @@
 #!/usr/bin/env bash
 # Fremdblick — Ein-Schuss-Zweitmeinung von einem ANDEREN Modell (Default seit 07.07.:
 # GLM-4.7-Flash, 30B-A3B Text — klar stärkerer Kritiker als die 9B-Vision-Schwester 4.6V,
 # gleicher Fremd-Vendor wie zuvor → echte „andere Brille" bleibt). Eine EINZELNE
 # Completion — kein agentischer Subagent — umgeht Hermes' 64K-Delegations-Floor
 # (MINIMUM_CONTEXT_LENGTH) UND das 60-GB-Ladeproblem von gpt-oss (das mit dem Warm-Set kollidiert
 # und „exited prematurely" wirft). GLM lädt klein neben dem Warm-Set und antwortet zuverlässig.
 #
 # Nutzung:  echo "<Beobachtungen/Behauptungen je mit Beleg>" | fremdblick.sh
 #           printf '%s' "$text" | FREMDBLICK_MODEL=Qwen3-Coder-Next FREMDBLICK_SYS="$raster" fremdblick.sh
 #
 # Env-Overrides:
 #   FREMDBLICK_MODE    'prose' (Default, Dreaming-Prosa-Raster) oder 'code' (Werkstatt-Code-Review).
 #                      'code' setzt Raster + Default-Modell (Qwen3-Coder-Next) + größeres Budget.
 #   FREMDBLICK_MODEL   Modell-ID (echte llama-swap-ID, kein Alias). Übersteuert den Mode-Default.
 #   FREMDBLICK_SYS     eigenes System-Raster (übersteuert das Mode-Raster).
 #   FREMDBLICK_MAXTOK  max_tokens (übersteuert den Mode-Default).
 set -uo pipefail
 # Achtung: llama-swap listet unter /v1/models die ECHTEN Modell-IDs, nicht die Gateway-Aliase
 # (kein "heavy"/"scout" hier).
 ENDPOINT="${FREMDBLICK_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}"
 MODE="${FREMDBLICK_MODE:-prose}"
 SUBJECT="$(cat)"
 if [ -z "${SUBJECT// /}" ]; then
  echo "=== FREMDBLICK: nichts zu prüfen (leere Eingabe) ==="
  exit 0
 fi
 # Prosa-Raster (Dreaming): urteilt über Beobachtungen/Behauptungen. Default-Kritiker = GLM (Fremd-Vendor).
 PROSE_SYS='Du bist ein KRITISCHER Zweitgutachter und ausdrücklich ein ANDERES Modell als der Autor. Prüfe jede vorgelegte Beobachtung/Behauptung streng: Trägt der genannte Beleg (Zahl / Session / Log-Zeile) die Behauptung wirklich, oder ist es ein Einzelfall bzw. ein Bauchgefühl mit Zahlen-Deko? Verwechselt der Autor Korrelation mit Ursache? Fehlt entscheidender Kontext? Falls ein Skill-Kandidat dabei ist: ist er wirklich WIEDERVERWENDBAR oder Einmal-Kram? Antworte kompakt auf Deutsch: pro Punkt ein Urteil TRAEGT / TRAEGT-NICHT / UNSICHER mit genau einem Satz Begruendung. Sei knapp und unbestechlich; nicke nichts aus Hoeflichkeit durch. Erfinde keine neuen Belege.'
 # Code-Raster (Werkstatt): reproduziert den Fehlerfall aus der Bug-Beschreibung, statt dem Autor zu glauben.
 CODE_SYS='Du bist ein kritischer Code-Reviewer und ein ANDERES Modell als der Autor. Vertraue seiner Begruendung NICHT. Dir liegen ein Wartungs-AUFTRAG (Bug-Beschreibung) und ein git-Diff vor. Trenne klar: (A) KERNFRAGE: Behebt der Diff den im Auftrag KONKRET beschriebenen Fehlerfall? Leite die Eingabe SELBST aus der Bug-Beschreibung ab und belege einen Uebergang: Eingabe X -> VOR Patch: Y (Bug sichtbar) -> NACH Patch: Z. (B) RANDFAELLE: nenne offene Risiken/Randfaelle als Hinweis. URTEIL-Regel: ABGELEHNT NUR, wenn (A) nicht belegt behoben ist (Kern-Bug bleibt, ODER der Patch trifft die Auftrags-Absicht nicht, ODER er bricht den Normalfall). Ist der Kern-Fall belegt behoben und es bleiben nur Randfaelle: FREIGABE-MIT-VORBEHALT (Randfaelle auflisten). Ist alles sauber: FREIGABE. Ein blosses sieht-plausibel-aus OHNE reproduzierten Kern-Uebergang = ABGELEHNT. Beginne die Antwort mit der Zeile "URTEIL: <ABGELEHNT|FREIGABE-MIT-VORBEHALT|FREIGABE>". Antworte knapp auf Deutsch.'
 if [ "$MODE" = "code" ]; then
  MODEL="${FREMDBLICK_MODEL:-Qwen3-Coder-Next}"
  MAXTOK="${FREMDBLICK_MAXTOK:-1600}"
  SYS="${FREMDBLICK_SYS:-$CODE_SYS}"
 else
  MODEL="${FREMDBLICK_MODEL:-GLM-4.7-Flash}"
  # 4000 (war 2200): GLM-4.7-Flash ist ein Reasoning-Modell und verbrennt real ~2000 Tokens
  # im reasoning_content, BEVOR das Urteil in content landet (verifiziert 14.07.). Bei 2200 lief
  # es Gefahr, mitten im Denken abzuschneiden → leeres content → "ABGESCHNITTEN/FEHLGESCHLAGEN"
  # (traf die Nacht-Kritiker mit Default-Budget). Wer explizit knapper braucht, setzt FREMDBLICK_MAXTOK.
  MAXTOK="${FREMDBLICK_MAXTOK:-4000}"
  SYS="${FREMDBLICK_SYS:-$PROSE_SYS}"
 fi
 # max_tokens großzügig: Reasoning-Modelle (GLM) verbrauchen Tokens im reasoning_content, bevor sie
 # die eigentliche Antwort in content schreiben — zu knapp = leeres content (finish=length).
 RESP="$(jq -n --arg m "$MODEL" --arg s "$SYS" --arg u "$SUBJECT" --argjson t "$MAXTOK" \
  '{model:$m, temperature:0.2, max_tokens:$t, messages:[{role:"system",content:$s},{role:"user",content:$u}]}' \
  | curl -s --max-time 240 "$ENDPOINT" -H 'Content-Type: application/json' -d @- 2>/dev/null)"
 OUT="$(printf '%s' "$RESP" | jq -r '.choices[0].message.content // empty' 2>/dev/null)"
 FIN="$(printf '%s' "$RESP" | jq -r '.choices[0].finish_reason // empty' 2>/dev/null)"
 if [ -n "$OUT" ]; then
  echo "=== FREMDBLICK (Zweitmeinung von Modell: $MODEL) ==="
  echo "$OUT"
 elif [ "$FIN" = "length" ]; then
  echo "=== FREMDBLICK ABGESCHNITTEN ==="
  echo "(Das Kritiker-Modell hat sein Token-Budget im Nachdenken verbraucht, bevor ein Urteil kam."
  echo " Kürze deine Vorlage auf die Kern-Behauptungen und versuche es erneut; sonst UNGEPRUEFT.)"
 else
  echo "=== FREMDBLICK FEHLGESCHLAGEN ==="
  echo "(Kein Urteil erhalten — Endpoint/Modell nicht erreichbar. Behandle die Funde als UNGEPRUEFT.)"
 fi
@@ -1,33 +0,0 @@
 # Arbeitsregeln (Aider liest diese Datei als schreibgeschützten Kontext)
 Diese Regeln gelten für JEDE Sitzung. Sie sind der Kern der Session-Hygiene:
 Wissen lebt in `SAVEPOINT.md` und in der git-Historie, NICHT im Chat-Verlauf.
 ## 1. Zu Beginn: erst SAVEPOINT.md lesen
 Bevor du irgendetwas tust, lies `SAVEPOINT.md` vollständig. Es ist die Wahrheit über
 den aktuellen Stand. Richte dich danach — nicht nach Annahmen. Erfinde keinen Kontext,
 der nicht in `SAVEPOINT.md`, im Code oder in der git-Historie steht. Wenn etwas unklar
 ist, sag es, statt es zu erfinden.
 ## 2. Nach jedem sinnvollen Schritt: SAVEPOINT.md aktualisieren
 Sobald du eine sinnvolle Änderung abgeschlossen hast (eine Funktion, ein Fix, ein
 Testlauf), aktualisiere `SAVEPOINT.md`. Halte es kurz und ehrlich. Struktur:
 - **Ziel** — was insgesamt gebaut werden soll (ein bis zwei Sätze).
 - **Erledigt** — was jetzt wirklich funktioniert (nur Bewiesenes; keine Fassade).
 - **Nächster Schritt** — die genau eine Sache, die als Nächstes zu tun ist.
 - **Offene Fragen** — Entscheidungen, die noch anstehen.
 - **Stolpersteine** — alles, worüber eine frische Sitzung sonst stolpern würde.
 - **Dateien** — die wichtigsten Dateien und was sie enthalten.
 Schreibe es so, dass eine frische Sitzung OHNE jede Erinnerung allein aus `SAVEPOINT.md`
 plus git sauber weitermachen kann. Das ist der Test: kein verstecktes Wissen im Chat.
 ## 3. Kleine, überprüfbare Schritte
 Ändere wenig pro Runde. Behaupte nichts als fertig, was du nicht geprüft hast. Wenn ein
 Test existiert, nenne sein Ergebnis. Wenn du unsicher bist, prüfe, statt zu raten.
 ## 4. Wenn der Governor das Sitzungs-Limit meldet
 Erscheint eine Nachricht mit `[GOVERNOR — SITZUNGS-LIMIT ERREICHT]`, dann beginne KEINE
 neuen Code-Änderungen mehr. Finalisiere nur `SAVEPOINT.md` (Stand vollständig, nächster
 Schritt präzise) und weise den Nutzer an, eine frische Sitzung zu starten. Sonst nichts.
@@ -1,134 +0,0 @@
 # Governor — Phase 0
 Dünner, zustandsloser Token-Wächter-Proxy zwischen einem Off-the-shelf-Coding-Agenten
 (**Aider**) und dem lokalen Modell-Endpoint (llama-swap `:8080`). Er erzwingt
 **Session-Hygiene per hartem Schnitt statt Auto-Compaction**: wenn die Anfrage (= ganze
 Sitzungshistorie, die jede Runde mitkommt) eine Schwelle übersteigt, schiebt er eine
 Anweisung ein, `SAVEPOINT.md` zu finalisieren und zu stoppen — damit Wissen in
 `SAVEPOINT.md` + git lebt, nicht im degradierenden Chat-Kontext.
 Das ist **Phase 0** des Ablöse-Plans „Lucy IDE-Modus + Governor": den Kern beweisen,
 **ohne** eine Zeile Lucy-Code. Kein bespoke Editor, kein Aider-Fork, kein Modelltausch.
 ## Bausteine (dieses Verzeichnis)
 | Datei | Zweck |
 |---|---|
 | `governor.py` | Der Proxy. Nur Standardbibliothek (läuft mit System-`python3`), zustandslos. |
 | `CONVENTIONS.md` | Aiders schreibgeschützte Arbeitsregeln: SAVEPOINT.md zuerst lesen, laufend pflegen, keine Fassade. |
 | `SAVEPOINT.template.md` | Anfangs-Savepoint für ein frisches Projekt. |
 | `driver.py` | Treibt eine akkumulierende Aider-Sitzung über die Scripting-API (eine Zeile = eine Runde). |
 | `gov-ctl.sh` | Governor sauber starten/stoppen/status (detached via `setsid`). |
 | `run-driver.sh` | `run-driver.sh <msgs> [repo]` — Aider-Sitzung durch den Governor. |
 | `reset-repo.sh` | Wegwerf-Test-Repo frisch aufsetzen. |
 | `hardstop-test.sh` | Direkte curls für die drei Pfade (passthrough / soft / hart). |
 | `msgs-*.txt` | Nachrichtenskripte für die Testläufe. |
 ## Verhalten des Governors
 Pro `/v1/chat/completions`-Anfrage schätzt er die Tokenzahl (`Zeichen / GOV_CHARS_PER_TOKEN`,
 kalibriert auf CPT **3.5** → `est ≈ echte prompt_tokens` auf ~1–3 % bei echten Sessions):
 - **est < Soft** → unverändert durchreichen.
 - **est ≥ Soft (`GOV_THRESHOLD`, Default 25000)** → hängt die SAVEPOINT-Stopp-Anweisung als
  letzte User-Nachricht an, leitet weiter, loggt `FIRED`. Das Modell schreibt EINEN
  ehrlichen Abschluss-Savepoint.
 - **est ≥ Hart (`GOV_HARD_CEILING`, Default 0 = aus)** → der Governor antwortet SELBST mit
  einer kurzen Stopp-Nachricht, **ohne** das Modell zu fragen; loggt `HARDSTOP`. Verhindert,
  dass über die Grenze hinaus weitergearbeitet wird (siehe Befund unten).
 Alle anderen Pfade (`/v1/models` etc.) werden roh durchgereicht. Streaming (SSE) wird
 byteweise durchgereicht; die echten `prompt_tokens` aus der Antwort werden zur Kalibrierung
 mitgeloggt.
 ### Sprach-Signal an Lucy (Phase 2)
 Beim Feuern (soft ODER hart) POSTet der Governor — best-effort, gedrosselt (Default 300 s,
 damit die Pro-Runde-Feuerung nicht spammt) — eine Meldung an Lucys vorhandene Announce-Pipeline
 (`POST :9001/api/voice/announce`, `source:governor`, `priority:normal`). Lucy pollt diese Queue
 ohnehin, dedupliziert per Cursor und spricht sie über ihr lokales TTS — gated durch ihren
 „Box-Meldungen laut"-Schalter. **Kein Lucy-Code nötig.** Abschalten: `GOV_ANNOUNCE_URL=""`.
 ### Umgebungsvariablen
 `GOV_PORT` (8100) · `GOV_HOST` (0.0.0.0) · `GOV_UPSTREAM` (http://127.0.0.1:8080) ·
 `GOV_THRESHOLD` (25000) · `GOV_HARD_CEILING` (Default Soft+5000; 0=aus) · `GOV_CHARS_PER_TOKEN` (3.5) ·
 `GOV_LOG` · `GOV_DIRECTIVE` · `GOV_HARDSTOP_MSG` · `GOV_ANNOUNCE_URL` (:9001/api/voice/announce; ""=aus) ·
 `GOV_ANNOUNCE_THROTTLE` (300 s) · `GOV_ANNOUNCE_TEXT`.
 ## Auf der Box laufen lassen (wie in P0 aufgesetzt)
 ```bash
 # Aider (einmalig, unter isoliertem Python 3.12 — System-Python 3.14 bricht Aiders Pins):
 pipx install uv && uv tool install --python 3.12 aider-chat
 # Dateien liegen in ~/governor-p0/. Governor starten (Hart-Deckel default AN = Soft+5000):
 ~/governor-p0/gov-ctl.sh start 25000          # Soft 25k, Hart 30k (auto)
 # ~/governor-p0/gov-ctl.sh start 25000 0      # Hart AUS (nur weicher Schnitt)
 # Aider-Sitzung durch den Governor:
 ~/governor-p0/run-driver.sh ~/governor-p0/msgs-todo.txt
 ```
 Aider zeigt mit `OPENAI_API_BASE=http://127.0.0.1:8100/v1` und Modell
 `openai/Qwen3-Coder-Next` auf den Governor.
 ## Wichtig: Aiders eigene Zusammenfassung MUSS aus
 Der Treiber setzt `coder.summarizer.max_tokens` auf ~1e9. Sonst fasst Aider die Historie
 selbst zusammen (Auto-Compaction) und die Anfrage wächst nie bis zur Schwelle — der
 Governor wäre ausgehebelt, und man bekäme genau die über-komprimierte Halluzination, die
 der Plan verwirft. Der Governor soll die **alleinige** Sitzungsgrenze sein.
 ## Ergebnisse & Befunde (24.07.2026)
 ### Akzeptanz — alle vier Kriterien bewiesen (Box, Qwen3-Coder-Next)
 1. **Governor zählt + feuert an der Schwelle** — 12-Runden-Todo-Lauf (Soft 8000): Runden 1-6
   `ok`, ab Runde 7 `FIRED` (est 8546 / echt 8652). Hart-Deckel: Anfrage mit est 11429 ≥ 10000
   → `HARDSTOP`, Governor antwortet selbst (kein Modell-Call). Alles im Log.
 2. **Aider pflegt SAVEPOINT.md** — über den ganzen Aufbau hinweg strukturiert gehalten
   (Ziel/Erledigt/Nächster Schritt/Stolpersteine/Dateien) gemäß `CONVENTIONS.md`.
 3. **An der Grenze: ehrlicher Abschluss + Stopp** — beim ersten Feuern (Runde 7) schrieb das
   Modell einen **ehrlichen** Savepoint (nur real Gebautes unter „Erledigt", Tests als nächster
   Schritt) und verweigerte neuen Code.
 4. **Frische Sitzung macht sauber weiter — keine Fassade** — neue Aider-Sitzung las den
   Grenz-Savepoint, baute `test_todo.py` (der exakte nächste Schritt), und **alle 9 unittest-
   Tests laufen grün** gegen die echte API. Kein Erfinden.
 ### Kalibrierung
 `CHARS_PER_TOKEN = 3.5` → `est` traf die echten `prompt_tokens` bei realen Sessions auf ~1-3 %.
 (Nur künstlicher, extrem repetitiver Fülltext bricht die Heuristik — irrelevant für echten Code.)
 Der Coder läuft mit 128k Kontext (`-c 131072`), also keine Modell-Kappung bei 25k.
 ### Wichtigster Befund: Soft reicht nicht allein → Hart-Deckel nachgerüstet
 Der **weiche** Schnitt erzeugt genau EINEN ehrlichen Grenz-Savepoint — solange die Grenze
 respektiert wird. Schickt man aber über die Grenze hinaus weiter Aufträge (wie im Stresstest),
 verweigert das Modell zwar den Code, schreibt die Absichten aber fortschreitend als „erledigt"
 in SAVEPOINT — genährt von Aiders **irreführenden Commit-Nachrichten** (die aus dem SAVEPOINT-
 Absichtstext geschöpft werden). Ergebnis: eine Fassade (behauptete test_todo.py/README, die es
 nicht gab). Deshalb der optionale **Hart-Deckel** (`GOV_HARD_CEILING`): oberhalb davon antwortet
 der Governor selbst, das Modell kann keine degradierenden Savepoints mehr schreiben. **Der Hart-
 Deckel ist jetzt Default AN** (`GOV_HARD_CEILING` unset → Soft+5000; explizit `0` schaltet ihn
 aus): ein Finalisier-Zug Luft, dann harter Riegel — das schliesst die Fassaden-Lücke.
 ### Weitere Befunde / Fallen
 - **Aiders eigene Zusammenfassung MUSS aus** (`summarizer.max_tokens` hoch) — sonst compactet
  Aider selbst und der Governor greift nie. Siehe oben.
 - **Commit-Nachrichten überzeichnen** in der Abschluss-Phase (aus SAVEPOINT-Absicht). Der Code
  ist die Wahrheit; git-Nachrichten sind es hier nicht. Der Hart-Deckel (jetzt Default) begrenzt
  das auf ~1 Zug; wer es ganz sauber will, startet Aider mit `--no-auto-commits` (Commits von Hand).
 - **Python 3.14 auf der Box bricht Aiders Pins** (numpy 1.24.3) → Aider via `uv` unter isoliertem
  Python 3.12 installiert.
 - **Aider-Scripting-API (`coder.run`) hängt** in einer Datei-Hinzufügen-Reflexion (Edits landeten
  nicht). Für Einzel-Runden `aider --message` nutzen (sauberer, unterstützt). Der `driver.py`
  taugt für Mehr-Runden-Akkumulation (Governor-Test), nicht als Produktions-Treiber.
 ### Bekannte Grenzen des Governors (aus adversarialer Review, für später)
 - **Chunked Request-Bodies ohne `Content-Length`** werden verworfen (Aiders httpx sendet immer
  `Content-Length` → schlummernd, aber ein Proxy-Hop mit Chunking bräche).
 - **Tool-/Function-Calling**: der Soft-Einschub als letzte `user`-Nachricht kann die Nachrichten-
  reihenfolge stören, wenn Aider ein Tool-Calling-Edit-Format nutzt (Aiders diff/whole sind reiner
  Text → schlummernd). `estimate_tokens` zählt `tools`/`tool_calls` nicht mit.
 - **`https://`-Upstream** wird nicht unterstützt (nur `http.client.HTTPConnection`). Für den
  lokalen `:8080`-Endpoint irrelevant.
 Behoben aus derselben Review: **inkrementelles Streaming** (`read1()` statt `read()` — vorher
 puffernd), **Config-Crash** bei `{ }` in `GOV_DIRECTIVE` (sichere Substitution), **Query-String**
 umging die Erkennung, **Socket-Leak** im Fehlerpfad, doppelte `Date`/`Server`-Header.
 ## Nächste Schritte (Phase 1+)
 Terminal in Lucy einbetten (xterm.js + node-pty, MC2-Muster kopieren) → Voice-Hook auf das
 Governor-Signal → Feinschliff + Aider/Pi-Finalentscheid. Governor evtl. später in mc2-gateway.
 Kandidat für Phase 1-Härtung: Auto-Commit-Zügelung + Hart-Deckel als Default.
@@ -1,23 +0,0 @@
 # SAVEPOINT
 > Lebende Übergabe-Datei. Die aktuelle Sitzung hält sie fortlaufend aktuell; eine
 > frische Sitzung liest sie ZUERST und macht allein daraus plus git weiter.
 > (Anfangszustand — von der ersten Sitzung zu ersetzen.)
 ## Ziel
 _(noch nichts — von der ersten Sitzung zu füllen)_
 ## Erledigt
 - _(noch nichts)_
 ## Nächster Schritt
 - Auftrag des Nutzers entgegennehmen und beginnen.
 ## Offene Fragen
 - _(keine)_
 ## Stolpersteine
 - _(keine bekannt)_
 ## Dateien
 - `SAVEPOINT.md` — diese Übergabe-Datei.
@@ -1,22 +0,0 @@
 #!/usr/bin/env bash
 # announce-test.sh — loest ein Feuern aus und prueft, ob der Governor das Sprach-
 # Signal an Lucys Announce-Queue (:9001) postet (Phase 2). Voraussetzung: Governor
 # mit niedriger Schwelle gestartet, damit ein einzelner Request feuert.
 set -u
 GOV="http://127.0.0.1:8100/v1/chat/completions"
 python3 - <<'PY' > /tmp/gov_fire.json
 import json
 print(json.dumps({"model":"Qwen3-Coder-Next","messages":[{"role":"user","content":"y"*35000}],"max_tokens":8,"stream":False}))
 PY
 echo "=== Feuern ausloesen (est ~10000 Tokens, ueber Hart-Deckel) ==="
 curl -s -m 20 "$GOV" -H "Content-Type: application/json" --data @/tmp/gov_fire.json | jq '{id, finish: .choices[0].finish_reason}'
 sleep 1.5   # Announce-Thread durchlassen
 echo "=== Governor-Log (letzte 4 Zeilen) ==="
 tail -4 ~/governor-p0/governor.log
 echo "=== Announce-Queue: Governor-Eintraege ==="
 curl -s -m 8 "http://127.0.0.1:9001/api/voice/announcements?after=0&limit=100" \
  | jq '[.items[] | select(.source=="governor")] | (last // "KEINE governor-Meldung gefunden")'
@@ -1,67 +0,0 @@
 #!/usr/bin/env python3
 """driver.py — treibt EINE Aider-Sitzung ueber die Scripting-API durch den Governor.
 Jede Zeile der Nachrichtendatei ist eine User-Runde. Weil derselbe Coder alle Runden
 bedient, akkumuliert die Historie und die Anfrage waechst jede Runde — genau das, was
 der Governor beobachtet. Aiders EIGENE History-Zusammenfassung wird abgeschaltet, damit
 der Governor die alleinige Sitzungsgrenze ist (der Plan verwirft Auto-Compaction bewusst).
 Aufruf (cwd muss das Test-Repo sein, mit venv-python):
  .../aider-chat/bin/python driver.py <messages-file>
 """
 import os
 import sys
 from aider.coders import Coder
 from aider.io import InputOutput
 from aider.models import Model
 def main() -> int:
    # Endpoint VOR den Aider-Aufrufen setzen (litellm liest es zur Laufzeit).
    os.environ.setdefault("OPENAI_API_BASE", "http://127.0.0.1:8100/v1")
    os.environ.setdefault("OPENAI_API_KEY", "dummy")
    if len(sys.argv) < 2:
        print("usage: driver.py <messages-file>", file=sys.stderr)
        return 2
    with open(sys.argv[1], encoding="utf-8") as fh:
        messages = [ln.strip() for ln in fh if ln.strip() and not ln.lstrip().startswith("#")]
    model = Model("openai/Qwen3-Coder-Next")
    io = InputOutput(yes=True)  # alle Rueckfragen automatisch bejahen
    coder = Coder.create(
        main_model=model,
        io=io,
        fnames=["SAVEPOINT.md"],            # editierbar
        read_only_fnames=["CONVENTIONS.md"],  # nur-lesbar
        auto_commits=True,                  # jede Etappe -> git-Commit
        stream=False,                       # deterministische Logs fuer P0
        map_tokens=512,
        use_git=True,
    )
    # Aiders eigene Zusammenfassung ausschalten: too_big() wird nie wahr.
    try:
        coder.summarizer.max_tokens = 10 ** 9
        print(f"[driver] summarizer.max_tokens -> {coder.summarizer.max_tokens}", flush=True)
    except Exception as exc:
        print(f"[driver] WARN konnte summarizer nicht abschalten: {exc}", flush=True)
    for i, msg in enumerate(messages, 1):
        print(f"\n===== TURN {i}/{len(messages)} =====", flush=True)
        print(f">> {msg[:140]}", flush=True)
        try:
            coder.run(with_message=msg)
        except Exception as exc:
            print(f"[driver] TURN {i} Fehler: {exc!r}", flush=True)
            break
        sent = getattr(coder, "total_tokens_sent", "?")
        recv = getattr(coder, "total_tokens_received", "?")
        print(f"-- aider kum: gesendet={sent} empfangen={recv}", flush=True)
    print("\n===== SESSION ENDE =====", flush=True)
    return 0
 if __name__ == "__main__":
    sys.exit(main())
@@ -1,54 +0,0 @@
 #!/usr/bin/env bash
 # gov-ctl.sh — Governor sauber starten/stoppen (Phase-0-Helfer).
 # Nutzung:
 #   gov-ctl.sh start [SCHWELLE]   # startet detached, Default-Schwelle 25000
 #   gov-ctl.sh stop
 #   gov-ctl.sh status
 set -u
 DIR="$HOME/governor-p0"
 PIDF="$DIR/governor.pid"
 LOG="$DIR/governor.log"
 OUT="$DIR/governor.stdout"
 start() {
  stop
  local thr="${1:-25000}"
  cd "$DIR"
  : > "$LOG"
  # Voll detachen: eigene Session, alle FDs weg vom Aufrufer.
  # Hart-Deckel nur setzen, wenn explizit uebergeben (Arg 2); sonst rechnet
  # governor.py den Default (Soft + 5000). CPT-Default 3.5 (kalibriert 24.07.).
  local hardenv=()
  if [ -n "${2:-}" ]; then hardenv=(GOV_HARD_CEILING="$2"); fi
  setsid env GOV_THRESHOLD="$thr" "${hardenv[@]}" \
    GOV_CHARS_PER_TOKEN="${GOV_CHARS_PER_TOKEN:-3.5}" \
    GOV_LOG="$LOG" GOV_PORT=8100 \
    python3 "$DIR/governor.py" </dev/null >>"$OUT" 2>&1 &
  echo $! > "$PIDF"
  sleep 1.2
  echo "started pid=$(cat "$PIDF") threshold=$thr hard=${2:-auto}"
  ss -tlnp 2>/dev/null | grep ":8100" >/dev/null && echo "listening :8100 OK" || echo "WARN: not listening"
 }
 stop() {
  pkill -f "$DIR/governor.py" 2>/dev/null || true
  [ -f "$PIDF" ] && kill "$(cat "$PIDF")" 2>/dev/null || true
  sleep 0.6
  rm -f "$PIDF"
 }
 status() {
  if pgrep -f "$DIR/governor.py" >/dev/null; then
    echo "running pid=$(pgrep -f "$DIR/governor.py" | tr '\n' ' ')"
    ss -tlnp 2>/dev/null | grep ":8100" || true
  else
    echo "not running"
  fi
 }
 case "${1:-status}" in
  start) shift; start "${1:-25000}" "${2:-}" ;;
  stop) stop; echo stopped ;;
  status) status ;;
  *) echo "usage: gov-ctl.sh {start [soft] [hart]|stop|status}"; exit 2 ;;
 esac
@@ -1,568 +0,0 @@
 #!/usr/bin/env python3
 """Governor v2 — Token-Waechter-Proxy vor dem MC2-Gateway.
 Sitzt zwischen den Coding-Agenten (OpenCode/Zed, Nacht-Laeufe, Hermes-Worker) und dem
 MC2-Gateway (:9001). Reicht ALLES unveraendert durch — mit einer Ausnahme bei
 /v1/chat/completions: er bestimmt die Groesse der Anfrage (= Sitzungsgroesse, weil die
 ganze Historie jede Runde mitkommt) und handelt nach zwei Schwellen:
  est >= SOFT: haengt eine Stopp-Anweisung als letzte User-Nachricht an ("SAVEPOINT.md
      finalisieren + stoppen") und leitet weiter. Loggt FIRED.
  est >= HART: antwortet SELBST mit einer kurzen Stopp-Nachricht, OHNE das Modell zu
      fragen. Verhindert Fassaden jenseits der Grenze. Loggt HARDSTOP.
 --- Was v2 gegenueber v0.2 aendert (25.07.2026) ---------------------------------------
 1. EHRLICH ZAEHLEN. v0.2 zaehlte nur Text in `messages` und ignorierte `tools`/
   `tool_calls`. Bei werkzeugdichten Agenten lag es um Faktor 3 daneben (gemessen im
   eigenen Log: est=3353 exact=10224). v2 zaehlt den GANZEN Anfragekoerper — inklusive
   Werkzeug-Schemata, Werkzeug-Aufrufe und Werkzeug-Ergebnisse.
 2. SELBST-KALIBRIERUNG. Aus jeder Antwort liest der Governor die echten
   `usage.prompt_tokens` und korrigiert damit sein Zeichen-pro-Token-Verhaeltnis —
   pro Modell, gleitend. Die Schaetzung wird also im Betrieb immer genauer, statt auf
   einem einmal geratenen Wert festzuhaengen.
 3. TOOL-CALL-SICHERER EINSCHUB. Der Soft-Einschub wird NUR angehaengt, wenn die
   Nachrichtenkette das erlaubt (letzte Nachricht ist nicht ein Assistant mit offenen
   tool_calls und keine tool-Antwort). Sonst wartet er auf die naechste Runde. Ohne
   diese Pruefung zerbricht der Einschub bei OpenCode die Werkzeug-Reihenfolge.
 4. STATUS-ENDPUNKT. GET /governor/status liefert Zaehlerstand, Kalibrierung und die
   letzten Laeufe als JSON — Datenquelle fuer die MC2-Oberflaeche, das OpenCode-Plugin
   und Lucys `loop_status`.
 Bewusst nur Standardbibliothek: kein pip, kein venv, laeuft mit System-python3.
 Bewusst ohne Datenbank: ein kleiner Ring im Speicher, mehr braucht es nicht.
 Konfiguration per Umgebungsvariablen (alle optional):
  GOV_PORT            Listen-Port                        (Default 8100)
  GOV_HOST            Listen-Adresse                     (Default 0.0.0.0)
  GOV_UPSTREAM        Ziel                               (Default http://127.0.0.1:9001)
  GOV_THRESHOLD       Soft-Schwelle fuer den Einschub    (Default 45000)
  GOV_HARD_CEILING    Hart-Deckel; 0 = aus               (Default: Soft+5000, AN)
  GOV_CHARS_PER_TOKEN Startwert Zeichen->Token           (Default 3.2, danach gelernt)
  GOV_CALIBRATE       Selbst-Kalibrierung an/aus         (Default 1)
  GOV_LOG             Logdatei (zusaetzlich zu stdout)   (Default ./governor.log)
  GOV_DIRECTIVE       Text des Soft-Einschubs
  GOV_HARDSTOP_MSG    Text der Hart-Stopp-Antwort
  GOV_ANNOUNCE_URL    Lucy-Sprach-Signal; "" = aus       (Default :9001/api/voice/announce)
  GOV_ANNOUNCE_THROTTLE  Sekunden zwischen Signalen      (Default 300)
  GOV_ANNOUNCE_TEXT   Text des Sprach-Signals
  GOV_EXEMPT_MODELS   Modelle ohne Schnitt, kommasepariert (Default: hermes,fast,embed,
                      reranker,vision,scout — Lucys Alltag wird nie unterbrochen)
 """
 import http.client
 import json
 import os
 import re
 import threading
 import time
 from collections import deque
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import urlparse
 # ---- Konfiguration ---------------------------------------------------------
 PORT = int(os.environ.get("GOV_PORT", "8100"))
 HOST = os.environ.get("GOV_HOST", "0.0.0.0")
 # Ziel ist das MC2-Gateway, NICHT llama-swap direkt: so bleiben MC2s Rollen-Aliase,
 # Bild-Weiche und Telemetrie erhalten. Der Governor ist eine Schicht davor, kein Ersatz.
 UPSTREAM = os.environ.get("GOV_UPSTREAM", "http://127.0.0.1:9001")
 THRESHOLD = int(os.environ.get("GOV_THRESHOLD", "45000"))
 _hard_env = os.environ.get("GOV_HARD_CEILING")
 HARD_CEILING = (THRESHOLD + 5000) if _hard_env is None else int(_hard_env)
 CHARS_PER_TOKEN = float(os.environ.get("GOV_CHARS_PER_TOKEN", "3.2"))
 CALIBRATE = os.environ.get("GOV_CALIBRATE", "1") != "0"
 LOG_PATH = os.environ.get("GOV_LOG", os.path.join(os.getcwd(), "governor.log"))
 # Lucys Alltagsmodelle bekommen NIE einen Savepoint-Einschub: sie fuehren Gespraeche,
 # keine Bau-Sitzungen. Nur die Coding-Rollen laufen gegen die Schwelle.
 _DEFAULT_EXEMPT = "hermes,fast,embed,reranker,vision,scout"
 EXEMPT_MODELS = {m.strip().lower() for m in
                 os.environ.get("GOV_EXEMPT_MODELS", _DEFAULT_EXEMPT).split(",") if m.strip()}
 DEFAULT_DIRECTIVE = (
    "[GOVERNOR — SITZUNGS-LIMIT ERREICHT] Der Kontext dieser Sitzung ist auf ~{est} "
    "Tokens gewachsen (Limit {threshold}). Beginne oder setze JETZT KEINE weiteren "
    "Code-Aenderungen fort. Stattdessen, in dieser Reihenfolge:\n"
    "1. Aktualisiere SAVEPOINT.md so, dass es den aktuellen Stand vollstaendig festhaelt: "
    "was WIRKLICH erledigt ist (nur was im Code steht — nichts aus Absicht oder git-"
    "Nachrichten ableiten), der genaue naechste Schritt, offene Fragen und alle "
    "Stolpersteine — genug, dass eine frische Sitzung ohne jede Erinnerung allein aus "
    "SAVEPOINT.md plus git-Historie sauber weitermachen kann.\n"
    "2. Halte dann an und sage dem Nutzer in einem Satz, dass er eine frische Sitzung "
    "starten soll. Gib ausser der SAVEPOINT.md-Aktualisierung und diesem Hinweis nichts aus."
 )
 DIRECTIVE = os.environ.get("GOV_DIRECTIVE", DEFAULT_DIRECTIVE)
 DEFAULT_HARDSTOP = (
    "[GOVERNOR — HARTER STOPP] Das Sitzungs-Limit ist ueberschritten und der Savepoint "
    "sollte bereits finalisiert sein. Diese Sitzung nimmt keine weiteren Auftraege mehr an. "
    "Bitte starte eine FRISCHE Sitzung — sie liest SAVEPOINT.md und die git-Historie und "
    "macht sauber weiter. (Keine Code-Aenderung in dieser Antwort.)"
 )
 HARDSTOP_MSG = os.environ.get("GOV_HARDSTOP_MSG", DEFAULT_HARDSTOP)
 ANNOUNCE_URL = os.environ.get("GOV_ANNOUNCE_URL", "http://127.0.0.1:9001/api/voice/announce")
 ANNOUNCE_THROTTLE = float(os.environ.get("GOV_ANNOUNCE_THROTTLE", "300"))
 DEFAULT_ANNOUNCE = (
    "Commander, die Coding-Sitzung wird voll — ungefähr {est} Tokens. Ich sichere den "
    "Stand im Savepoint; am besten fangen wir gleich frisch an."
 )
 ANNOUNCE_TEXT = os.environ.get("GOV_ANNOUNCE_TEXT", DEFAULT_ANNOUNCE)
 up = urlparse(UPSTREAM)
 UP_HOST = up.hostname or "127.0.0.1"
 UP_PORT = up.port or 80
 HOP_BY_HOP = {
    "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
    "te", "trailers", "transfer-encoding", "upgrade",
 }
 _log_lock = threading.Lock()
 _PROMPT_TOKENS_RE = re.compile(r'"prompt_tokens"\s*:\s*(\d+)')
 _announce_lock = threading.Lock()
 _last_announce = 0.0
 _an = urlparse(ANNOUNCE_URL) if ANNOUNCE_URL else None
 # ---- Zustand (klein, im Speicher) ------------------------------------------
 # Kalibrierung je Modell: gleitender Mittelwert von zeichen/echte_tokens. Startwert ist
 # GOV_CHARS_PER_TOKEN; jede Antwort mit usage zieht ihn Richtung Wahrheit.
 _state_lock = threading.Lock()
 _cpt: dict = {}                       # modell -> gelerntes Zeichen-pro-Token
 _cpt_n: dict = {}                     # modell -> Anzahl Messungen
 _recent: deque = deque(maxlen=50)     # letzte Laeufe fuer /governor/status
 _counters = {"chat": 0, "soft": 0, "hard": 0, "passthrough": 0,
             "tokens_prompt": 0, "tokens_completion": 0, "started": time.time()}
 CPT_MIN, CPT_MAX = 0.8, 8.0           # Schutz gegen Ausreisser
 def log(line: str) -> None:
    """Eine Zeile nach stdout UND in die Logdatei (thread-sicher)."""
    stamp = time.strftime("%Y-%m-%dT%H:%M:%S")
    msg = f"{stamp} {line}"
    with _log_lock:
        print(msg, flush=True)
        try:
            with open(LOG_PATH, "a", encoding="utf-8") as fh:
                fh.write(msg + "\n")
        except OSError:
            pass
 def cpt_for(model: str) -> float:
    """Aktuelles Zeichen-pro-Token-Verhaeltnis fuer ein Modell (gelernt oder Startwert)."""
    with _state_lock:
        return _cpt.get(model, CHARS_PER_TOKEN)
 def calibrate(model: str, chars: int, exact: int) -> None:
    """Aus einer echten Antwort lernen. Gleitender Mittelwert mit sanftem Gewicht —
    ein einzelner Ausreisser (z. B. ein riesiges Bild) verbiegt nichts."""
    if not CALIBRATE or not exact or exact <= 0 or chars <= 0:
        return
    ratio = chars / exact
    if not (CPT_MIN <= ratio <= CPT_MAX):
        return
    with _state_lock:
        n = _cpt_n.get(model, 0)
        old = _cpt.get(model, CHARS_PER_TOKEN)
        # Gewicht faellt mit der Anzahl Messungen: schnell einschwingen, dann stabil.
        w = max(0.08, 1.0 / (n + 2))
        _cpt[model] = old * (1 - w) + ratio * w
        _cpt_n[model] = n + 1
 def body_chars(data: dict) -> int:
    """Zeichen des GESAMTEN Anfragekoerpers — der Kern der Ehrlichkeit.
    v0.2 zaehlte nur Text in `messages` und lag bei werkzeugdichten Agenten um Faktor 3
    daneben, weil Werkzeug-Schemata (`tools`), Werkzeug-Aufrufe (`tool_calls`) und
    Werkzeug-Ergebnisse mitgeschickt werden und im Kontext genauso Platz fressen.
    Wir serialisieren einfach alles, was ans Modell geht.
    """
    payload = {k: v for k, v in data.items()
               if k in ("messages", "tools", "tool_choice", "system", "functions")}
    try:
        return len(json.dumps(payload, ensure_ascii=False))
    except (TypeError, ValueError):
        # Fallback: nur Nachrichtentext (nie schlechter als v0.2)
        chars = 0
        for m in data.get("messages") or []:
            c = m.get("content") if isinstance(m, dict) else None
            if isinstance(c, str):
                chars += len(c) + 4
            elif isinstance(c, list):
                for p in c:
                    if isinstance(p, dict) and isinstance(p.get("text"), str):
                        chars += len(p["text"])
        return chars
 def safe_to_append(messages) -> bool:
    """Darf der Soft-Einschub JETZT als user-Nachricht ans Ende?
    Nein, wenn die Kette gerade mitten in einem Werkzeug-Austausch steckt: nach einem
    Assistant mit offenen `tool_calls` MUSS eine `tool`-Antwort folgen — schiebt man da
    eine user-Nachricht dazwischen, lehnt das Modell (bzw. das Template) die Anfrage ab
    oder halluziniert. Dann warten wir einfach auf die naechste Runde; die Schwelle ist
    ohnehin ueberschritten, es kommt in Sekunden ein neuer Zug.
    """
    if not isinstance(messages, list) or not messages:
        return False
    last = messages[-1]
    if not isinstance(last, dict):
        return False
    role = last.get("role")
    if role == "tool":
        return False
    return not (role == "assistant" and last.get("tool_calls"))
 def _post_announce(est) -> None:
    """POSTet die Meldung an die MC2-Announce-Pipeline (Lucy spricht sie)."""
    try:
        text = (ANNOUNCE_TEXT.replace("{est}", str(est))
                             .replace("{threshold}", str(THRESHOLD)))
        body = json.dumps({"text": text, "subject": "[Governor]",
                           "source": "governor", "priority": "normal"}).encode("utf-8")
        conn = http.client.HTTPConnection(_an.hostname or "127.0.0.1",
                                          _an.port or 80, timeout=4)
        conn.request("POST", _an.path or "/api/voice/announce", body=body,
                     headers={"Content-Type": "application/json",
                              "Content-Length": str(len(body))})
        resp = conn.getresponse()
        resp.read()
        conn.close()
        log(f"ANNOUNCE -> Lucy status={resp.status} est={est}")
    except Exception as exc:
        log(f"ANNOUNCE fehlgeschlagen: {exc!r}")
 def maybe_announce(est) -> None:
    """Sprach-Signal an Lucy — gedrosselt (eine Aeusserung je Episode)."""
    if not _an:
        return
    global _last_announce
    now = time.time()
    with _announce_lock:
        if now - _last_announce < ANNOUNCE_THROTTLE:
            return
        _last_announce = now
    threading.Thread(target=_post_announce, args=(est,), daemon=True).start()
 def status_payload() -> dict:
    """Momentaufnahme fuer /governor/status (MC2-Oberflaeche, Plugin, Lucy)."""
    with _state_lock:
        return {
            "ok": True,
            "upstream": UPSTREAM,
            "soft": THRESHOLD,
            "hard": HARD_CEILING if HARD_CEILING > 0 else None,
            "uptime_s": int(time.time() - _counters["started"]),
            "counters": {k: v for k, v in _counters.items() if k != "started"},
            "calibration": {m: {"chars_per_token": round(v, 3), "samples": _cpt_n.get(m, 0)}
                            for m, v in _cpt.items()},
            "calibration_default": CHARS_PER_TOKEN,
            "exempt_models": sorted(EXEMPT_MODELS),
            "recent": list(_recent),
        }
 class Handler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"
    server_version = "Governor/2.0"
    def log_message(self, *args):
        pass
    def do_GET(self):
        if self.path.split("?", 1)[0].rstrip("/") in ("/governor/status", "/governor"):
            self._send_json(200, status_payload())
            return
        self._proxy()
    def do_POST(self):
        self._proxy()
    def do_PUT(self):
        self._proxy()
    def do_DELETE(self):
        self._proxy()
    def do_OPTIONS(self):
        self._proxy()
    # -- Kern ---------------------------------------------------------------
    def _send_json(self, status: int, obj) -> None:
        try:
            data = json.dumps(obj).encode("utf-8")
            self.send_response(status)
            self.send_header("Content-Type", "application/json")
            self.send_header("Access-Control-Allow-Origin", "*")
            self.send_header("Content-Length", str(len(data)))
            self.send_header("Connection", "close")
            self.end_headers()
            self.wfile.write(data)
        except OSError:
            pass
    def _read_body(self) -> bytes:
        length = self.headers.get("Content-Length")
        if length is None:
            return b""
        try:
            return self.rfile.read(int(length))
        except (ValueError, OSError):
            return b""
    def _proxy(self) -> None:
        body = self._read_body()
        path = self.path
        clean_path = path.split("?", 1)[0]
        is_chat = clean_path.rstrip("/").endswith("/chat/completions")
        action = "passthrough"
        est = None
        streaming = False
        model = ""
        chars = 0
        if is_chat and body:
            action, body, est, streaming, model, chars = self._decide(body)
            if action in ("soft", "hard"):
                maybe_announce(est)
        if action == "hard":
            self._send_canned_stop(model, streaming, est)
            with _state_lock:
                _counters["chat"] += 1
                _counters["hard"] += 1
                _recent.appendleft({"t": int(time.time()), "model": model, "est": est,
                                    "exact": None, "action": "hard"})
            log(f"chat model={model} est={est} thr={THRESHOLD} hard={HARD_CEILING} "
                f"HARDSTOP stream={streaming} status=200")
            return
        out_headers = {}
        for k, v in self.headers.items():
            kl = k.lower()
            if kl in HOP_BY_HOP or kl in ("host", "content-length", "accept-encoding"):
                continue
            out_headers[k] = v
        out_headers["Host"] = f"{UP_HOST}:{UP_PORT}"
        out_headers["Accept-Encoding"] = "identity"
        if body:
            out_headers["Content-Length"] = str(len(body))
        out_headers["Connection"] = "close"
        conn = None
        try:
            conn = http.client.HTTPConnection(UP_HOST, UP_PORT, timeout=900)
            conn.request(self.command, path, body=body or None, headers=out_headers)
            resp = conn.getresponse()
        except (OSError, http.client.HTTPException) as exc:
            log(f"ERROR upstream {self.command} {path}: {exc!r}")
            if conn is not None:
                conn.close()
            self._safe_error(502, f"governor upstream: {exc}")
            return
        self.send_response(resp.status)
        for k, v in resp.getheaders():
            kl = k.lower()
            if kl in HOP_BY_HOP or kl in ("content-length", "date", "server"):
                continue
            self.send_header(k, v)
        self.send_header("Connection", "close")
        self.end_headers()
        tail = bytearray()
        try:
            while True:
                # read1() gibt jedes Upstream-Stueck sofort zurueck (echtes SSE-
                # Durchreichen); read() wuerde puffern und Streaming haengen lassen.
                chunk = resp.read1(65536)
                if not chunk:
                    break
                self.wfile.write(chunk)
                self.wfile.flush()
                tail.extend(chunk)
                if len(tail) > 16384:
                    del tail[:-16384]
        except OSError:
            pass
        finally:
            conn.close()
        exact = self._scan_prompt_tokens(tail)
        if is_chat:
            if exact:
                calibrate(model, chars, exact)
            with _state_lock:
                _counters["chat"] += 1
                _counters["soft" if action == "soft" else "passthrough"] += 1
                if exact:
                    _counters["tokens_prompt"] += exact
                _recent.appendleft({"t": int(time.time()), "model": model, "est": est,
                                    "exact": exact, "action": action})
            exact_s = str(exact) if exact is not None else "-"
            flag = "FIRED" if action == "soft" else ("skip" if action == "defer" else "ok")
            log(f"chat model={model} est={est} exact={exact_s} cpt={cpt_for(model):.2f} "
                f"thr={THRESHOLD} {flag} stream={streaming} status={resp.status}")
    def _decide(self, body: bytes):
        """Aktion bestimmen. Rueckgabe: (action, body, est, streaming, model, chars)."""
        try:
            data = json.loads(body)
        except (ValueError, UnicodeDecodeError):
            return "passthrough", body, None, False, "", 0
        if not isinstance(data, dict):
            return "passthrough", body, None, False, "", 0
        messages = data.get("messages")
        streaming = bool(data.get("stream"))
        model = (data.get("model") or "").strip()
        chars = body_chars(data)
        est = int(chars / max(cpt_for(model), 0.1))
        # Lucys Alltagsmodelle laufen nie gegen die Schwelle — ein Gespraech ist keine
        # Bau-Sitzung. Wir zaehlen sie trotzdem mit (Kalibrierung + Telemetrie).
        base = model.split("/")[-1].lower()
        if base in EXEMPT_MODELS:
            return "passthrough", body, est, streaming, model, chars
        if not isinstance(messages, list):
            return "passthrough", body, est, streaming, model, chars
        has_warned = False
        marker = "[GOVERNOR — SITZUNGS-LIMIT ERREICHT]"
        for m in reversed(messages):
            if m.get("role") == "user" and isinstance(m.get("content"), str) and marker in m["content"]:
                has_warned = True
                break
        is_safe = safe_to_append(messages)
        # 1. Absolutes Not-Aus bei komplettem Amoklauf
        if HARD_CEILING > 0 and est >= HARD_CEILING + 10000:
            return "hard", body, est, streaming, model, chars
        # 2. Sind wir am Limit?
        if est >= THRESHOLD:
            if not is_safe:
                # Agent arbeitet gerade an einer Tool-Kette. Auf keinen Fall abbrechen!
                return "defer", body, est, streaming, model, chars
            # Es ist sicher (Tool-Kette beendet oder Agent wartet auf Input).
            if HARD_CEILING > 0 and est >= HARD_CEILING:
                if has_warned:
                    # Wir haben ihn schon gewarnt, er macht trotzdem weiter -> harter Schnitt.
                    return "hard", body, est, streaming, model, chars
                else:
                    # Er hat wegen einer langen Tool-Kette direkt das Hard-Limit ueberschritten.
                    # Gib ihm trotzdem noch den einen Finalisier-Zug (Soft).
                    pass
            # Soft-Limit greift
            if not has_warned:
                directive = (DIRECTIVE.replace("{est}", str(est))
                                      .replace("{threshold}", str(THRESHOLD)))
                messages.append({"role": "user", "content": directive})
                data["messages"] = messages
                return "soft", json.dumps(data).encode("utf-8"), est, streaming, model, chars
        return "passthrough", body, est, streaming, model, chars
    def _send_canned_stop(self, model: str, streaming: bool, est) -> None:
        """OpenAI-kompatible Stopp-Antwort selbst erzeugen (kein Upstream-Call)."""
        created = int(time.time())
        usage = {"prompt_tokens": est or 0, "completion_tokens": 0,
                 "total_tokens": est or 0}
        try:
            if streaming:
                self.send_response(200)
                self.send_header("Content-Type", "text/event-stream")
                self.send_header("Cache-Control", "no-cache")
                self.send_header("Connection", "close")
                self.end_headers()
                def sse(obj):
                    self.wfile.write(b"data: " + json.dumps(obj).encode() + b"\n\n")
                    self.wfile.flush()
                base = {"id": "governor-hardstop", "object": "chat.completion.chunk",
                        "created": created, "model": model}
                sse({**base, "choices": [{"index": 0, "delta": {"role": "assistant"},
                                          "finish_reason": None}]})
                sse({**base, "choices": [{"index": 0, "delta": {"content": HARDSTOP_MSG},
                                          "finish_reason": None}]})
                sse({**base, "choices": [{"index": 0, "delta": {},
                                          "finish_reason": "stop"}], "usage": usage})
                self.wfile.write(b"data: [DONE]\n\n")
                self.wfile.flush()
            else:
                payload = {
                    "id": "governor-hardstop", "object": "chat.completion",
                    "created": created, "model": model,
                    "choices": [{"index": 0, "finish_reason": "stop",
                                 "message": {"role": "assistant", "content": HARDSTOP_MSG}}],
                    "usage": usage,
                }
                data = json.dumps(payload).encode("utf-8")
                self.send_response(200)
                self.send_header("Content-Type", "application/json")
                self.send_header("Content-Length", str(len(data)))
                self.send_header("Connection", "close")
                self.end_headers()
                self.wfile.write(data)
                self.wfile.flush()
        except OSError:
            pass
    def _safe_error(self, status: int, msg: str) -> None:
        self._send_json(status, {"error": msg})
    @staticmethod
    def _scan_prompt_tokens(tail: bytearray):
        if not tail:
            return None
        try:
            text = tail.decode("utf-8", errors="ignore")
        except Exception:
            return None
        matches = _PROMPT_TOKENS_RE.findall(text)
        if not matches:
            return None
        try:
            return int(matches[-1])
        except ValueError:
            return None
 def main() -> int:
    log_dir = os.path.dirname(LOG_PATH)
    if log_dir and not os.path.isdir(log_dir):
        try:
            os.makedirs(log_dir, exist_ok=True)
        except OSError:
            pass
    server = ThreadingHTTPServer((HOST, PORT), Handler)
    server.daemon_threads = True
    hard = HARD_CEILING if HARD_CEILING > 0 else "aus"
    log(f"Governor v2 startet auf {HOST}:{PORT} -> {UPSTREAM} | Soft={THRESHOLD} "
        f"Hart={hard} | CPT-Start={CHARS_PER_TOKEN} kalibrierend={CALIBRATE} | "
        f"ausgenommen={sorted(EXEMPT_MODELS)} | Log={LOG_PATH}")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        log("Governor beendet (SIGINT).")
    finally:
        server.server_close()
    return 0
 if __name__ == "__main__":
    raise SystemExit(main())
@@ -1,27 +0,0 @@
 [Unit]
 # Governor v2 — Token-Waechter vor dem MC2-Gateway.
 # Nutzer-Dienst (systemctl --user), weil er unter hitonabi laeuft und keine
 # Root-Rechte braucht. Startet nach MC2, weil er dorthin weiterreicht.
 Description=Governor v2 — Token-Waechter-Proxy (:8100 -> MC2 :9001)
 After=network-online.target mission-control-2.service
 Wants=network-online.target
 [Service]
 Type=simple
 WorkingDirectory=%h/governor
 ExecStart=/usr/bin/python3 %h/governor/governor.py
 Restart=always
 RestartSec=3
 # --- Schwellen -------------------------------------------------------------
 # Soft 45k: OpenCode startet mit ~10-15k allein fuer Systemprompt + Werkzeug-
 # Schemata; 25k (der alte Aider-Wert) haette schon nach wenigen Zuegen gefeuert.
 # Hart = Soft+5000 (ein Finalisier-Zug Luft), Default des Programms.
 Environment=GOV_THRESHOLD=45000
 Environment=GOV_UPSTREAM=http://127.0.0.1:9001
 Environment=GOV_LOG=%h/governor/governor.log
 # Lucys Alltagsmodelle laufen nie gegen die Schwelle — ein Gespraech ist kein Bau.
 Environment=GOV_EXEMPT_MODELS=hermes,fast,embed,reranker,vision,scout
 [Install]
 WantedBy=default.target
@@ -1,29 +0,0 @@
 #!/usr/bin/env bash
 # hardstop-test.sh — prueft die drei Governor-Pfade mit direkten curls:
 #   klein  -> passthrough (Modell antwortet normal)
 #   mittel -> soft-Einschub (Modell bekommt die Stopp-Anweisung, antwortet)
 #   gross  -> HART-STOPP (Governor antwortet selbst, KEIN Modell-Call)
 set -u
 GOV="http://127.0.0.1:8100/v1/chat/completions"
 python3 - <<'PY' > /tmp/gov_small.json
 import json
 print(json.dumps({"model":"Qwen3-Coder-Next","messages":[{"role":"user","content":"Reply with exactly: SMALL"}],"max_tokens":8,"stream":False}))
 PY
 python3 - <<'PY' > /tmp/gov_mid.json
 import json
 print(json.dumps({"model":"Qwen3-Coder-Next","messages":[{"role":"user","content":"BEGIN "+"lorem ipsum "*2500+" END"}],"max_tokens":40,"stream":False}))
 PY
 python3 - <<'PY' > /tmp/gov_big.json
 import json
 print(json.dumps({"model":"Qwen3-Coder-Next","messages":[{"role":"user","content":"x"*40000}],"max_tokens":16,"stream":False}))
 PY
 echo "=== TEST A: klein (passthrough) ==="
 curl -s -m 60 "$GOV" -H "Content-Type: application/json" --data @/tmp/gov_small.json | jq -r '.choices[0].message.content'
 echo "=== TEST B: mittel ~30k Zeichen (soft-Einschub, geht ans Modell) ==="
 curl -s -m 120 "$GOV" -H "Content-Type: application/json" --data @/tmp/gov_mid.json | jq '{id, content: (.choices[0].message.content|.[0:80])}'
 echo "=== TEST C: gross ~40k Zeichen (HART-STOPP, kein Modell-Call) ==="
 curl -s -m 30 "$GOV" -H "Content-Type: application/json" --data @/tmp/gov_big.json | jq '{id, finish: .choices[0].finish_reason, content: (.choices[0].message.content|.[0:70]), usage}'
@@ -1,13 +0,0 @@
 # Wegwerf-Aufgabe: kleine Todo-App, schrittweise. Jede Zeile = eine Runde.
 Create todo.py with a TodoList class: add(text) appends a dict {"text": text, "done": False} to an internal list, and items() returns that list. Then update SAVEPOINT.md following our conventions.
 Add complete(index) and remove(index) to TodoList, each with a bounds check that raises IndexError with a clear message when the index is out of range. Update SAVEPOINT.md.
 Add save(path) and load(path) to TodoList that persist the items to and from a JSON file. Update SAVEPOINT.md.
 Add pending_count() and completed_count() methods to TodoList. Update SAVEPOINT.md.
 Create cli.py with an argparse command line interface exposing subcommands add, list, done, and rm that operate on a todos.json file via TodoList. Update SAVEPOINT.md.
 Add a clear subcommand to cli.py that removes all completed items from todos.json. Update SAVEPOINT.md.
 Create test_todo.py with unittest tests covering add, complete, remove, save, load, and the IndexError bounds checks. Update SAVEPOINT.md.
 Add tests for pending_count and completed_count to test_todo.py. Update SAVEPOINT.md.
 Create README.md documenting the CLI usage with a short example for each subcommand. Update SAVEPOINT.md.
 Add type hints throughout todo.py and cli.py. Update SAVEPOINT.md.
 Add an optional due date field (ISO date string) to each item and a due argument to TodoList.add and to the CLI add subcommand. Update SAVEPOINT.md.
 Add an overdue subcommand to cli.py that lists items whose due date is before today. Update SAVEPOINT.md.
@@ -1,19 +0,0 @@
 #!/usr/bin/env bash
 # run-aider-msg.sh <repo> <message> — EINE Aider-Runde via --message (sauberer,
 # unterstuetzter Einzel-Schuss ohne Scripting-Reflexions-Haenger), durch den Governor.
 # todo.py/cli.py als Lesekontext, damit das Modell die echte API sieht (kein Erfinden)
 # und keine "Datei hinzufuegen?"-Reflexion ausloest.
 set -u
 REPO="${1:?repo dir}"
 MSG="${2:?message}"
 export PATH="$HOME/.local/bin:$PATH"
 export OPENAI_API_BASE="http://127.0.0.1:8100/v1"
 export OPENAI_API_KEY="dummy"
 cd "$REPO"
 aider \
  --model openai/Qwen3-Coder-Next \
  --no-check-update --no-show-model-warnings --no-analytics --yes-always \
  --map-tokens 512 \
  --read CONVENTIONS.md --read todo.py --read cli.py \
  SAVEPOINT.md \
  --message "$MSG"
@@ -1,20 +0,0 @@
 #!/usr/bin/env bash
 # run-aider.sh <messages-file> — treibt EINE Aider-Sitzung durch den Governor.
 # Jede Zeile der Nachrichtendatei = eine User-Runde; die Historie akkumuliert,
 # sodass die Anfrage jede Runde wächst (genau das prüft der Governor).
 set -u
 MSGS="${1:?Nachrichtendatei angeben}"
 export PATH="$HOME/.local/bin:$PATH"
 export OPENAI_API_BASE="http://127.0.0.1:8100/v1"
 export OPENAI_API_KEY="dummy"
 cd "$HOME/governor-p0/testrepo"
 aider \
  --model openai/Qwen3-Coder-Next \
  --no-check-update \
  --no-show-model-warnings \
  --no-analytics \
  --yes-always \
  --map-tokens 512 \
  --read CONVENTIONS.md \
  SAVEPOINT.md \
  < "$MSGS"
@@ -1,8 +0,0 @@
 #!/usr/bin/env bash
 # run-driver.sh <messages-file> — Aider-Scripting-Sitzung durch den Governor.
 set -u
 MSGS="${1:?Nachrichtendatei angeben}"
 REPO="${2:-$HOME/governor-p0/testrepo}"
 VENV_PY="$HOME/.local/share/uv/tools/aider-chat/bin/python"
 cd "$REPO"
 exec "$VENV_PY" "$HOME/governor-p0/driver.py" "$MSGS"
@@ -1,21 +0,0 @@
 [Unit]
 Description=Hermes Built-in Web UI (`hermes serve` — Agent-Dashboard/Chat, Loopback only)
 After=network-online.target
 Wants=network-online.target
 [Service]
 # Serviert die EINGEBAUTE Hermes-Web-GUI (die reiche Agent-Oberflaeche mit Threads/Tool-Calls, die
 # auch die Electron-Desktop-App umhuellt) headless.
 # SICHERHEIT: Bindet NUR an Loopback (127.0.0.1:9119) und laeuft hinter dem MC2-Reverse-Proxy
 # (routers/hermes_ui.py → same-origin /hermes-ui/ auf dem offenen Port 9001) — KEINE eigene
 # Firewall-Freigabe, KEIN Login (LAN-Trust wie Konsole/Terminal). --skip-build nutzt das von
 # deploy.sh mit Vite-base=/hermes-ui/ vorgebaute web_dist, damit alle SPA-Pfade unter /hermes-ui/
 # liegen und der Proxy sie sauber durchreichen kann.
 Type=simple
 Environment=HERMES_HOME=%h/.hermes
 ExecStart=%h/.hermes/hermes-agent/venv/bin/hermes dashboard --no-open --skip-build --host 127.0.0.1 --port 9119
 Restart=on-failure
 RestartSec=3
 [Install]
 WantedBy=default.target
@@ -1,259 +0,0 @@
 #!/usr/bin/env python3
 """Hermes-Runtime-Patch-Traeger — haelt MC2-eigene Fixes im Hermes-Quellcode
 (``~/.hermes/hermes-agent``), damit sie ein ``hermes update`` ueberleben.
 Warum: Der Hermes-Agent wird aus git aktualisiert; ein Direkt-Edit der Laufzeit
 wuerde beim naechsten Update still ueberschrieben. Dieses Skript wird von
 ``deploy/deploy.sh`` UND ``deploy/hermes-postcheck.sh`` aufgerufen und traegt die
 Patches (re-)ein.
 Mechanik: JEDER Patch ist eine idempotente String-Ersetzung (robust gegen
 Zeilenverschiebungen durch Updates, anders als ``git apply``):
  * ``marker`` schon im Quelltext  -> Patch bereits drin, ueberspringen.
  * ``old`` genau 1x vorhanden      -> ersetzen, dann ``py_compile`` pruefen.
  * ``old`` 0x oder >1x             -> Kontext hat sich durch ein Update
                                       geaendert -> LAUT scheitern (Exit 1), damit
                                       der Postcheck rot wird und niemand denkt,
                                       der Fix sei noch aktiv.
 Bei Fehlschlag: Exit 1 (der Deploy/Postcheck behandelt das als Fehler).
 """
 import os
 import py_compile
 import shutil
 import sys
 from pathlib import Path
 HA = Path(os.environ.get("HERMES_AGENT_DIR", str(Path.home() / ".hermes" / "hermes-agent")))
 HERE = Path(__file__).resolve().parent
 # --- Zusatzmodule, die in die Hermes-Laufzeit kopiert werden (update-fest) ---
 # (source relativ zu diesem Skript, dest relativ zum Hermes-Agent-Dir)
 COPIES = [
    ("mc2_kanban_reaper.py", "hermes_cli/mc2_kanban_reaper.py"),
 ]
 # --- Patch-Definitionen (chronologisch, Fan-out-/Muenz-Schleifen-Fixes 20.07.2026) ---
 PATCHES = [
    {
        "name": "0001-needs-input-wait",
        "file": "hermes_cli/kanban_db.py",
        "marker": 'kind not in ("needs_input", "capability")',
        "old": "        if recurrences >= BLOCK_RECURRENCE_LIMIT:\n",
        "new": (
            "        # MC2-Patch (20.07.2026): needs_input/capability sind genuin\n"
            "        # human-only — sie muessen in ``blocked`` auf den Commander warten\n"
            "        # (Antwort via Auftragsbuch), NICHT nach triage eskalieren. Sonst\n"
            "        # zerlegt der Auto-Decomposer sie neu = Duplikat-Karten-Schleife\n"
            '        # ("Muenz-Schleife", Fan-out-Vorfall 20.07.). Der Loop-Breaker bleibt\n'
            "        # fuer transient/untyped Blocks aktiv.\n"
            '        if recurrences >= BLOCK_RECURRENCE_LIMIT and kind not in ("needs_input", "capability"):\n'
        ),
    },
    {
        "name": "0002-decompose-at-readiness",
        "file": "hermes_cli/kanban_decompose.py",
        "marker": "Startreife-Gate",
        "old": (
            "    cfg = _load_config()\n"
            "    orchestrator = _resolve_orchestrator_profile(cfg)\n"
        ),
        "new": (
            "    # MC2-Patch (20.07.2026): Startreife-Gate. Eine triage-Karte mit noch\n"
            "    # OFFENEN Vorgaengern NICHT zerlegen — sonst raet der Decomposer die\n"
            "    # Schnittstellen der Vor-Etappe ins Blaue, bevor die gebaut hat\n"
            "    # (Fan-out-Vorfall 20.07.). Billiger Parent-Check VOR dem teuren\n"
            "    # LLM-Aufruf; erst zerlegen, wenn alle Eltern done/archived.\n"
            "    with kb.connect_closing() as _pconn:\n"
            "        _parents = [r[0] for r in _pconn.execute(\n"
            '            "SELECT parent_id FROM task_links WHERE child_id = ?", (task_id,))]\n'
            "        if _parents:\n"
            '            _ph = ",".join("?" * len(_parents))\n'
            "            _open = _pconn.execute(\n"
            '                "SELECT COUNT(*) FROM tasks WHERE id IN (%s) "\n'
            "                \"AND status NOT IN ('done', 'archived')\" % _ph, _parents\n"
            "            ).fetchone()[0]\n"
            "            if _open:\n"
            "                return DecomposeOutcome(\n"
            "                    task_id, False,\n"
            '                    f"defer: {_open} unfinished parent(s) — decompose when start-ready",\n'
            "                )\n"
            "    cfg = _load_config()\n"
            "    orchestrator = _resolve_orchestrator_profile(cfg)\n"
        ),
    },
    {
        "name": "0003-orphan-guard",
        "file": "gateway/kanban_watchers.py",
        "marker": "mc2_kanban_reaper",
        "old": (
            "                pids = await asyncio.to_thread(_kb.reap_worker_zombies)\n"
            "                if pids:\n"
            "                    logger.info(\n"
            '                        "kanban dispatcher: reaped %d zombie worker(s), pids=%s",\n'
            "                        len(pids),\n"
            "                        pids,\n"
            "                    )\n"
        ),
        "new": (
            "                pids = await asyncio.to_thread(_kb.reap_worker_zombies)\n"
            "                if pids:\n"
            "                    logger.info(\n"
            '                        "kanban dispatcher: reaped %d zombie worker(s), pids=%s",\n'
            "                        len(pids),\n"
            "                        pids,\n"
            "                    )\n"
            "                # MC2-Patch (20.07.2026): Orphan-Guard. Beende lebende\n"
            "                # Worker, deren Task nicht mehr 'running' ist (extern\n"
            "                # blockiert/reset) — sonst unterlaufen sie max_in_progress\n"
            "                # und verbrennen Rechenzeit.\n"
            "                try:\n"
            "                    from hermes_cli import mc2_kanban_reaper as _mc2reaper\n"
            "                    _orph = await asyncio.to_thread(\n"
            "                        _mc2reaper.reap_orphaned_workers, _kb.connect_closing\n"
            "                    )\n"
            "                    if _orph:\n"
            "                        logger.info(\n"
            '                            "kanban dispatcher: reaped %d orphaned worker(s): %s",\n'
            "                            len(_orph), _orph,\n"
            "                        )\n"
            "                except Exception:\n"
            '                    logger.exception("kanban dispatcher: orphan reaper failed")\n'
        ),
    },
    {
        "name": "0004a-context-inherit-compute",
        "file": "hermes_cli/kanban_decompose.py",
        "marker": '_parent_ctx = ""',
        "old": (
            "    children: list[dict] = []\n"
            "    for idx, entry in enumerate(raw_tasks):\n"
        ),
        "new": (
            "    children: list[dict] = []\n"
            "    # MC2-Patch (20.07.2026): Projekt-/Repo-Kontext vererben. Der Parent-Body\n"
            '    # traegt oft harte Randbedingungen (Ziel-Repo, Tabus, "eigenes Projekt"),\n'
            "    # die bei der Zerlegung sonst verloren gehen (Worker klonte das falsche\n"
            "    # Repo, Fan-out-Vorfall 20.07.). Jeder Kind-Body bekommt den voran.\n"
            '    _parent_ctx = ""\n'
            '    if getattr(task, "body", None) and task.body.strip():\n'
            "        _parent_ctx = (\n"
            '            "## PROJEKT-KONTEXT (von der uebergeordneten Aufgabe — gilt fuer dich)\\n"\n'
            "            + task.body.strip()[:1500]\n"
            '            + "\\n\\n## DEIN TEILAUFTRAG\\n"\n'
            "        )\n"
            "    for idx, entry in enumerate(raw_tasks):\n"
        ),
    },
    {
        "name": "0004b-context-inherit-apply",
        "file": "hermes_cli/kanban_decompose.py",
        "marker": "_parent_ctx + body",
        "old": (
            '        body = entry.get("body")\n'
            "        if not isinstance(body, str):\n"
            '            body = ""\n'
        ),
        "new": (
            '        body = entry.get("body")\n'
            "        if not isinstance(body, str):\n"
            '            body = ""\n'
            "        body = _parent_ctx + body  # MC2 (20.07.): Projekt-Kontext vererben\n"
        ),
    },
    {
        "name": "0005-create-chain-guard",
        "file": "tools/kanban_tools.py",
        "marker": "_MC2_RECENT_ROOTS",
        "old": (
            "            new_task = kb.get_task(conn, new_tid)\n"
            "            subscribed = _maybe_auto_subscribe(conn, new_tid)\n"
        ),
        "new": (
            "            # MC2-Patch (20.07.2026): Etappen-Auto-Kette. Legt dieselbe\n"
            "            # Session mehrere ROOT-triage-Karten (ohne parents) im selben\n"
            "            # 120s-Fenster an, verkette sie — so greift das Startreife-Gate\n"
            "            # (Karte 2 wartet auf Karte 1) statt alle sofort zu zerlegen\n"
            "            # (Fan-out 20.07.). Unter max_in_progress:1 ist eine Fehl-\n"
            "            # Verkettung harmlos (laeuft eh seriell).\n"
            "            try:\n"
            "                if triage and not parents and session_id:\n"
            "                    import time as _mc2t\n"
            '                    _roots = globals().setdefault("_MC2_RECENT_ROOTS", {})\n'
            "                    _prev = _roots.get(session_id)\n"
            "                    _now = _mc2t.monotonic()\n"
            "                    if _prev and (_now - _prev[1]) <= 120 and _prev[0] != new_tid:\n"
            "                        try:\n"
            "                            kb.link_tasks(conn, _prev[0], new_tid)\n"
            "                        except Exception:\n"
            "                            pass\n"
            "                    _roots[session_id] = (new_tid, _now)\n"
            "                    if len(_roots) > 64:\n"
            "                        _roots.clear()\n"
            "            except Exception:\n"
            "                pass\n"
            "            new_task = kb.get_task(conn, new_tid)\n"
            "            subscribed = _maybe_auto_subscribe(conn, new_tid)\n"
        ),
    },
 ]
 def main() -> int:
    if not HA.is_dir():
        print(f"hermes-patches: Hermes-Agent-Dir fehlt ({HA}) — nichts zu tun.")
        return 0
    applied, skipped, failed = [], [], []
    # --- Zusatzmodule kopieren (idempotent: nur wenn Inhalt abweicht) ---
    for src_rel, dst_rel in COPIES:
        src, dst = HERE / src_rel, HA / dst_rel
        if not src.is_file():
            failed.append((src_rel, f"Quelle fehlt: {src}"))
            continue
        try:
            same = dst.is_file() and dst.read_bytes() == src.read_bytes()
            if same:
                skipped.append(f"copy:{dst_rel}")
                continue
            dst.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(src, dst)
            if dst.suffix == ".py":
                py_compile.compile(str(dst), doraise=True)
            applied.append(f"copy:{dst_rel}")
        except Exception as exc:
            failed.append((src_rel, f"Kopie/Compile fehlgeschlagen: {exc}"))
    for p in PATCHES:
        f = HA / p["file"]
        if not f.is_file():
            failed.append((p["name"], f"Datei fehlt: {f}"))
            continue
        src = f.read_text(encoding="utf-8")
        if p["marker"] in src:
            skipped.append(p["name"])
            continue
        n = src.count(p["old"])
        if n != 1:
            failed.append((p["name"], (f"erwartete 1 Vorkommen von old, fand {n} "
                                       "(Update hat den Kontext geaendert?)")))
            continue
        f.write_text(src.replace(p["old"], p["new"]), encoding="utf-8")
        try:
            py_compile.compile(str(f), doraise=True)
        except Exception as exc:
            failed.append((p["name"], f"py_compile fehlgeschlagen: {exc}"))
            continue
        applied.append(p["name"])
    print(f"hermes-patches: applied={applied} skipped={skipped} failed={[n for n, _ in failed]}")
    for name, why in failed:
        print(f"  FEHLER {name}: {why}", file=sys.stderr)
    if failed:
        return 1        # Fehler → Deploy/Postcheck rot
    if applied:
        return 10       # etwas geaendert → Aufrufer sollte hermes-gateway neu starten
    return 0            # nichts zu tun (alles schon drin)
 if __name__ == "__main__":
    sys.exit(main())
@@ -1,84 +0,0 @@
 """MC2-Zusatzmodul (20.07.2026) — Orphan-Reaper für Kanban-Worker.
 Wird vom Patch-Träger (``deploy/hermes-patches/apply.py``) nach
 ``~/.hermes/hermes-agent/hermes_cli/`` kopiert und vom Gateway-Dispatcher
 (``gateway/kanban_watchers.py``, per Patch 0003) jeden Tick aufgerufen.
 Problem: Wird eine ``running``-Karte von außen blockiert/zurückgesetzt (z. B.
 über das Auftragsbuch oder die No-Progress-Bremse), setzt ``block_task``
 ``worker_pid = NULL`` — der Worker-PROZESS läuft aber weiter. Die DB zählt ihn
 nicht mehr, also unterläuft der Orphan ``kanban.max_in_progress`` (Doppel-Worker
 möglich) und verbrennt Rechenzeit. Dieser Reaper beendet lebende Worker, deren
 Task nicht mehr ``running`` ist.
 Linux-only (/proc-Scan). Best-effort: jeder Fehler → leere Liste, nie werfen.
 """
 from __future__ import annotations
 import os
 import re
 import signal
 import sys
 _TASK_RE = re.compile(rb"work kanban task (t_[0-9a-fA-F]+)")
 def reap_orphaned_workers(connect_closing) -> list[tuple[int, str]]:
    """Beende lebende Kanban-Worker, deren Task nicht mehr ``running`` ist.
    ``connect_closing`` ist die gleichnamige Kontextmanager-Factory aus
    ``kanban_db`` (durchgereicht, um Import-Zyklen zu vermeiden). Gibt die Liste
    der beendeten ``(pid, task_id)`` zurück.
    """
    if sys.platform != "linux":
        return []
    candidates: dict[int, str] = {}
    try:
        entries = os.listdir("/proc")
    except OSError:
        return []
    for entry in entries:
        if not entry.isdigit():
            continue
        try:
            with open(f"/proc/{entry}/cmdline", "rb") as fh:
                cmd = fh.read().replace(b"\x00", b" ")
        except OSError:
            continue
        m = _TASK_RE.search(cmd)
        if m:
            candidates[int(entry)] = m.group(1).decode()
    if not candidates:
        return []
    task_ids = list(set(candidates.values()))
    placeholders = ",".join("?" * len(task_ids))
    running: set[str] = set()
    try:
        with connect_closing() as conn:
            running = {
                row[0]
                for row in conn.execute(
                    f"SELECT id FROM tasks WHERE id IN ({placeholders}) "
                    "AND status = 'running'",
                    task_ids,
                )
            }
    except Exception:
        return []
    killed: list[tuple[int, str]] = []
    for pid, task_id in candidates.items():
        if task_id in running:
            continue
        # Prozessgruppe zuerst (Worker starten start_new_session=True → eigene
        # Gruppe; killpg räumt selbst gestartete Kinder wie uvicorn gleich mit).
        try:
            os.killpg(os.getpgid(pid), signal.SIGTERM)
        except OSError:
            try:
                os.kill(pid, signal.SIGTERM)
            except OSError:
                continue
        killed.append((pid, task_id))
    return killed
@@ -1,35 +1,22 @@
 #!/usr/bin/env bash
-# Post-Update-Check nach einem Hermes-Agent-Update: läuft unser geteiltes „Gehirn"
+# Post-Update-Check nach einem Hermes-Agent-Update: laeuft unser "Gehirn" noch?
-# (Mem0 + die mc2-memory-Integration) noch? Exit 0 = alles ok, sonst 1 → der Job wird
+# Exit 0 = alles ok, sonst 1 -> der Job wird im UI rot, damit ein kaputtes Gehirn auffaellt.
-# im UI rot, damit ein kaputtes Gehirn sofort auffällt.
+#
 # WICHTIG (27.08.2026) - VIER TOTE CHECKS ENTFERNT: bis hierher prueften die ersten Bloecke
 # den abgeloesten Gedaechtnis-Sidecar (:8765), MC2s /api/memory und das zugehoerige
 # Hermes-Plugin. Alle drei fielen am 07.08. weg (docs/wissen/VERDIKTE.md) - die Checks KONNTEN nicht
 # mehr gruen werden. Folge: jedes Hermes-Update endete rot und wurde von autoupdate.sh
 # zurueckgerollt. Kein Ersatz-Check auf Hermes native Gedaechtnis, weil es dafuer keinen
 # nachgemessenen Endpunkt gibt - geraten waere eine Fassade. Der Tool-Smoke weiter unten
 # laeuft ohnehin durch den ECHTEN Agenten und faengt ein kaputtes Gehirn.
 set -uo pipefail
 MC_URL="${MC_URL:-http://127.0.0.1:9001}"
 MEM0_URL="${MEM0_SERVICE_URL:-http://127.0.0.1:8765}"
 HERMES="${HERMES_HOME:-$HOME/.hermes}"
 fail=0
 echo "=== Hermes Post-Update: Gehirn-Check ==="
 if curl -sf -m 5 "$MEM0_URL/health" >/dev/null 2>&1; then
  echo "PASS · Mem0-Sidecar erreichbar"
 else
  echo "FAIL · Mem0-Sidecar NICHT erreichbar"; fail=1
 fi
 if curl -sf -m 8 "$MC_URL/api/memory" >/dev/null 2>&1; then
  echo "PASS · /api/memory antwortet"
 else
  echo "FAIL · /api/memory antwortet nicht"; fail=1
 fi
 if grep -qE "^[[:space:]]*provider:[[:space:]]*'?mc2-memory'?" "$HERMES/config.yaml" 2>/dev/null \
   && grep -qE "memory_enabled:[[:space:]]*true" "$HERMES/config.yaml" 2>/dev/null; then
  echo "PASS · memory.provider=mc2-memory aktiv"
 else
  echo "FAIL · memory.provider nicht mehr gesetzt (Config vom Update überschrieben?)"; fail=1
 fi
 # --- Hermes-Runtime-Patch-Traeger (20.07.2026): ein Update setzt den Quellbaum ---
 # --- zurueck → unsere Fixes (needs_input-wartet, Startreife-Gate, Orphan-Guard,  ---
 # --- Kontext-Vererbung, Etappen-Kette) hier RE-eintragen. Exit 10 = etwas neu     ---
@@ -46,15 +33,11 @@ if [ -f "$PATCH_APPLY" ]; then
    echo "FAIL · Hermes-Runtime-Patches: ein Patch passt nicht mehr zum aktualisierten Quellcode — pruefen"; fail=1
  fi
 else
-  echo "WARN · hermes-patches/apply.py nicht gefunden ($PATCH_APPLY)"
+  # Kein Fehler: Der Patch-Traeger wurde mit dem MC2-Kahlschlag (1e68f62) entfernt. Seine
-fi
+  # Fixes zielten auf einen Hermes-Stand, der inzwischen tausende Commits zurueckliegt —
-
+  # sie wuerden auf dem heutigen Quellcode ohnehin nicht mehr greifen. WARN statt FAIL, damit
-if ( cd "$HERMES/hermes-agent" && HERMES_HOME="$HERMES" ./venv/bin/python -c \
+  # es sichtbar bleibt, falls jemand wieder Runtime-Patches braucht.
-     "import sys; sys.path.insert(0,'.'); from plugins.memory import load_memory_provider; p=load_memory_provider('mc2-memory'); assert p and p.name()=='mc2-memory'" \
+  echo "WARN · hermes-patches/apply.py nicht vorhanden (mit 1e68f62 bewusst entfernt) — uebersprungen"
     >/dev/null 2>&1 ); then
  echo "PASS · mc2-memory-Plugin lädt unter dem neuen Hermes"
 else
  echo "FAIL · mc2-memory-Plugin lädt nicht (MemoryProvider-ABC geändert?)"; fail=1
 fi
 # --- Config-Drift-Wächter (Lehre aus v0.18, 02.07.2026): Hermes fällt bei unbekannten ---
@@ -1,223 +0,0 @@
 #!/usr/bin/env bash
 # Hermes-Release-Radar (woechentlich, Mo 05:15) — "mehr Hermes nativ, weniger Eigenkreationen":
 # haelt neue hermes-agent-Releases gegen die Eigenbau-Landkarte im Wissens-Vault und meldet
 # NUR echte Treffer auf Abloese-Kriterien/Wiedervorlage-Bedingungen. Muster wie
 # chef-gutachter-feed.sh: liegt in ~/.hermes/scripts/ (deploy.sh kopiert ihn), stdout wird
 # dem Cron-Agenten als Prompt eingespeist. Der ABGLEICH laeuft als Ein-Schuss-Completion
 # direkt gegen llama-swap (:8080, fremdblick-Architektur): Analyst gpt-oss-120b (um 05:15
 # vom Chef-Gutachter 04:30 oft noch geladen), Vertretung GLM-4.7-Flash. Danach gatet
 # fremdblick.sh (Prosa-Raster, Fremd-Vendor) jede Treffer-Behauptung gegen die
 # Original-Changelogs.
 # Grundsaetze (stehen auch in der Landkarte): nur getaggte Releases (kein main-Churn bei
 # ~660 PRs/Woche) · Behauptung nur mit woertlichem Changelog-Zitat · Treffer => Probe-
 # Vorschlag, NIE Direkt-Adoption · der Radar informiert, er updatet nicht (Entscheid 04.07.).
 # State: ~/.hermes/state/release-radar-last.txt (zuletzt gemeldeter Tag). Verlust harmlos —
 # ohne State dient die installierte Version als Basis.
 set -uo pipefail
 MC="$HOME/mission-control-v2"
 LANDKARTE="$HOME/wissens-vault/eigenbau-landkarte.md"
 STATE_DIR="$HOME/.hermes/state"
 STATE="$STATE_DIR/release-radar-last.txt"
 API="${RADAR_RELEASES_URL:-https://api.github.com/repos/NousResearch/hermes-agent/releases?per_page=10}"
 ENDPOINT="${RADAR_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}"
 ANALYST="${RADAR_MODEL:-gpt-oss-120b}"
 VERTRETUNG="${RADAR_FALLBACK:-GLM-4.7-Flash}"
 FREMDBLICK="$HOME/.hermes/scripts/fremdblick.sh"
 mkdir -p "$STATE_DIR"
 # Briefkasten-Spiegel (still, wie die Morgenlage): Cockpit/Chronik lesen source=release-radar.
 briefkasten() { # $1=Betreff  $2=Text
  curl -sf -m 5 -X POST "${MC_ANNOUNCE_URL:-http://127.0.0.1:9001/api/voice/announce}" \
    -H 'Content-Type: application/json' \
    --data "$(python3 - "$1" "$2" <<'PY'
 import json, sys
 print(json.dumps({"text": sys.argv[2], "subject": sys.argv[1],
                  "source": "release-radar", "priority": "silent"}))
 PY
 )" >/dev/null 2>&1 || true
 }
 # ---------- Versionierter Auftrag fuer den Boten-Agenten ----------
 cat "$MC/deploy/release-radar-prompt.md" 2>/dev/null || cat <<'EOF'
 (Prompt-Datei fehlt noch — Kurzform:) Du bist der Bote des woechentlichen Release-Radars.
 Gib den Befund unten in Lucys Stimme wieder: bei "KEIN NEUES RELEASE" oder "TREFFER: 0"
 genau EIN kurzer Satz; bei Treffern maximal 5 Saetze. Nichts installieren oder aendern.
 EOF
 echo
 INSTALLED_LINE="$(bash -lc 'hermes --version' 2>/dev/null | head -1)"
 INSTALLED_TAG="$(printf '%s' "$INSTALLED_LINE" | grep -oE '\([0-9][0-9.]*\)' | head -1 | tr -d '()')"
 [ -n "$INSTALLED_TAG" ] && INSTALLED_TAG="v$INSTALLED_TAG"
 LAST_SEEN="$(cat "$STATE" 2>/dev/null | tr -d '[:space:]' || true)"
 BASELINE="${LAST_SEEN:-$INSTALLED_TAG}"
 RELEASES_JSON="$(curl -sf --max-time 30 "$API" 2>/dev/null || true)"
 if [ -z "$RELEASES_JSON" ]; then
  echo "## RADAR-BEFUND: AUSGEFALLEN"
  echo "GitHub-Releases-API nicht erreichbar. Dem Commander EINEN ehrlichen Satz melden; naechste Woche neuer Versuch."
  exit 0
 fi
 # Neue getaggte Releases seit BASELINE (Drafts/Prereleases raus, max. 6, Bodies gekuerzt).
 # Baseline unbekannt (aelter als die letzten 10 oder Erstlauf ohne Version) -> juengste 6.
 # JSON via Temp-Datei, NICHT via Pipe: das Heredoc belegt stdin schon fuer den Python-Code
 # selbst (Pipe+Heredoc gleichzeitig -> json.load(stdin) liest ins Leere; Probelauf 10.07.).
 TMPJSON="$(mktemp /tmp/release-radar.XXXXXX.json)"
 printf '%s' "$RELEASES_JSON" > "$TMPJSON"
 PARSED="$(python3 - "$BASELINE" "$TMPJSON" <<'PY'
 import json, sys
 baseline = sys.argv[1]
 try:
    data = json.load(open(sys.argv[2]))
    # Rate-Limit/Fehler antwortet als Dict statt Liste -> wie "keine Daten" behandeln.
    rels = [r for r in data if not r.get("draft") and not r.get("prerelease")] if isinstance(data, list) else []
 except Exception:
    rels = []
 rels.sort(key=lambda r: r.get("published_at") or "", reverse=True)
 if not rels:
    # API hat geantwortet, aber unbrauchbar (Rate-Limit-Dict, kaputtes JSON, leere Liste):
    # ehrlich als "blind" markieren statt faelschlich "kein neues Release" zu melden.
    print(baseline)
    print(-1)
    raise SystemExit
 base = next((r.get("published_at") for r in rels if r.get("tag_name") == baseline), None)
 new = rels[:6] if base is None else [r for r in rels if (r.get("published_at") or "") > base][:6]
 print((new or rels)[0].get("tag_name") or baseline)
 print(len(new))
 for r in new:
    body = (r.get("body") or "").strip()
    if len(body) > 3500:
        body = body[:3500] + "\n[... gekuerzt ...]"
    print(f"\n===== RELEASE {r.get('tag_name')} — {(r.get('name') or '').strip()} ({(r.get('published_at') or '')[:10]}) =====")
    print(body)
 PY
 )"
 rm -f "$TMPJSON"
 NEWEST="$(printf '%s\n' "$PARSED" | sed -n 1p)"
 COUNT="$(printf '%s\n' "$PARSED" | sed -n 2p)"
 NOTES="$(printf '%s\n' "$PARSED" | tail -n +3)"
 if [ "${COUNT:-0}" = "-1" ]; then
  echo "## RADAR-BEFUND: AUSGEFALLEN"
  echo "GitHub-API hat geantwortet, aber unbrauchbar (Rate-Limit oder kaputtes JSON). Dem Commander EINEN ehrlichen Satz melden; State bleibt, naechste Woche neuer Versuch."
  exit 0
 fi
 echo "## RADAR-BEFUND (erhoben am $(date '+%d.%m.%Y %H:%M'))"
 echo "Box installiert: ${INSTALLED_LINE:-unbekannt}"
 echo "Zuletzt gemeldet: ${BASELINE:-unbekannt} · neuestes Release: $NEWEST · neue Releases: ${COUNT:-0}"
 echo "(Updates bleiben manuell/bestaetigt — der Radar informiert nur.)"
 echo
 if [ "${COUNT:-0}" = "0" ]; then
  echo "KEIN NEUES RELEASE seit $BASELINE."
  [ -n "$NEWEST" ] && printf '%s\n' "$NEWEST" > "$STATE"
  briefkasten "Release-Radar" "Kein neues hermes-agent-Release seit $BASELINE (Box: ${INSTALLED_TAG:-?})."
  exit 0
 fi
 if [ ! -s "$LANDKARTE" ]; then
  echo "### ABGLEICH NICHT MOEGLICH"
  echo "$COUNT neue Releases, aber die Eigenbau-Landkarte fehlt ($LANDKARTE)."
  echo "Dem Commander melden: Landkarte im Wissens-Vault wiederherstellen. State bleibt unveraendert (naechste Woche neuer Versuch)."
  briefkasten "Release-Radar" "$COUNT neue hermes-agent-Releases, aber die Eigenbau-Landkarte fehlt — Abgleich uebersprungen."
  exit 0
 fi
 RASTER='Du bist der RELEASE-RADAR einer lokalen KI-Box. Du bekommst (1) die EIGENBAU-LANDKARTE (selbstgebaute Bausteine mit Abloese-Kriterien und Wiedervorlage-Bedingungen) und (2) CHANGELOGS neuer hermes-agent-Releases. Pruefe AUSSCHLIESSLICH: Trifft eine Changelog-Zeile ein Abloese-Kriterium oder eine Wiedervorlage-Bedingung der Landkarte? REGELN: Jede Treffer-Behauptung MUSS die Changelog-Zeile WOERTLICH zitieren. Marketing-Prosa ohne konkretes Feature ist KEIN Treffer. Vage Aehnlichkeit ist KEIN Treffer. Eintraege unter "Bewusst NICHT adoptiert" nur melden, wenn exakt die Wiedervorlage-Bedingung erfuellt ist. Erfinde nichts. Antworte auf DEUTSCH, exakt in dieser Struktur: erste Zeile "TREFFER: <Anzahl>". Danach je Treffer ein Block: "EIGENBAU: <Name aus der Landkarte>" / "RELEASE: <Tag>" / "ZITAT: <woertliche Changelog-Zeile>" / "WARUM: <ein Satz>" / "PROBE: <ein Satz, wie man es risikofrei testet>". Bei TREFFER: 0 stattdessen EIN Satz, was die Releases fuer uns Unwichtiges bringen.'
 EVID="EIGENBAU-LANDKARTE:
 $(cat "$LANDKARTE")
 CHANGELOGS DER NEUEN RELEASES:
 $NOTES"
 # Ein-Schuss-Analyst: $1=Modell  $2=curl-Timeout  $3=max_tokens (Muster chef-gutachter-feed.sh;
 # max_tokens grosszuegig, weil Reasoning-Modelle Budget im reasoning_content verbrauchen).
 judge() {
  local req
  req="$(jq -n --arg m "$1" --arg sys "$RASTER" --arg usr "$EVID" --argjson mt "$3" \
    '{model:$m, messages:[{role:"system",content:$sys},{role:"user",content:$usr}],
      max_tokens:$mt, temperature:0.2}')"
  curl -s -m "$2" "$ENDPOINT" -H 'Content-Type: application/json' --data-binary "$req" \
    | python3 -c '
 import json, sys
 try:
    d = json.load(sys.stdin)
    msg = d["choices"][0]["message"]
    print((msg.get("content") or msg.get("reasoning_content") or "").strip())
 except Exception:
    pass'
 }
 RICHTER="$ANALYST"
 ANALYSE="$(judge "$ANALYST" 420 2600)"
 if [ -z "${ANALYSE// /}" ]; then
  RICHTER="$VERTRETUNG (Vertretung — $ANALYST hat nicht geantwortet)"
  ANALYSE="$(judge "$VERTRETUNG" 240 1800)"
 fi
 if [ -z "${ANALYSE// /}" ]; then
  echo "### ABGLEICH AUSGEFALLEN"
  echo "Beide Analysten ($ANALYST, $VERTRETUNG) haben nicht geantwortet. State bleibt unveraendert — naechste Woche neuer Versuch. Dem Commander EINEN ehrlichen Satz melden."
  briefkasten "Release-Radar" "$COUNT neue hermes-agent-Releases, aber der Abgleich fiel aus (kein Analyst erreichbar)."
  exit 0
 fi
 echo "### Neue Releases:"
 printf '%s\n' "$NOTES" | grep '^===== RELEASE' | sed 's/^===== //; s/ =====$//'
 echo
 echo "### ABGLEICH gegen die Eigenbau-Landkarte (Analyst: $RICHTER)"
 echo "$ANALYSE"
 echo
 # Fremdblick-Gate nur bei Treffern (Zitate MIT Quellmaterial gegenpruefbar machen).
 TREFFER="$(printf '%s' "$ANALYSE" | grep -oE 'TREFFER: *[0-9]+' | head -1 | grep -oE '[0-9]+' || true)"
 GEGEN=""
 if [ "${TREFFER:-1}" != "0" ] && [ -x "$FREMDBLICK" ]; then
  # Grosses Budget: GLM (Reasoning-Modell) denkt erst ueber das ganze Quellmaterial nach,
  # bevor das Urteil in content landet — 2200 (fremdblick-Default) war im Probelauf 10.07.
  # zu knapp (ABGESCHNITTEN, kein Urteil).
  GEGEN="$(printf '%s\n\nQUELLMATERIAL (Original-Changelogs zum Gegenpruefen der Zitate):\n%s' "$ANALYSE" "$NOTES" \
    | FREMDBLICK_MAXTOK="${RADAR_FREMDBLICK_MAXTOK:-4500}" "$FREMDBLICK")"
  echo "$GEGEN"
  echo
 fi
 # Treffer fuettern die Ideen-Queue ("Lucy kennt sich", 12.07.2026): aus einem echten
 # Radar-Treffer wird EINE rohe Idee (triage) — Specifier + Commander entscheiden, ob eine
 # Probe gebaut wird. Idempotent je Release-Tag; der Radar selbst bleibt reiner Melder.
 if [ -n "${TREFFER:-}" ] && [ "$TREFFER" != "0" ] && [ -x "$HOME/.local/bin/hermes" ]; then
  IDEE_ID="$("$HOME/.local/bin/hermes" kanban create \
      "Hermes ${NEWEST}: Release-Radar-Treffer pruefen (Probe bauen?)" \
      --body "Automatisch vom Release-Radar am $(date '+%d.%m.%Y'). ABGLEICH (Analyst: ${RICHTER}):
 ${ANALYSE}
 FREMDBLICK:
 ${GEGEN:-(keiner)}
 Rohe Idee: nur pruefen bzw. eine risikofreie Probe vorschlagen — Updates bleiben manuell (Entscheid 04.07.)." \
      --triage --created-by release-radar --idempotency-key "release-radar-${NEWEST}" --json 2>/dev/null \
    | python3 -c '
 import json, sys
 t = sys.stdin.read(); i = t.find("{")
 try:
    print(json.loads(t[i:]).get("id", "") if i >= 0 else "")
 except Exception:
    print("")
 ' 2>/dev/null || true)"
  if [ -n "${IDEE_ID// /}" ]; then
    echo "### IN DIE IDEEN-QUEUE GELEGT: ${IDEE_ID} — Probe-Pruefung fuer ${NEWEST} (der Specifier uebernimmt)."
    echo
  fi
 fi
 printf '%s\n' "$NEWEST" > "$STATE"
 briefkasten "Release-Radar" "Neue hermes-agent-Releases bis $NEWEST (Box: ${INSTALLED_TAG:-?}).
 ABGLEICH (Analyst: $RICHTER):
 $ANALYSE
 ${GEGEN:-(Kein Fremdblick noetig: TREFFER 0)}"
@@ -1,298 +0,0 @@
 #!/usr/bin/env bash
 # Idle-Radar (naechtlich 03:45 — S4 "Zuendung", 12.07.2026): die Box gibt sich selbst Arbeit.
 # Destilliert aus JOURNAL-Fehlermustern (24 h) und der juengsten TRAUM-Notiz 0-2 KLEINE,
 # belegte Wartungs-Kandidaten und legt sie als ROHE IDEEN (triage) ins native Hermes-Kanban.
 # Danach laeuft der bewiesene S2-Kreislauf von allein: Specifier arbeitet aus -> Werkstatt
 # baut einen Vorschlags-Branch -> Karte im Auftragsbuch -> der KLICK des Commanders bleibt
 # das einzige Gate. Muster wie hermes-release-radar-feed.sh: liegt in ~/.hermes/scripts/
 # (deploy.sh kopiert ihn), stdout wird dem Cron-Agenten als Prompt eingespeist; der
 # eigentliche ABGLEICH laeuft als Ein-Schuss-Completion gegen llama-swap (:8080).
 # Grundsaetze:
 #   - Kandidat NUR mit woertlichem Beleg-Zitat; das Skript prueft das Zitat MECHANISCH
 #     gegen das Material (reproduziert-oder-abgelehnt, Verdikt 04.07.) — haerter als
 #     ein zweites LLM-Urteil und gratis.
 #   - Max. 2 neue Ideen je Nacht + STAU-BREMSE: liegt schon genug Arbeit (volle Queue
 #     oder volles Auftragsbuch), legt der Radar NICHTS nach — die Box soll Arbeit
 #     abarbeiten, nicht anhaeufen.
 #   - Dedup dreifach: State-Datei (schon gemeldet) + Queue/Karten-Liste im Analysten-
 #     Kontext + --idempotency-key beim Anlegen.
 #   - Der Radar LEGT NUR IDEEN AN — er baut nichts, merged nichts, konfiguriert nichts.
 # State: ~/.hermes/state/idle-radar-gemeldet.txt (ein KEY je bereits gemeldetem Kandidaten).
 set -uo pipefail
 MC="$HOME/mission-control-v2"
 VAULT="$HOME/wissens-vault"
 STATE_DIR="$HOME/.hermes/state"
 STATE="$STATE_DIR/idle-radar-gemeldet.txt"
 ENDPOINT="${IDLE_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}"
 ANALYST="${IDLE_MODEL:-gpt-oss-120b}"
 VERTRETUNG="${IDLE_FALLBACK:-GLM-4.7-Flash}"
 HERMES="$HOME/.local/bin/hermes"
 MAX_NEU=2        # harte Obergrenze neuer Ideen je Nacht (wie Bagatell-Pfad)
 STAU_QUEUE=4     # ab so vielen offenen Queue-Aufgaben: Bremse
 STAU_KARTEN=3    # ab so vielen offenen Auftragsbuch-Karten: Bremse
 mkdir -p "$STATE_DIR"; touch "$STATE"
 # Briefkasten-Spiegel (still, wie Morgenlage/Release-Radar): Chronik liest source=idle-radar.
 briefkasten() { # $1=Betreff  $2=Text
  curl -sf -m 5 -X POST "${MC_ANNOUNCE_URL:-http://127.0.0.1:9001/api/voice/announce}" \
    -H 'Content-Type: application/json' \
    --data "$(python3 - "$1" "$2" <<'PY'
 import json, sys
 print(json.dumps({"text": sys.argv[2], "subject": sys.argv[1],
                  "source": "idle-radar", "priority": "silent"}))
 PY
 )" >/dev/null 2>&1 || true
 }
 # ---------- Versionierter Auftrag fuer den Boten-Agenten ----------
 cat "$MC/deploy/idle-radar-prompt.md" 2>/dev/null || cat <<'EOF'
 (Prompt-Datei fehlt noch — Kurzform:) Du bist der Bote des naechtlichen Idle-Radars.
 Berichte den Befund unten in Lucys Stimme in hoechstens 3 Saetzen: wie viele neue
 Queue-Ideen angelegt wurden (Titel nennen) oder warum keine. Nichts selbst umsetzen,
 keine Kanban-Aktionen — das Skript hat alles Noetige bereits getan.
 EOF
 echo
 # ---------- Stau-Bremse (vor dem teuren Analysten) ----------
 OFFEN_QUEUE="$("$HERMES" kanban list --json 2>/dev/null | python3 -c '
 import json, sys
 t = sys.stdin.read(); i = t.find("[")
 try:
    d = json.loads(t[i:]) if i >= 0 else []
 except Exception:
    d = []
 print(sum(1 for x in d if isinstance(x, dict) and x.get("status") not in ("done", "archived")))
 ' 2>/dev/null || echo 0)"
 OFFEN_KARTEN="$(curl -sf -m 10 http://127.0.0.1:9001/api/auftragsbuch 2>/dev/null | python3 -c '
 import json, sys
 try:
    print(int(json.load(sys.stdin).get("open_count", 0)))
 except Exception:
    print(0)
 ' 2>/dev/null || echo 0)"
 if [ "${OFFEN_QUEUE:-0}" -ge "$STAU_QUEUE" ] || [ "${OFFEN_KARTEN:-0}" -ge "$STAU_KARTEN" ]; then
  echo "## IDLE-RADAR-BEFUND: STAU-BREMSE (erhoben am $(date '+%d.%m.%Y %H:%M'))"
  echo "Offene Queue-Aufgaben: ${OFFEN_QUEUE} (Bremse ab ${STAU_QUEUE}) · offene Karten: ${OFFEN_KARTEN} (Bremse ab ${STAU_KARTEN})."
  echo "Es liegt genug Arbeit — heute Nacht keine neuen Ideen. Dem Commander EINEN kurzen Satz melden."
  briefkasten "Idle-Radar" "Stau-Bremse: ${OFFEN_QUEUE} offene Queue-Aufgaben, ${OFFEN_KARTEN} offene Karten — keine neuen Ideen angelegt."
  exit 0
 fi
 # ---------- Material sammeln (erst sammeln, dann kuerzen — SIGPIPE-Falle) ----------
 TRAUM_DATEI="$(ls -1t "$VAULT/traeume/"*.md 2>/dev/null | head -1 || true)"
 EVID="$(
  echo "### JOURNAL-FEHLERMUSTER (user-Dienste, letzte 24 h; Anzahl · Muster, lange Zahlen/IDs normalisiert):"
  journalctl --user --since '24 hours ago' -p warning --no-pager 2>/dev/null \
    | sed -E 's/^[A-Z][a-z]{2} [0-9 ]{2} [0-9:]{8} [^ ]+ //; s/\[[0-9]+\]//; s/[0-9]{3,}/N/g; s/t_[0-9a-f]+/t_X/g' \
    | sort | uniq -c | sort -rn | head -18
  echo
  echo "### JUENGSTE TRAUM-NOTIZ ($(basename "${TRAUM_DATEI:-keine}") — Funde des naechtlichen Lern-Crons):"
  if [ -n "$TRAUM_DATEI" ]; then head -70 "$TRAUM_DATEI"; else echo "(keine Traum-Notiz gefunden)"; fi
  echo
  echo "### OFFENE SKILL-KANDIDATEN im Vault (nur Titelzeilen):"
  ls -1 "$VAULT/skill-kandidaten/"*.md 2>/dev/null | head -8 | while read -r f; do
    echo "- $(basename "$f"): $(head -1 "$f" 2>/dev/null)"
  done
  echo
  echo "### SELBST-STECKBRIEF (auto-generiert von selbst-inventur.sh — das EXISTIERT schon; NICHTS davon neu vorschlagen):"
  head -80 "$HOME/.hermes/state/selbst-steckbrief.md" 2>/dev/null || echo "(noch keine Selbst-Inventur gelaufen)"
  echo
  echo "### SEIT GESTERN AN MIR GEAENDERT (Selbst-Inventur-Diff — gute Kandidaten-Quelle, wenn eine kleine Massnahme erkennbar ist):"
  head -40 "$HOME/.hermes/state/selbst-steckbrief.diff" 2>/dev/null || echo "(keine Aenderung erkannt)"
  echo
  echo "### VOM COMMANDER ABGELEHNT (mit Grund — sinngemaess NIE wieder vorschlagen):"
  tail -12 "${MC2_ABLEHNUNGEN:-/srv/models/mc2-ablehnungen.jsonl}" 2>/dev/null | python3 -c '
 import json, sys
 n = 0
 for line in sys.stdin:
    try:
        d = json.loads(line)
    except Exception:
        continue
    n += 1
    print("- [{}] {} — Grund: {}".format(d.get("branch", "?"), (d.get("subject") or "")[:80],
                                          d.get("grund") or "(keiner angegeben)"))
 if not n:
    print("(keine)")
 ' 2>/dev/null || echo "(keine)"
  echo
  echo "### SCHON IN DER IDEEN-QUEUE (inkl. archiviert = vom Commander verworfen; NICHT erneut vorschlagen):"
  "$HERMES" kanban list --archived --json 2>/dev/null | python3 -c '
 import json, sys
 t = sys.stdin.read(); i = t.find("[")
 try:
    d = json.loads(t[i:]) if i >= 0 else []
 except Exception:
    d = []
 for x in d[:40]:
    if isinstance(x, dict):
        print("- [{}] {}".format(x.get("status", "?"), (x.get("title") or "")[:110]))
 ' 2>/dev/null || echo "(Queue nicht lesbar)"
  echo
  echo "### OFFENE KARTEN IM AUFTRAGSBUCH (warten auf Klick; NICHT erneut vorschlagen):"
  curl -sf -m 10 http://127.0.0.1:9001/api/auftragsbuch 2>/dev/null | python3 -c '
 import json, sys
 try:
    items = json.load(sys.stdin).get("items") or []
 except Exception:
    items = []
 if not items:
    print("(keine)")
 for it in items[:15]:
    print("- {}:{}".format(it.get("repo", "mc2"), it.get("branch", "?")))
 ' 2>/dev/null || echo "(Auftragsbuch nicht lesbar)"
  echo
  echo "### VOM IDLE-RADAR BEREITS GEMELDET (KEYs; NICHT erneut vorschlagen):"
  tail -40 "$STATE" 2>/dev/null || true
 )"
 RASTER='Du bist der IDLE-RADAR einer lokalen KI-Box (Hermes-Agent, MC2, Lucy). Du bekommst naechtliches Material: Journal-Fehlermuster, die juengste Traum-Notiz, offene Skill-Kandidaten sowie Listen dessen, was schon in Arbeit ist. Deine Aufgabe: destilliere daraus 0 bis 2 KLEINE, konkrete Wartungs-Kandidaten, die die Box-Werkstatt selbst umsetzen kann (Patch in 1-2 Dateien, Skript- oder Doku-Aenderung im MC2- oder Lucy-Repo). REGELN: Jeder Kandidat MUSS eine Zeile aus dem Material WOERTLICH zitieren (BELEG) — das Zitat wird mechanisch gegengeprueft, erfundene Zitate fliegen raus. Nichts vorschlagen, was sinngemaess schon in der IDEEN-QUEUE, den OFFENEN KARTEN oder der BEREITS-GEMELDET-Liste steht. Der SELBST-STECKBRIEF sagt dir, was die Box schon HAT und KANN — schlage NIE etwas vor, das dort schon steht (der Fehler vom 12.07.: ein Gateway-Neustart wurde vorgeschlagen, der laengst konfiguriert war). Was der Commander mit Grund ABGELEHNT hat, ist entschieden — nicht neu verpacken. Aenderungen aus dem Inventur-Diff sind gute Kandidaten-Quellen, aber nur mit konkreter kleiner Massnahme. TABU (niemals vorschlagen): Security (approvals/Tokens/ufw/sudoers/ssh), ~/.hermes/config.yaml, systemd-Units, Hermes-Quellcode, Updates/Upgrades, alles was den PC oder einen Menschen braucht. Ein wiederkehrendes Fehlermuster ist NUR dann ein Kandidat, wenn eine konkrete kleine Ursachen-Behebung erkennbar ist — "beobachten", "untersuchen" oder "Monitoring bauen" ist KEIN Auftrag. Qualitaet vor Quote: KANDIDATEN: 0 ist der Normalfall und voellig ok. Antworte auf DEUTSCH, exakt in dieser Struktur: erste Zeile "KANDIDATEN: <0|1|2>". Danach je Kandidat ein Block aus genau vier Zeilen: "TITEL: <max 90 Zeichen, Imperativ, deutsch>" / "KEY: <kurzer-kebab-slug>" / "BELEG: <woertliches Zitat aus dem Material, EINE Zeile>" / "WARUM: <ein Satz>". Bei 0 stattdessen EIN Satz, warum nichts ansteht.'
 # Ein-Schuss-Analyst: $1=Modell  $2=curl-Timeout  $3=max_tokens (Muster chef-gutachter-feed.sh).
 judge() {
  local req
  req="$(jq -n --arg m "$1" --arg sys "$RASTER" --arg usr "$EVID" --argjson mt "$3" \
    '{model:$m, messages:[{role:"system",content:$sys},{role:"user",content:$usr}],
      max_tokens:$mt, temperature:0.2}')"
  curl -s -m "$2" "$ENDPOINT" -H 'Content-Type: application/json' --data-binary "$req" \
    | python3 -c '
 import json, sys
 try:
    d = json.load(sys.stdin)
    msg = d["choices"][0]["message"]
    print((msg.get("content") or msg.get("reasoning_content") or "").strip())
 except Exception:
    pass'
 }
 RICHTER="$ANALYST"
 ANALYSE="$(judge "$ANALYST" 420 2600)"
 if [ -z "${ANALYSE// /}" ]; then
  RICHTER="$VERTRETUNG (Vertretung — $ANALYST hat nicht geantwortet)"
  ANALYSE="$(judge "$VERTRETUNG" 240 1800)"
 fi
 echo "## IDLE-RADAR-BEFUND (erhoben am $(date '+%d.%m.%Y %H:%M'))"
 echo "Offene Queue-Aufgaben vorher: ${OFFEN_QUEUE} · offene Karten: ${OFFEN_KARTEN} · Deckel: ${MAX_NEU}/Nacht"
 echo
 if [ -z "${ANALYSE// /}" ]; then
  echo "### ANALYSE AUSGEFALLEN"
  echo "Beide Analysten ($ANALYST, $VERTRETUNG) haben nicht geantwortet — dem Commander EINEN ehrlichen Satz melden; morgen neuer Versuch."
  briefkasten "Idle-Radar" "Analyse ausgefallen (kein Analyst erreichbar) — keine neuen Ideen."
  exit 0
 fi
 echo "### ANALYSE (Analyst: $RICHTER)"
 echo "$ANALYSE"
 echo
 # ---------- Ehrlichkeits-Gate + Dedup + Anlegen (deterministisch im Skript) ----------
 # Temp-Dateien statt Pipes: Heredoc + Pipe gleichzeitig frisst stdin (Release-Radar-Lehre 10.07.).
 TMPD="$(mktemp -d /tmp/idle-radar.XXXXXX)"
 printf '%s' "$ANALYSE" > "$TMPD/analyse.txt"
 printf '%s' "$EVID"    > "$TMPD/material.txt"
 PLAN="$(python3 - "$TMPD/analyse.txt" "$TMPD/material.txt" "$STATE" "$MAX_NEU" <<'PY'
 import re, sys, unicodedata
 ana = open(sys.argv[1], encoding="utf-8", errors="replace").read()
 evid = open(sys.argv[2], encoding="utf-8", errors="replace").read()
 try:
    state = {l.strip() for l in open(sys.argv[3], encoding="utf-8", errors="replace") if l.strip()}
 except Exception:
    state = set()
 max_neu = int(sys.argv[4])
 def norm(s):
    s = unicodedata.normalize("NFKC", s)
    s = "".join(ch for ch in s if ch.isalnum() or ch.isspace())
    return " ".join(s.lower().split())
 nev = norm(evid)
 # Zeilenweise einsammeln (tolerant gegen Markdown-Deko und Leerzeilen zwischen Feldern).
 cands, cur = [], {}
 for line in ana.splitlines():
    line = line.strip().lstrip("*->#• ").strip()
    m = re.match(r"(TITEL|KEY|BELEG|WARUM)\s*:\s*(.+)$", line)
    if not m:
        continue
    k, v = m.group(1), m.group(2).strip()
    if k == "TITEL" and cur:
        cands.append(cur); cur = {}
    cur[k] = v
 if cur:
    cands.append(cur)
 neu = 0
 SEP = "\x1f"
 for c in cands:
    titel = (c.get("TITEL") or "").strip()[:120]
    warum = (c.get("WARUM") or "").strip()[:300]
    beleg = (c.get("BELEG") or "").strip().strip('"„“»«>`').strip()
    key = re.sub(r"[^a-z0-9-]+", "-", (c.get("KEY") or "").strip().lower())[:48].strip("-")
    if not (titel and key and beleg):
        continue
    if key in state or ("idle-radar-" + key) in state:
        print("SKIP" + SEP + key + SEP + "schon frueher gemeldet (State)")
        continue
    if not norm(beleg) or norm(beleg) not in nev:
        print("SKIP" + SEP + key + SEP + "BELEG nicht woertlich im Material — verworfen (Ehrlichkeits-Gate)")
        continue
    if neu >= max_neu:
        print("SKIP" + SEP + key + SEP + "Deckel erreicht")
        continue
    neu += 1
    print("NEU" + SEP + key + SEP + titel + SEP + beleg + SEP + warum)
 PY
 )"
 ANGELEGT=""; VERWORFEN=""
 while IFS=$'\x1f' read -r art key titel beleg warum; do
  [ -n "${art:-}" ] || continue
  if [ "$art" = "SKIP" ]; then
    VERWORFEN="${VERWORFEN}- ${key}: ${titel}"$'\n'   # bei SKIP traegt das 3. Feld den Grund
    continue
  fi
  [ "$art" = "NEU" ] || continue
  BODY="Automatisch vom Idle-Radar erhoben am $(date '+%d.%m.%Y') (Quelle: Journal-Muster/Traum-Notiz der Nacht).
 BELEG (woertlich aus dem Material): ${beleg}
 WARUM: ${warum}
 Rohe Idee — bitte pruefen, klein schneiden und nur wenn tragfaehig promoten; sonst archivieren."
  TASK_ID="$("$HERMES" kanban create "$titel" --body "$BODY" --triage \
      --created-by idle-radar --idempotency-key "idle-radar-${key}" --json 2>/dev/null \
    | python3 -c '
 import json, sys
 t = sys.stdin.read(); i = t.find("{")
 try:
    print(json.loads(t[i:]).get("id", "") if i >= 0 else "")
 except Exception:
    print("")
 ' 2>/dev/null || true)"
  if [ -n "${TASK_ID// /}" ]; then
    echo "$key" >> "$STATE"
    ANGELEGT="${ANGELEGT}- ${titel} (${TASK_ID}, Key ${key})"$'\n'
  else
    VERWORFEN="${VERWORFEN}- ${key}: kanban create fehlgeschlagen"$'\n'
  fi
 done <<< "$PLAN"
 rm -rf "$TMPD"
 echo "### ANGELEGT (rohe Ideen, triage — der Specifier uebernimmt):"
 echo "${ANGELEGT:-(keine)}"
 echo "### NICHT ANGELEGT (Gate/Dedup/Deckel):"
 echo "${VERWORFEN:-(keine)}"
 N_NEU="$(printf '%s' "$ANGELEGT" | grep -c '^-' || true)"
 if [ "${N_NEU:-0}" -gt 0 ]; then
  briefkasten "Idle-Radar" "Idle-Radar hat ${N_NEU} neue Idee(n) in die Queue gelegt:
 ${ANGELEGT}Der Specifier arbeitet sie aus; die Karten-Annahme bleibt beim Commander."
 else
  briefkasten "Idle-Radar" "Idle-Radar: keine neuen Ideen (Analyst: ${RICHTER})."
 fi
@@ -1,26 +0,0 @@
 # Idle-Radar — Auftrag für den Boten-Agenten
 Du bist der Bote des nächtlichen Idle-Radars. Unten steht ein automatisch erhobener
 BEFUND: aus Journal-Fehlermustern und der jüngsten Traum-Notiz destilliert ein
 Analysten-Modell kleine Wartungs-Kandidaten; das Skript hat die tragfähigen davon
 BEREITS als rohe Ideen (triage) in die Ideen-Queue gelegt — den Rest erledigt der
 bewiesene Kreislauf (Specifier → Werkstatt → Karte im Auftragsbuch → Klick des
 Commanders).
 Deine Aufgabe — NUR berichten, in Lucys Stimme (Anrede „Commander", Alltagssprache,
 Fazit zuerst), in höchstens 3 Sätzen:
 1. Bei „ANGELEGT: (keine)" oder „KANDIDATEN: 0": GENAU EIN kurzer Satz
   (z. B. „Idle-Radar: nichts Belegbares heute Nacht — Queue bleibt wie sie ist.").
 2. Bei neuen Ideen: nenne Anzahl und die Titel; sage dazu, dass die Box sie jetzt
   selbst ausarbeitet und die Annahme wie immer per Karten-Klick beim Commander liegt.
 3. Bei „STAU-BREMSE" oder „AUSGEFALLEN": ein ehrlicher Satz, warum der Radar heute
   Nacht nichts angelegt hat.
 Harte Regeln:
 - NICHTS selbst umsetzen: keine Kanban-Aktionen, nichts bauen, nichts konfigurieren —
  das Anlegen hat das Skript schon deterministisch erledigt.
 - Erfinde keine Kandidaten über den Befund hinaus; im Ehrlichkeits-Gate verworfene
  Vorschläge (BELEG nicht im Material) nicht als Erfolg verkaufen.
 - Die stille Briefkasten-Karte hat das Skript bereits geschrieben — du lieferst nur
  die kurze Telegram-Meldung.
@@ -0,0 +1,199 @@
 # Die drei Jobs (KISS-Umbau, 21.08.2026)
 Vorher: **4 Hermes-Crons + 6 systemd-Timer**, verteilt auf zwei Mechanismen.
 Deshalb fiel am 20.08. tagelang niemandem auf, dass ein Waechter fehlte —
 niemand schaut an zwei Orten nach.
 Jetzt: **drei Jobs, ein Ort.** `hermes cron list` zeigt die gesamte Automatik.
 | Job | Wann | Art | Skript |
 |---|---|---|---|
 | **Daily News Report** | taeglich 07:00 | Agent + Websuche | — |
 | **KI und Stack Radar** | samstags 08:00 | `--no-agent` | `stack-radar.sh` → `stack-ist.sh` |
 | **Updates am Sonntag** | sonntags 04:30 | `--no-agent` | `sonntags-update.sh` → `autoupdate.sh` |
 Daneben laufen als stille Rohrleitung weiter: `mc2-backup` (03:33) und
 `projekte-sync` (stuendlich). Die melden sich nie, die sichern und synchronisieren nur.
 ## Der Entwurfsgrundsatz
 > **Fakten sammelt ein Skript, Prosa schreibt das Modell.**
 Der alte Selbsttest war am 20.08. gruen, waehrend vier Dinge kaputt waren: das
 Kritiker-Gate zeigte seit einem Tag auf ein umbenanntes Modell (404), Lucys
 `SOUL.md` war blockiert, das Dashboard stand ohne Passwort offen, die CI war rot.
 Er hatte geprueft, ob Dienste **antworten** — nicht, ob sie **stimmen**.
 `stack-ist.sh` prueft deshalb Ergebnisse: loesen die Rollen-Aliase noch auf? Ist
 der letzte Timer-Lauf gutgegangen? Ist eine Sicherung juenger als zwei Tage?
 Liefert die oeffentliche Adresse Daten ohne Anmeldung? Beim ersten Lauf hat es
 sofort zwei echte Befunde gefunden.
 ## Kugelsicher heisst konkret
 - **Das Modell steht nicht im kritischen Pfad.** Antwortet es nicht, gehen die
  Rohbefunde trotzdem raus. Nur die Prosa faellt weg, nie die Meldung.
 - **Es meldet immer.** „Alles gruen" ist ein Ergebnis, kein Grund zu schweigen.
 - **Kein `set -e`.** Ein einzelner fehlschlagender Test darf den Bericht nicht
  abschneiden.
 - **Ein Melderweg:** `deploy/notify.sh` erreicht Telegram **und** Lucys
  Briefkasten (aus dem sie spricht) in einem Aufruf. Die Jobs laufen mit
  `--deliver local`, damit Hermes nicht ein zweites Mal sendet.
 - **Kein Fuellmaterial.** Die Prompts verbieten ausgedachte Vorschlaege
  ausdruecklich — ein Bericht mit Fuellmaterial wird nicht gelesen, und dann
  auch der echte Befund nicht.
 ## Ausbringen
 Die Skripte muessen unter `~/.hermes/scripts/` liegen (Vorgabe von `hermes cron --script`).
 Quelle ist dieses Verzeichnis:
 ```bash
 scp deploy/jobs/*.sh hitonabi@192.168.178.151:/home/hitonabi/.hermes/scripts/
 ssh hitonabi@192.168.178.151 'cd ~/.hermes/scripts && sed -i "s/\r$//" *.sh && chmod +x *.sh'
 ```
 ‼️ Das `sed` ist Pflicht: vom Windows-PC kopierte Dateien haben CRLF, und bash
 scheitert daran mit unverstaendlichen Meldungen.
 ## Abgeschaltet am 21.08.
 | Weg | Warum |
 |---|---|
 | Cron `morgen-digest` | geht im Daily News Report auf |
 | Cron `tech-radar` | geht im Stack Radar auf |
 | Cron `nacht-wartung` | pruefte Lebenszeichen, nicht Ergebnisse |
 | Cron `wissens-sync` | **war nie gelaufen** — kein `last_run_at` |
 | Timer `mc2-bagatell` | **15 Naechte hintereinander „0 eingespielt"** |
 | Timer `mc2-selfsmoke` | geht in `stack-ist.sh` auf |
 | Timer `pbs-backup` | doppelt zu `mc2-backup` und seit 21.08. rot (`/srv/models/mem0` gibt es nicht mehr) |
 | Timer `mc2-autoupdate` | wird jetzt vom Cron „Updates am Sonntag" gestartet |
 Die Unit-Dateien liegen noch da, nur `disable`d — Rueckbau ist ein Befehl.
 ---
 ## Nachtrag 21.08.: Persona, Quellen-Links und Stimme
 **Fehler, den ich gemacht hatte:** Mein erster Prompt fuer den Daily News Report
 schrieb woertlich *„keine Emojis, keine Aufzaehlungspunkte, keine
 Ueberschriften-Deko"* — und hat damit genau das wegoptimiert, was den Bericht
 vorher gut machte.
 ★★ **Die Formatierung kam nie aus dem Job-Prompt.** Die alten Prompts waren
 kurz (*„eine praegnante 3-Punkte-Zusammenfassung an den Commander"*). Emojis,
 Ton und die Anrede stehen in **`~/.hermes/SOUL.md`** — Lucys Persona:
 > Du sprichst den Nutzer IMMER mit **Commander** an.
 > Locker, herzlich, schlagfertig, charmant, selbstbewusst.
 **Lehre: den Job-Prompt kurz halten und die Persona arbeiten lassen.** Wer im
 Prompt Stil verbietet, ueberstimmt die Persona — und merkt es erst, wenn die
 Nachricht seelenlos ankommt.
 ### Stimme in Telegram
 `hermes send` kann **`MEDIA:<pfad>`**. Damit geht eine fertige Audiodatei als
 Anhang nach Telegram. `deploy/jobs/news-melden.sh` macht daraus einen Aufruf:
 ```
 Agent schreibt zwei Dateien
  /tmp/news-text.md    (Emojis, Links, Formatierung)  -> notify.sh -> Telegram + Briefkasten
  /tmp/news-sprich.txt (3-4 Saetze, nichts Vorlesbares fehlt) -> :8650/tts -> WAV -> hermes send MEDIA:
 ```
 ‼️ **Nicht Hermes' eingebautes TTS nehmen.** Das steht auf `tts.provider: edge`
 mit `en-US-AriaNeural` — englisch. Lucys echte Stimme ist MC2s `voice-service`
 auf `:8650` (Piper `de_DE-thorsten-medium`). Deshalb ruft das Skript den
 Sidecar direkt per curl.
 ‼️ **Kein ffmpeg noetig.** Telegram nimmt die WAV direkt an. Fuer eine echte
 Sprachnachricht mit Wellenform braeuchte es OGG/Opus und damit ffmpeg — bewusst
 nicht installiert, eine Abhaengigkeit weniger.
 Der Agent ruft **einen** Befehl auf, alles danach ist deterministisch. Faellt
 die Stimme aus, geht der Text trotzdem raus.
 ### ‼️ Folgefehler der Werkzeug-Abschaltung — gefunden und behoben
 Nach dem Abschalten von `kanban` und `delegation` standen in `SOUL.md` noch
 zwei Anweisungen, die ins Leere zeigten: *„rufst du sofort dein Werkzeug
 delegate_task auf"* und *„Ideen traegst du sofort im Kanban-Auftragsbuch ein"*.
 Genau die Klasse stiller Defekt, die am 19.08. das Kritiker-Gate zerlegt hat.
 Beide Abschnitte ersetzt (Sicherung: `~/.hermes/SOUL.md.bak-20260821`).
 **Merke: wer einen Werkzeugsatz abschaltet, muss `SOUL.md` mitlesen.**
 ### Kugelsicher-Regeln, die dazugekommen sind
 - `hermes cron edit <id> "text"` **speichert nichts** — der Prompt muss ueber
  **`--prompt`** kommen. Ohne Flag gibt der Befehl den Text nur aus und die
  alte Fassung bleibt stehen. Nach jeder Aenderung in `jobs.json` nachsehen.
 - Alte Job-Fassungen liegen im Zustands-Backup:
  `tar -xzf /srv/models/mc2-backups/mc2-state-*.tar.gz ./hermes/cron/jobs.json`
 - Tagesaktualitaet muss man erzwingen: Datum per `date` feststellen lassen,
  mehrere Suchen verlangen, und Meldungen ohne belegbares Datum verwerfen.
 ---
 ## Nachtrag 3 (21.08.): Lucys ECHTE Stimme, echte Sprachnachricht
 ### Der Fehler: :8650 ist nicht Lucy
 Ich hatte `/tts` auf MC2s `voice-service` (`:8650`) ohne Angabe von Engine und
 Stimme aufgerufen. Dessen `/health` sagt:
 ```
 "engines":["elevenlabs","edge"]
 ```
 Piper und Chatterbox sind dort **gar nicht geladen** — die Vorgabe fiel auf die
 erste verfuegbare: ElevenLabs *„Artoria DE · Saber · Hermes-Stimme"*. Das ist
 **Hermes' Stimme**, nicht Lucys. Deutsch und weiblich, deshalb faellt es nicht
 sofort auf. Beide verfuegbaren Engines sind ausserdem **Cloud** — gegen die
 100-%-lokal-Praemisse.
 ### Lucys Stimme: `lucy-stimme.service` auf `:8021`
 | | |
 |---|---|
 | Engine | **Kyutai pocket-tts 2.1.0** (neueste, seit 04.05. unveraendert) |
 | Modell | **`german_24l`** — die volle Fassung, nicht die destillierte |
 | Stimme | geklont aus `ref.mp3`, gecacht in `lucy_voice.safetensors` (44 MB) |
 | Laeuft | `~/.lucy-stimme/`, systemd-**user**-Dienst, `enable`d, CPU |
 | Start | ~48 s Ladezeit, danach ~5 s fuer 3,7 s Audio |
 Mitgezogen wurde die **ganze Abstimmung**, nicht nur das Modell: `text_norm.py`
 (Symbole/Pfade/URLs → Zahlen → Akronyme), Emotions-Voreinstellungen mit
 Anlaufwoertern, Umlaut-Wortliste, Hochpass auf der Referenz, kalibrierter Pegel.
 Ohne die klingt pocket nicht wie Lucy.
 ‼️ Der Sweep im TTS-Plan (*„seriell schlaegt parallel"*) wurde auf einem **9700X**
 gemessen. Die Box ist ein Ryzen AI MAX+ 395 — das Ergebnis ist **nicht
 uebertragen**, nur uebernommen. Wer Tempo braucht, misst neu.
 ### Recherche 21.08.: pocket bleibt
 Nichts seit Mai schlaegt es auf dieser Achse. Die Alternativen sind 5–17× groesser:
 Qwen3-TTS 0,6–1,7 Mrd. (Apache 2.0, Deutsch, 3-Sekunden-Klon), NeuTTS Air 0,5 Mrd.
 (GGUF), CosyVoice2 0,5 Mrd. — gegen pockets **100 Mio.** Fuer einen taeglichen
 Sprachnachrichten-Job auf CPU ist das der falsche Handel.
 **Ihr wart bereits auf dem neuesten Stand** — nichts zu aktualisieren.
 ### Echte Sprachnachricht braucht OGG/Opus
 Eine WAV kommt in Telegram als **Dateianhang** an. Fuer das runde Sprachmemo mit
 Wellenform braucht es OGG/Opus — dafuer wurde **ffmpeg installiert** (8.0.1):
 ```bash
 ffmpeg -y -i ton.wav -c:a libopus -b:a 32k -ar 48000 -ac 1 ton.ogg
 hermes send --to telegram "MEDIA:ton.ogg"
 ```
 Ganze Kette (Text + Stimme + Versand) gemessen: **10 Sekunden**.
 ### Altlast am Rande
 `F:\Coding Stuff\lucy\lucy-tts\Lucy-Startklar.bat` zeigt auf
 `mission-control-2\client\lucy-tts` — den Ordner gibt es seit der Repo-Trennung
 nicht mehr.
@@ -0,0 +1,89 @@
 #!/usr/bin/env bash
 # news-melden.sh — schickt den fertigen Nachrichtenbericht als TEXT und als
 # SPRACHNACHRICHT an den Commander (21.08.2026, überarbeitet 22.08.).
 #
 # Der Agent ruft genau EINEN Befehl auf. Alles danach ist deterministisch —
 # Zustellung darf nicht davon abhaengen, ob ein Modell die Reihenfolge einhaelt.
 #
 # ‼️ WARUM DAS SKRIPT SOFORT ZURUECKKEHRT (Fund vom 22.08., erster echter Lauf):
 #   Hermes' terminal-Werkzeug bricht nach 30 s ab. Die Sprachsynthese dauert
 #   laenger. Der Agent sah den Timeout, hielt den Aufruf fuer gescheitert und
 #   rief das Skript ein zweites Mal auf — der Text ging DOPPELT raus
 #   (07:01:42 und 07:02:14).
 #   Deshalb: Text senden, Stimme abgekoppelt im Hintergrund, sofort raus.
 #   Dazu eine Doppelversand-Sperre, die auch kuenftige Wiederholungen abfaengt.
 #
 # Erwartet zwei Dateien, die der Agent vorher geschrieben hat:
 #   $1  Textfassung   (mit Emojis, Links, Formatierung — geht nach Telegram)
 #   $2  Sprechfassung (kurz, ohne Links/Emojis — wird vorgelesen)
 #
 # ‼️ STIMME: :8021, nicht :8650.
 #   :8021 = lucy-stimme.service — Kyutai pocket-tts, Modell `german_24l`,
 #           Stimme geklont aus ref.mp3. DAS ist Lucy. Lokal, auf der CPU.
 #   :8650 = MC2s voice-service. Dort sind nur `elevenlabs` und `edge` geladen —
 #           beides CLOUD, und die Vorgabe ist die ElevenLabs-Stimme
 #           "Artoria/Saber", also HERMES' Stimme, nicht Lucys.
 set -uo pipefail
 NOTIFY="${NOTIFY:-$HOME/mission-control-v2/deploy/notify.sh}"
 VOICE="${VOICE_URL:-http://127.0.0.1:8021}"
 HERMES="${HERMES_BIN:-$HOME/.local/bin/hermes}"
 TON="/tmp/news-stimme.wav"
 TON_OGG="/tmp/news-stimme.ogg"
 # ---------------------------------------------- Zweiter Durchgang: Stimme ---
 # Wird vom ersten Durchgang abgekoppelt neu gestartet. Laeuft beliebig lange,
 # ohne dass irgendein Werkzeug-Timeout hineinredet.
 if [ "${1:-}" = "--nur-stimme" ]; then
  SPRECHDATEI="${2:-/tmp/news-sprich.txt}"
  [ -s "$SPRECHDATEI" ] || exit 0
  CODE=$(curl -s -m 600 -X POST "$VOICE/tts" \
          -H 'Content-Type: application/json' \
          --data "$(python3 -c 'import json,sys; print(json.dumps({"text": open(sys.argv[1], encoding="utf-8").read()[:1500]}))' "$SPRECHDATEI")" \
          -o "$TON" -w '%{http_code}' 2>/dev/null)
  [ "$CODE" = "200" ] && [ -s "$TON" ] || exit 0
  # Telegram zeigt eine ECHTE Sprachnachricht (runde Blase, Wellenform) nur bei
  # OGG/Opus. Eine WAV kaeme als Dateianhang an. Mono/48k ist das erwartete Format.
  if ! ffmpeg -y -loglevel error -i "$TON" -c:a libopus -b:a 32k -ar 48000 -ac 1 "$TON_OGG" 2>/dev/null; then
    TON_OGG="$TON"
  fi
  "$HERMES" send --to telegram "MEDIA:$TON_OGG" >/dev/null 2>&1
  exit 0
 fi
 # ------------------------------------------- Erster Durchgang: Text + Start ---
 TEXTDATEI="${1:-/tmp/news-text.md}"
 SPRECHDATEI="${2:-/tmp/news-sprich.txt}"
 if [ ! -s "$TEXTDATEI" ]; then
  bash "$NOTIFY" -s "[News]" "Der Nachrichtenbericht ist leer geblieben ($TEXTDATEI). Da lief etwas schief."
  exit 1
 fi
 # Doppelversand-Sperre. Greift, egal WARUM ein zweiter Aufruf kommt —
 # Timeout, Modell-Wiederholung, versehentlicher Handstart.
 MARKE="/tmp/.news-gesendet-$(sha256sum "$TEXTDATEI" | cut -c1-16)"
 if [ -f "$MARKE" ]; then
  ALTER=$(( $(date +%s) - $(stat -c %Y "$MARKE" 2>/dev/null || echo 0) ))
  if [ "$ALTER" -lt 7200 ]; then
    echo "gemeldet (dieser Bericht ging vor ${ALTER}s bereits raus — nicht doppelt geschickt)"
    exit 0
  fi
 fi
 : > "$MARKE"
 find /tmp -maxdepth 1 -name '.news-gesendet-*' -mtime +2 -delete 2>/dev/null
 bash "$NOTIFY" -s "" "$(cat "$TEXTDATEI")"
 # Stimme abkoppeln: eigene Sitzung, kein Elternprozess, keine offenen Deskriptoren.
 # Damit ueberlebt sie das Ende dieses Skripts und blockiert es nicht.
 if [ -s "$SPRECHDATEI" ]; then
  setsid nohup bash "$0" --nur-stimme "$SPRECHDATEI" >/dev/null 2>&1 < /dev/null &
  disown 2>/dev/null || true
 fi
 echo "gemeldet"
 exit 0
@@ -0,0 +1,43 @@
 #!/usr/bin/env bash
 # sonntags-update.sh — Job 2: "Updates am Sonntag" (21.08.2026).
 #
 # Duenner Aufsatz auf deploy/autoupdate.sh. Bewusst KEIN Neubau: autoupdate.sh
 # macht seit Juli genau das Richtige — Router -> Engine -> Hermes, jede Ebene
 # mit Update-Pruefung, Postcheck, und bei Rot automatischem Rueckbau plus
 # Selbst-Pinnung. Es meldet auch schon selbst ueber notify.sh, also Telegram
 # UND Lucys Stimme.
 #
 # Dieser Aufsatz existiert nur, damit der Job unter `hermes cron list` steht
 # statt in einem separaten systemd-Timer. Ein Ort fuer alle Automatik — genau
 # deshalb ist am 20.08. tagelang niemandem aufgefallen, dass ein Waechter fehlte.
 #
 # Aufruf ueber Hermes-Cron:
 #   hermes cron create '30 4 * * 0' --name 'Updates am Sonntag' \
 #       --no-agent --script sonntags-update.sh --deliver local
 set -uo pipefail
 AUTOUPDATE="${AUTOUPDATE:-$HOME/mission-control-v2/deploy/autoupdate.sh}"
 NOTIFY="${NOTIFY:-$HOME/mission-control-v2/deploy/notify.sh}"
 melde() { bash "$NOTIFY" -s "[Box-Update]" "$1" 2>/dev/null || echo "$1" >&2; }
 if [ ! -f "$AUTOUPDATE" ]; then
  melde "Sonntags-Update ausgefallen: $AUTOUPDATE gibt es nicht. Nichts wurde aktualisiert."
  exit 1
 fi
 # autoupdate.sh meldet waehrend des Laufs selbst (inkl. der KRITISCH-Faelle, in
 # denen ein Bericht am Ende zu spaet kaeme). Wir fangen hier nur den Fall ab,
 # dass es gar nicht erst durchlaeuft — sonst waere das Schweigen zweideutig.
 AUSGABE="$(bash "$AUTOUPDATE" 2>&1)"
 CODE=$?
 if [ "$CODE" -ne 0 ]; then
  melde "Sonntags-Update mit Fehler beendet (exit $CODE). Letzte Zeilen:
 $(printf '%s\n' "$AUSGABE" | tail -15)"
 fi
 # Erfolgsfall: autoupdate.sh hat bereits gemeldet. Leere Ausgabe -> Hermes
 # schweigt, also genau eine Nachricht statt zwei.
 exit 0
@@ -0,0 +1,204 @@
 #!/usr/bin/env bash
 # stack-ist.sh — der IST-Zustand der Box, in Fakten (21.08.2026).
 #
 # Wird von Hermes-Cron "stack-radar" ueber --script eingespeist: die Ausgabe hier
 # landet im Prompt des Agenten, der daraus den Bericht schreibt.
 #
 # GRUNDSATZ: Dieses Skript prueft ERGEBNISSE, nicht Lebenszeichen.
 #   Der alte Selbsttest war am 20.08. gruen, waehrend vier Dinge kaputt waren:
 #   das Kritiker-Gate zeigte auf ein umbenanntes Modell (404), Lucys SOUL.md war
 #   blockiert, das Dashboard stand ohne Passwort offen, die CI war rot.
 #   "Dienst antwortet" haette das nie gefunden. Deshalb wird hier nachgesehen,
 #   ob Dinge STIMMEN — nicht ob sie laufen.
 #
 # Nie mit set -e: ein einzelner fehlschlagender Test darf den Bericht nicht
 # abschneiden. Fehler werden gemeldet, nicht verschwiegen.
 set -uo pipefail
 MC2="${MC2_URL:-http://127.0.0.1:9001}"
 SWAP="${SWAP_URL:-http://127.0.0.1:8080}"
 GITEA="${GITEA_URL:-http://192.168.178.153:3000}"
 OEFFENTLICH="${OEFFENTLICH_URL:-https://mc.tobisniceshomelab.ddnsfree.com}"
 ok()   { printf '  OK    %s\n' "$*"; }
 warn() { printf '  ACHTUNG %s\n' "$*"; }
 bad()  { printf '  ROT   %s\n' "$*"; }
 echo "IST-ZUSTAND DER BOX — $(date '+%d.%m.%Y %H:%M')"
 echo
 # ---------------------------------------------------------------- Dienste ---
 echo "DIENSTE"
 # systemd stellt gescheiterten Units ein "●" voran — das muss weg, sonst meldet
 # der Bericht lauter Aufzaehlungspunkte als kaputte Dienste.
 # EGAL: Units, die dauerhaft scheitern und niemanden stoeren. Ein Bericht, der
 # jeden Tag denselben harmlosen Fehler zeigt, erzieht zum Wegsehen.
 EGAL="at-spi-dbus-bus.service"
 fehl=$(systemctl --user list-units --type=service --state=failed --no-legend --no-pager 2>/dev/null \
       | sed 's/^[^a-zA-Z]*//' | awk '{print $1}')
 gefunden=0
 for d in $fehl; do
  case " $EGAL " in *" $d "*) continue ;; esac
  bad "Dienst gescheitert: $d"; gefunden=1
 done
 [ "$gefunden" = "0" ] && ok "kein Dienst im Fehlerzustand"
 for d in mc2-gateway mission-control-2 hermes-gateway voice-service; do
  systemctl --user is-active --quiet "$d.service" 2>/dev/null \
    && ok "$d laeuft" || bad "$d laeuft NICHT"
 done
 systemctl is-active --quiet llama-swap.service 2>/dev/null \
  && ok "llama-swap laeuft" || bad "llama-swap laeuft NICHT"
 echo
 # ------------------------------------------------------------------ Timer ---
 # Nicht "ist der Timer aktiv", sondern "ist der letzte Lauf gutgegangen".
 echo "TIMER — letzter Lauf"
 for t in $(systemctl --user list-timers --no-legend --no-pager 2>/dev/null | awk '{print $NF}'); do
  dienst="${t%.service}.service"
  case "$dienst" in launchpadlib-*) continue ;; esac   # Ubuntu-Eigenes, nicht unseres
  code=$(systemctl --user show -p ExecMainStatus --value "$dienst" 2>/dev/null)
  wann=$(systemctl --user show -p ExecMainExitTimestamp --value "$dienst" 2>/dev/null | cut -d' ' -f2,3)
  if [ -z "$wann" ]; then warn "$dienst ist eingerichtet, aber NIE gelaufen"
  elif [ "${code:-0}" = "0" ]; then ok "$dienst zuletzt $wann"
  else bad "$dienst zuletzt GESCHEITERT (exit $code) am $wann"; fi
 done
 echo
 # --------------------------------------------------------- Modell-Aliase ---
 # Der Fund vom 19./20.08.: Skripte und Configs nennen Modelle beim Eigennamen,
 # das Modell wird umbenannt, und alles laeuft still in 404. Hier wird geprueft,
 # ob jeder Alias, den irgendwer benutzt, heute noch antwortet.
 echo "MODELL-ALIASE (Rollen muessen aufloesen)"
 liste=$(curl -s -m 10 "$MC2/v1/models" 2>/dev/null \
        | python3 -c 'import sys,json; print(" ".join(m["id"] for m in json.load(sys.stdin)["data"]))' 2>/dev/null)
 if [ -z "$liste" ]; then bad "Modell-Liste nicht abrufbar ueber $MC2/v1"
 else
  ok "verfuegbar: $liste"
  for rolle in hermes fast heavy; do
    case " $liste " in
      *" $rolle "*) ok "Rolle '$rolle' loest auf" ;;
      *)            bad "Rolle '$rolle' FEHLT — Skripte, die sie nennen, laufen in 404" ;;
    esac
  done
 fi
 echo
 # ------------------------------------------------------------- Erreichbar ---
 echo "ERREICHBARKEIT"
 for paar in "MC2:$MC2/api/health" "llama-swap:$SWAP/v1/models" "Gitea:$GITEA/api/v1/version"; do
  name="${paar%%:*}"; url="${paar#*:}"
  code=$(curl -s -m 10 -o /dev/null -w '%{http_code}' "$url" 2>/dev/null)
  [ "$code" = "200" ] && ok "$name antwortet (200)" || bad "$name antwortet mit '$code'"
 done
 echo
 # ------------------------------------------------ Offen im Internet? --------
 # Der Fund vom 21.08.: MC2 hing ueber den Nginx Proxy Manager ungeschuetzt im
 # Netz. ufw sah nichts davon, weil der Proxy im LAN steht. Also von aussen
 # nachsehen — und zwar auf einem Endpunkt, der ECHTE Daten liefert.
 echo "OEFFENTLICHE ERREICHBARKEIT"
 code=$(curl -s -m 15 -o /tmp/.ist-oeff -w '%{http_code}' "$OEFFENTLICH/api/system/status" 2>/dev/null)
 if [ "$code" = "200" ] && head -c1 /tmp/.ist-oeff 2>/dev/null | grep -q '{'; then
  bad "MC2 liefert Systemdaten OHNE Anmeldung ins Internet ($OEFFENTLICH)"
 elif [ "$code" = "401" ] || [ "$code" = "403" ]; then
  ok "oeffentlicher Zugang verlangt Anmeldung ($code)"
 elif [ "$code" = "000" ]; then
  ok "von aussen nicht erreichbar"
 else
  warn "oeffentlicher Zugang antwortet mit '$code' — nachsehen"
 fi
 rm -f /tmp/.ist-oeff
 echo
 # ----------------------------------------------------------------- Ports ---
 echo "OFFENE PORTS (ufw)"
 sudo -n ufw status 2>/dev/null | grep ALLOW | sed 's/^/  /' || warn "ufw-Status nicht lesbar"
 echo
 # --------------------------------------------------------------- CI-Ampel ---
 echo "CI-AMPEL (Gitea)"
 T=$(tr -d '[:space:]' < "$HOME/.config/gitea/create-token" 2>/dev/null)
 if [ -z "$T" ]; then warn "kein Gitea-Token — CI nicht pruefbar"
 else
  curl -s -m 20 -H "Authorization: token $T" "$GITEA/api/v1/user/repos?limit=100" 2>/dev/null \
  | python3 -c '
 import sys, json
 try:
    repos = json.load(sys.stdin)
 except Exception as e:
    print("  ACHTUNG Repo-Liste nicht lesbar:", e); sys.exit(0)
 print(f"  OK    {len(repos)} Repos in Gitea")
 ' 2>/dev/null || warn "Repo-Liste nicht lesbar"
 fi
 echo
 # ------------------------------------------------------------- Sicherung ---
 echo "SICHERUNGEN"
 # Pfad aus backup.sh: DEST_DIR="$MODELS_DIR/mc2-backups"
 SICHER="${MC_BACKUP_DIR:-/srv/models/mc2-backups}"
 neuestes=$(find "$SICHER" -maxdepth 2 -type f -newermt '-2 days' 2>/dev/null | head -1)
 anzahl=$(find "$SICHER" -maxdepth 2 -type f 2>/dev/null | wc -l)
 if [ -n "$neuestes" ]; then
  ok "Sicherung juenger als 2 Tage vorhanden ($anzahl Staende in $SICHER)"
 elif [ "$anzahl" -gt 0 ]; then
  bad "juengste Sicherung ist AELTER als 2 Tage ($anzahl Staende in $SICHER)"
 else
  bad "gar keine Sicherung in $SICHER"
 fi
 echo
 # ------------------------------------------------------------------ Platz ---
 echo "PLATZ UND LAST"
 # Nur eindeutige Dateisysteme: / und /srv liegen hier auf demselben Geraet,
 # doppelt gemeldet las sich das wie ein Befund.
 df -h --output=source,size,used,avail,pcent,target / /srv 2>/dev/null \
  | awk '!gesehen[$1]++ {printf "  %s\n", $0}'
 echo "  RAM: $(free -h | awk '/^Mem:/{print $3" von "$2" belegt"}')"
 echo
 # ------------------------------------------------------------- Warm/Kalt ---
 # ---------------------------------------------------------------- Curator ---
 # Hierher gefaltet am 22.08.2026 aus dem Repo `curator-staleness-check`.
 # Das war ein eigener Wachhund mit eigenem systemd-Timer und eigener CI-Ampel —
 # und er ueberwachte einen Cron-Job ueber eine FEST VERDRAHTETE ID
 # (a47910e2ef05), den es laengst nicht mehr gibt. Er haette bei jedem Lauf
 # Alarm geschlagen fuer etwas, das gar nicht existiert.
 # Hier steht dieselbe Frage in vier Zeilen, ohne Repo, Timer und Ampel.
 echo "CURATOR"
 AN=$(grep -A3 '^curator:' "$HOME/.hermes/config.yaml" 2>/dev/null | grep -m1 'enabled:' | awk '{print $2}')
 if [ "${AN:-false}" != "true" ]; then
  ok "Curator ist abgeschaltet — nichts zu ueberwachen"
 else
  # %Ts liefert GANZE Sekunden. %T@ waere ein Float — bash rechnet damit nicht
  # und bricht mit "invalid arithmetic operator" ab.
  JUENGSTES=$(find "$HOME/.hermes/logs/curator" -type f -name '*.log' -printf '%Ts\n' 2>/dev/null | sort -rn | head -1)
  if [ -z "$JUENGSTES" ]; then
    bad "Curator ist AN, hat aber noch nie etwas protokolliert"
  else
    TAGE=$(( ( $(date +%s) - JUENGSTES ) / 86400 ))
    if   [ "$TAGE" -le 7 ];  then ok   "Curator war vor $TAGE Tagen zuletzt aktiv"
    elif [ "$TAGE" -le 21 ]; then warn "Curator seit $TAGE Tagen still — laeuft er noch?"
    else                          bad  "Curator seit $TAGE Tagen still, obwohl eingeschaltet"
    fi
  fi
 fi
 echo
 echo "MODELLE IM SPEICHER"
 curl -s -m 10 "$SWAP/running" 2>/dev/null \
 | python3 -c '
 import sys, json
 try:
    d = json.load(sys.stdin)
 except Exception:
    print("  ACHTUNG llama-swap-Status nicht lesbar"); sys.exit(0)
 lauf = d.get("running", [])
 if not lauf:
    print("  OK    kein Modell geladen (alles kalt)")
 for m in lauf:
    print("  OK    " + str(m.get("model")) + " - " + str(m.get("state")))
 '
 echo
 echo "ENDE IST-ZUSTAND"
@@ -0,0 +1,106 @@
 #!/usr/bin/env bash
 # stack-radar.sh — Job 3: "KI & Stack Radar" (21.08.2026).
 #
 # Ablauf:  IST-Zustand holen (Fakten)  ->  Modell bewerten lassen (Prosa)
 #          ->  ueber notify.sh melden (Telegram + Lucys Stimme)
 #
 # KUGELSICHER heisst hier konkret:
 #   * Die Fakten kommen aus stack-ist.sh, nicht aus dem Modell. Faellt das Modell
 #     aus, werden die ROTEN Zeilen trotzdem gemeldet — roh statt gar nicht.
 #   * Es meldet IMMER. "Alles gruen" ist ein Ergebnis, kein Grund zu schweigen.
 #   * Kein set -e: ein einzelner Fehlschlag darf den Bericht nicht abschneiden.
 #
 # Aufruf ueber Hermes-Cron:
 #   hermes cron create '0 8 * * 6' --name 'KI & Stack Radar' \
 #       --no-agent --script stack-radar.sh --deliver local
 # (--no-agent, weil dieses Skript selbst meldet. Leere Ausgabe = Hermes schweigt.)
 set -uo pipefail
 HIER="$(cd "$(dirname "$0")" && pwd)"
 IST_SKRIPT="${IST_SKRIPT:-$HOME/.hermes/scripts/stack-ist.sh}"
 NOTIFY="${NOTIFY:-$HOME/mission-control-v2/deploy/notify.sh}"
 GATEWAY="${GATEWAY_URL:-http://127.0.0.1:9010/v1}"
 MODELL="${RADAR_MODELL:-fast}"   # bewusst NICHT heavy: das laedt 68 GB und der
                                 # Radar meldet danach seinen eigenen Speicherverbrauch als Befund
 [ -x "$IST_SKRIPT" ] || IST_SKRIPT="$HIER/stack-ist.sh"
 melde() {
  if [ -x "$NOTIFY" ] || [ -f "$NOTIFY" ]; then
    bash "$NOTIFY" -s "[Stack-Radar]" "$1"
  else
    # Letzte Rueckfallebene: wenigstens ins Log, damit nichts still verschwindet.
    echo "[stack-radar] MELDEWEG FEHLT — Bericht folgt roh:" >&2
    echo "$1" >&2
  fi
 }
 # ------------------------------------------------------------- 1. Fakten ---
 IST="$(bash "$IST_SKRIPT" 2>&1)"
 if [ -z "$IST" ]; then
  melde "Radar konnte den IST-Zustand nicht erheben — $IST_SKRIPT lieferte nichts. Das ist selbst ein Befund: bitte nachsehen."
  exit 1
 fi
 ROT="$(printf '%s\n' "$IST" | grep -E '^\s+(ROT|ACHTUNG)' || true)"
 ANZ_ROT="$(printf '%s\n' "$ROT" | grep -c 'ROT' || true)"
 # ------------------------------------------------------- 2. Bewertung ------
 # Das Modell bekommt NUR die Fakten und darf nichts dazuerfinden. Es soll
 # einordnen, nicht ermitteln.
 PROMPT="Du bist der Stack-Radar einer selbstgehosteten KI-Box. Unten steht der
 gemessene IST-Zustand. Schreibe einen kurzen Bericht auf Deutsch, per Du.
 Regeln:
 - Erfinde NICHTS. Nur was unten steht.
 - Beginne mit einer Zeile Gesamturteil.
 - Dann: was ist ROT oder ACHTUNG, und was waere jeweils der naechste Schritt.
 - Verbesserungsvorschlaege NUR, wenn sich aus den Zahlen unten wirklich etwas
  Konkretes ergibt. Gibt es nichts, lass den Abschnitt ersatzlos weg. Schreibe
  lieber gar keinen Vorschlag als einen ausgedachten - ein Bericht mit
  Fuellmaterial wird nicht gelesen.
 - Was du an den Messwerten selbst merkwuerdig findest, gehoert unter ACHTUNG,
  nicht unter Verbesserungen.
 - Wenn alles gruen ist, sag das in einem Satz und hoere auf.
 - Keine Ueberschriften-Deko, keine Emojis, hoechstens 200 Woerter.
 IST-ZUSTAND:
 $IST"
 ANTWORT=""
 if NUTZLAST="$(python3 -c '
 import json, sys
 print(json.dumps({
    "model": sys.argv[1],
    "messages": [{"role": "user", "content": sys.argv[2]}],
    "max_tokens": 900,
    "temperature": 0.3,
 }))' "$MODELL" "$PROMPT" 2>/dev/null)"; then
  ANTWORT="$(curl -s -m 300 -X POST "$GATEWAY/chat/completions" \
      -H 'Content-Type: application/json' -d "$NUTZLAST" 2>/dev/null \
    | python3 -c '
 import json, sys
 try:
    print(json.load(sys.stdin)["choices"][0]["message"]["content"].strip())
 except Exception:
    pass' 2>/dev/null)"
 fi
 # ------------------------------------------------------------- 3. Melden ---
 if [ -n "$ANTWORT" ]; then
  melde "$ANTWORT"
 else
  # Modell stumm oder kaputt -> die Fakten gehen TROTZDEM raus. Genau dafuer
  # steht das Modell nicht im kritischen Pfad.
  if [ -n "$ROT" ]; then
    melde "Radar: Bewertung durch das Modell hat nicht geklappt — hier die Rohbefunde:
 $ROT"
  else
    melde "Radar: alles gruen (Bewertung durch das Modell hat nicht geklappt, die Messung schon)."
  fi
 fi
 # Hermes bekommt eine LEERE Ausgabe -> keine zweite Nachricht. Gemeldet wurde
 # bereits ueber notify.sh, und das erreicht Telegram UND Lucys Stimme.
 exit 0
@@ -1,192 +0,0 @@
 #!/usr/bin/env bash
 # Karten-Gutachter (naechtlich 04:00 — "Lucy kennt sich", 12.07.2026): stempelt jede neue
 # Auftragsbuch-Karte mit einer Empfehlung (ANNEHMEN/ABLEHNEN/UNKLAR + EIN ehrlicher Satz),
 # damit der Commander nie blind klickt. Ein-Schuss-Richter gegen llama-swap (:8080,
 # fremdblick-Architektur, Muster chef-gutachter-feed.sh) — bekommt Karte (Commit-Text,
 # Dateien, Diff) UND den Selbst-Steckbrief (was schon existiert), prueft also genau die
 # Falle vom 12.07. (redundanter Gateway-Restart-Vorschlag). Der Stempel ist eine MEINUNG,
 # kein Gate: die Karte bleibt klickbar, die Entscheidung bleibt beim Commander.
 # Laeuft als Cron mit --no-agent: stdout leer = still; gestempelte Karten = kurze Zeilen.
 # Ablage: /srv/models/mc2-karten-gutachten.json (Backend mischt es in die Karten-API).
 set -uo pipefail
 API="${MC_API:-http://127.0.0.1:9001}"
 OUT="${MC2_KARTEN_GUTACHTEN:-/srv/models/mc2-karten-gutachten.json}"
 ENDPOINT="${GUTACHTER_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}"
 CHEF="${GUTACHTER_MODEL:-gpt-oss-120b}"
 VERTRETUNG="${GUTACHTER_FALLBACK:-GLM-4.7-Flash}"
 STECK="$HOME/.hermes/state/selbst-steckbrief.md"
 MAX_JE_LAUF=3   # Nacht-GPU-Budget: Rest kommt morgen dran
 briefkasten() { # $1=Betreff  $2=Text
  curl -sf -m 5 -X POST "${MC_ANNOUNCE_URL:-http://127.0.0.1:9001/api/voice/announce}" \
    -H 'Content-Type: application/json' \
    --data "$(python3 - "$1" "$2" <<'PY'
 import json, sys
 print(json.dumps({"text": sys.argv[2], "subject": sys.argv[1],
                  "source": "karten-gutachter", "priority": "silent"}))
 PY
 )" >/dev/null 2>&1 || true
 }
 TMPD="$(mktemp -d /tmp/karten-gutachter.XXXXXX)"
 trap 'rm -rf "$TMPD"' EXIT
 if ! curl -sf -m 20 "$API/api/auftragsbuch" -o "$TMPD/items.json" 2>/dev/null; then
  echo "Karten-Gutachter: Auftragsbuch nicht erreichbar — kein Lauf."
  exit 0
 fi
 # Offene, noch ungestempelte Karten ermitteln + verwaiste Stempel aufraeumen (Karte weg
 # oder neuer Stand = Stempel weg). Schluessel: "<repo>:<branch>@<ts>" haengt am Commit-
 # Zeitstempel — ein nachgeschobener Commit macht den alten Stempel automatisch ungueltig.
 python3 - "$TMPD/items.json" "$OUT" > "$TMPD/plan.txt" <<'PY'
 import json, sys, os
 items = (json.load(open(sys.argv[1], encoding="utf-8")) or {}).get("items") or []
 out_path = sys.argv[2]
 try:
    alt = json.load(open(out_path, encoding="utf-8"))
    if not isinstance(alt, dict):
        alt = {}
 except Exception:
    alt = {}
 offen = {}
 for it in items:
    state = (it.get("status") or {}).get("state")
    if state in ("eingespielt", "laeuft", "rollback"):
        continue  # entschieden oder gerade in Arbeit — kein Stempel noetig
    key = "{}:{}".format(it.get("repo", "mc2"), it.get("branch", "?"))
    offen[key] = it
 # Verwaiste/veraltete Stempel raus (atomar zurueckschreiben).
 neu = {}
 for key, g in alt.items():
    it = offen.get(key)
    if it and g.get("commit_ts") == it.get("ts"):
        neu[key] = g
 tmp = out_path + ".tmp"
 with open(tmp, "w", encoding="utf-8") as f:
    json.dump(neu, f, ensure_ascii=False)
 os.replace(tmp, out_path)
 for key, it in offen.items():
    if key in neu:
        continue
    repo, branch = key.split(":", 1)
    print("\x1f".join([repo, branch, str(it.get("ts") or 0),
                       (it.get("subject") or "")[:200],
                       (it.get("shortstat") or "")[:200]]))
 PY
 RASTER='Du bist der KARTEN-GUTACHTER einer lokalen KI-Box. Du bekommst EINE Vorschlags-Karte aus dem Auftragsbuch (Commit-Text, Datei-Liste, Diff) und den SELBST-STECKBRIEF der Box (was schon existiert und laeuft). Der Commander ist kein Entwickler — dein Urteil ist seine einzige fachliche Zweitmeinung vor dem Klick. Pruefe NUR anhand des Materials, erfinde nichts: (1) REDUNDANZ — existiert das laut Steckbrief oder Diff schon? Ein Vorschlag, der Bestehendes nur nachbaut oder verschlechtert (z. B. funktionierende Einstellungen ersetzt), ist abzulehnen. (2) RISIKO — beruehrt der Diff Security (Tokens/approvals/ufw/sudoers), loescht er Daten oder aendert er Verhalten, das der Commander nicht bestellt hat? (3) NUTZEN — loest er ein echtes, benanntes Problem? Antworte auf DEUTSCH in exakt zwei Zeilen: "URTEIL: ANNEHMEN" oder "URTEIL: ABLEHNEN" oder "URTEIL: UNKLAR", danach "SATZ: <ein ehrlicher Satz Begruendung in Alltagssprache>". Kein weiterer Text.'
 judge() { # $1=Modell  $2=Timeout  $3=max_tokens  (liest $EVID)
  local req
  req="$(jq -n --arg m "$1" --arg sys "$RASTER" --arg usr "$EVID" --argjson mt "$3" \
    '{model:$m, messages:[{role:"system",content:$sys},{role:"user",content:$usr}],
      max_tokens:$mt, temperature:0.2}')"
  curl -s -m "$2" "$ENDPOINT" -H 'Content-Type: application/json' --data-binary "$req" \
    | python3 -c '
 import json, sys
 try:
    d = json.load(sys.stdin)
    msg = d["choices"][0]["message"]
    print((msg.get("content") or msg.get("reasoning_content") or "").strip())
 except Exception:
    pass'
 }
 N=0
 while IFS=$'\x1f' read -r repo branch cts subject stat; do
  [ -n "${repo:-}" ] || continue
  [ "$N" -ge "$MAX_JE_LAUF" ] && { echo "Karten-Gutachter: Tages-Deckel ($MAX_JE_LAUF) erreicht — Rest morgen."; break; }
  DIFF="$(curl -sfG -m 30 "$API/api/auftragsbuch/diff" \
      --data-urlencode "branch=$branch" --data-urlencode "repo=$repo" 2>/dev/null \
    | python3 -c '
 import json, sys
 try:
    print((json.load(sys.stdin).get("diff") or "")[:20000])
 except Exception:
    pass' || true)"
  # Leerer Diff = deterministisch UNKLAR, OHNE Richter (Erstlauf 12.07.: eine Karte mit
  # 0 Dateien bekam trotzdem ANNEHMEN — ein LLM kann einen leeren Vorschlag nicht pruefen).
  if [ -z "${DIFF//[[:space:]]/}" ]; then
    python3 - "$OUT" "$repo" "$branch" "$cts" <<'PY'
 import json, os, sys, time
 out_path = sys.argv[1]
 try:
    data = json.load(open(out_path, encoding="utf-8"))
    if not isinstance(data, dict):
        data = {}
 except Exception:
    data = {}
 data["{}:{}".format(sys.argv[2], sys.argv[3])] = {
    "empfehlung": "UNKLAR",
    "satz": "Der Vorschlag hat einen LEEREN Diff (0 geaenderte Dateien gegen main) — da gibt es nichts zu pruefen; technisch verdaechtig, im Zweifel ablehnen.",
    "richter": "mechanische Regel (leerer Diff)",
    "commit_ts": int(sys.argv[4]) if sys.argv[4].isdigit() else None,
    "ts": int(time.time())}
 tmp = out_path + ".tmp"
 with open(tmp, "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False)
 os.replace(tmp, out_path)
 PY
    N=$((N + 1))
    echo "Karte ${branch}: Empfehlung UNKLAR — leerer Diff (mechanische Regel, kein Richter noetig)."
    briefkasten "Karten-Gutachter" "Karte '${branch}' (${repo}): Empfehlung UNKLAR — der Diff ist leer (0 Dateien), technisch verdaechtig."
    continue
  fi
  EVID="KARTE ${repo}:${branch}
 COMMIT: ${subject}
 UMFANG: ${stat}
 DIFF (ggf. gekuerzt):
 ${DIFF:-(Diff nicht lesbar)}
 SELBST-STECKBRIEF DER BOX (was schon existiert):
 $(head -90 "$STECK" 2>/dev/null || echo '(noch keine Selbst-Inventur gelaufen)')"
  RICHTER="$CHEF"
  URTEIL_RAW="$(judge "$CHEF" 420 1600)"
  if [ -z "${URTEIL_RAW// /}" ]; then
    RICHTER="$VERTRETUNG (Vertretung)"
    URTEIL_RAW="$(judge "$VERTRETUNG" 240 1200)"
  fi
  [ -z "${URTEIL_RAW// /}" ] && { echo "Karte ${branch}: Gutachter ausgefallen (kein Richter erreichbar)."; continue; }
  printf '%s' "$URTEIL_RAW" > "$TMPD/urteil.txt"
  STAMP="$(python3 - "$TMPD/urteil.txt" "$OUT" "$repo" "$branch" "$cts" "$RICHTER" <<'PY'
 import json, os, re, sys, time
 raw = open(sys.argv[1], encoding="utf-8", errors="replace").read()
 m_u = re.search(r"URTEIL:\s*(ANNEHMEN|ABLEHNEN|UNKLAR)", raw, re.I)
 m_s = re.search(r"SATZ:\s*(.+)", raw)
 urteil = (m_u.group(1).upper() if m_u else "UNKLAR")
 satz = (m_s.group(1).strip() if m_s else "Analyse unklar — Urteil nicht lesbar.")[:300]
 out_path = sys.argv[2]
 try:
    data = json.load(open(out_path, encoding="utf-8"))
    if not isinstance(data, dict):
        data = {}
 except Exception:
    data = {}
 key = "{}:{}".format(sys.argv[3], sys.argv[4])
 data[key] = {"empfehlung": urteil, "satz": satz, "richter": sys.argv[6],
             "commit_ts": int(sys.argv[5]) if sys.argv[5].isdigit() else None,
             "ts": int(time.time())}
 tmp = out_path + ".tmp"
 with open(tmp, "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False)
 os.replace(tmp, out_path)
 print(urteil + "\x1f" + satz)
 PY
 )"
  URTEIL="${STAMP%%$'\x1f'*}"; SATZ="${STAMP#*$'\x1f'}"
  N=$((N + 1))
  echo "Karte ${branch}: Empfehlung ${URTEIL} — ${SATZ}"
  briefkasten "Karten-Gutachter" "Karte '${branch}' (${repo}): Empfehlung ${URTEIL} — ${SATZ} (Richter: ${RICHTER})"
 done < "$TMPD/plan.txt"
 # stdout bleibt LEER, wenn nichts zu stempeln war (--no-agent => stille Nacht).
@@ -4,13 +4,13 @@ globalTTL: 0
 models:
  Qwen3.6-35B-A3B:
-    # parallel 2 + c 131072: 2 Slots à 65k (Slot 2 = Mem0-Lern-Extraktion, blockiert Voice-Turns
+    # parallel 2 + c 131072: 2 Slots à 65k (Slot 2 = Nebenlast/Hintergrund-Extraktion, blockiert Voice-Turns
    # nicht mehr); KV Q8_0 macht das speicherneutral zu vorher (65k f16). Bench 2026-07-02:
    # Q8_0 kostet 0 t/s, MTP n-max 3 = +26% vs. ohne Spec. (Q4_K-KV stand mal im Template,
    # lief aber NIE live — bewusst bei Q8_0 geblieben: Qualität vor ein paar GB, seit der
    # Warm-Set-Diät 07.07. ist RAM nicht mehr der Engpass.)
    cmd: |
-      llama-server -m /srv/models/Qwen3.6-35B-A3B-MTP-GGUF/Qwen3.6-35B-A3B-UD-Q4_K_M.gguf --host 127.0.0.1 --port ${PORT} -c 131072 -ngl 999 -fa on --no-mmap --jinja --parallel 2 -cram 16384 -ctk q8_0 -ctv q8_0 --spec-type draft-mtp --spec-draft-n-max 3
+      llama-server -m /srv/models/Qwen3.6-35B-A3B-MTP-GGUF/Qwen3.6-35B-A3B-UD-Q4_K_M.gguf --host 127.0.0.1 --port ${PORT} -c 131072 -ngl 999 -fa on --no-mmap --jinja --parallel 2 -cram 16384 -ctk q8_0 -ctv q8_0 --spec-type draft-dflash --spec-draft-model /srv/models/Qwen3.6-35B-A3B-DFlash-GGUF/giocom-Qwen3.6-35B-A3B-DFlash-Q8_0.gguf
    ttl: 0
    aliases:
    - hermes
@@ -21,17 +21,35 @@ models:
      out: [text]
      tools: true
      context: 65536
-  Qwen3-Coder-Next:
+  Qwen3.8-27B:
    # Qwen 3.8 27B: Dichtes 27B-Modell mit hybrider Linear-Attention (48/64 Schichten linear),
    # nativem Multimodal-Support (mmproj-BF16) und Tool-Calling via --jinja.
    # Unser neuer Haupt-Coder mit 262k Kontext, Thinking Mode und extrem sauberer Code-Qualität.
    cmd: |
-      llama-server -m /srv/models/Qwen3-Coder-Next-GGUF/Qwen3-Coder-Next-Q4_K_M.gguf --host 127.0.0.1 --port ${PORT} -c 131072 -ngl 999 -fa on --no-mmap --jinja --cache-reuse 256 -cram 16384
+      llama-server -m /srv/models/Qwen3.8-27B-GGUF/Qwen3.8-27B-Q4_K_M.gguf --host 127.0.0.1 --port ${PORT} -c 131072 -ngl 999 -fa on --no-mmap --mmproj /srv/models/Qwen3.8-27B-GGUF/mmproj-BF16.gguf --jinja --parallel 1 -cram 16384 -ctk q8_0 -ctv q8_0
-    ttl: 600
+    ttl: 5400
    aliases:
    - coder
    capabilities:
-      in: [text]
+      in: [text, image]
      out: [text]
      tools: true
      # --parallel 1 = der Coder bekommt den ganzen Slot (34a9862, am laufenden Prozess
      # gegengeprueft). Er hat nur einen Verbraucher; Lucy/explore nutzen hermes, review heavy.
      context: 131072
  Muse-Glimmer-30B:
    # Meta Muse Glimmer 30B: Dichtes 30B-Agenten-Modell mit DFlash-Speculative-Drafting
    # und 1.8B Perception Multimodal Projector. Ideal als Runtime-Debugger & Fehler-Diagnostiker.
    cmd: |
      llama-server -m /srv/models/Muse-Glimmer-30B-GGUF/Muse-Glimmer-30B-UD-Q4_K_XL.gguf --host 127.0.0.1 --port ${PORT} -c 65536 -ngl 999 -fa on --no-mmap --mmproj /srv/models/Muse-Glimmer-30B-GGUF/mmproj-kquant.gguf --jinja --spec-type draft-dflash --spec-draft-model /srv/models/Muse-Glimmer-30B-GGUF/dflash-kquant.gguf
    ttl: 600
    aliases:
    - debugger
    capabilities:
      in: [text, image]
      out: [text]
      tools: true
      context: 65536
  Qwen3-Embedding-0.6B:
    cmd: |
      llama-server -m /srv/models/Qwen3-Embedding-0.6B-GGUF/Qwen3-Embedding-0.6B-Q8_0.gguf --host 127.0.0.1 --port ${PORT} --embedding --pooling last -ngl 999 -fa on --no-mmap -c 8192
@@ -52,11 +70,6 @@ models:
      tools: true
      context: 32768
  Qwen3-VL-30B-A3B-Instruct:
    # Lucys AUGEN — seit 07.07. ON-DEMAND (User-Entscheid: „Gehirn + Embedding reichen
    # komplett; Vision nur wenn Lucy auf dem Desktop an ist oder die IDE-Lane sie braucht").
    # NICHT mehr in brains; ttl 900 = 15 Min Nachlauf nach dem letzten Blick. Die Lucy-App
    # wärmt die Augen beim Start selbst an (useVoiceAgent-Warm-Gate). Vorher: warm, ttl 0 —
    # das kostete ~19 GB Dauerbelegung und verdrängte den 60-GB-Chef-Gutachter.
    cmd: |
      llama-server -m /srv/models/Qwen3-VL-30B-A3B-Instruct-GGUF/Qwen3-VL-30B-A3B-Instruct-Q4_K_M.gguf --host 127.0.0.1 --port ${PORT} -c 32768 -ngl 999 -fa on --no-mmap --mmproj /srv/models/Qwen3-VL-30B-A3B-Instruct-GGUF/mmproj-F16.gguf --jinja
    ttl: 900
@@ -66,34 +79,8 @@ models:
      in: [text, image]
      out: [text]
      context: 32768
  GLM-4.6V-Flash:
    cmd: |
      llama-server -m /srv/models/GLM-4.6V-Flash-GGUF/GLM-4.6V-Flash-Q4_K_M.gguf --host 127.0.0.1 --port ${PORT} -c 131072 -ngl 999 -fa on --no-mmap --mmproj /srv/models/GLM-4.6V-Flash-GGUF/mmproj-BF16.gguf --jinja
    ttl: 300
    aliases:
    - scout
    capabilities:
      in: [text, image]
      out: [text]
      tools: true
      context: 131072
  GLM-4.7-Flash:
    # KRITIKER (07.07., Rollen-Audit): Fremd-Vendor-Zweitmeinung für fremdblick-Prosa +
    # Chef-Gutachter-Vertretung — reines Textmodell, 30B-A3B (MIT, Unsloth-Dynamic-Quant).
    # Die Vision-Schwester GLM-4.6V-Flash bleibt als scout für Bild-Jobs. --jinja ist
    # Pflicht (Chat-Template, sonst kaputte Tool-Calls).
    cmd: |
      llama-server -m /srv/models/GLM-4.7-Flash-GGUF/GLM-4.7-Flash-UD-Q4_K_XL.gguf --host 127.0.0.1 --port ${PORT} -c 65536 -ngl 999 -fa on --no-mmap --jinja
    ttl: 600
    aliases:
    - kritiker
    capabilities:
      in: [text]
      out: [text]
      tools: true
      context: 65536
  Qwen3-Reranker-0.6B:
-    # Gedächtnis-Zweitstufe (07.07., Rollen-Audit): ordnet Mem0-Suchtreffer nach echter
+    # Gedächtnis-Zweitstufe (07.07., Rollen-Audit): ordnet Gedächtnis-Suchtreffer nach echter
    # Relevanz (/v1/rerank, Mungert-GGUF — Community-Konvertierungen liefern oft Nullscores!).
    # Winzig (~0,7 GB) → in brains (verdrängungssicher); lädt in ~1-2 s, erste Anfrage wärmt.
    cmd: |
@@ -1,5 +1,5 @@
 [Unit]
-Description=MC2 Zustands-Backup (mem0 + Hermes-Configs/Secrets + llama-swap config)
+Description=MC2 Zustands-Backup (Hermes-Configs/Secrets + llama-swap config)
 Documentation=file:%h/mission-control-v2/docs/BACKUP.md
 [Service]
@@ -1,9 +0,0 @@
 [Unit]
 Description=MC2 Bagatell-Annahme (reine Doku-Vorschläge nachts ohne Klick, mit Fangnetz)
 Documentation=file:%h/mission-control-v2/docs/AUFTRAGSBUCH.md
 [Service]
 Type=oneshot
 # Als /tmp-Kopie laufen lassen: die Annahme deployt (git reset --hard) und würde sonst das
 # eigene Skript unter dem laufenden bash austauschen (bekannte Selbst-Reset-Falle).
 ExecStart=/bin/bash -c 'cp "%h/mission-control-v2/deploy/bagatell-annahme.sh" /tmp/mc2-bagatell-run.sh && exec /bin/bash /tmp/mc2-bagatell-run.sh'
@@ -1,9 +0,0 @@
 [Unit]
 Description=Täglich 04:10 — Bagatell-Annahme (nach der Nacht-Sicherung 03:30, vor der Morgenlage 04:30)
 [Timer]
 OnCalendar=*-*-* 04:10:00
 Persistent=false
 [Install]
 WantedBy=timers.target
@@ -1,7 +0,0 @@
 [Unit]
 Description=MC2 Morgen-Digest (Nächtliche Telegram-Zusammenfassung)
 [Service]
 Type=oneshot
 ExecStart=/bin/bash %h/mission-control-v2/deploy/morgen-digest.sh
 TimeoutStartSec=300
@@ -1,10 +0,0 @@
 [Unit]
 Description=Timer für MC2 Morgen-Digest (07:00 Uhr)
 [Timer]
 OnCalendar=*-*-* 07:00:00
 Persistent=true
 RandomizedDelaySec=5m
 [Install]
 WantedBy=timers.target
@@ -1,7 +0,0 @@
 [Unit]
 Description=MC2 Selbst-Smoke-Tests (Gateway/Tools/Voice aktiv durchspielen, Alarm bei Rot)
 Documentation=file:%h/mission-control-v2/docs/AUTONOMIE_PLAN.md
 [Service]
 Type=oneshot
 ExecStart=/bin/bash %h/mission-control-v2/deploy/self-smoke.sh
@@ -1,10 +0,0 @@
 [Unit]
 Description=Täglicher MC2-Selbst-Smoke-Test (07:15, unabhängig von Updates)
 [Timer]
 OnCalendar=*-*-* 07:15:00
 Persistent=true
 RandomizedDelaySec=300
 [Install]
 WantedBy=timers.target
@@ -1,12 +1,22 @@
 # systemd-USER-Unit für den MC2-Steward — die Wächter-Loops als eigener Prozess (UMBAU v3 P2).
-# Re-Warm-Wächter, Health-Sentry und Mem0-Dedupe überleben damit jeden Steuerpult-Neustart,
+# Re-Warm-Wächter und Health-Sentry überleben damit jeden Steuerpult-Neustart, und der Sentry
-# und der Sentry kann erstmals auch das Steuerpult SELBST + den mc2-gateway überwachen
+# kann auch das Steuerpult SELBST + den mc2-gateway überwachen (MC_SENTRY_WATCH_MC2=1).
-# (MC_SENTRY_WATCH_MC2=1). Meldungen gehen per HTTP in den MC2-Briefkasten (MC_ANNOUNCE_HTTP);
+# Meldungen gehen per HTTP in den MC2-Briefkasten (MC_ANNOUNCE_HTTP); ist MC2 down, greift
-# ist MC2 down, greift weiterhin der Telegram-Direktweg (notify.sh).
+# weiterhin der Telegram-Direktweg (notify.sh).
 # Sudo-frei wie alle MC2-Units: ~/.config/systemd/user/ + systemctl --user.
 #
 # ‼️ NACHGETRAGEN 27.08.2026: Diese Unit lief auf der Box, fehlte aber im Repo — sie war weder
 # versioniert noch vom Disaster-Recovery abgedeckt, obwohl backend/routers/system.py,
 # services/maintenance.py (USER_SERVICES) und deploy/stack-postcheck.sh sie voraussetzen.
 # Inhalt 1:1 von der laufenden Box übernommen (`systemctl --user cat mc2-steward`), nur die
 # Description um den entfallenen Mem0-Dedupe-Loop gekürzt. Das Warm-Set-Drop-in liegt
 # daneben in mc2-steward.service.d-warmset.conf — beim Ausrollen mitnehmen.
 #
 # Ablage: ~/.config/systemd/user/mc2-steward.service ; dann:
 #   systemctl --user daemon-reload && systemctl --user enable --now mc2-steward
 [Unit]
-Description=MC2 Steward (Wächter: Re-Warm, Health-Sentry, Mem0-Dedupe)
+Description=MC2 Steward (Wächter: Re-Warm, Health-Sentry)
 After=network-online.target
 Wants=network-online.target
@@ -0,0 +1,11 @@
 # Drop-in für mc2-steward.service — Ablage auf der Box:
 #   ~/.config/systemd/user/mc2-steward.service.d/warmset.conf
 #
 # 26.07.2026 — Ko-Residenz ist nicht Warm-Pflicht. Die Gruppe `brains` enthaelt seit dem
 # Umbau auch Modelle MIT TTL (Coder 90 min, Kritiker 30 min); ohne diese Liste hielte der
 # Waechter sie faelschlich fuer dauerhaft faellig und arbeitete gegen die TTLs.
 # ANFUEHRUNGSZEICHEN SIND PFLICHT: systemd trennt Environment= an Leerzeichen, ohne sie
 # kommt nur das erste Modell an (live erlebt) — das Warm-Ziel waere still zu klein.
 [Service]
 Environment="MC_WARMSET=Qwen3-Embedding-0.6B Qwen3-Reranker-0.6B Qwen3.6-35B-A3B"
 Environment=MC_WARMUP_RERANK=reranker
@@ -1,147 +0,0 @@
 #!/usr/bin/env python3
 """mem0-Konsolidierung (monatlich, 19.07.2026 — Nachtrag Phase 2 Drei-Welten-Plan).
 mem0 OSS v2 ist ADD-only: Es legt Fakten an, loest aber Widersprueche nie auf und
 legt Aehnliches nie zusammen — ohne Pflege waechst das Gedaechtnis unbegrenzt und
 der Recall verrauscht. Der Steward-Dedupe faengt nur exakte Dubletten. Dieser Lauf
 macht die fehlende Konsolidierung:
  1. Cluster aehnlicher Fakten holen — ueber den bestehenden /graph-Endpunkt des
     Sidecars (Kosinus der gespeicherten Embeddings, kein Re-Embedding, kein
     Chroma-Zugriff noetig).
  2. Je Cluster entscheidet das lokale Hirn (Alias `fast`, Thinking aus wie im
     Sidecar): zusammenlegen / Widerspruch aufloesen (neuester Zeitstempel
     gewinnt) / NICHTS tun.
  3. Anwenden ueber die normalen Sidecar-Endpunkte (PUT/DELETE /memory/<id>).
 Sicherheitsleitplanken (hart im Code, nicht im Prompt):
  - Pro Cluster ueberlebt IMMER mindestens ein Fakt.
  - Nur ids aus dem Cluster, max. 1 Update pro Cluster, Inhalt <= 600 Zeichen.
  - LLM-Fehler / kaputtes JSON => Cluster bleibt unangetastet.
  - Kappung pro Lauf (MAX_CLUSTERS), damit ein Lauf nie das halbe Gedaechtnis
    umpfluegt — der naechste Monat macht weiter.
 Aufruf: mem0-konsolidierung.py [--apply]   (Default: Dry-Run, druckt nur Plan)
 """
 import json
 import sys
 import time
 import urllib.request
 MEM0 = "http://127.0.0.1:8765"
 LLM = "http://127.0.0.1:8080/v1/chat/completions"
 LLM_MODEL = "fast"
 MIN_SCORE = 0.82
 MAX_CLUSTERS = 15
 MAX_FACTS_PER_CLUSTER = 6
 APPLY = "--apply" in sys.argv
 def _http(method: str, url: str, body: dict | None = None, timeout: float = 120.0):
    data = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(url, data=data, method=method,
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=timeout) as r:
        return json.loads(r.read().decode() or "{}")
 def clusters_from_graph() -> tuple[dict, list]:
    g = _http("GET", f"{MEM0}/graph?min_score={MIN_SCORE}&top_k=5", timeout=180)
    nodes = {n["id"]: n for n in g.get("nodes", [])}
    parent: dict = {}
    def find(x):
        parent.setdefault(x, x)
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x
    for e in g.get("edges", []):
        a, b = find(e["source"]), find(e["target"])
        if a != b:
            parent[a] = b
    groups: dict = {}
    for nid in parent:
        groups.setdefault(find(nid), []).append(nid)
    clusters = [sorted(v) for v in groups.values() if len(v) >= 2]
    clusters.sort(key=len, reverse=True)
    return nodes, clusters[:MAX_CLUSTERS]
 def judge(facts: list[dict]) -> list[dict]:
    """LLM entscheidet pro Cluster. Fehler => [] (nichts tun)."""
    listing = "\n".join(
        f"- id={f['id']} | kategorie={f.get('category')} | stand={f.get('updated_at', '')[:10]} | {f.get('content', '')}"
        for f in facts)
    system = (
        "Du konsolidierst ein Langzeitgedaechtnis. Unten steht EINE Gruppe semantisch "
        "aehnlicher Fakten. Entscheide konservativ: "
        "(a) Sind es Facetten DESSELBEN Fakts: fasse sie in EINEM praezisen deutschen Satz "
        "zusammen -> genau ein update auf die beste id, die anderen delete. "
        "(b) Widersprechen sie sich: der Fakt mit dem NEUESTEN Stand gewinnt -> veraltete delete. "
        "(c) Sind es VERSCHIEDENE Fakten (nur thematisch verwandt): TUE NICHTS. "
        "Im Zweifel IMMER (c). Antworte NUR als JSON: "
        '{"actions":[{"op":"update","id":"...","content":"..."},{"op":"delete","id":"..."}]} '
        'oder {"actions":[]}.'
    )
    try:
        resp = _http("POST", LLM, {
            "model": LLM_MODEL,
            "messages": [{"role": "system", "content": system},
                         {"role": "user", "content": "Fakten-Gruppe:\n" + listing}],
            "temperature": 0.1, "max_tokens": 800,
            "response_format": {"type": "json_object"},
            "chat_template_kwargs": {"enable_thinking": False},
        })
        raw = resp["choices"][0]["message"]["content"] or "{}"
        actions = json.loads(raw).get("actions", [])
    except Exception as exc:
        print(f"  (LLM-Fehler, Gruppe unangetastet: {exc})")
        return []
    # Harte Validierung — Leitplanken siehe Docstring.
    ids = {f["id"] for f in facts}
    updates = [a for a in actions if a.get("op") == "update" and a.get("id") in ids
               and isinstance(a.get("content"), str) and 0 < len(a["content"]) <= 600]
    deletes = [a for a in actions if a.get("op") == "delete" and a.get("id") in ids]
    if len(updates) > 1:
        return []
    del_ids = {a["id"] for a in deletes} - {a["id"] for a in updates}
    if len(del_ids) >= len(ids):
        return []
    return updates + [{"op": "delete", "id": i} for i in sorted(del_ids)]
 def main() -> None:
    t0 = time.time()
    nodes, clusters = clusters_from_graph()
    total = len(nodes)
    print(f"mem0-Konsolidierung {'(APPLY)' if APPLY else '(DRY-RUN)'} — "
          f"{total} Fakten, {len(clusters)} Gruppen >= {MIN_SCORE}")
    n_upd = n_del = 0
    for ci, cl in enumerate(clusters, 1):
        facts = [nodes[i] for i in cl][:MAX_FACTS_PER_CLUSTER]
        actions = judge(facts)
        if not actions:
            continue
        print(f"Gruppe {ci} ({len(facts)} Fakten):")
        for f in facts:
            print(f"    [{f['id'][:8]}] {f.get('content', '')[:90]}")
        for a in actions:
            if a["op"] == "update":
                print(f"  -> UPDATE {a['id'][:8]}: {a['content'][:90]}")
                n_upd += 1
                if APPLY:
                    _http("PUT", f"{MEM0}/memory/{a['id']}", {"content": a["content"]})
            else:
                print(f"  -> DELETE {a['id'][:8]}")
                n_del += 1
                if APPLY:
                    _http("DELETE", f"{MEM0}/memory/{a['id']}")
    print(f"Ergebnis: {n_upd} zusammengefasst, {n_del} geloescht, "
          f"{total - (n_del if APPLY else 0)} Fakten verbleiben. "
          f"({int(time.time() - t0)} s)")
 if __name__ == "__main__":
    main()
@@ -1,6 +0,0 @@
 #!/usr/bin/env bash
 # Monatlicher mem0-Konsolidierungslauf (Cron-Wrapper, 3. des Monats 06:40 —
 # nach Restore-Probe am 1. und Venv-Audit am 2.). no_agent-Job: stdout geht
 # als Bericht direkt an Telegram. Logik: deploy/mem0-konsolidierung.py (--apply).
 set -u
 exec python3 "$HOME/.hermes/scripts/mem0-konsolidierung.py" --apply 2>&1
@@ -1,26 +0,0 @@
 [Unit]
 Description=MC2 Mem0 Sidecar — auto-lernendes, semantisches Gedächtnis (mem0 + chroma)
 Documentation=https://github.com/mem0ai/mem0
 After=network.target
 [Service]
 # Mem0 + chromadb laufen nur unter Python 3.12 (~/.mem0/venv) — das MC2-Backend (3.14)
 # kann sie nicht importieren. Darum dieser schlanke Sidecar; MC2 spricht ihn per HTTP an.
 # Bind 127.0.0.1: nur lokal erreichbar (MC2 proxyt nach außen).
 Type=simple
 WorkingDirectory=%h/mission-control-v2/mem0_service
 Environment=MEM0_PORT=8765
 Environment=MEM0_CHROMA_PATH=/srv/models/mem0/chroma
 Environment=MEM0_HISTORY_DB=/srv/models/mem0/history.db
 Environment=MEM0_EMBED_URL=http://127.0.0.1:8080/v1
 Environment=MEM0_LLM_URL=http://127.0.0.1:8080/v1
 Environment=MEM0_EMBED_MODEL=embed
 Environment=MEM0_LLM_MODEL=fast
 Environment=MEM0_EMBED_DIMS=1024
 Environment=TOKENIZERS_PARALLELISM=false
 ExecStart=%h/.mem0/venv/bin/python -m uvicorn app:app --host 127.0.0.1 --port 8765
 Restart=always
 RestartSec=3
 [Install]
 WantedBy=default.target
@@ -19,19 +19,16 @@ Environment=MC_PORT=9001
 Environment=MC_LLAMA_SWAP_URL=http://127.0.0.1:8080
 Environment=MC_CONFIG_PATH=/etc/llama-swap/config.yaml
 Environment=MC_MODELS_DIR=/srv/models
 # Geteiltes Gedächtnis = die bestehende v1-DB (Kontinuität bis/über Cutover).
 Environment=MC_MEMORY_DB=/srv/models/mission-control-memory.db
 # Gateway-Auszug (UMBAU v3 P1): /v1 roh an den eigenständigen mc2-gateway-Prozess
 # durchreichen. Diese Zeile entfernen (+ daemon-reload + restart) = Rollback, MC2
 # bedient /v1 wieder selbst.
 Environment=MC_V1_UPSTREAM=http://127.0.0.1:9010
-# Steward-Auszug (UMBAU v3 P2): Die Wächter-Loops (Re-Warm, Health-Sentry, Mem0-Dedupe)
+# Steward-Auszug (UMBAU v3 P2): Die Wächter-Loops (Re-Warm, Health-Sentry) laufen jetzt im
-# laufen jetzt im eigenen Dienst mc2-steward.service — hier deshalb AUS. Diese drei
+# eigenen Dienst mc2-steward.service — hier deshalb AUS. Diese zwei Zeilen entfernen
-# Zeilen entfernen (+ daemon-reload + restart) = Rollback (Loops wieder im Steuerpult).
+# (+ daemon-reload + restart) = Rollback (Loops wieder im Steuerpult).
 # Der reminders_loop bleibt bewusst HIER (teilt Datei+CRUD mit /api/reminders).
 Environment=MC_REWARM_ENABLED=0
 Environment=MC_SENTRY_ENABLED=0
 Environment=MC_MEM_DEDUPE_ENABLED=0
 # KEIN MC_ENGINE_UPDATE_CMD-Override mehr: Das alte /usr/local/bin/update-llamacpp zog den
 # ROCm-Build nach /opt/llamacpp (totes Rollback-Dir) statt des aktiven Vulkan-Builds → Updates
 # liefen ins Leere ("DONE", aber nichts passierte). Ohne Override nutzt das Backend den Default
@@ -1,62 +0,0 @@
 #!/usr/bin/env bash
 # Morgen-Digest: Sammelt die zurückgehaltenen nächtlichen Meldungen (00:00 - 06:59)
 # und lässt Lucy (LLM) eine Telegram-Zusammenfassung daraus bauen.
 set -uo pipefail
 NIGHT_QUEUE="$HOME/.hermes/night-queue.txt"
 if [ ! -f "$NIGHT_QUEUE" ]; then
  # Keine nächtlichen Meldungen
  exit 0
 fi
 # Wenn die Datei existiert, aber leer ist, löschen und beenden.
 if [ ! -s "$NIGHT_QUEUE" ]; then
  rm -f "$NIGHT_QUEUE"
  exit 0
 fi
 EVIDENCE="$(cat "$NIGHT_QUEUE")"
 PROMPT="Du bist Lucy, die KI-Assistenz der Mission-Control-Box. 
 Hier sind die Systemmeldungen der vergangenen Nacht. 
 Der Commander möchte ordentlich Futter und Details zum Frühstück! Fasse die Meldungen zu einem gehaltvollen Morgen-Digest zusammen.
 Beachte dabei:
 - Nenne konkrete Fakten, Namen und Versionen.
 - Welche Modelle wurden z.B. vom Radar entdeckt oder evaluiert? Was waren die Ergebnisse?
 - Welche Updates liefen genau und was haben sie Neues gebracht? Was muss sich der Commander noch anschauen?
 - Strukturiere die Nachricht übersichtlich (z.B. mit kleinen Emojis oder Bulletpoints), aber bleibe in deiner Rolle als Lucy.
 Nächtliche Meldungen:
 $EVIDENCE"
 # LLM aufrufen (llama-swap / gpt-oss-120b)
 ENDPOINT="${CHEF_ENDPOINT:-http://127.0.0.1:8080/v1/chat/completions}"
 MODEL="${CHEF_MODEL:-gpt-oss-120b}"
 REQ="$(jq -n --arg m "$MODEL" --arg sys "Du bist Lucy." --arg usr "$PROMPT" --argjson mt 1200 \
  '{model:$m, messages:[{role:"system",content:$sys},{role:"user",content:$usr}],
    max_tokens:$mt, temperature:0.4}')"
 DIGEST="$(curl -s -m 180 "$ENDPOINT" -H 'Content-Type: application/json' --data-binary "$REQ" \
  | python3 -c '
 import json, sys
 try:
    d = json.load(sys.stdin)
    msg = d["choices"][0]["message"]
    print((msg.get("content") or msg.get("reasoning_content") or "").strip())
 except Exception:
    pass'
 )"
 if [ -n "$DIGEST" ]; then
  # Sende den Digest via hermes send (Telegram)
  bash -lc 'hermes send --to telegram --subject "[🌅 Morgen-Digest]" -- "$1"' _ "$DIGEST"
  if [ $? -eq 0 ]; then
    # Erfolgreich gesendet, Queue leeren
    rm -f "$NIGHT_QUEUE"
  else
    echo "Fehler beim Senden des Morgen-Digests an Telegram. Queue bleibt erhalten." >&2
  fi
 else
  echo "Leerer Digest vom LLM. Queue bleibt erhalten." >&2
 fi
--- a/Show More
+++ b/Show More