chore: correct hardware specs to 128GB RAM in AGENTS.md and trend-radar

This reverts commit ae622dfa88, reversing
changes made to 76d2d7c74b.

.agents/mcp_config.json

@@ -0,0 +1,22 @@
+{
+  "mcpServers": {
+    "mc2-memory": {
+      "command": "python",
+      "args": [
+        "F:\\Coding Stuff\\mission-control-2\\mcp\\mcp_memory.py"
+      ]
+    },
+    "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"
+      ]
+    }
+  }
+}

.aiexclude

@@ -0,0 +1,27 @@
+# .aiexclude — was der KI-Assistent (Antigravity/Gemini) NICHT lesen/indexieren soll.
+# Gitignore-Syntax. Ziel: der Review fokussiert auf QUELLCODE, nicht auf Abhängigkeiten,
+# Build-Output oder Binärdateien.
+
+# Abhängigkeiten & Build-Output (kein Review-Ziel)
+backend/.venv/
+frontend/node_modules/
+frontend/dist/
+**/__pycache__/
+*.pyc
+.git/
+
+# Große / binäre / sensible Dateien
+*.vrm
+*.gguf
+*.onnx
+*.safetensors
+*.wav
+*.env
+.env
+credentials*
+*.key
+*.pem
+
+# Lokale Scratch-/Recon-Skripte
+box_recon*
+gemma_swap*

.claude/launch.json

@@ -1,28 +1,37 @@
-{
-  "version": "0.0.1",
-  "configurations": [
-    {
-      "name": "mc2",
-      "runtimeExecutable": "F:\\Coding Stuff\\mission-control-2\\backend\\.venv\\Scripts\\python.exe",
-      "runtimeArgs": [
-        "-m",
-        "uvicorn",
-        "app:app",
-        "--app-dir",
-        "F:\\Coding Stuff\\mission-control-2\\backend",
-        "--port",
-        "9000"
-      ],
-      "port": 9000
-    },
-    {
-      "name": "frontend",
-      "runtimeExecutable": "npm",
-      "runtimeArgs": ["run", "dev", "--", "--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
-    }
-  ]
-}
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "mc2",
+      "runtimeExecutable": "F:\\Coding Stuff\\mission-control-2\\backend\\.venv\\Scripts\\python.exe",
+      "runtimeArgs": [
+        "-m",
+        "uvicorn",
+        "app:app",
+        "--app-dir",
+        "F:\\Coding Stuff\\mission-control-2\\backend",
+        "--port",
+        "9000"
+      ],
+      "port": 9000
+    },
+    {
+      "name": "frontend",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": ["run", "dev", "--", "--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
+    }
+  ]
+}

.claude/settings.local.json

@@ -0,0 +1,100 @@
+{
+  "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 *)",
+      "Bash(ssh hitonabi@192.168.178.151:*)",
+      "Bash(grep -E \"\\\\.py$|^d\")",
+      "Bash(grep -rn \"http://\\\\|https://\\\\|/srv/\\\\|/opt/\\\\|/etc/\" services/*.py routers/*.py)",
+      "Bash(awk '/^\\(async \\)?def /{in_func=1; func=$0; line=NR} in_func {count++} /^\\(async \\)?def / && NR!=line {if\\(count>30\\) print \"Line \" line \": \" func \" \\(\" count \" lines\\)\"; count=0; func=$0; line=NR} END{if\\(count>30\\) print \"Line \" line \": \" func \" \\(\" count \" lines\\)\"}' routers/*.py services/*.py)",
+      "Bash(grep -rhoE 'api\\(<[^>]+>\\)?\\\\\\(\"\\(/api|/v1\\)[^\"`]*' frontend/src/)",
+      "Bash(sed -E 's/api\\(<[^>]+>\\)?\\\\\\(\"//')",
+      "Bash(grep -rhoE 'api\\(<[^>]+>\\)?\\\\\\(`[^`]*`' frontend/src/)",
+      "Bash(python -c ' *)",
+      "Bash(echo \"tsc exit: $?\")",
+      "WebSearch",
+      "WebFetch(domain:lobehub.com)",
+      "WebFetch(domain:docs.litellm.ai)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:runaihome.com)",
+      "WebFetch(domain:docs.getbifrost.ai)",
+      "WebFetch(domain:thefrontierlab.ai)",
+      "WebFetch(domain:www.glukhov.org)",
+      "WebFetch(domain:cognio.so)",
+      "Bash(ssh -o BatchMode=yes -o ConnectTimeout=10 hitonabi@192.168.178.151 'curl -s http://127.0.0.1:8080/running; echo; echo \"--- after a quick hermes ping, whats running ---\"; curl -s http://127.0.0.1:8080/running')",
+      "Bash(git checkout *)",
+      "Bash(ssh -o BatchMode=yes -o ConnectTimeout=10 hitonabi@192.168.178.151 \"sed -n '46,75p' /etc/llama-swap/config.yaml\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"node --version 2>/dev/null || echo 'no-node'; docker --version 2>/dev/null || echo 'no-docker'; python3 --version; systemctl --user list-units --type=service --state=running 2>/dev/null | head -10\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"systemctl --user cat hermes-gateway.service 2>/dev/null; echo '---'; ls ~/hermes-gateway/ 2>/dev/null || ls ~/mission-control-v2/deploy/ | grep gateway\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"ls ~/.hermes/ && echo '---' && ls ~/.hermes/hermes-agent/ 2>/dev/null && echo '---' && cat ~/.hermes/config/config.yaml 2>/dev/null || cat ~/.hermes/config.yaml 2>/dev/null\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"journalctl --user -u hermes-gateway.service --no-pager -n 20\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"cat ~/.hermes/config.yaml | grep -A5 'api_server\\\\|api_key\\\\|gateway_api\\\\|secret' | head -30\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"grep -r 'gateway_api_key\\\\|api_server\\\\|HERMES_API_KEY\\\\|8642' ~/.hermes/config.yaml ~/.config/environment.d/ 2>/dev/null | head -20; echo '---'; cat ~/.config/environment.d/*.conf 2>/dev/null | grep -i hermes | head -20\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"grep -r 'hermes.*gateway\\\\|gateway.*url\\\\|8642\\\\|GATEWAY' ~/mission-control-v2/backend/ 2>/dev/null | grep -v '.pyc' | head -20\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"grep -A20 'def get_agent_status\\\\|def check\\\\|HERMES_API' ~/mission-control-v2/backend/services/agent.py | head -40\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"cat ~/.hermes/gateway_state.json 2>/dev/null | python3 -c 'import json,sys; d=json.load\\(sys.stdin\\); print\\(list\\(d.keys\\(\\)\\)\\); print\\(d.get\\(\\\\\"api_key\\\\\"\\) or d.get\\(\\\\\"key\\\\\"\\) or \\\\\"no key field\\\\\"\\)' 2>/dev/null; echo '---'; ls ~/.hermes/auth* ~/.hermes/pairing/ 2>/dev/null\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"~/.hermes/hermes-agent/venv/bin/python -m hermes_cli.main gateway status 2>&1 | head -20; echo '---'; curl -s http://127.0.0.1:8642/health 2>/dev/null || curl -s http://127.0.0.1:8642/ 2>/dev/null | head -5\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"cat ~/.hermes/gateway_state.json | python3 -c 'import json,sys; d=json.load\\(sys.stdin\\); print\\(json.dumps\\(d.get\\(\\\\\"platforms\\\\\", {}\\), indent=2\\)\\)'\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"bash ~/mission-control-v2/deploy/deploy.sh\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"~/.hermes/hermes-agent/venv/bin/python -m hermes_cli.main gateway connect --help 2>&1 | head -30\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"~/.hermes/hermes-agent/venv/bin/python -m hermes_cli.main gateway enroll --help 2>&1\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"~/.hermes/hermes-agent/venv/bin/python -m hermes_cli.main gateway setup --help 2>&1\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"~/.hermes/hermes-agent/venv/bin/python -m hermes_cli.main --help 2>&1 | head -40\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"cat ~/.hermes/.env 2>/dev/null; echo '---'; ~/ .hermes/hermes-agent/venv/bin/python -m hermes_cli.main config --help 2>&1 | head -20\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"sed -i 's|# TELEGRAM_BOT_TOKEN=|TELEGRAM_BOT_TOKEN=8908266336:AAElPDmdEJXZ5cs0gUzbAnm4a9glRY18Zac|' ~/.hermes/.env && grep TELEGRAM_BOT_TOKEN ~/.hermes/.env\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"systemctl --user restart hermes-gateway && sleep 3 && journalctl --user -u hermes-gateway --no-pager -n 15\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"sleep 4 && journalctl --user -u hermes-gateway --no-pager -n 20 --since '1 minute ago'\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"sleep 3 && journalctl --user -u hermes-gateway --no-pager -n 25 --since '2 minutes ago'\")",
+      "Bash(ssh hitonabi@192.168.178.151 \"sed -i 's|# TELEGRAM_ALLOWED_USERS=.*|TELEGRAM_ALLOWED_USERS=6150562984|' ~/.hermes/.env && grep TELEGRAM_ALLOWED ~/.hermes/.env\")",
+      "Bash(mkdir -p \"F:\\\\Coding Stuff\\\\mission-control-2\\\\docs\\\\memory\")",
+      "Bash(cp \"C:\\\\Users\\\\TobisPC\\\\.claude\\\\projects\\\\F--Coding-Stuff-mission-control-2\\\\memory\\\\project-stack-state.md\" \"F:\\\\Coding Stuff\\\\mission-control-2\\\\docs\\\\memory\\\\\" && cp \"C:\\\\Users\\\\TobisPC\\\\.claude\\\\projects\\\\F--Coding-Stuff-mission-control-2\\\\memory\\\\project-hermes-setup.md\" \"F:\\\\Coding Stuff\\\\mission-control-2\\\\docs\\\\memory\\\\\")",
+      "Bash(cp \"C:\\\\Users\\\\TobisPC\\\\.claude\\\\projects\\\\F--Coding-Stuff-mission-control-2\\\\memory\\\\project-mc2-architecture.md\" \"F:\\\\Coding Stuff\\\\mission-control-2\\\\docs\\\\memory\\\\\" && cp \"C:\\\\Users\\\\TobisPC\\\\.claude\\\\projects\\\\F--Coding-Stuff-mission-control-2\\\\memory\\\\project-pending-tasks.md\" \"F:\\\\Coding Stuff\\\\mission-control-2\\\\docs\\\\memory\\\\\")",
+      "Bash(ssh -o BatchMode=yes -o ConnectTimeout=8 hitonabi@192.168.178.151 'echo \"=== ENGINE VERSION ===\"; /usr/local/bin/llama-server --version 2>&1 | head -3; echo \"=== LLAMA-SWAP VERSION ===\"; \\(llama-swap --version 2>&1 || /usr/local/bin/llama-swap --version 2>&1 || echo \"no --version\"\\) | head -3; echo \"=== RUNNING MODELS ===\"; curl -s http://127.0.0.1:8080/running 2>&1 | head -c 2000; echo; echo \"=== FREE MEM ===\"; free -g | head -3')",
+      "Bash(ssh -o BatchMode=yes -o ConnectTimeout=8 hitonabi@192.168.178.151 'echo \"=== HERMES CONFIG ===\"; cat ~/.hermes/config.yaml 2>&1 | head -120; echo \"=== HERMES DIR ===\"; ls -la ~/.hermes/ 2>&1 | head -40')",
+      "Bash(ssh -o BatchMode=yes -o ConnectTimeout=8 hitonabi@192.168.178.151 'echo \"=== HERMES CONFIG \\(rest\\) ===\"; sed -n \"120,400p\" ~/.hermes/config.yaml 2>&1; echo \"=== TOOLS COUNT \\(api/all\\) ===\"; cd ~/.hermes 2>/dev/null; \\(hermes tools list 2>&1 | tail -40\\) || echo \"hermes CLI not on PATH\"')",
+      "Bash(ssh -o BatchMode=yes -o ConnectTimeout=8 hitonabi@192.168.178.151 ' *)",
+      "Bash(xargs cat)",
+      "Bash(ssh -o ConnectTimeout=8 -o BatchMode=yes hitonabi@192.168.178.151 'echo \"=== llama-server version ===\"; /usr/local/bin/llama-server --version 2>&1 | head -5; echo \"=== running models ===\"; curl -s http://127.0.0.1:8080/running 2>/dev/null | head -c 2000; echo; echo \"=== free ===\"; free -g')",
+      "Bash(ssh -o ConnectTimeout=8 -o BatchMode=yes hitonabi@192.168.178.151 'echo \"=== config.yaml ===\"; cat /etc/llama-swap/config.yaml; echo; echo \"=== models on disk ===\"; du -sh /srv/models/* 2>/dev/null | sort -h')",
+      "Bash(ssh -o ConnectTimeout=8 -o BatchMode=yes hitonabi@192.168.178.151 'echo \"=== Qwen3.6 MTP dir ===\"; ls -la /srv/models/Qwen3.6-35B-A3B-MTP-GGUF/ 2>/dev/null; echo \"=== drafts dir ===\"; ls -la /srv/models/drafts/ 2>/dev/null; echo \"=== disk free ===\"; df -h /srv 2>/dev/null; echo \"=== gemma remnant ===\"; ls -la /srv/models/gemma-4-26B-A4B-it-GGUF/ 2>/dev/null')",
+      "Bash(ssh -o ConnectTimeout=8 -o BatchMode=yes hitonabi@192.168.178.151 ' *)",
+      "Bash(ssh -o ConnectTimeout=12 -o BatchMode=yes hitonabi@192.168.178.151 ' *)",
+      "WebFetch(domain:unsloth.ai)",
+      "WebFetch(domain:huggingface.co)",
+      "Bash(xargs ls -la)",
+      "Bash(xargs wc -l)",
+      "PowerShell(ssh -o StrictHostKeyChecking=accept-new -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"echo '=== engine ==='; /opt/llamacpp-vulkan/llama-server --version 2>&1 | head -3; echo; echo '=== llama-swap version ==='; /opt/llama-swap/llama-swap --version 2>/dev/null || llama-swap --version 2>/dev/null || ls -la /opt/llama-swap 2>/dev/null | head -5; echo; echo '=== running models ==='; curl -s http://127.0.0.1:8080/running; echo; echo '=== services ==='; for s in llama-swap mc2-backend hermes-api hermes-webui mem0-service voice-service; do printf '%s: ' $s; systemctl is-active $s 2>/dev/null; done; echo '=== uname/mem ==='; uname -r; free -g | head -2\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"echo '=== ports ==='; ss -tlnp 2>/dev/null | grep -E ':\\(9001|8642|8650|8765|8787|7681|8080|8130\\)'; echo; echo '=== wer serviert 9001? ==='; systemctl list-units --all --type=service --no-pager --no-legend | grep -iE 'gateway|backend|control|api'; echo; echo '=== mem0 venv ==='; systemctl cat mem0-service 2>/dev/null | grep -E 'ExecStart|WorkingDirectory'; echo; echo '=== voice venv ==='; systemctl cat voice-service 2>/dev/null | grep -E 'ExecStart|WorkingDirectory'\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"echo '=== 9001 Prozess ==='; cat /proc/11257/cmdline 2>/dev/null | tr '\\\\0' ' '; echo; readlink /proc/11257/cwd; ps -o etime= -p 11257; echo; echo '=== mc2 backend unit? ==='; ls /etc/systemd/system/ | grep -iE 'mc2|mission|backend'; echo; echo '=== mem0 pip ==='; MEMPY=/proc/7277/exe; readlink /proc/7277/cwd; readlink /proc/7277/exe; V=\\(dirname \\(readlink /proc/7277/exe\\)\\); echo; /srv/mc2/mem0-venv/bin/pip show mem0ai 2>/dev/null | head -2\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"echo '=== 9001 Prozess ==='; tr '\\\\0' ' ' < /proc/11257/cmdline; echo; readlink /proc/11257/cwd; ps -o etime= -p 11257; echo '=== mc2 unit? ==='; ls /etc/systemd/system/ | grep -iE 'mc2|mission|backend|llama|hermes|mem0|voice'; echo '=== mem0 exe ==='; readlink /proc/7277/exe; readlink /proc/7277/cwd\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"echo '=== mission-control.service ==='; systemctl is-enabled mission-control 2>&1; systemctl is-active mission-control 2>&1; grep -E 'ExecStart|WorkingDirectory' /etc/systemd/system/mission-control.service; echo; echo '=== mem0ai version ==='; ls /home/hitonabi/mission-control-v2/mem0_service/ | head; for p in /home/hitonabi/mission-control-v2/mem0_service/.venv/bin/pip /home/hitonabi/mission-control-v2/mem0_service/venv/bin/pip; do [ -x \\\\\"\\\\$p\\\\\" ] && \\\\\"\\\\$p\\\\\" show mem0ai chromadb 2>/dev/null | grep -E 'Name|Version'; done\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"tr '\\\\0' '\\\\n' < /proc/7277/environ | grep -E 'VIRTUAL_ENV|PATH=' | head -3; tr '\\\\0' ' ' < /proc/7277/cmdline; echo; /home/hitonabi/.local/share/uv/python/cpython-3.12.13-linux-x86_64-gnu/bin/python3.12 -c 'import mem0; print\\(mem0.__version__\\)' 2>&1 | tail -1\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"/home/hitonabi/.mem0/venv/bin/pip show mem0ai 2>/dev/null | grep -E 'Name|Version'; /home/hitonabi/.mem0/venv/bin/pip show chromadb 2>/dev/null | grep Version\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"ls /home/hitonabi/.mem0/venv/bin/ | head -8; /home/hitonabi/.mem0/venv/bin/python -m pip show mem0ai chromadb 2>&1 | grep -E 'Name:|Version:'\")",
+      "PowerShell(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 \"/home/hitonabi/.mem0/venv/bin/python -c 'import importlib.metadata as m; print\\(\\\\\"mem0ai\\\\\", m.version\\(\\\\\"mem0ai\\\\\"\\)\\); print\\(\\\\\"chromadb\\\\\", m.version\\(\\\\\"chromadb\\\\\"\\)\\)' 2>&1\")",
+      "Bash(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 '/home/hitonabi/.mem0/venv/bin/python -c \"import importlib.metadata as m; print\\(\\\\\"mem0ai\\\\\", m.version\\(\\\\\"mem0ai\\\\\"\\)\\); print\\(\\\\\"chromadb\\\\\", m.version\\(\\\\\"chromadb\\\\\"\\)\\)\"')",
+      "WebFetch(domain:docs.mem0.ai)",
+      "PowerShell(Write-Output '=== Lucy-Prozesse lokal ==='; Get-Process | Where-Object {$_.ProcessName -match 'electron|python|node'} | Select-Object ProcessName, Id, WorkingSet64 | Format-Table; Write-Output '=== Port 8130 \\(Pocket-TTS\\) ==='; Get-NetTCPConnection -LocalPort 8130 -State Listen -ErrorAction SilentlyContinue | Select-Object LocalAddress, OwningProcess; Write-Output '=== GPU ==='; Get-CimInstance Win32_VideoController | Select-Object Name, DriverVersion | Format-Table)",
+      "PowerShell($p = 'F:\\\\Coding Stuff\\\\mission-control-2\\\\client\\\\lucy-tts\\\\ptts-venv\\\\Scripts\\\\python.exe'; if \\(Test-Path $p\\) { & $p -c \"import importlib.metadata as m; [print\\(n, m.version\\(n\\)\\) for n in ['pocket-tts','torch','onnxruntime','fastapi','numpy'] if True]\" 2>&1 } else { Write-Output 'ptts-venv nicht gefunden'; Get-ChildItem 'F:\\\\Coding Stuff\\\\mission-control-2\\\\client\\\\lucy-tts' -Directory | Select-Object Name })",
+      "Bash(ssh -o ConnectTimeout=10 -o BatchMode=yes hitonabi@192.168.178.151 'echo \"=== /v1/models ===\"; curl -s http://127.0.0.1:9001/v1/models | head -c 600; echo; echo \"=== voice metrics ===\"; curl -s http://127.0.0.1:9001/api/voice/metrics | head -c 1200')",
+      "Bash(ssh -o ConnectTimeout=15 -o BatchMode=yes hitonabi@192.168.178.151 'curl -s -o /dev/null -w \"TTFB_chat_lane: %{time_starttransfer}s total: %{time_total}s\\\\n\" -N -X POST http://127.0.0.1:9001/v1/chat/completions -H \"Content-Type: application/json\" -d \"{\\\\\"model\\\\\":\\\\\"chat\\\\\",\\\\\"stream\\\\\":true,\\\\\"max_tokens\\\\\":24,\\\\\"messages\\\\\":[{\\\\\"role\\\\\":\\\\\"user\\\\\",\\\\\"content\\\\\":\\\\\"Sag nur: hallo\\\\\"}]}\"')",
+      "Bash(ssh -o ConnectTimeout=30 -o BatchMode=yes hitonabi@192.168.178.151 'curl -s -N -X POST http://127.0.0.1:9001/v1/chat/completions -H \"Content-Type: application/json\" -d \"{\\\\\"model\\\\\":\\\\\"chat\\\\\",\\\\\"stream\\\\\":true,\\\\\"max_tokens\\\\\":24,\\\\\"messages\\\\\":[{\\\\\"role\\\\\":\\\\\"user\\\\\",\\\\\"content\\\\\":\\\\\"Sag nur: hallo\\\\\"}]}\" | head -c 500')",
+      "Bash(ssh -o ConnectTimeout=60 -o BatchMode=yes hitonabi@192.168.178.151 'echo \"=== routing policy ===\"; curl -s http://127.0.0.1:9001/api/routing | head -c 800; echo; echo \"=== aliases in llama-swap config ===\"; grep -B1 -A3 \"aliases:\" /etc/llama-swap/config.yaml | head -40; echo \"=== direkt hermes ===\"; curl -s -o /dev/null -w \"TTFB: %{time_starttransfer}s\\\\n\" -N -X POST http://127.0.0.1:9001/v1/chat/completions -H \"Content-Type: application/json\" -d \"{\\\\\"model\\\\\":\\\\\"hermes\\\\\",\\\\\"stream\\\\\":true,\\\\\"max_tokens\\\\\":24,\\\\\"messages\\\\\":[{\\\\\"role\\\\\":\\\\\"user\\\\\",\\\\\"content\\\\\":\\\\\"Sag nur: hallo\\\\\"}]}\"')",
+      "Bash(ssh -o ConnectTimeout=60 -o BatchMode=yes hitonabi@192.168.178.151 'curl -s -N -X POST http://127.0.0.1:9001/v1/chat/completions -H \"Content-Type: application/json\" -d \"{\\\\\"model\\\\\":\\\\\"hermes\\\\\",\\\\\"stream\\\\\":true,\\\\\"max_tokens\\\\\":24,\\\\\"messages\\\\\":[{\\\\\"role\\\\\":\\\\\"user\\\\\",\\\\\"content\\\\\":\\\\\"Sag nur: hallo\\\\\"}]}\" | head -c 400; echo; echo \"=== direkt an llama-swap :8080 ===\"; curl -s -o /dev/null -w \"TTFB: %{time_starttransfer}s total: %{time_total}s\\\\n\" -N -X POST http://127.0.0.1:8080/v1/chat/completions -H \"Content-Type: application/json\" -d \"{\\\\\"model\\\\\":\\\\\"hermes\\\\\",\\\\\"stream\\\\\":true,\\\\\"max_tokens\\\\\":24,\\\\\"messages\\\\\":[{\\\\\"role\\\\\":\\\\\"user\\\\\",\\\\\"content\\\\\":\\\\\"Sag nur: hallo\\\\\"}]}\"')",
+      "WebFetch(domain:www.hermes-ai.net)",
+      "WebFetch(domain:releases.electronjs.org)",
+      "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:*)"
+    ]
+  }
+}

.gitattributes

@@ -7,6 +7,15 @@
 *.service   text eol=lf
 *.timer     text eol=lf
 
+# Agent-Hooks laufen auf der Box (Shebang!) — .py-Hooks MÜSSEN LF behalten,
+# sonst bricht `#!/usr/bin/env python3\r`. (Nur die Hooks + Deploy-Helfer, nicht der ganze Baum.)
+deploy/agent-hooks/*.py  text eol=lf
+deploy/*.py              text eol=lf
+# `deploy/*.py` greift NUR eine Ebene tief (* matcht kein /). Alles darunter
+# (z. B. deploy/governor/governor.py) braucht ein eigenes Muster — sonst kommt es
+# nach einem Windows-Checkout mit CRLF zurück und der Shebang auf der Box bricht.
+deploy/**/*.py           text eol=lf
+
 # Windows-Batch-Wrapper bleiben CRLF.
 *.cmd       text eol=crlf
 *.bat       text eol=crlf

.gitea/workflows/ampel-ci.yml

@@ -0,0 +1,76 @@
+# Ampel-CI fuer MC2 — auf dieses Multi-Service-Monorepo zugeschnitten (24.07.2026).
+#
+# Die universelle Vorlage (deploy/ampel-ci.yml) passt fuer EIN-Service-Repos. MC2 hat
+# 5 Python-Dienste (backend/voice_service/mem0_service/mcp/client) mit schweren ML-
+# Abhaengigkeiten (Whisper/TTS/Embeddings) + ein Frontend. "pip install ALLER requirements
+# + pytest repo-weit" in einem stateless Container ist weder machbar (GB-schwere Wheels,
+# CUDA) noch aussagekraeftig — die echten Tests sind der Pruefstand (deploy/pruefstand)
+# und die Integration auf der Box mit LIVE-Diensten/Modellen, nicht isolierte Unit-Tests.
+#
+# 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.
+name: Ampel
+on: [push, pull_request]
+
+jobs:
+  ampel:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Ampel — Lint + Import + Frontend-Build (MC2-Zuschnitt)
+        shell: bash
+        run: |
+          # Runner-bash laeuft mit -e; abschalten und JEDEN Fehler selbst werten (rot=1),
+          # am Ende EIN Klartext-Urteil (Lehre Ampel-Lauf #5).
+          set -u +e
+          rot=0
+
+          echo "== Python: Lint (ruff, Projekt-Politik aus ruff.toml) =="
+          python3 -m venv /tmp/ampel-venv && . /tmp/ampel-venv/bin/activate || { echo "❌ venv kaputt"; exit 1; }
+          pip install -q ruff || { echo "❌ ruff-Install kaputt"; exit 1; }
+          ruff check . || rot=1
+
+          echo "== Python: Import/Syntax (compileall) =="
+          python3 -m compileall -q backend voice_service mem0_service mcp client deploy hermes scripts || rot=1
+
+          echo "== Frontend: reproduzierbarer Build (npm ci + tsc + vite) =="
+          if [ -f frontend/package.json ]; then
+            if [ ! -f frontend/package-lock.json ]; then
+              echo "❌ frontend/: kein package-lock.json — Build nicht reproduzierbar."
+              rot=1
+            else
+              ( cd frontend && npm ci --no-audit --no-fund && npm run build ) || rot=1
+              
+              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
+
+          if [ $rot -ne 0 ]; then
+            echo "❌ AMPEL ROT — nichts heißt ‚fertig', solange das rot ist."
+          else
+            echo "✅ AMPEL GRÜN — Lint + Import + Frontend-Build sauber."
+          fi
+          exit $rot

.gitignore

@@ -1,44 +1,26 @@
-# Python
-backend/.venv/
-__pycache__/
-*.pyc
-
-# Node / Vite
-frontend/node_modules/
-# 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.
-# Wird per Direkt-Deploy auf die Box gespielt (dist/avatar.vrm), nicht über git.
-frontend/public/avatar.vrm
-frontend/dist/avatar.vrm
-
-# Env / local
-*.env
-.DS_Store
-
-# Box-Recon-/Scratch-Skripte (lokale Diagnose, nicht fürs Repo)
-box_recon*
-gemma_swap*
-
-# Lucy-TTS/F5-Experimente: nur Code/Batch committen — venvs, Modelle, Audio, Logs bleiben lokal
-client/lucy-tts/ptts-venv/
-client/lucy-tts/venv/
-client/lucy-tts/llamacpp-vulkan/
-client/lucy-tts/llamacpp-vulkan.zip
-client/lucy-tts/models/
-client/lucy-tts/out_*/
-client/lucy-tts/*.wav
-client/lucy-tts/*.mp3
-client/lucy-tts/*.log
-client/lucy-tts/*.safetensors
-client/lucy-tts/*.json
-client/lucy-f5/.cache/
-client/lucy-f5/F5-TTS-ONNX/
-client/lucy-f5/onnx_de/
-client/lucy-f5/onnx_f32/
-client/lucy-f5/vocos-mel-24khz/
-client/lucy-f5/*.onnx
-client/lucy-f5/*.safetensors
-client/lucy-f5/*.wav
-client/lucy-f5/*.zip
-client/lucy-f5/venv/
+# Python
+backend/.venv/
+__pycache__/
+*.pyc
+
+# Node / Vite
+frontend/node_modules/
+# 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.
+# Wird per Direkt-Deploy auf die Box gespielt (dist/avatar.vrm), nicht über git.
+frontend/public/avatar.vrm
+frontend/dist/avatar.vrm
+
+# Env / local
+*.env
+.DS_Store
+
+# Box-Recon-/Scratch-Skripte (lokale Diagnose, nicht fürs Repo)
+box_recon*
+gemma_swap*
+
+# TypeScript-Inkrementalcache (reines Build-Artefakt, maschinenabhängig)
+frontend/tsconfig.tsbuildinfo
+
+frontend/dist/

AGENTS.md

@@ -0,0 +1,61 @@
+# AGENTS.md — Mission Control 2.0
+
+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/`.
+
+## Was das ist
+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) ·
+**Hermes-Agent (das autonome Gehirn "Lucy")**. Backend Python (Box läuft Python 3.14), Frontend Vite/React/shadcn/Tailwind.
+
+**Hardware-Spezifikationen der Box (WICHTIG für alle Agenten):**
+- **System:** Bosgame M5 (AMD Strix Halo APU)
+- **Arbeitsspeicher (RAM/VRAM):** 128 GB Shared Memory (ca. 122.7 GB nutzbar).
+- **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.
+- **Inference-Backend:** Primär Vulkan/RADV, experimentell ROCm.
+
+**WICHTIG:** Alle alten Dienste wie `mem0`, `governor` oder `eigenleben` sind komplett gelöscht. Hermes ist das EINZIGE "Gehirn" und läuft autonom. Es nutzt keine alte Mem0-DB, sondern sein eigenes System.
+## Sprache (nicht verhandelbar)
+- **Alles User-Sichtbare ist Deutsch:** UI-Texte, Fehlermeldungen, Update-/Radar-Meldungen,
+  Skills, LLM-Summaries, Commit-Messages, Code-Kommentare.
+- **Hermes' INTERNE System-Prompts bleiben Englisch** (fremde Software, wir forken sie nicht).
+  Antwort-Sprache ≠ Prompt-Sprache — Deutsch kommt aus SOUL.md, nicht aus den Tool-Prompts.
+
+## Build & Deploy (die häufigste Falle)
+- **`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
+  **das neue `frontend/dist` mit-committen**. Vergessen = Box zeigt alten Stand.
+  (Ausnahme: `frontend/dist/avatar.vrm` ist bewusst nicht in git — siehe `.gitignore`.)
+- **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).
+- **Nie direkt auf `main` arbeiten.** Immer Branch (`wartung/...`), Gate grün, dann Merge/Deploy.
+
+## Agentic IDE & Vibe Coding
+- **Zero Middle-Layers:** Coding passiert zu 100% lokal auf dem Dev-PC in der **OpenCode Desktop IDE**.
+- Es gibt keinen Zed-Workflow, keine OpenCode-CLI-Mittelschicht und keinen Governor mehr.
+- Der Agent in OpenCode Desktop nutzt via MCP (`.agents/mcp_config.json`) die API der Box (`:9001/v1`), um autonom Projekte zu bauen.
+- **Mix-Ansatz beim Testen:** Der Agent testet lokal. Vor dem Push muss er prüfen, ob das Gitea-`VERIFY`-Skript fehlerfrei durchläuft.
+
+## Zeit & Umgebung
+- **Box = Ubuntu, läuft in `Europe/Berlin`** (seit 03.07.2026; vorher UTC). Dev-PC = Windows.
+  Naive/lokale Zeiten immer über `MC_LOCAL_TZ` (= `Europe/Berlin`) auflösen, nie `datetime.now()` ohne TZ annehmen
+  (siehe `backend/services/reminders.py`).
+
+## Backend-Konventionen
+- Router unter `backend/routers/` (`APIRouter(prefix="/api")`), Logik in `backend/services/`
+  (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`);
+  keine zweite Allowlist in einem Router duplizieren.
+- **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 =
+  System-Dienst), sauber über die NOPASSWD-Whitelist / `password_required`-Rückgabe, nie hart failen.
+- 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.

README.md

@@ -1,68 +1,144 @@
 # Mission Control 2.0
 
-Komponierbarer Local-AI-Stack für den Bosgame M5. Greenfield-Neuaufbau —
-siehe Architektur-Plan (`docs/` bzw. der genehmigte Plan).
+Steuerzentrale des lokalen KI-Stacks auf dem **Bosgame M5** (AMD Ryzen AI MAX+ 395 „Strix Halo",
+122 GB Unified Memory, **keine dedizierte GPU** — llama.cpp über **Vulkan/RADV**). Läuft live als
+sudo-freier systemd-User-Dienst und ist auf **Autonomie** ausgelegt: Die Box wartet sich selbst,
+prüft sich selbst und meldet sich, wenn etwas nicht stimmt.
 
-**Schichten:** Engine (llama-swap, **Vulkan/RADV** auf Strix Halo) · **Builtin-Routing-Gateway**
-in MC2 (`model: auto`, kein externer LiteLLM-Dienst — scheitert auf Python 3.14) ·
-Mission Control 2.0 (FastAPI + React/shadcn) · Hermes Agent + hermes-webui ·
-Shared Memory (SQLite via MCP). Jede Schicht hinter stabilem Vertrag austauschbar.
+> **100 % lokal.** Kein Cloud-Modell, kein externer Dienst im Datenpfad.
 
-## Status: Phasen 0–5 ✅ · MC2 **live auf der Box** (:9001) · Modelle/Hermes-Wiring + Cutover offen
+## Die drei Bahnen
 
-Fortschritt & Resume-Guide: siehe [`docs/STATUS.md`](docs/STATUS.md).
+| Bahn | Was sie tut | Wo |
+|---|---|---|
+| **Steuerzentrale** | Modelle, Routing, Wartung, Gedächtnis, Ideen-Queue, Auftragsbuch | MC2 `:9001` |
+| **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` |
 
-- **Phase 0** — FastAPI-Skeleton + React/shadcn-Shell (Cmd+K, Dark, PWA).
-- **Phase 1** — Compute-Module (fit/caps/sources, portiert), **Discover** (live HF + Fit + Caps),
-  **Engine-Write** (register + `groups`/Ko-Residenz + vocab-geprüfte Spec-Drafts),
-  **Builtin-Gateway** (`model: auto` + Fallbacks), Frontend **Modelle & Routing** (Caps-Chips, Fit, Discover, Routing-View).
+Lucy holt ihr Hirn über MC2, spricht aber nie durch den Governor — ein Gespräch ist keine
+Bau-Sitzung und wird nie unterbrochen.
 
-- **Phase 2** — System-Status (CPU/RAM/GPU/Disk), Wartung (restart/self-update, sudo-frei),
-  **Connect** (saubere IDE-Snippets → Gateway `model:auto`, LAN-IP-Override).
-- **Phase 3** — Geteiltes **Gedächtnis** (SQLite/WAL, 5 Kategorien, Dedupe-Kurator) + **MCP-Server**
-  (`mcp/mcp_memory.py` shared, `mcp/mcp_mc.py` Stack-Management für Hermes), MemoryView.
+## Ports & Dienste
 
-- **Phase 4** — Hermes-**Agent-Status** (`/api/agent/status`, AgentView mit Tiles + „Hermes öffnen"),
-  `deploy/hermes-webui.service`, **Box-Runbook** [`docs/HERMES_SETUP.md`](docs/HERMES_SETUP.md)
-  (hermes-webui, Brain=`auto`, Tools/MCP-Verdrahtung). Box-Ausführung steht noch aus.
+| Port | Dienst | Erreichbar |
+|---|---|---|
+| `9001` | **MC2** (FastAPI + React) — Cockpit, API, Konsole | LAN |
 
-- **Phase 5** — **Backup** (Memory + Configs), **Services-Health** + Observability-Links,
-  **Theme-Toggle** (Hell/Dunkel). Box-Deploy/-Wiring + Cutover (Phase 6) brauchen die Box.
+| `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 |
 
-API: `health · models · discover · fit · models/register · groups · routing · system/* · connect ·
-memory/* · agent/status` (Details in `docs/STATUS.md`). MCP: `mcp/` (siehe `mcp/requirements.txt`).
-Box-Runbooks: `docs/HERMES_SETUP.md` + `deploy/` (Units, deploy.sh, backup.sh).
+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
+
+```
+Idee in MC2  →  Gitea-Repo (mit CI-Ampel + VERIFY)  →  in Agentic IDE bauen  →  Ampel  →  main
+     └── 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. Die Agentic IDE
+  führt sie im Mix-Ansatz vor jedem Push aus, um Code-Fehler ("Quality Gap") abzufangen.
+  Keine `VERIFY`-Datei = Prüf-Tor aus.
+
+## Modelle & Rollen
+
+Gemessen auf der Box (25.07.2026, Vulkan, Q4):
+
+| 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 |
+| `hermes` / `fast` | Qwen3.6-35B-A3B | **69,6 t/s** | Lucys Hirn **und** der Sucher-Subagent. Immer warm |
+| `kritiker` | Devstral-Small-2-24B | **15,0 t/s** · Prefill **265–318 t/s** | Liest gegen — bewusst **fremde Modellfamilie** (Mistral statt Qwen) |
+| `vision` | Qwen3-VL-30B-A3B | auf Abruf | Lucys Augen |
+| `heavy` | gpt-oss-120b | nur nachts | Chef-Gutachter (4:30). **Nie tagsüber** — verdrängt das warme Set |
+| `embed` · `reranker` | Qwen3 0.6B | immer warm | Gedächtnis + Feinsortierung |
+
+‼️ **Der Kritiker ist bewusst auf 16k Kontext gedeckelt.** Devstral ist ein *dichtes* Modell —
+auf dieser bandbreitenbegrenzten Box bricht sein Prefill mit wachsendem Kontext ein (bei 32k
+gemessene 63 t/s ≈ **9 Minuten nur zum Lesen**). Mit dem 16k-Deckel bleibt der schlimmste Fall
+je Review unter einer Minute. Deshalb ist er der **Gegenleser für Etappen**, nicht der Coder —
+als Coder ist er auf dieser Box disqualifiziert (siehe VERDIKTE).
+
+‼️ **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
+llama-swap vor einem großen Modell nicht ab und der Kernel schießt Prozesse ab. Details und
+Messwerte: [`docs/wissen/VERDIKTE.md`](docs/wissen/VERDIKTE.md).
+
+## Qualitäts-Tore
+
+1. **Prüf-Tor** — `VERIFY` nach jeder Etappe; rot → der Agent (OpenCode Desktop) repariert lokal nach.
+2. **CI-Ampel** — Lint (ruff) · Import/Syntax (compileall) · Frontend-Build. Läuft in Gitea.
+
+Gemeinsame Lehre dahinter: **Wissen lebt in Datei + git, nicht im schrumpfenden Chat-Kontext.**
+Kontext-Komprimierung löscht still die Regeln mit.
+
+## Selbsterhaltung
+
+- **Health-Wächter** (`sentry`) + **Warm-Set-Wächter** (`warmer`, per Env abschaltbar)
+- **Updates mit Fangnetz** — Backup → Update → Postcheck → bei Fehler **Auto-Rollback + Pin**
+- **Melde-Briefkasten** (`/api/voice/announce`) — alles, was die Box von sich aus sagen will;
+  Lucy pollt ihn und spricht es. Absender `loop` = Coding-Ereignisse
+- **Gedächtnis** — Mem0-Sidecar, auto-lernend, semantisch, mit Auto-Dedupe
+- Tägliche Self-Smokes, Zeitmaschine (Snapshot + Ein-Klick-Restore), Chronik der autonomen Taten
+
+## API (Auswahl)
+
+`health · models/* · discover · fit · groups · routing/* · system/* · maintenance/* · connect ·
+memory/* · agent/* · ideen/* · auftragsbuch/* · chronik · eigenleben · wissen ·
+zeitmaschine/* · reminders/* · voice/* · events (SSE)`
+OpenAI-kompatibel: `/v1/chat/completions`, `/v1/completions`. MCP-Server: [`mcp/`](mcp/).
 
 ## Entwickeln
 
-**Backend:**
 ```bash
+# Backend
 cd backend
 python -m venv .venv && .venv/Scripts/python -m pip install -r requirements.txt   # Windows
 .venv/Scripts/python -m uvicorn app:app --port 9000
+
+# Frontend (Dev, proxyt /api → :9000)
+cd frontend && npm install && npm run dev        # http://localhost:5173
+
+# Frontend (Build → wird vom Backend ausgeliefert)
+cd frontend && npm run build                     # → frontend/dist
 ```
 
-**Frontend (Dev, proxyt /api → :9000):**
-```bash
-cd frontend
-npm install
-npm run dev          # http://localhost:5173
-```
-
-**Frontend (Build → wird vom Backend ausgeliefert):**
-```bash
-cd frontend && npm run build   # → frontend/dist
-```
+`frontend/dist` **wird mitcommittet** — die Box hat kein Node; Deploy ist ein `git pull` plus
+Dienst-Neustart. Vor jedem Commit lohnt der Ampel-Vorlauf: `ruff check .` und `npm run build`.
 
 ## Env-Vars (Auswahl)
 
 | Variable | Default | Zweck |
 |---|---|---|
-| `MC_LLAMA_SWAP_URL` | `http://127.0.0.1:8080` | Engine |
-| `MC_CONFIG_PATH` | `/etc/llama-swap/config.yaml` | llama-swap Config |
-| `MC_GATEWAY_URL` | `http://127.0.0.1:$MC_PORT` | Builtin-Gateway (Teil von MC2, kein externer Dienst) |
-| `MC_PORT` | `9000` | MC-Backend-Port |
-| `MC_ENGINE_PATH` | `/opt/llamacpp-vulkan` | Aktive Engine-Binary (Vulkan-Build) |
-| `MC_ENGINE_REPO` | `ggml-org/llama.cpp` | Quelle für Engine-Update-Check |
-| `MC_DRAFTS_DIR` | `$MODELS/drafts` | Spec-Draft-Modelle (vocab-geprüft) |
-| `MC_SPEC_TYPE` | `draft-simple` | Speculative-Decoding-Typ (llama.cpp) |
+| `MC_PORT` | `9000` | MC-Backend-Port (**die Unit auf der Box setzt `9001`**) |
+| `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_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 |
+
+
+
+## Weiterlesen
+
+| Dokument | Inhalt |
+|---|---|
+| [`docs/BEDIENUNG.md`](docs/BEDIENUNG.md) | Wie man MC2 benutzt |
+| [`docs/RUNBOOK.md`](docs/RUNBOOK.md) · [`docs/DISASTER_RECOVERY.md`](docs/DISASTER_RECOVERY.md) | Betrieb, Störungen, Wiederherstellung |
+| [`docs/HERMES_SETUP.md`](docs/HERMES_SETUP.md) | Hermes-Agent, Profile, Crons |
+| [`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 |
+
+| [`AGENTS.md`](AGENTS.md) | Arbeitsregeln für Agenten in diesem Repo |

SAVEPOINT.md

@@ -0,0 +1,50 @@
+# Savepoint — Mission Control 2.0 (MC2)
+
+_Stand: 2026-07-05. Zustands-Snapshot für einen externen Code-Review (Antigravity). Zuerst
+`AGENTS.md` lesen (Projekt-Regeln), dann diese Datei (wo wir stehen), dann `README.md`/`docs/`._
+
+## Was das ist (in einem Satz)
+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,
+Agenten-Status, Updates & Wartung — und dient teils als Gedächtnis-Oberfläche für die Sprach-
+Begleiterin „Lucy".
+
+## Architektur (Kurzform — Details in AGENTS.md/docs/)
+- **Backend** `backend/` — FastAPI, `:9001` als systemd-**User-Dienst** (reboot-fest, sudo-frei).
+  Router (`routers/`, dünn) → Logik (`services/`, Single Source of Truth).
+- **Frontend** `frontend/` — React/Vite/Tailwind/shadcn. **`frontend/dist` ist ABSICHT im git**
+  (Box hat kein Node; Backend liefert die gebauten Assets aus).
+- **Eingebautes Gateway** `:9001/v1` (OpenAI-kompatibel) → llama-swap `:8080` (Engine, Vulkan/RADV).
+- **Sidecars:** `mem0_service/` (Mem0-Gedächtnis), `voice_service/` (STT/TTS für den „Sprechen"-Tab),
+  `mcp/` (MCP-Server), `hermes/` (Hermes-Agent-Plugin), `client/hermes-pc` (PC-Executor).
+
+## Aktueller Zustand
+- **Stabil, in Produktion, „MC2 Final".** Ein Neubau („MC3") wurde bewusst VERWORFEN — MC2 wird
+  sauber gehalten und eingefroren, nicht neu erfunden.
+- **Autonomie-Ausbau abgeschlossen** (Observability-Latenztrace, Fremd-Modell-Kritiker/Härtung,
+  nächtliches „Dreaming" mit Wissens-Vault) — jeweils propose-only, Mensch = Gate.
+- **Zuletzt (Commit `ff1b9a0`, 05.07.):** `coder-lite` (Qwen3-Coder-30B) entfernt; der Verbinden-Tab
+  (`services/connect.py`) empfiehlt IDEs jetzt die realen Direkt-Modelle `coder`/`heavy`/`vision`
+  statt der virtuellen „coding"-Lane. Davor u. a. Engine-Update-Fix, Hermes-Terminal same-origin.
+- **Modelle live:** hermes=Qwen3.6-35B-A3B (Agent-Hirn, immer warm) · coder=Qwen3-Coder-Next ·
+  heavy=gpt-oss-120b · vision=Qwen3-VL-30B · scout=GLM-4.6V · embed. Warm-Set = hermes+vision+embed.
+
+## Nordstern & Randbedingungen (WICHTIG für den Review)
+- **Zieht ohne Wartung über JAHRE durch.** Robustheit + Einfachheit schlagen Features. Der Betreiber
+  ist **kein Entwickler** — alles muss reboot-/update-fest und selbsterklärend sein.
+- **100 % lokal, kein Cloud-Zwang** (Privatsphäre ist der Sinn). Hardware-Decke: ~124 GB, ein Topf.
+- **Lucy ist ein SEPARATES Repo** (`F:\Coding Stuff\lucy`) — **nicht Teil dieses Reviews.**
+
+## Bekannte raue Kanten (Kandidaten — gern bestätigen/erweitern)
+- Doku-Drift möglich: `AGENTS.md` nennt „Box läuft in UTC" — die Box wurde inzwischen auf
+  `Europe/Berlin` umgestellt.
+- Alte, disabled v1-System-Unit `mission-control.service` liegt kosmetisch herum (sudo zum Entfernen).
+- Ein paar frühere Frontend-Monolithen wurden entflochten; Rest-Altlasten möglich.
+
+## Was NICHT empfohlen werden soll (bereits entschieden)
+Cloud-Migration · Voll-Rewrite · schwere neue Frameworks · Engine-/Modell-Wechsel, die nicht in
+124 GB passen · `frontend/dist` aus git nehmen (Absicht) · Security-Config anfassen. Erwünscht sind
+**Bugs, Fragilität, tote Pfade, Sicherheitslücken, Vereinfachung (KISS/DRY), Wartbarkeit.**
+
+## Letzter Sicherungspunkt
+- git `ff1b9a0` „coder-lite raus + Verbinden-Tab auf echte Direkt-Modelle" (auf `main`, deployt, live).

backend/app.py

@@ -9,18 +9,40 @@ Server (proxyt /api hierher), daher CORS für localhost offen.
 import asyncio
 import logging
 import os
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from contextlib import asynccontextmanager
+from typing import Any
 
+import httpx
+from config import FRONTEND_DIST, V1_UPSTREAM, VERSION
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
+from routers import (
+    agent,
+    auftragsbuch,
+    chronik,
+    connect,
+    console,
+    events,
+    gateway_proxy,
+    health,
+    hermes_ui,
+    ideen,
+    maintenance,
+    models,
+    routing,
+    skills,
+    system,
+    voice,
+    wissen,
+    zeitmaschine,
+)
+from routers import reminders as reminders_router
+from services import metrics_history, reminders, sentry, warmer
 from starlette.requests import Request
 
-from config import FRONTEND_DIST, VERSION
-from routers import agent, connect, gateway_proxy, health, maintenance, memory, models, routing, system, voice
-from services import warmer
-
 # Zentrales Logging — Level via MC_LOG_LEVEL (INFO default). Eine Konfiguration
 # für alle Module (logging.getLogger(__name__)).
 logging.basicConfig(
@@ -29,17 +51,35 @@ logging.basicConfig(
 )
 log = logging.getLogger(__name__)
 
+
 @asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Hintergrund-Tasks an den App-Lebenszyklus binden: Re-Warm-Wächter fürs Agent-Hirn."""
-    task = asyncio.create_task(warmer.rewarm_loop()) if warmer.ENABLED else None
-    if task:
-        log.info("Hirn-Re-Warm-Wächter aktiv (Intervall %ss, Hirn dynamisch aus Hermes-Config)", warmer.INTERVAL)
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Hintergrund-Tasks an den App-Lebenszyklus binden: Re-Warm-Wächter fürs Agent-Hirn
+    + Health-Wächter (meldet Ausfälle/Erholung in den Lucy-Briefkasten und auf Telegram)."""
+    tasks: list[asyncio.Task[Any]] = []
+    if warmer.ENABLED:
+        tasks.append(asyncio.create_task(warmer.rewarm_loop()))
+        log.info(
+            "Hirn-Re-Warm-Wächter aktiv (Intervall %ss, Hirn dynamisch aus Hermes-Config)",
+            warmer.INTERVAL,
+        )
+    if sentry.ENABLED:
+        tasks.append(asyncio.create_task(sentry.sentry_loop()))
+    tasks.append(asyncio.create_task(reminders.reminders_loop()))
+    # 24-h-Metrik-Verlauf (Cockpit-Zeitachse): 10-s-Sampler, Ringpuffer, persistiert.
+    tasks.append(asyncio.create_task(metrics_history.sampler_loop()))
+    # 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(
+        timeout=httpx.Timeout(connect=10.0, read=None, write=None, pool=10.0),
+        limits=httpx.Limits(max_keepalive_connections=100, max_connections=200),
+    )
     try:
         yield
     finally:
-        if task:
-            task.cancel()
+        for task in tasks:
+            _ = task.cancel()
+        await app.state.gw_client.aclose()
 
 
 app = FastAPI(title="Mission Control 2.0", version=VERSION, lifespan=lifespan)
@@ -54,7 +94,9 @@ app.add_middleware(
 
 
 @app.middleware("http")
-async def no_cache(request: Request, call_next):
+async def no_cache(
+    request: Request, call_next: Callable[[Request], Awaitable[httpx.Response]]
+) -> httpx.Response:
     resp = await call_next(request)
     if request.url.path.startswith("/api"):
         resp.headers["Cache-Control"] = "no-cache"
@@ -65,28 +107,61 @@ 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)  # Sprache: STT/TTS-Proxy + Hermes-Agent-Chat (Voice-Tab)
-app.include_router(gateway_proxy.router)  # OpenAI-kompatibler /v1-Gateway (model:auto)
+app.include_router(
+    voice.router
+)  # Sprache: STT/TTS-Proxy + Hermes-Agent-Chat (Voice-Tab)
+app.include_router(
+    reminders_router.router
+)  # Erinnerungen/Routinen (A3) — feuern in den Briefkasten
+# /v1-Datenpfad: Nach dem Gateway-Auszug (UMBAU v3 P1) läuft der eigentliche Gateway als
+# eigener Prozess (mc2-gateway, Loopback :9010) — MC2 reicht /v1 dann nur roh durch, damit
+# LAN-Clients (IDE-Lane) weiter über :9001 kommen. Ohne MC_V1_UPSTREAM (vor dem ersten
+# Deploy der neuen Unit / nach Rollback) bedient MC2 /v1 wie bisher selbst.
+if V1_UPSTREAM:
+    from routers import gateway_forward
+    app.include_router(gateway_forward.router)  # dünner Roh-Weiterleiter → mc2-gateway
+else:
+    app.include_router(gateway_proxy.router)  # OpenAI-kompatibler /v1-Gateway (model:auto)
 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(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
+app.include_router(
+    hermes_ui.router
+)  # Eingebaute Hermes-Web-GUI (hermes serve) same-origin unter /hermes-ui/ — VOR dem SPA-Catch-all
 
 
 # Prod: gebautes Frontend ausliefern (falls vorhanden). SPA-Fallback auf index.html.
 if FRONTEND_DIST.exists():
     app.mount("/assets", StaticFiles(directory=FRONTEND_DIST / "assets"), name="assets")
 
+    _DIST_ROOT = FRONTEND_DIST.resolve()
+
     @app.get("/{full_path:path}")
     def spa(full_path: str):
-        # Falls die Datei direkt in FRONTEND_DIST liegt (z.B. manifest.webmanifest, favicon.ico), liefere sie aus
-        target = FRONTEND_DIST / full_path
-        if target.is_file():
-            return FileResponse(target)
-            
+        # Datei direkt aus FRONTEND_DIST ausliefern (manifest.webmanifest, favicon.ico, …) — aber
+        # NUR innerhalb des dist-Ordners: Pfad auflösen + Traversal (../, absolute Pfade) hart raus.
+        try:
+            target = (FRONTEND_DIST / full_path).resolve()
+            if target.is_relative_to(_DIST_ROOT) and target.is_file():
+                return FileResponse(target)
+        except (ValueError, OSError):
+            pass
+
         index = FRONTEND_DIST / "index.html"
         if index.exists():
             # index.html nie cachen → Browser zieht nach jedem Deploy das aktuelle (gehashte) Bundle.
-            return FileResponse(index, headers={"Cache-Control": "no-cache, must-revalidate"})
+            return FileResponse(
+                index, headers={"Cache-Control": "no-cache, must-revalidate"}
+            )
         return {"detail": "frontend not built"}
-

backend/config.py

@@ -1,118 +1,136 @@
-"""
-Zentrale Konfiguration für Mission Control 2.0.
-
-Eine Quelle der Wahrheit für Pfade, URLs und Defaults — alles über Env-Vars
-überschreibbar. Bewusst schlank: MC 2.0 ist ein Glue-Cockpit, das vorhandene
-Dienste (llama-swap, LiteLLM-Gateway, Hermes) steuert, statt sie nachzubauen.
-"""
-
-import os
-from pathlib import Path
-
-from ruamel.yaml import YAML
-
-# --- Engine (llama-swap) -----------------------------------------------------
-LLAMA_SWAP_URL = os.environ.get("MC_LLAMA_SWAP_URL", "http://127.0.0.1:8080").rstrip("/")
-CONFIG_PATH = Path(os.environ.get("MC_CONFIG_PATH", "/etc/llama-swap/config.yaml"))
-MODELS_DIR = Path(os.environ.get("MC_MODELS_DIR", "/srv/models"))
-# Cache der Modell-Entdeckung ("aktuell beste Modelle", live von HuggingFace).
-# 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.
-# Hinweis: nur noch für die einmalige Mem0-Migration relevant — das aktive Gedächtnis
-# liegt jetzt in Mem0/Chroma hinter dem Sidecar (siehe MEM0_SERVICE_URL).
-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
-# macht llama-server ohnehin automatisch pro Slot (KV-Reuse).
-_DEFAULT_CMD_TEMPLATE = (
-    "llama-server -m {model} --host 127.0.0.1 --port ${PORT} "
-    "-c {ctx} -ngl 999 -fa on --no-mmap"
-)
-CMD_TEMPLATE = os.environ.get("MC_CMD_TEMPLATE", _DEFAULT_CMD_TEMPLATE)
-if "{model}" not in CMD_TEMPLATE:
-    CMD_TEMPLATE = _DEFAULT_CMD_TEMPLATE
-DEFAULT_TTL = int(os.environ.get("MC_DEFAULT_TTL", "300"))
-# Verzeichnis mit Draft-Modellen für Speculative Decoding. Beim Hinzufügen eines
-# fast/coder-Modells wird hieraus automatisch ein **vocab-kompatibler** Draft gewählt
-# (Vocab-Check via services.gguf_meta; ein inkompatibler Draft lässt llama.cpp scheitern).
-DRAFTS_DIR = Path(os.environ.get("MC_DRAFTS_DIR", str(MODELS_DIR / "drafts")))
-# Optionaler expliziter Default-Draft (leer = Auto-Erkennung aus DRAFTS_DIR). Wird nur
-# verwendet, wenn er zum Ziel-Modell vocab-kompatibel ist. (Früher fix qwen2.5 → entfernt,
-# weil das mit neueren Vocabs wie Qwen3.6 inkompatibel ist und Spec stillschweigend brach.)
-SPEC_DRAFT_MODEL_PATH = os.environ.get("MC_SPEC_DRAFT_MODEL", "")
-# Speculative-Decoding-Typ (llama.cpp dieser Generation braucht --spec-type zusätzlich
-# zu --spec-draft-model, sonst ist Spec inaktiv).
-SPEC_TYPE = os.environ.get("MC_SPEC_TYPE", "draft-simple")
-# MTP-Speculative-Decoding (Multi-Token-Prediction): manche Modelle bringen einen eigenen
-# MTP-Kopf mit (z.B. gemma-4 → arch 'gemma4-assistant', Datei 'mtp-*.gguf'). Der wird mit
-# `--model-draft <mtp.gguf> --spec-type draft-mtp --spec-draft-n-max N` geladen (NICHT
-# --spec-draft-model/draft-simple). 1,5–2× Durchsatz bei null Qualitätsverlust.
-SPEC_DRAFT_N_MAX = int(os.environ.get("MC_SPEC_DRAFT_N_MAX", "4"))
-# Env für HuggingFace-Downloads: XET deaktivieren (Hänger bei ~6 MB, siehe v1-Gotcha).
-HF_DOWNLOAD_ENV = {"HF_HUB_DISABLE_XET": "1"}
-
-# --- Routing-Gateway (builtin in MC2, model: auto) ---------------------------
-# MC2 IST der Gateway (services/gateway.py + routers/gateway_proxy.py). KEIN externer
-# LiteLLM-Dienst (scheitert auf Python 3.14). Daher keine Gateway-Config-Datei mehr.
-GATEWAY_URL = os.environ.get("MC_GATEWAY_URL", f"http://127.0.0.1:{os.environ.get('MC_PORT', '9000')}").rstrip("/")
-
-# --- Hermes Agent (eigener Dienst auf der Box) -------------------------------
-# Gateway (OpenAI-API des Agenten) + interaktives Web-Terminal (ttyd → `hermes chat`).
-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.
-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."""
-    try:
-        env_path = Path(os.path.expanduser(os.environ.get("HERMES_HOME", "~/.hermes"))) / ".env"
-        for line in env_path.read_text(encoding="utf-8").splitlines():
-            line = line.strip()
-            if line.startswith(f"{key}="):
-                return line.split("=", 1)[1].strip().strip('"').strip("'")
-    except OSError:
-        pass
-    return ""
-
-
-HERMES_API_KEY = (
-    os.environ.get("HERMES_API_KEY")
-    or os.environ.get("API_SERVER_KEY")
-    or _read_hermes_env("API_SERVER_KEY")
-)
-# Modellfeld im OpenAI-Request; die api_server-Plattform nutzt ihr konfiguriertes Hirn,
-# das Feld ist i.d.R. kosmetisch. Override via Env, falls die Plattform strikt prüft.
-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.
-VOICE_SERVICE_URL = os.environ.get("MC_VOICE_SERVICE_URL", "http://127.0.0.1:8650").rstrip("/")
-# Hermes-Terminal: ttyd-Web-Terminal der interaktiven Agent-CLI (Ersatz für AnythingLLM-Chat).
-# Wird in MC2 per iframe eingebettet (Terminal-Seite). Siehe deploy/hermes-terminal.service.
-HERMES_TERMINAL_URL = os.environ.get("MC_HERMES_TERMINAL_URL", "http://192.168.178.151:7681").rstrip("/")
-# GitHub-Repo für Update-Checks.
-HERMES_AGENT_REPO = os.environ.get("MC_HERMES_AGENT_REPO", "NousResearch/hermes-agent")
-HERMES_HOME = Path(os.path.expanduser(os.environ.get("HERMES_HOME", "~/.hermes")))
-# PC Executor — läuft auf dem Windows-PC, erreichbar über LAN.
-PC_EXECUTOR_URL = os.environ.get("MC_PC_EXECUTOR_URL", "http://192.168.178.98:7777").rstrip("/")
-
-# --- Server ------------------------------------------------------------------
-HOST = os.environ.get("MC_HOST", "0.0.0.0")
-PORT = int(os.environ.get("MC_PORT", "9000"))
-# Gebautes React-Frontend (frontend/dist). In Prod liefert FastAPI es statisch aus;
-# im Dev läuft der Vite-Dev-Server separat und proxyt /api hierher.
-FRONTEND_DIST = Path(os.environ.get("MC_FRONTEND_DIST", str(Path(__file__).resolve().parent.parent / "frontend" / "dist")))
-
-# Version (Phase 0 — Greenfield-Skeleton).
-VERSION = "2.0.0-w8"
-
-# Gemeinsame YAML-Instanz (preserve_quotes hält Kommentare/Quotes in config.yaml).
-yaml = YAML()
-yaml.preserve_quotes = True
+"""
+Zentrale Konfiguration für Mission Control 2.0.
+
+Eine Quelle der Wahrheit für Pfade, URLs und Defaults — alles über Env-Vars
+überschreibbar. Bewusst schlank: MC 2.0 ist ein Glue-Cockpit, das vorhandene
+Dienste (llama-swap, LiteLLM-Gateway, Hermes) steuert, statt sie nachzubauen.
+"""
+
+import os
+from pathlib import Path
+
+from ruamel.yaml import YAML
+
+# --- Engine (llama-swap) -----------------------------------------------------
+LLAMA_SWAP_URL = os.environ.get("MC_LLAMA_SWAP_URL", "http://127.0.0.1:8080").rstrip("/")
+CONFIG_PATH = Path(os.environ.get("MC_CONFIG_PATH", "/etc/llama-swap/config.yaml"))
+MODELS_DIR = Path(os.environ.get("MC_MODELS_DIR", "/srv/models"))
+# Cache der Modell-Entdeckung ("aktuell beste Modelle", live von HuggingFace).
+# 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.
+# Hinweis: nur noch für die einmalige Mem0-Migration relevant — das aktive Gedächtnis
+# liegt jetzt in Mem0/Chroma hinter dem Sidecar (siehe MEM0_SERVICE_URL).
+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
+# macht llama-server ohnehin automatisch pro Slot (KV-Reuse).
+_DEFAULT_CMD_TEMPLATE = (
+    "llama-server -m {model} --host 127.0.0.1 --port ${PORT} "
+    "-c {ctx} -ngl 999 -fa on --no-mmap"
+)
+CMD_TEMPLATE = os.environ.get("MC_CMD_TEMPLATE", _DEFAULT_CMD_TEMPLATE)
+if "{model}" not in CMD_TEMPLATE:
+    CMD_TEMPLATE = _DEFAULT_CMD_TEMPLATE
+DEFAULT_TTL = int(os.environ.get("MC_DEFAULT_TTL", "300"))
+# Verzeichnis mit Draft-Modellen für Speculative Decoding. Beim Hinzufügen eines
+# fast/coder-Modells wird hieraus automatisch ein **vocab-kompatibler** Draft gewählt
+# (Vocab-Check via services.gguf_meta; ein inkompatibler Draft lässt llama.cpp scheitern).
+DRAFTS_DIR = Path(os.environ.get("MC_DRAFTS_DIR", str(MODELS_DIR / "drafts")))
+# Optionaler expliziter Default-Draft (leer = Auto-Erkennung aus DRAFTS_DIR). Wird nur
+# verwendet, wenn er zum Ziel-Modell vocab-kompatibel ist. (Früher fix qwen2.5 → entfernt,
+# weil das mit neueren Vocabs wie Qwen3.6 inkompatibel ist und Spec stillschweigend brach.)
+SPEC_DRAFT_MODEL_PATH = os.environ.get("MC_SPEC_DRAFT_MODEL", "")
+# Speculative-Decoding-Typ (llama.cpp dieser Generation braucht --spec-type zusätzlich
+# zu --spec-draft-model, sonst ist Spec inaktiv).
+SPEC_TYPE = os.environ.get("MC_SPEC_TYPE", "draft-simple")
+# MTP-Speculative-Decoding (Multi-Token-Prediction): manche Modelle bringen einen eigenen
+# MTP-Kopf mit (z.B. gemma-4 → arch 'gemma4-assistant', Datei 'mtp-*.gguf'). Der wird mit
+# `--model-draft <mtp.gguf> --spec-type draft-mtp --spec-draft-n-max N` geladen (NICHT
+# --spec-draft-model/draft-simple). 1,5–2× Durchsatz bei null Qualitätsverlust.
+SPEC_DRAFT_N_MAX = int(os.environ.get("MC_SPEC_DRAFT_N_MAX", "4"))
+# Env für HuggingFace-Downloads: XET deaktivieren (Hänger bei ~6 MB, siehe v1-Gotcha).
+HF_DOWNLOAD_ENV = {"HF_HUB_DISABLE_XET": "1"}
+
+# --- Routing-Gateway (builtin in MC2, model: auto) ---------------------------
+# MC2 IST der Gateway (services/gateway.py + routers/gateway_proxy.py). KEIN externer
+# LiteLLM-Dienst (scheitert auf Python 3.14). Daher keine Gateway-Config-Datei mehr.
+GATEWAY_URL = os.environ.get("MC_GATEWAY_URL", f"http://127.0.0.1:{os.environ.get('MC_PORT', '9000')}").rstrip("/")
+# Gateway-Auszug (UMBAU v3 P1): Ist MC_V1_UPSTREAM gesetzt (Unit-Env, z. B.
+# http://127.0.0.1:9010), bedient der eigenständige mc2-gateway-Prozess den /v1-Pfad
+# und MC2 reicht /v1 nur noch roh durch (routers/gateway_forward.py). Leer = altes
+# Verhalten, MC2 bedient /v1 selbst — die Zeile aus der Unit nehmen ist der Rollback.
+V1_UPSTREAM = os.environ.get("MC_V1_UPSTREAM", "").rstrip("/")
+
+# --- Hermes Agent (eigener Dienst auf der Box) -------------------------------
+# Gateway (OpenAI-API des Agenten) + interaktives Web-Terminal (ttyd → `hermes chat`).
+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.
+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."""
+    try:
+        env_path = Path(os.path.expanduser(os.environ.get("HERMES_HOME", "~/.hermes"))) / ".env"
+        for line in env_path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line.startswith(f"{key}="):
+                return line.split("=", 1)[1].strip().strip('"').strip("'")
+    except OSError:
+        pass
+    return ""
+
+
+HERMES_API_KEY = (
+    os.environ.get("HERMES_API_KEY")
+    or os.environ.get("API_SERVER_KEY")
+    or _read_hermes_env("API_SERVER_KEY")
+)
+# Modellfeld im OpenAI-Request; die api_server-Plattform nutzt ihr konfiguriertes Hirn,
+# das Feld ist i.d.R. kosmetisch. Override via Env, falls die Plattform strikt prüft.
+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.
+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
+# rückwärts geproxyt (routers/console.py → same-origin /console/). So braucht die Konsole
+# KEINE eigene Firewall-Freigabe (Port 7682 ist von außen dicht) und keinen sudo-Eingriff.
+# Direkter, SSH-artiger Zugriff, kein Passwort — gleiches LAN-Trust-Modell wie das Dashboard.
+BOX_CONSOLE_UPSTREAM = os.environ.get("MC_BOX_CONSOLE_UPSTREAM", "http://127.0.0.1:7682").rstrip("/")
+# Ö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
+# (127.0.0.1:9119, kein Login — LAN-Trust wie Terminal/Konsole) und wird von MC2 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.
+HERMES_BUILTIN_UI_UPSTREAM = os.environ.get("MC_HERMES_BUILTIN_UI_UPSTREAM", "http://127.0.0.1:9119").rstrip("/")
+HERMES_BUILTIN_UI_PATH = "/hermes-ui/"
+# GitHub-Repo für Update-Checks.
+HERMES_AGENT_REPO = os.environ.get("MC_HERMES_AGENT_REPO", "NousResearch/hermes-agent")
+HERMES_HOME = Path(os.path.expanduser(os.environ.get("HERMES_HOME", "~/.hermes")))
+# PC Executor — läuft auf dem Windows-PC, erreichbar über LAN.
+PC_EXECUTOR_URL = os.environ.get("MC_PC_EXECUTOR_URL", "http://192.168.178.98:7777").rstrip("/")
+
+# --- Server ------------------------------------------------------------------
+HOST = os.environ.get("MC_HOST", "0.0.0.0")
+PORT = int(os.environ.get("MC_PORT", "9000"))
+# Gebautes React-Frontend (frontend/dist). In Prod liefert FastAPI es statisch aus;
+# im Dev läuft der Vite-Dev-Server separat und proxyt /api hierher.
+FRONTEND_DIST = Path(os.environ.get("MC_FRONTEND_DIST", str(Path(__file__).resolve().parent.parent / "frontend" / "dist")))
+
+# Version (Phase 0 — Greenfield-Skeleton).
+VERSION = "2.0.0-w8"
+
+# Gemeinsame YAML-Instanz (preserve_quotes hält Kommentare/Quotes in config.yaml).
+yaml = YAML()
+yaml.preserve_quotes = True

backend/gateway_app.py

@@ -0,0 +1,63 @@
+"""
+MC2-Gateway — der /v1-Datenpfad als EIGENER Prozess (UMBAU v3, P1).
+
+Befund der Live-Inspektion 15.07.2026: Jeder LLM-Aufruf der Box (Lucys Haupt-Hirn,
+Nacht-Crons, Worker-Delegation, Vision, Decomposer/Specifier/Curator) lief durch den
+Steuerpult-Prozess auf :9001 — den am häufigsten neu gestarteten Dienst des Stacks.
+Dieser Einstieg hebt denselben Gateway-Router (routers/gateway_proxy.py) UNVERÄNDERT
+in einen bewusst winzigen, langweiligen Prozess: Unit mc2-gateway.service, Loopback
+:9010, Restart=always. Das Steuerpult darf beliebig neu starten — die Wirbelsäule steht.
+
+Bewusst NICHT hier: weitere Router, Hintergrund-Loops, CORS, Frontend-Auslieferung.
+LAN-Clients (IDE-Lane) erreichen /v1 weiter über MC2 :9001, das roh hierher
+durchreicht (routers/gateway_forward.py, MC_V1_UPSTREAM).
+"""
+
+import logging
+import os
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import httpx
+from config import LLAMA_SWAP_URL, VERSION
+from fastapi import FastAPI, Request
+from routers import gateway_proxy
+
+logging.basicConfig(
+    level=os.environ.get("MC_LOG_LEVEL", "INFO").upper(),
+    format="%(asctime)s %(levelname)-7s %(name)s: %(message)s",
+)
+log = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    # Gleiche Client-Parameter wie zuvor in app.py: Keep-Alive/Pooling statt neuer
+    # Client pro Anfrage (Sockets/TIME_WAIT unter parallelen Agent-Strömen).
+    app.state.gw_client = httpx.AsyncClient(
+        timeout=httpx.Timeout(connect=10.0, read=None, write=None, pool=10.0),
+        limits=httpx.Limits(max_keepalive_connections=100, max_connections=200),
+    )
+    log.info("mc2-gateway bereit (Engine: %s)", LLAMA_SWAP_URL)
+    try:
+        yield
+    finally:
+        await app.state.gw_client.aclose()
+
+
+app = FastAPI(title="MC2 Gateway", version=VERSION, lifespan=lifespan)
+app.include_router(gateway_proxy.router)
+
+
+@app.get("/gw/health")
+async def health(request: Request):
+    """Eigener Health-Pfad (nicht /api/health — das gehört dem Steuerpult):
+    beweist Prozess UND Engine-Erreichbarkeit, für deploy.sh/stack-postcheck.sh."""
+    engine = False
+    try:
+        r = await request.app.state.gw_client.get(f"{LLAMA_SWAP_URL}/v1/models", timeout=5.0)
+        engine = r.status_code == 200
+    except httpx.HTTPError:
+        pass
+    return {"status": "ok", "service": "mc2-gateway", "version": VERSION,
+            "engine_reachable": engine}

backend/migrate_config.py

@@ -1,56 +1,57 @@
-import sys
-from pathlib import Path
-
-# Add backend directory to sys.path so we can import services
-sys.path.append(str(Path(__file__).resolve().parent))
-
-from services.llamaswap import read_config, write_config, spec_draft_flags, _PATH_RE
-from config import CONFIG_PATH
-
-def migrate():
-    print(f"Reading config from {CONFIG_PATH}...")
-    if not CONFIG_PATH.exists():
-        print(f"Config path {CONFIG_PATH} does not exist. Skipping.")
-        return
-        
-    cfg = read_config()
-    models = cfg.get("models", {})
-
-    for name, spec in models.items():
-        if not isinstance(spec, dict):
-            continue
-        cmd = spec.get("cmd", "")
-        if not cmd:
-            continue
-            
-        print(f"Migrating model: {name}")
-
-        # 1. Defektes --prompt-cache/--prompt-cache-all entfernen (llama-CLI-Flags,
-        #    die llama-server ablehnt → Start scheitert). Caching macht llama-server
-        #    automatisch pro Slot.
-        cmd = cmd.replace(" --prompt-cache-all", "").replace(" --prompt-cache", "")
-
-        # 2. Extract aliases/role
-        aliases = spec.get("aliases", [])
-        role = aliases[0] if aliases else None
-        
-        # 3. Add parallel + (nur vocab-kompatibles) Speculative Decoding für fast/coder.
-        #    spec_draft_flags() prüft die Vocab-Kompatibilität und hängt --spec-type an;
-        #    ein inkompatibler Draft (z.B. qwen2.5 ↔ Qwen3.6) wird NICHT gesetzt.
-        if role in ("fast", "coder"):
-            if "--parallel" not in cmd:
-                cmd = cmd.strip() + " --parallel 2"
-            if "--spec-draft-model" not in cmd:
-                target = mt.group(1) if (mt := _PATH_RE.search(cmd)) else ""
-                cmd = cmd.strip() + spec_draft_flags(target)
-                
-        # Update cmd
-        from ruamel.yaml.scalarstring import LiteralScalarString
-        spec["cmd"] = LiteralScalarString(cmd.strip() + "\n")
-        
-    print(f"Writing updated config back to {CONFIG_PATH}...")
-    write_config(cfg)
-    print("Migration completed successfully!")
-
-if __name__ == "__main__":
-    migrate()
+import sys
+from pathlib import Path
+
+# Add backend directory to sys.path so we can import services
+sys.path.append(str(Path(__file__).resolve().parent))
+
+from config import CONFIG_PATH
+from services.llamaswap import _PATH_RE, read_config, spec_draft_flags, write_config
+
+
+def migrate():
+    print(f"Reading config from {CONFIG_PATH}...")
+    if not CONFIG_PATH.exists():
+        print(f"Config path {CONFIG_PATH} does not exist. Skipping.")
+        return
+        
+    cfg = read_config()
+    models = cfg.get("models", {})
+
+    for name, spec in models.items():
+        if not isinstance(spec, dict):
+            continue
+        cmd = spec.get("cmd", "")
+        if not cmd:
+            continue
+            
+        print(f"Migrating model: {name}")
+
+        # 1. Defektes --prompt-cache/--prompt-cache-all entfernen (llama-CLI-Flags,
+        #    die llama-server ablehnt → Start scheitert). Caching macht llama-server
+        #    automatisch pro Slot.
+        cmd = cmd.replace(" --prompt-cache-all", "").replace(" --prompt-cache", "")
+
+        # 2. Extract aliases/role
+        aliases = spec.get("aliases", [])
+        role = aliases[0] if aliases else None
+        
+        # 3. Add parallel + (nur vocab-kompatibles) Speculative Decoding für fast/coder.
+        #    spec_draft_flags() prüft die Vocab-Kompatibilität und hängt --spec-type an;
+        #    ein inkompatibler Draft (z.B. qwen2.5 ↔ Qwen3.6) wird NICHT gesetzt.
+        if role in ("fast", "coder"):
+            if "--parallel" not in cmd:
+                cmd = cmd.strip() + " --parallel 2"
+            if "--spec-draft-model" not in cmd:
+                target = mt.group(1) if (mt := _PATH_RE.search(cmd)) else ""
+                cmd = cmd.strip() + spec_draft_flags(target)
+                
+        # Update cmd
+        from ruamel.yaml.scalarstring import LiteralScalarString
+        spec["cmd"] = LiteralScalarString(cmd.strip() + "\n")
+        
+    print(f"Writing updated config back to {CONFIG_PATH}...")
+    write_config(cfg)
+    print("Migration completed successfully!")
+
+if __name__ == "__main__":
+    migrate()

backend/models_catalog.json

@@ -1,60 +1,71 @@
-{
-  "_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-06-27",
-  "models": [
-    {
-      "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,
-      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": true, "vision": true
-    },
-    {
-      "role": "fast", "name": "Qwen3-30B-A3B-Instruct", "repo": "unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF",
-      "family": "qwen", "generation": 3.0, "total_params_b": 30, "active_params_b": 3,
-      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": true, "vision": false
-    },
-
-    {
-      "role": "heavy", "name": "Qwen3.5-122B-A10B", "repo": "Qwen/Qwen3.5-122B-A10B-GGUF",
-      "family": "qwen", "generation": 3.5, "total_params_b": 122, "active_params_b": 10,
-      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": true, "vision": false
-    },
-    {
-      "role": "heavy", "name": "gpt-oss-120b", "repo": "ggml-org/gpt-oss-120b-GGUF",
-      "family": "gpt-oss", "generation": 1.0, "total_params_b": 120, "active_params_b": 5,
-      "moe": true, "quant": "MXFP4", "ctx": 32768, "tools": true, "vision": false
-    },
-
-    {
-      "role": "coder", "name": "Qwen3-Coder-Next", "repo": "Qwen/Qwen3-Coder-Next-GGUF",
-      "family": "qwen-coder", "generation": 3.0, "total_params_b": 84, "active_params_b": 3,
-      "moe": true, "quant": "Q4_K_M", "ctx": 65536, "tools": true, "vision": false
-    },
-    {
-      "role": "coder", "name": "Qwen3-Coder-30B-A3B-Instruct", "repo": "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF",
-      "family": "qwen-coder", "generation": 3.0, "total_params_b": 30, "active_params_b": 3,
-      "moe": true, "quant": "Q4_K_M", "ctx": 65536, "tools": true, "vision": false
-    },
-
-    {
-      "role": "vision", "name": "Qwen3-VL-8B-Instruct", "repo": "Qwen/Qwen3-VL-8B-Instruct-GGUF",
-      "family": "qwen-vl", "generation": 3.0, "total_params_b": 8, "active_params_b": 8,
-      "moe": false, "quant": "Q4_K_M", "ctx": 32768, "tools": false, "vision": true
-    },
-    {
-      "role": "vision", "name": "Qwen3-VL-2B-Instruct", "repo": "Qwen/Qwen3-VL-2B-Instruct-GGUF",
-      "family": "qwen-vl", "generation": 3.0, "total_params_b": 2, "active_params_b": 2,
-      "moe": false, "quant": "Q4_K_M", "ctx": 32768, "tools": false, "vision": true
-    },
-
-    {
-      "role": "scout", "name": "gemma-4-26B-A4B-it", "repo": "google/gemma-4-26B-A4B-it-GGUF",
-      "family": "gemma", "generation": 4.0, "total_params_b": 26, "active_params_b": 4,
-      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": false, "vision": true
-    },
-    {
-      "role": "scout", "name": "gemma-4-31B-it", "repo": "google/gemma-4-31B-it-GGUF",
-      "family": "gemma", "generation": 4.0, "total_params_b": 31, "active_params_b": 31,
-      "moe": false, "quant": "Q4_K_M", "ctx": 32768, "tools": false, "vision": true
-    }
-  ]
-}
+{
+  "_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": "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,
+      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": true, "vision": true
+    },
+    {
+      "role": "fast", "name": "Qwen3-30B-A3B-Instruct", "repo": "unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF",
+      "family": "qwen", "generation": 3.0, "total_params_b": 30, "active_params_b": 3,
+      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": true, "vision": false
+    },
+
+    {
+      "role": "heavy", "name": "Qwen3.5-122B-A10B", "repo": "Qwen/Qwen3.5-122B-A10B-GGUF",
+      "family": "qwen", "generation": 3.5, "total_params_b": 122, "active_params_b": 10,
+      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": true, "vision": false
+    },
+    {
+      "role": "heavy", "name": "gpt-oss-120b", "repo": "ggml-org/gpt-oss-120b-GGUF",
+      "family": "gpt-oss", "generation": 1.0, "total_params_b": 120, "active_params_b": 5,
+      "moe": true, "quant": "MXFP4", "ctx": 32768, "tools": true, "vision": false
+    },
+
+    {
+      "role": "coder", "name": "Qwen3-Coder-Next", "repo": "Qwen/Qwen3-Coder-Next-GGUF",
+      "family": "qwen-coder", "generation": 3.0, "total_params_b": 84, "active_params_b": 3,
+      "moe": true, "quant": "Q4_K_M", "ctx": 65536, "tools": true, "vision": false
+    },
+    {
+      "role": "coder", "name": "Qwen3-Coder-30B-A3B-Instruct", "repo": "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF",
+      "family": "qwen-coder", "generation": 3.0, "total_params_b": 30, "active_params_b": 3,
+      "moe": true, "quant": "Q4_K_M", "ctx": 65536, "tools": true, "vision": false
+    },
+
+    {
+      "role": "vision", "name": "Qwen3-VL-30B-A3B-Instruct", "repo": "Qwen/Qwen3-VL-30B-A3B-Instruct-GGUF",
+      "family": "qwen-vl", "generation": 3.0, "total_params_b": 30, "active_params_b": 3,
+      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": false, "vision": true
+    },
+    {
+      "role": "vision", "name": "Qwen3-VL-8B-Instruct", "repo": "Qwen/Qwen3-VL-8B-Instruct-GGUF",
+      "family": "qwen-vl", "generation": 3.0, "total_params_b": 8, "active_params_b": 8,
+      "moe": false, "quant": "Q4_K_M", "ctx": 32768, "tools": false, "vision": true
+    },
+    {
+      "role": "vision", "name": "Qwen3-VL-2B-Instruct", "repo": "Qwen/Qwen3-VL-2B-Instruct-GGUF",
+      "family": "qwen-vl", "generation": 3.0, "total_params_b": 2, "active_params_b": 2,
+      "moe": false, "quant": "Q4_K_M", "ctx": 32768, "tools": false, "vision": true
+    },
+
+    {
+      "role": "scout", "name": "GLM-4.6V-Flash", "repo": "ggml-org/GLM-4.6V-Flash-GGUF",
+      "family": "glm", "generation": 4.6, "total_params_b": 9, "active_params_b": 3,
+      "moe": true, "quant": "Q4_K_M", "ctx": 32768, "tools": true, "vision": true
+    },
+
+    {
+      "role": "kritiker", "name": "Devstral-Small-2-24B", "repo": "mistralai/Devstral-Small-2-24B-Instruct-2512",
+      "family": "mistral-devstral", "generation": 2.0, "total_params_b": 24, "active_params_b": 24,
+      "moe": false, "quant": "Q4_K_M", "ctx": 65536, "tools": true, "vision": false
+    },
+    {
+      "role": "kritiker", "name": "GLM-4.7-Flash", "repo": "zai-org/GLM-4.7-Flash",
+      "family": "glm", "generation": 4.7, "total_params_b": 30, "active_params_b": 3,
+      "moe": true, "quant": "Q4_K_XL", "ctx": 65536, "tools": true, "vision": false
+    }
+  ]
+}

backend/requirements.txt

@@ -1,7 +1,9 @@
 fastapi>=0.115
+python-multipart>=0.0.9
 uvicorn[standard]>=0.30
 httpx>=0.27
 ruamel.yaml>=0.18
 psutil>=5.9
 huggingface_hub>=0.27
 mcp>=1.2.0
+tzdata>=2024.1

backend/routers/agent.py

@@ -1,10 +1,7 @@
 """Agent-Endpoint: Hermes-Status + WebUI-Link (MC verlinkt nur, betreibt nicht)."""
 
-from fastapi import APIRouter
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-
-from fastapi import HTTPException
-
 from services.agent import agent_status, hermes_brain_info, set_agent_brain, update_brain_model
 
 router = APIRouter(prefix="/api")

backend/routers/auftragsbuch.py

@@ -0,0 +1,63 @@
+"""Auftragsbuch-Endpoints (Vorschlags-Inbox) — dünner REST-Layer über services/auftragsbuch.py.
+LAN-only wie alle MC2-Endpoints; das Gate ist der Klick des Commanders."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from services import auftragsbuch
+
+router = APIRouter(prefix="/api")
+
+
+class BranchIn(BaseModel):
+    branch: str
+    repo: str = "mc2"  # "mc2" (Box-Stack) oder "lucy" (Desktop-App, Annahme baut am PC)
+    grund: str = ""    # nur beim Ablehnen: optionaler Grund → Lern-Gedächtnis des Kreislaufs
+
+
+class KandidatIn(BaseModel):
+    file: str
+
+
+@router.get("/auftragsbuch")
+def list_proposals() -> dict:
+    return auftragsbuch.list_proposals()
+
+
+@router.get("/auftragsbuch/diff")
+def diff(branch: str, repo: str = "mc2") -> dict:
+    res = auftragsbuch.diff_of(branch, repo)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Diff nicht verfügbar."))
+    return res
+
+
+@router.post("/auftragsbuch/annehmen")
+def accept(body: BranchIn) -> dict:
+    res = auftragsbuch.accept(body.branch, body.repo)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Annehmen fehlgeschlagen."))
+    return res
+
+
+@router.post("/auftragsbuch/ablehnen")
+def reject(body: BranchIn) -> dict:
+    res = auftragsbuch.reject(body.branch, body.repo, body.grund)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Ablehnen fehlgeschlagen."))
+    return res
+
+
+@router.post("/auftragsbuch/skill/annehmen")
+def skill_accept(body: KandidatIn) -> dict:
+    res = auftragsbuch.skill_accept(body.file)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Beauftragen fehlgeschlagen."))
+    return res
+
+
+@router.post("/auftragsbuch/skill/ablehnen")
+def skill_reject(body: KandidatIn) -> dict:
+    res = auftragsbuch.skill_reject(body.file)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Verwerfen fehlgeschlagen."))
+    return res

backend/routers/chronik.py

@@ -0,0 +1,28 @@
+"""Chronik — die lesbare Timeline dessen, was die Box von allein getan und gemeldet hat.
+Quelle ist der persistente Melde-Briefkasten (services/announce.py): Health-Wächter,
+Auto-Updates, Erinnerungen, Radar/Traum/Chef-Gutachter-Crons, Auftragsbuch — alle
+autonomen Kanäle laufen dort bereits durch. Hier wird nichts Neues erhoben, nur erzählt."""
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+from services import announce
+
+router = APIRouter(prefix="/api")
+
+
+class ChronikItem(BaseModel):
+    id: int
+    ts: float
+    subject: str
+    text: str
+    source: str
+    priority: str
+
+
+class ChronikResponse(BaseModel):
+    items: list[ChronikItem]
+
+
+@router.get("/chronik", response_model=ChronikResponse)
+def chronik(limit: int = 150) -> dict:
+    return {"items": announce.list_recent(limit)}

backend/routers/connect.py

@@ -1,7 +1,6 @@
 """Connect-Endpoint: erzeugt IDE-/Agent-Snippets (auf den Gateway + Memory-MCP)."""
 
 from fastapi import APIRouter
-
 from services.connect import DEFAULT_HOST, build_snippets, check_health
 
 router = APIRouter(prefix="/api")

backend/routers/console.py

@@ -0,0 +1,87 @@
+"""
+ttyd-Reverse-Proxy für die eingebetteten Web-Terminals (Box-Konsole + Hermes-Terminal).
+
+Beide ttyd-Dienste binden NUR an Loopback (--base-path /<name>) und werden hier über
+den ohnehin offenen MC2-Port (9001) same-origin durchgereicht — HTTP (index.html/token)
++ WebSocket (/<name>/ws). Vorteil: keine eigene Firewall-Freigabe je Terminal nötig und
+alles läuft same-origin zum Dashboard. Reiner Byte-Durchreicher; ttyds `tty`-Subprotokoll
+wird auf beiden Seiten ausgehandelt. Der Login-Schutz sitzt IM Terminal (ttyd startet die
+Shell über `su` → fragt das Box-Passwort ab), nicht im Proxy.
+"""
+
+import asyncio
+import logging
+
+import httpx
+import websockets
+from config import BOX_CONSOLE_UPSTREAM
+from fastapi import APIRouter, Request, WebSocket
+from starlette.responses import Response
+
+log = logging.getLogger(__name__)
+router = APIRouter()
+
+
+def _register(base: str, upstream: str) -> None:
+    """Registriert HTTP- + WS-Proxy-Routen für eine ttyd-Instanz (base-path `/<base>`)."""
+    ws_upstream = upstream.replace("http://", "ws://").replace("https://", "wss://")
+
+    @router.websocket(f"/{base}/ws")
+    async def _proxy_ws(ws: WebSocket) -> None:
+        await ws.accept(subprotocol="tty")
+        try:
+            async with websockets.connect(
+                f"{ws_upstream}/{base}/ws", subprotocols=["tty"],
+                open_timeout=10, max_size=None, ping_interval=None,
+            ) as up:
+                async def c2u() -> None:
+                    while True:
+                        msg = await ws.receive()
+                        if msg.get("type") == "websocket.disconnect":
+                            return
+                        if (t := msg.get("text")) is not None:
+                            await up.send(t)
+                        elif (b := msg.get("bytes")) is not None:
+                            await up.send(b)
+
+                async def u2c() -> None:
+                    async for m in up:
+                        if isinstance(m, (bytes, bytearray)):
+                            await ws.send_bytes(bytes(m))
+                        else:
+                            await ws.send_text(m)
+
+                _done, pending = await asyncio.wait(
+                    [asyncio.create_task(c2u()), asyncio.create_task(u2c())],
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for task in pending:
+                    task.cancel()
+        except Exception:
+            log.debug("ttyd-proxy ws (%s) beendet/fehlgeschlagen", base, exc_info=True)
+        finally:
+            try:
+                await ws.close()
+            except Exception:
+                pass
+
+    async def _proxy_http(request: Request, path: str = "") -> Response:
+        url = f"{upstream}/{base}/{path}"
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as c:
+                r = await c.request(request.method, url, content=await request.body())
+            return Response(content=r.content, status_code=r.status_code,
+                            media_type=r.headers.get("content-type"))
+        except httpx.HTTPError as exc:
+            log.debug("ttyd-proxy http (%s) nicht erreichbar: %s", base, exc)
+            return Response(content=b"Terminal (ttyd) nicht erreichbar.", status_code=502,
+                            media_type="text/plain")
+
+    router.add_api_route(f"/{base}", _proxy_http, methods=["GET"], name=f"{base}_root")
+    router.add_api_route(f"/{base}/{{path:path}}", _proxy_http, methods=["GET", "POST"],
+                         name=f"{base}_path")
+
+
+# Box-Konsole (Login-Shell) — Loopback-ttyd. (Das Hermes-Terminal-ttyd ist mit dem
+# Umzug auf Hermes Desktop entfallen; die Agent-Oberfläche ist die Desktop-App bzw. /hermes-ui/.)
+_register("console", BOX_CONSOLE_UPSTREAM)

backend/routers/events.py

@@ -0,0 +1,100 @@
+"""SSE-Eventstrom (UMBAU v3 P3a) — ein Kanal sagt der Zentrale, WANN neu laden lohnt.
+
+GET /api/events liefert Server-Sent Events. Ein Sammler prüft alle paar Sekunden
+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),
+Auftragsbuch + Erinnerungen (Datei-mtimes), geladene Modelle (Running-Set — Idee aus
+der Werkstatt-Karte feature/sse-backend-v1). BEWUSST NICHT dabei: System-/Token-
+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
+`event:` (ungültiges SSE-Framing → EventSource-Listener feuert NIE), einen globalen
+Snapshot über alle Clients und einen nicht existierenden Ideen-Endpunkt — Kern
+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
+Caches, entspannt die Fallback-Poller ×5; reißt der Strom, reconnectet EventSource
+selbst und bis dahin pollt die UI wie bisher).
+"""
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+
+from config import MODELS_DIR
+from fastapi import APIRouter, Request
+from fastapi.responses import StreamingResponse
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api")
+
+TICK_S = 3.0        # Prüf-Takt des Sammlers (nur Fingerabdrücke, kein Neuberechnen)
+KEEPALIVE_S = 20.0  # Kommentar-Ping, damit Proxies/Browser die Verbindung halten
+
+
+def _mtime(p: Path) -> float:
+    try:
+        return p.stat().st_mtime
+    except OSError:
+        return 0.0
+
+
+def _fingerprints() -> dict[str, object]:
+    """Billige Änderungs-Signale je Quelle → React-Query-Key. Fehler einer Quelle
+    dürfen den Strom nie reißen (dann bleibt ihr Abdruck einfach stehen)."""
+    fp: dict[str, object] = {}
+    try:  # Briefkasten trägt Chronik UND Kontext-Limit-Warnungen — in-process, spottbillig
+        from services import announce
+        fp["chronik"] = announce.list_after(None)["latest"]
+    except Exception:
+        pass
+    try:  # Queue: (id,status)-Paare; list_queue cached selbst ~15 s, der Tick kostet nichts
+        from services import ideen
+        d = ideen.list_queue()
+        fp["ideen"] = json.dumps([(i.get("id"), i.get("status")) for i in d.get("items") or []])
+    except Exception:
+        pass
+    try:  # Geladene Modelle (Running-Set): Laden/Entladen soll die Modelle-Ansicht anstoßen
+        from services import llamaswap
+        fp["models"] = json.dumps(sorted(str(m) for m in llamaswap.get_running_models()))
+    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"))
+    fp["reminders"] = _mtime(MODELS_DIR / "mc2-reminders.json")
+    return fp
+
+
+@router.get("/events")
+async def events(request: Request) -> StreamingResponse:
+    async def strom():
+        # Basislinie JE VERBINDUNG (der Client hat beim Verbinden frisch geladen) —
+        # ein globaler Snapshot würde bei mehreren Clients Events verschlucken.
+        alt = _fingerprints()
+        yield ": verbunden\n\n"
+        seit_ping = 0.0
+        while True:
+            if await request.is_disconnected():
+                return
+            await asyncio.sleep(TICK_S)
+            seit_ping += TICK_S
+            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",
+                             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})

backend/routers/gateway_forward.py

@@ -0,0 +1,66 @@
+"""
+Dünner /v1-Roh-Weiterleiter (UMBAU v3, P1).
+
+Wenn MC_V1_UPSTREAM gesetzt ist (Unit-Env), reicht das Steuerpult /v1 unangefasst an
+den eigenständigen mc2-gateway-Prozess (Loopback :9010) durch — LAN-Clients wie die
+IDE-Lane erreichen den Gateway sonst nicht. Hier passiert BEWUSST nichts: kein
+Routing, keine Bild-Weiche, keine Token-Zählung — all das macht genau einmal der
+Gateway-Prozess (routers/gateway_proxy.py). Rollback = Env-Zeile aus der Unit
+entfernen → app.py bindet wieder den lokalen Gateway ein.
+"""
+
+import logging
+
+from config import V1_UPSTREAM
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/v1")
+
+# Hop-by-hop-Header dürfen nicht blind weitergereicht werden; content-length wird von
+# httpx (Request) bzw. Starlette-Chunking (Response) neu bestimmt.
+_HOP_HEADERS = {
+    "host", "content-length", "connection", "keep-alive", "transfer-encoding",
+    "upgrade", "proxy-authenticate", "proxy-authorization", "te", "trailer",
+}
+
+
+def _clean(headers) -> dict:
+    return {k: v for k, v in headers.items() if k.lower() not in _HOP_HEADERS}
+
+
+@router.api_route("/{path:path}", methods=["GET", "POST"])
+async def forward(path: str, request: Request):
+    client = request.app.state.gw_client  # geteilter Keep-Alive-Client (app.py lifespan)
+    url = f"{V1_UPSTREAM}/v1/{path}"
+    if request.url.query:
+        url = f"{url}?{request.url.query}"
+    body = await request.body()
+    req = client.build_request(
+        request.method, url, content=body or None, headers=_clean(request.headers),
+        timeout=None,
+    )
+    try:
+        upstream = await client.send(req, stream=True)
+    except Exception as exc:  # Gateway-Prozess weg → ehrlicher 502 statt Hänger
+        log.warning("/v1-Weiterleitung an %s fehlgeschlagen: %s", V1_UPSTREAM, exc)
+        return JSONResponse(
+            {"error": {"message": f"mc2-gateway ({V1_UPSTREAM}) nicht erreichbar: {exc}",
+                       "type": "gateway_unavailable"}},
+            status_code=502,
+        )
+
+    async def gen():
+        try:
+            async for chunk in upstream.aiter_raw():
+                yield chunk
+        finally:
+            await upstream.aclose()
+
+    # Streaming-Passthrough für BEIDE Fälle (SSE + normale JSON-Antwort): Starlette
+    # chunkt selbst, Status/Header (inkl. x-mc-routed-to) kommen vom Gateway.
+    return StreamingResponse(
+        gen(), status_code=upstream.status_code, headers=_clean(upstream.headers)
+    )

backend/routers/gateway_proxy.py

@@ -1,33 +1,194 @@
+import logging
+import os
+
 import httpx
+from config import LLAMA_SWAP_URL
 from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse, StreamingResponse
-
-from config import LLAMA_SWAP_URL
-from services.gateway_stream import record_stream_chunk, record_usage
-from services.router_logic import LANES, choose_for_lane
+from services.gateway_stream import record_stream_chunk, record_usage, warn_truncation
+from services.router_logic import IMAGE_PART_TYPES, VISION_CAPABLE, choose_for_lane, has_image
 from services.routing_policy import load_policy
 
+log = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/v1")
 
-# Virtuelle Lanes, die der Gateway zusätzlich zu den echten Modellen als „Modell" anbietet.
-_LANE_LABELS = {"coding": "Coding (Router → coder/heavy/fast)", "chat": "Chat (Router → fast/heavy)"}
+# Antwortsprache für IDE-/Lane-Traffic: die Coding-Modelle antworten sonst englisch
+# (User-Anforderung 03.07.2026). Leerer String (MC_GATEWAY_LANG_DIRECTIVE="") schaltet ab.
+_LANG_DIRECTIVE = os.environ.get(
+    "MC_GATEWAY_LANG_DIRECTIVE",
+    "Antworte dem Nutzer grundsätzlich auf Deutsch (Erklärungen, Pläne, Rückfragen, "
+    "Zusammenfassungen) — auch wenn die Frage oder Tool-Anweisungen englisch sind. "
+    "Quellcode, Bezeichner und Shell-Befehle bleiben unverändert.")
 
 
+# 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(
+    "MC_CODER_IMAGE_PROMPT",
+    "Beschreibe dieses Bild vollstaendig und praezise auf Deutsch: sichtbarer Text, "
+    "Code, Zahlen/Daten, UI-Elemente, Layout, Farben und alles Auffaellige. "
+    "Sichtbaren Code und Fehlermeldungen gib WOERTLICH wieder.")
+
+
+# Lucy-Voice-Schnellspur (16.07.): Lucys Sprach-Turns tragen diesen Marker im System-Prompt.
+# Er schaltet das Qwen-Denken für GENAU diese Requests ab (gemessen direkt am Hirn: 9,9 s -> 0,8 s
+# bis zur Antwort; reasoning_content 2500 Zeichen -> 0) — die „Hirn"-Latenz der Voice-Turns war
+# fast vollständig Reasoning-Generierung VOR dem ersten sprechbaren Wort. Der Marker wird VOR dem
+# Modell aus allen Messages entfernt (konstanter Text -> Prefix-Cache bleibt stabil). Requests ohne
+# Marker (Crons, Telegram, Werkstatt) bleiben unangetastet. Leerer Env-Wert schaltet die Spur ab.
+_NO_THINK_MARKER = os.environ.get("MC_NO_THINK_MARKER", "[[MC:NO_THINK]]")
+
+
+def _apply_no_think_marker(body: dict) -> None:
+    """Marker aus allen Message-Inhalten strippen; war er da, Thinking abschalten
+    (sofern der Client chat_template_kwargs nicht selbst gesetzt hat)."""
+    if not _NO_THINK_MARKER:
+        return
+    found = False
+    for m in body.get("messages") or []:
+        if not isinstance(m, dict):
+            continue
+        c = m.get("content")
+        if isinstance(c, str) and _NO_THINK_MARKER in c:
+            m["content"] = c.replace(_NO_THINK_MARKER, "").strip()
+            found = True
+        elif isinstance(c, list):
+            for part in c:
+                if (isinstance(part, dict) and isinstance(part.get("text"), str)
+                        and _NO_THINK_MARKER in part["text"]):
+                    part["text"] = part["text"].replace(_NO_THINK_MARKER, "").strip()
+                    found = True
+    if found and "chat_template_kwargs" not in body:
+        body["chat_template_kwargs"] = {"enable_thinking": False}
+
+
+def _ist_coder_alias(alias: str) -> bool:
+    """Coder-Ziele (coder, rohe Qwen-Coder-IDs) bekommen Bild-BESCHREIBUNGEN statt der
+    stumpfen Vision-Umleitung — die Code-Frage bleibt beim Spezialisten."""
+    return "coder" in (alias or "").lower()
+
+
+async def _bilder_fuer_coder_beschreiben(body: dict, client, vision_alias: str) -> bool:
+    """Ersetzt jeden Bild-Part durch eine Text-Beschreibung vom Vision-Modell.
+
+    Idee aus einem verwaisten, nie verdrahteten Patch in der Hermes-Quelle
+    (gateway/platforms/api_server.py, 07/2026) — bei der Projekt-Review 15.07.
+    regelkonform hierher umgezogen (Archiv: docs/archiv/). True = alle Bilder
+    ersetzt; False = eine Analyse scheiterte, Aufrufer nutzt die normale
+    Vision-Umleitung als Fallback.
+    """
+    fundstellen: list[tuple[dict, int, dict]] = []
+    for m in body.get("messages") or []:
+        if not isinstance(m, dict) or not isinstance(m.get("content"), list):
+            continue
+        for i, part in enumerate(m["content"]):
+            if isinstance(part, dict) and part.get("type") in IMAGE_PART_TYPES:
+                fundstellen.append((m, i, part))
+    for nr, (msg, idx, part) in enumerate(fundstellen, start=1):
+        frage = {
+            "model": vision_alias,
+            "stream": False,
+            "max_tokens": 700,
+            "messages": [{"role": "user",
+                          "content": [part, {"type": "text", "text": _BILD_BESCHREIB_PROMPT}]}],
+        }
+        # Eigener Kurzzeit-Client statt des gepoolten (Befund 15.07.: ReadTimeout nach
+        # Sekunden trotz timeout=240 — llama-swap kappt beim Modell-Swap gern alte
+        # Keep-Alive-Sockets, der Pool reicht sie trotzdem wieder aus) + 1 Retry.
+        text = ""
+        for versuch in (1, 2):
+            try:
+                async with httpx.AsyncClient(timeout=240.0) 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 ""
+                if text.strip():
+                    break
+                log.warning("Bild-Weiche v2 (Versuch %s): Beschreibung leer/HTTP %s — %.200s",
+                            versuch, r.status_code, r.text)
+            except Exception:
+                log.warning("Bild-Weiche v2 (Versuch %s): Vision-Aufruf scheiterte", versuch, exc_info=True)
+        if not text.strip():
+            return False
+        msg["content"][idx] = {"type": "text", "text": (
+            f"[Bild {nr}: dem Request lag ein Bild bei — {vision_alias} beschreibt es so:\n"
+            f"{text.strip()}]")}
+    return True
+
+
+def _inject_language(body: dict, alias: str) -> None:
+    """Deutsch-Direktive anhängen. An die ERSTE System-Message (viele Chat-Templates
+    erwarten nur eine), sonst als neue System-Message. `hermes` ausgenommen — Lucys
+    Persona (SOUL.md) regelt die Sprache selbst."""
+    if not _LANG_DIRECTIVE or alias == "hermes":
+        return
+    msgs = body.get("messages")
+    if not isinstance(msgs, list):
+        return
+    first_sys = next((m for m in msgs if isinstance(m, dict) and m.get("role") == "system"), None)
+    if first_sys is None:
+        msgs.insert(0, {"role": "system", "content": _LANG_DIRECTIVE})
+    elif isinstance(first_sys.get("content"), str):
+        first_sys["content"] = first_sys["content"].rstrip() + "\n\n" + _LANG_DIRECTIVE
+    elif isinstance(first_sys.get("content"), list):
+        first_sys["content"].append({"type": "text", "text": _LANG_DIRECTIVE})
+
 @router.get("/models")
-async def models():
-    async with httpx.AsyncClient(timeout=10) as c:
-        r = await c.get(f"{LLAMA_SWAP_URL}/v1/models")
-        data = r.json()
-    # Lanes ganz oben einblenden, damit IDEs einfach „coding"/„chat" wählen können.
-    lanes = [{"id": lane, "object": "model", "owned_by": "mc2-router",
-              "description": _LANE_LABELS.get(lane, lane)} for lane in LANES]
+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()
+    # 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.
+    # Kontextlänge je Modell mitliefern (aus der llama-swap-Config geparst). Ohne sie
+    # budgetieren Clients blind — Hermes-Subagents nahmen 256k an, schickten passende
+    # max_tokens und rissen damit den echten Server-Kontext (Radar-Lauf 02.07.).
+    # Rollen-Aliase (heavy/coder/hermes …) tauchen bei llama-swap NICHT als Einträge auf,
+    # Clients fragen aber genau damit an → als eigene Einträge einblenden.
+    ctx_map: dict[str, int] = {}
+    alias_entries: list[dict] = []
+    aliased_raw: set[str] = set()  # rohe Modellnamen, die ein Klarnamen-Alias schon zeigt
+    try:
+        from services import llamaswap
+        for m in llamaswap.list_models():
+            ctx = m.get("ctx")
+            # --parallel teilt den Server-Kontext HART auf die Slots auf — ohne die
+            # Division budgetieren Clients (v. a. Hermes) gegen 131k, real sind 65k/Slot:
+            # Kompaktierung feuert nie, llama-server kappt Prompt/Antwort → abgerissene
+            # Tool-Calls + Retry-Schleifen (Log 07.07., Session bei ~52k Tokens).
+            slots = m.get("parallel_slots") or 1
+            if ctx and slots > 1:
+                ctx = ctx // slots
+            if ctx:
+                for api_id in m.get("api_ids", []):
+                    ctx_map[api_id] = ctx
+            aliases = m.get("aliases", [])
+            if aliases:
+                aliased_raw.add(m["name"])
+            for alias in aliases:
+                entry = {"id": alias, "object": "model", "owned_by": "mc2-alias",
+                         "description": f"Alias für {m['name']}"}
+                if ctx:
+                    entry["context_length"] = ctx
+                alias_entries.append(entry)
+    except Exception:
+        pass
     if isinstance(data, dict) and isinstance(data.get("data"), list):
-        data["data"] = lanes + data["data"]
+        for entry in data["data"]:
+            if (ctx := ctx_map.get(entry.get("id"))):
+                entry.setdefault("context_length", ctx)
+        # Rohe Doppel-IDs ausblenden, wenn ein Klarnamen-Alias sie schon zeigt → in der
+        # Liste erscheinen nur die freundlichen Rollen-Namen. Routing per roher ID bleibt.
+        raw = [e for e in data["data"] if e.get("id") not in aliased_raw]
+        data["data"] = alias_entries + raw
     return JSONResponse(data, status_code=r.status_code)
 
 
 async def _proxy(path: str, request: Request):
     body = await request.json()
+    _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"):
         lane = requested.lower()
@@ -37,26 +198,59 @@ async def _proxy(path: str, request: Request):
     else:
         alias = requested
         routed = {"x-mc-routed-to": requested}
-    # fast-Spur: Thinking aus für flotte Antworten (sofern Client es nicht selbst setzt).
+
     pol = load_policy()
+    client = request.app.state.gw_client  # geteilter Keep-Alive-Client (siehe app.py lifespan)
+    # Bild-Weiche (Faden 11): Requests mit Bild-Anhang automatisch ans Vision-Modell umleiten,
+    # sofern das Ziel nicht ohnehin bildfähig ist. Das MTP-Hirn (fast/hermes) kann keine Bilder —
+    # so bleibt Lucy schnell, ohne dass jemand manuell das Modell wechselt (Entscheid Weg A).
+    # Coder-Sonderweg (15.07.): Coder-Ziele behalten den Request — die Bilder werden vorab vom
+    # Vision-Modell BESCHRIEBEN und als Text injiziert (Screenshot-Debugging bleibt beim Coder).
+    vision_alias = pol.get("vision")
+    if vision_alias and alias not in VISION_CAPABLE and has_image(body):
+        if _ist_coder_alias(alias) and await _bilder_fuer_coder_beschreiben(body, client, vision_alias):
+            routed = {"x-mc-routed-to": alias,
+                      "x-mc-route-reason": "Bild beschrieben (Vision) -> bleibt beim Coder",
+                      "x-mc-lane": routed.get("x-mc-lane", "-")}
+        else:
+            alias = vision_alias
+            body["model"] = alias
+            # HTTP-Header-Werte muessen latin-1 sein — kein '→' o.ae. (sonst 500, 13.07.).
+            routed = {"x-mc-routed-to": alias, "x-mc-route-reason": "Bild erkannt -> Vision-Modell",
+                      "x-mc-lane": routed.get("x-mc-lane", "-")}
+    # fast-Spur: Thinking aus für flotte Antworten (sofern Client es nicht selbst setzt).
     if pol["fast_no_think"] and alias == pol["fast"] and "chat_template_kwargs" not in body:
         body["chat_template_kwargs"] = {"enable_thinking": False}
+    _inject_language(body, alias)
     url = f"{LLAMA_SWAP_URL}{path}"
-
     if body.get("stream"):
+        req = client.build_request("POST", url, json=body, timeout=None)
+        r = await client.send(req, stream=True)
+        if r.status_code != 200:
+            await r.aread()
+            try:
+                resp_json = r.json()
+            except Exception:
+                resp_json = {"error": {"message": r.text, "type": "upstream_error"}}
+            return JSONResponse(resp_json, status_code=r.status_code, headers=routed)
+
         async def gen():
-            async with httpx.AsyncClient(timeout=None) as c:
-                async with c.stream("POST", url, json=body) as r:
-                    async for chunk in r.aiter_raw():
-                        record_stream_chunk(chunk, alias)
-                        yield chunk
+            try:
+                async for chunk in r.aiter_raw():
+                    record_stream_chunk(chunk, alias, body.get("max_tokens"))
+                    yield chunk
+            finally:
+                await r.aclose()
         return StreamingResponse(gen(), media_type="text/event-stream", headers=routed)
 
-    async with httpx.AsyncClient(timeout=600) as c:
-        r = await c.post(url, json=body)
-        resp_json = r.json()
-        record_usage(resp_json.get("usage") if isinstance(resp_json, dict) else None, alias)
-        return JSONResponse(resp_json, status_code=r.status_code, headers=routed)
+    r = await client.post(url, json=body, timeout=600.0)
+    resp_json = r.json()
+    if isinstance(resp_json, dict):
+        record_usage(resp_json.get("usage"), alias)
+        if any(isinstance(c, dict) and c.get("finish_reason") == "length"
+               for c in resp_json.get("choices") or []):
+            warn_truncation(alias, body.get("max_tokens"))
+    return JSONResponse(resp_json, status_code=r.status_code, headers=routed)
 
 
 @router.post("/chat/completions")

backend/routers/health.py

@@ -1,14 +1,22 @@
 """Health-/Status-Endpoint — schlanker Lebenszeichen-Check für MC 2.0."""
 
-from fastapi import APIRouter
-
 from config import VERSION
+from fastapi import APIRouter
+from pydantic import BaseModel
 from services import gateway, llamaswap
 
 router = APIRouter(prefix="/api")
 
 
-@router.get("/health")
+class HealthResponse(BaseModel):
+    status: str
+    version: str
+    engine_reachable: bool
+    gateway_reachable: bool
+    brain: dict
+
+
+@router.get("/health", response_model=HealthResponse)
 def health() -> dict:
     return {
         "status": "ok",

backend/routers/hermes_ui.py

@@ -0,0 +1,134 @@
+"""
+Same-origin Reverse-Proxy für die EINGEBAUTE Hermes-Web-GUI (`hermes serve`/`dashboard`).
+
+Anders als das ttyd-Terminal (reiner Byte-Durchreicher, siehe routers/console.py) ist die
+Hermes-GUI eine volle Single-Page-App: HTML + gehashte Assets + JSON-API + MEHRERE WebSockets
+(/api/ws, /api/console, /api/pty, /api/events). Deshalb hier ein GENERISCHER Reverse-Proxy für
+alles unter `/hermes-ui/*` (alle HTTP-Methoden + beliebige WebSockets).
+
+Der Backend-Server läuft NUR auf Loopback (127.0.0.1:9119, `hermes serve --skip-build`, kein
+Login — gleiches LAN-Trust-Modell wie Konsole/Terminal) und wird über den ohnehin offenen
+MC2-Port (9001) same-origin durchgereicht → keine eigene Firewall-Freigabe, kein CORS.
+
+Damit die absoluten Pfade der SPA (`/assets`, `/api`, `/api/ws`) nicht mit MC2s eigenen (`/assets`,
+`/api`) kollidieren, wird das Hermes-Bundle mit Vite-`base=/hermes-ui/` gebaut (deploy.sh) — dann
+liegen ALLE seine Pfade unter `/hermes-ui/`. Dieser Proxy streift das Präfix ab und leitet an
+`:9119/...` weiter.
+"""
+
+import asyncio
+import logging
+import re
+
+import httpx
+import websockets
+from config import HERMES_BUILTIN_UI_UPSTREAM
+from fastapi import APIRouter, Request, WebSocket
+from starlette.responses import RedirectResponse, Response
+
+log = logging.getLogger(__name__)
+router = APIRouter()
+
+_BASE = "hermes-ui"
+
+# Hop-by-hop- + Kodierungs-Header, die ein Proxy nicht 1:1 weiterreichen darf (Länge/Encoding
+# rechnet Starlette neu; httpx liefert bereits dekodierten Body).
+_DROP = {
+    "connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailers",
+    "transfer-encoding", "upgrade", "content-encoding", "content-length", "host",
+}
+
+
+@router.websocket(f"/{_BASE}/{{path:path}}")
+async def _proxy_ws(ws: WebSocket, path: str) -> None:
+    """Beliebige WebSocket unter /hermes-ui/* (z. B. /hermes-ui/api/ws) an :9119 durchreichen."""
+    ws_upstream = HERMES_BUILTIN_UI_UPSTREAM.replace("http://", "ws://").replace("https://", "wss://")
+    query = ws.url.query
+    target = f"{ws_upstream}/{path}" + (f"?{query}" if query else "")
+    await ws.accept()
+    try:
+        async with websockets.connect(
+            target, open_timeout=10, max_size=None, ping_interval=None,
+        ) as up:
+            async def c2u() -> None:
+                while True:
+                    msg = await ws.receive()
+                    if msg.get("type") == "websocket.disconnect":
+                        return
+                    if (t := msg.get("text")) is not None:
+                        await up.send(t)
+                    elif (b := msg.get("bytes")) is not None:
+                        await up.send(b)
+
+            async def u2c() -> None:
+                async for m in up:
+                    if isinstance(m, (bytes, bytearray)):
+                        await ws.send_bytes(bytes(m))
+                    else:
+                        await ws.send_text(m)
+
+            _done, pending = await asyncio.wait(
+                [asyncio.create_task(c2u()), asyncio.create_task(u2c())],
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            for task in pending:
+                task.cancel()
+    except Exception:
+        log.debug("hermes-ui ws-proxy (%s) beendet/fehlgeschlagen", path, exc_info=True)
+    finally:
+        try:
+            await ws.close()
+        except Exception:
+            pass
+
+
+# Die SPA liest ihren API/WS-Basis-Pfad zur Laufzeit aus `window.__HERMES_BASE_PATH__` (nf() im
+# Bundle). `hermes serve` injiziert diese Zuweisung selbst ans Ende von <head> (Wert leer, weil es
+# auf Root läuft) — dessen Wert überschreiben wir auf /hermes-ui, sonst setzt die GUI ihre /api-Calls
+# auf MC2s eigenen /api-Namensraum (SPA-Fallback = HTML) ab. Die Assets liegen bereits per
+# Vite-base=/hermes-ui/ richtig. MC2 macht die Ersetzung → überlebt Hermes-Updates, ohne die gebaute
+# index.html patchen zu müssen. Fällt die Server-Injektion je weg, setzen wir sie ersatzweise selbst.
+_BASE_PATH_RE = re.compile(rb'window\.__HERMES_BASE_PATH__\s*=\s*"[^"]*"')
+_BASE_PATH_SET = b'window.__HERMES_BASE_PATH__="/' + _BASE.encode() + b'"'
+_HEAD_INJECT = b"<head><script>" + _BASE_PATH_SET + b";</script>"
+
+
+async def _proxy_http(request: Request, path: str = "") -> Response:
+    upstream = f"{HERMES_BUILTIN_UI_UPSTREAM}/{path}"
+    fwd_headers = {k: v for k, v in request.headers.items() if k.lower() not in _DROP}
+    # Upstream unkomprimiert anfordern: sonst greift die HTML-Injektion nicht und die
+    # content-encoding-Header würden nicht zum (bereits dekodierten) Body passen.
+    fwd_headers["accept-encoding"] = "identity"
+    try:
+        async with httpx.AsyncClient(timeout=30.0, follow_redirects=False) as c:
+            r = await c.request(
+                request.method, upstream,
+                headers=fwd_headers, params=request.query_params, content=await request.body(),
+            )
+    except httpx.HTTPError as exc:
+        log.debug("hermes-ui http-proxy (%s) nicht erreichbar: %s", path, exc)
+        return Response(
+            content=b"Hermes-WebUI (hermes dashboard) nicht erreichbar.",
+            status_code=502, media_type="text/plain",
+        )
+    body = r.content
+    if "text/html" in r.headers.get("content-type", "").lower():
+        if _BASE_PATH_RE.search(body):
+            body = _BASE_PATH_RE.sub(_BASE_PATH_SET, body)
+        elif b"<head>" in body:
+            body = body.replace(b"<head>", _HEAD_INJECT, 1)
+    resp_headers = {k: v for k, v in r.headers.items() if k.lower() not in _DROP}
+    return Response(content=body, status_code=r.status_code, headers=resp_headers)
+
+
+@router.get(f"/{_BASE}")
+async def _root_redirect() -> RedirectResponse:
+    # Ohne Schrägstrich → auf /hermes-ui/ umleiten (die SPA erwartet den Präfix mit Slash).
+    return RedirectResponse(url=f"/{_BASE}/")
+
+
+router.add_api_route(
+    f"/{_BASE}/{{path:path}}", _proxy_http,
+    methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"],
+    name="hermes_ui_proxy",
+)

backend/routers/ideen.py

@@ -0,0 +1,154 @@
+"""Ideen-Queue-Endpoints — dünner REST-Layer über services/ideen.py (natives Hermes-Kanban).
+LAN-only wie alle MC2-Endpoints; das Mensch-Gate bleibt die Karte im Auftragsbuch."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from services import ideen
+
+router = APIRouter(prefix="/api")
+
+
+class IdeeIn(BaseModel):
+    titel: str
+    notiz: str = ""
+    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)
+
+
+class TaskIn(BaseModel):
+    id: str
+
+
+class AntwortIn(BaseModel):
+    id: str
+    antwort: str
+
+
+class ArchivAlleIn(BaseModel):
+    # Leer = alle fertigen Karten der Queue; gesetzt = nur die dieses Projekts.
+    projekt: str = ""
+
+
+class EinordnenIn(BaseModel):
+    text: str
+
+
+@router.get("/ideen")
+def list_queue() -> dict:
+    return ideen.list_queue()
+
+
+@router.post("/ideen")
+def add_idea(body: IdeeIn) -> dict:
+    res = ideen.add_idea(body.titel, body.notiz, welt=body.welt, tiefe=body.tiefe,
+                         ziel=body.ziel, art=body.art)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Idee konnte nicht angelegt werden."))
+    return res
+
+
+@router.post("/ideen/antwort")
+def answer(body: AntwortIn) -> dict:
+    res = ideen.answer_task(body.id, body.antwort)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Antwort konnte nicht gesendet werden."))
+    return res
+
+
+class PrioIn(BaseModel):
+    id: str
+    richtung: str  # hoch | runter
+
+
+@router.post("/ideen/stopp")
+def stop(body: TaskIn) -> dict:
+    res = ideen.stop_task(body.id)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Stoppen fehlgeschlagen."))
+    return res
+
+
+@router.post("/ideen/retry")
+def retry(body: TaskIn) -> dict:
+    res = ideen.retry_task(body.id)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Neuer Versuch fehlgeschlagen."))
+    return res
+
+
+@router.post("/ideen/prio")
+def prio(body: PrioIn) -> dict:
+    res = ideen.prio_task(body.id, body.richtung)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Prio-Änderung fehlgeschlagen."))
+    return res
+
+
+class WeiterIn(BaseModel):
+    id: str
+    ziel: str = ""     # "lxc" | "docker" (leer = Box entscheidet)
+    tiefe: str = ""    # "simpel" | "gruendlich" (leer = Box schätzt selbst)
+
+
+@router.post("/ideen/weiterfuehren")
+def weiterfuehren(body: WeiterIn) -> dict:
+    """„Konzept gefällt mir" → IDE-Projekt-Karte mit dem fertigen Konzept als Vorlage."""
+    res = ideen.projekt_aus_idee(body.id, ziel=body.ziel, tiefe=body.tiefe)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Projekt konnte nicht angelegt werden."))
+    return res
+
+
+class NachschaerfenIn(BaseModel):
+    id: str
+    hinweis: str
+
+
+@router.post("/ideen/nachschaerfen")
+def nachschaerfen(body: NachschaerfenIn) -> dict:
+    """„Punkt X passt nicht" → Überarbeitungs-Runde am bestehenden Konzept."""
+    res = ideen.konzept_ueberarbeiten(body.id, body.hinweis)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Überarbeitung konnte nicht gestartet werden."))
+    return res
+
+
+@router.post("/ideen/archivieren")
+def archive(body: TaskIn) -> dict:
+    res = ideen.archive_task(body.id)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Archivieren fehlgeschlagen."))
+    return res
+
+
+@router.post("/ideen/einordnen")
+def einordnen(body: EinordnenIn) -> dict:
+    """Einordnungs-VORSCHLAG beim Tippen. Wirft nie — scheitert es, kommt `ok: false`
+    und die Oberfläche behält ihre Voreinstellung."""
+    return ideen.einordnen(body.text)
+
+
+@router.post("/ideen/archivieren-alle")
+def archive_alle(body: ArchivAlleIn) -> dict:
+    """Fertige Karten sammelweise wegräumen. Fasst ausschließlich `done` an."""
+    res = ideen.archive_done(body.projekt)
+    if not res.get("ok"):
+        raise HTTPException(400, res.get("error", "Archivieren fehlgeschlagen."))
+    return res
+
+
+@router.get("/ideen/{id}/log")
+def get_log(id: str) -> dict:
+    return ideen.log_of(id)
+
+
+@router.get("/ideen/{id}/ergebnis")
+def get_ergebnis(id: str) -> dict:
+    return ideen.ergebnis_of(id)
+
+
+@router.get("/ideen/{id}/konzept")
+def get_konzept(id: str) -> dict:
+    return ideen.konzept_of(id)

backend/routers/maintenance.py

@@ -1,8 +1,7 @@
 """Wartungs-Endpoints: Update-Badge, OS-/Engine-Update, Reboot, Restart, Logs."""
 
-from fastapi import APIRouter, HTTPException, Header
+from fastapi import APIRouter, Header, HTTPException
 from pydantic import BaseModel
-
 from services import maintenance
 
 router = APIRouter(prefix="/api")
@@ -65,6 +64,11 @@ def hermes_update() -> dict:
     return maintenance.hermes_update_job()
 
 
+@router.post("/maintenance/update-all")
+def update_all(body: SudoReq) -> dict:
+    return maintenance.update_all_job(body.sudo_password)
+
+
 @router.post("/maintenance/reboot")
 def reboot(body: SudoReq) -> dict:
     return maintenance.reboot(body.sudo_password)

backend/routers/memory.py

@@ -1,81 +0,0 @@
-"""Memory-Endpoints (geteiltes Gedächtnis). LAN-only, kein Token in 2.0-Phase 3."""
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-
-from services import memory
-
-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]:
-    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}

backend/routers/models.py

@@ -1,10 +1,9 @@
 """Modelle-Endpoints: Liste (mit Caps), Discover, Fit, Register, Groups."""
 
 import psutil
+from config import HF_DOWNLOAD_ENV, MODELS_DIR
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-
-from config import HF_DOWNLOAD_ENV, MODELS_DIR
 from services import budget, discover, hf, jobengine, llamaswap
 from services.fit import evaluate_fit, max_ctx_for
 
@@ -114,24 +113,41 @@ def install(req: InstallReq) -> dict:
         # SETUP-BEWUSST: größter ctx, der neben Hirn/warmem Set passt (nicht nur Modell allein).
         ctx = budget.setup_aware_ctx(budget.params_b_for(repo), req.quant, role=req.role)["ctx"]
 
-    # Sofort registrieren (Datei kommt gleich) — robust gegen -watch-config.
+    # Sofort registrieren (robust gegen -watch-config) — aber OHNE den Rollen-Alias
+    # umzuhängen: der zeigte sonst minutenlang auf eine noch ladende Datei (Lane kalt;
+    # bei role=hermes wäre Lucy bis Download-Ende tot gewesen — Review 16.07.).
     try:
         model_id = llamaswap.register_model(
-            model_path, role=req.role, ctx=ctx, mmproj_path=mmproj_path, jinja=req.jinja)
+            model_path, role=req.role, ctx=ctx, mmproj_path=mmproj_path, jinja=req.jinja,
+            set_alias=False)
     except PermissionError as exc:
         raise HTTPException(500, str(exc))
 
+    # Rolle erst NACH erfolgreichem Download übernehmen. hermes geht dabei durch den
+    # warm-bewussten Hirn-Flow (brains-Gruppe, ttl 0, Hermes-Config, Gateway-Restart) —
+    # der rohe Alias-Move hatte diesen Flow bisher umgangen.
+    role = (req.role or "").strip().lower()
+
+    def _apply_role() -> None:
+        if role == "hermes":
+            from services.agent import set_agent_brain
+            res = set_agent_brain(model_id)
+            if not res.get("ok"):
+                raise RuntimeError(res.get("reason", "Hirn-Wechsel fehlgeschlagen"))
+        else:
+            llamaswap.set_role(model_id, role)
+
     # Download-Job: alle GGUF-Teile (+ mmproj) per --include holen.
     args = [hf.hf_bin(), "download", repo]
-    for f in info["files"]:
-        args.append(f)
+    args.extend(info["files"])
     if info["mmproj"]:
         args.append(info["mmproj"])
     args += ["--local-dir", str(target)]
     env = dict(HF_DOWNLOAD_ENV)
     if req.hf_token:
         env["HF_TOKEN"] = req.hf_token
-    job_id = jobengine.start_job(args, f"download {req.repo}", env=env)
+    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"])
     return {"ok": True, "job_id": job_id, "model_id": model_id, "model_path": model_path,
             "total_bytes": info["total_bytes"], "files": len(info["files"])}
@@ -161,9 +177,18 @@ def recommend_role(role: str) -> dict:
 
 @router.post("/models/{model_id}/role")
 def set_model_role(model_id: str, body: RoleReq) -> dict:
+    new_role = (body.role or "").strip().lower()
+    # Guard: Hält das Modell einen LEBENSWICHTIGEN Alias (hermes/embed), darf die Rolle
+    # hier nicht weggeklickt werden — sonst verliert Lucy Hirn/Gedächtnis mit einem Klick.
+    # Weg: die geschützte Rolle zuerst einem ANDEREN Modell zuweisen (Alias zieht um).
+    prot = llamaswap.protected_alias_of(model_id)
+    if prot and new_role != prot:
+        raise HTTPException(400,
+            f"Dieses Modell hält die lebenswichtige Rolle '{prot}'. Weise '{prot}' zuerst "
+            f"einem anderen Modell zu — danach lässt sich die Rolle hier ändern.")
     # Das Agent-Hirn (Rolle 'hermes') braucht den warm-bewussten Flow (Alias + brains-Gruppe +
     # ttl 0 + Hermes config.default + Gateway-Restart) — Single Source of Truth UI ↔ Hermes.
-    if (body.role or "").strip().lower() == "hermes":
+    if new_role == "hermes":
         from services.agent import set_agent_brain
         res = set_agent_brain(model_id)
         if not res.get("ok"):

backend/routers/reminders.py

@@ -0,0 +1,49 @@
+"""Erinnerungen & Routinen (A3) — dünner REST-Layer über services/reminders.py.
+Konsument ist v.a. der Hermes-Agent via mcp_mc.py (reminder_create/list/delete);
+LAN-only wie alle MC2-Endpoints."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from services import reminders
+
+router = APIRouter(prefix="/api")
+
+
+class ReminderIn(BaseModel):
+    text: str          # was angesagt werden soll
+    when: str          # ISO-8601; ohne Offset = Commander-Zeitzone (Europe/Berlin)
+    repeat: str = ""   # '' einmalig | daily | weekdays | weekly
+
+
+class ReminderOut(BaseModel):
+    id: int
+    text: str
+    next_ts: float
+    repeat: str
+    created_ts: float
+    when_local: str
+
+
+class ReminderListResponse(BaseModel):
+    items: list[ReminderOut]
+
+
+@router.get("/reminders", response_model=ReminderListResponse)
+def list_reminders() -> dict:
+    return {"items": reminders.list_all()}
+
+
+@router.post("/reminders")
+def create_reminder(body: ReminderIn) -> dict:
+    try:
+        return {"ok": True, "item": reminders.create(body.text, body.when, body.repeat)}
+    except ValueError as exc:
+        raise HTTPException(400, str(exc))
+
+
+@router.delete("/reminders/{reminder_id}")
+def delete_reminder(reminder_id: int) -> dict:
+    try:
+        return {"ok": True, "deleted": reminders.delete(reminder_id)}
+    except KeyError as exc:
+        raise HTTPException(404, str(exc.args[0]))

backend/routers/routing.py

@@ -2,7 +2,6 @@
 
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-
 from services import gateway
 from services.routing_policy import policy_meta, save_policy
 

backend/routers/skills.py

@@ -0,0 +1,83 @@
+import os
+import subprocess
+
+import psutil
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api")
+
+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,
+                    "description": description or "Keine Beschreibung verfügbar.",
+                    "running": 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
+    cmd = [hermes_bin, "-z", f"Führe den '{req.skill_name}' Skill aus", "chat"]
+    try:
+        log_path = os.path.expanduser(f"~/.hermes/logs/skill_{req.skill_name.replace('/', '_')}.log")
+        os.makedirs(os.path.dirname(log_path), exist_ok=True)
+        with open(log_path, "a") as f:
+            f.write(f"\n--- Starting Skill: {req.skill_name} ---\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)}

backend/routers/system.py

@@ -1,128 +1,175 @@
-"""System-Endpoints: Live-Status + Wartung (Restart/Self-Update — auf der Box).
-
-Wartung läuft als systemd-USER-Dienst → KEIN sudo/Passwort (Nordstern).
-Lokal (Windows) schlagen die Shell-Befehle harmlos fehl und werden als Fehler
-zurückgegeben statt zu crashen.
-"""
-
-import logging
-import os
-import subprocess
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-
-import httpx
-
-from config import GATEWAY_URL, HERMES_API_URL, LLAMA_SWAP_URL, MEM0_SERVICE_URL, VOICE_SERVICE_URL
-from services import backup as backup_svc
-from services.agent import agent_status
-from services.gateway import gateway_reachable
-from services.llamaswap import engine_reachable, list_models
-from services.pricing import compute_savings
-from services.system import system_status
-from services.token_stats import get_stats
-
-log = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api")
-
-# Nur diese User-Dienste dürfen neugestartet werden.
-ALLOWED_SERVICES = {"mission-control-2", "hermes-gateway", "hermes-webui", "mem0-service", "voice-service"}
-# Quelle für Self-Update (auf der Box ~/mission-control-v2).
-SOURCE_DIR = os.path.expanduser(os.environ.get("MC2_SOURCE_DIR", "~/mission-control-v2"))
-
-
-@router.get("/system/status")
-def status() -> dict:
-    return system_status()
-
-
-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
-    except Exception:
-        return False
-
-
-@router.get("/system/services")
-def services() -> dict:
-    """Aggregierte Erreichbarkeit aller Stack-Dienste (für die Health-Anzeige)."""
-    a = agent_status()
-    gw_url = f"{GATEWAY_URL}/v1"
-    return {
-        "services": [
-            {"name": "Engine (llama-swap)", "url": LLAMA_SWAP_URL, "ok": engine_reachable()},
-            {"name": "Gateway (integriert)", "url": gw_url, "ok": gateway_reachable()},
-            {"name": "Hermes-Gateway", "url": HERMES_API_URL, "ok": a["gateway_reachable"]},
-            {"name": "Hermes-Terminal", "url": a["terminal_url"], "ok": a["terminal_reachable"]},
-            {"name": "Mem0 (Gedächtnis)", "url": MEM0_SERVICE_URL, "ok": _mem0_reachable()},
-            {"name": "Voice (STT/TTS)", "url": VOICE_SERVICE_URL, "ok": _voice_reachable()},
-        ],
-        "links": {
-            "engine_ui": f"{LLAMA_SWAP_URL}/ui",
-            "gateway": gw_url,
-            "hermes_terminal": a["terminal_url"],
-        },
-    }
-
-
-@router.post("/system/backup")
-def backup() -> dict:
-    return backup_svc.backup_now()
-
-
-@router.get("/system/backups")
-def backups() -> dict:
-    return {"backups": backup_svc.list_backups()}
-
-
-def _run(cmd: list[str], cwd: str | None = None) -> dict:
-    try:
-        p = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, timeout=180)
-        return {"ok": p.returncode == 0, "code": p.returncode,
-                "out": (p.stdout or "")[-2000:], "err": (p.stderr or "")[-2000:]}
-    except Exception as exc:  # noqa: BLE001
-        return {"ok": False, "code": -1, "out": "", "err": str(exc)}
-
-
-class RestartReq(BaseModel):
-    service: str
-
-
-@router.post("/system/restart")
-def restart(req: RestartReq) -> dict:
-    if req.service not in ALLOWED_SERVICES:
-        raise HTTPException(400, f"Dienst '{req.service}' nicht erlaubt.")
-    return _run(["systemctl", "--user", "restart", req.service])
-
-
-@router.post("/system/self-update")
-def self_update() -> dict:
-    """git pull (Source) → venv-Deps → Dienst-Restart. Auf der Box; lokal Fehler."""
-    pull = _run(["git", "fetch", "--all"], cwd=SOURCE_DIR)
-    reset = _run(["git", "reset", "--hard", "origin/main"], cwd=SOURCE_DIR)
-    restart_res = _run(["systemctl", "--user", "restart", "mission-control-2"])
-    return {"pull": pull, "reset": reset, "restart": restart_res}
-
-
-@router.get("/system/token-stats")
-def token_stats() -> dict:
-    """Token-Verbrauch + Cloud-Ersparnis. Logik im pricing-Service (SSoT)."""
-    # Rolle je Modell/Alias (lowercase) für die Tarif-Auflösung auflösen.
-    role_map: dict[str, str | None] = {}
-    try:
-        for m in list_models():
-            role_map[m["name"].lower()] = m.get("role")
-            for alias in m.get("aliases", []):
-                role_map[alias.lower()] = m.get("role")
-    except Exception:
-        log.warning("token_stats: list_models fehlgeschlagen, Tarife per Name", exc_info=True)
-    return compute_savings(get_stats(), role_map)
+"""System-Endpoints: Live-Status + Wartung (Restart/Self-Update — auf der Box).
+
+Wartung läuft als systemd-USER-Dienst → KEIN sudo/Passwort (Nordstern).
+Lokal (Windows) schlagen die Shell-Befehle harmlos fehl und werden als Fehler
+zurückgegeben statt zu crashen.
+"""
+
+import logging
+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 fastapi import APIRouter
+from pydantic import BaseModel
+from services import backup as backup_svc
+from services import maintenance
+from services.agent import agent_status
+from services.gateway import gateway_reachable
+from services.llamaswap import engine_reachable, list_models
+from services.pricing import compute_savings
+from services.system import system_status
+from services.token_stats import get_stats
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api")
+
+# Quelle für Self-Update (auf der Box ~/mission-control-v2).
+SOURCE_DIR = os.path.expanduser(os.environ.get("MC2_SOURCE_DIR", "~/mission-control-v2"))
+
+
+@router.get("/system/status")
+def status() -> dict:
+    return system_status()
+
+
+@router.get("/system/history")
+def history(minutes: int = 60) -> dict:
+    """Metrik-Verlauf (max. 24 h) für die Cockpit-Zeitachse — s. services/metrics_history."""
+    from services import metrics_history
+    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
+    except Exception:
+        return False
+
+
+def _user_unit_active(unit: str) -> bool:
+    """systemd-User-Unit ohne eigenen HTTP-Port (z. B. mc2-steward) — Zustand via is-active.
+    Auf Windows/Dev schlägt das harmlos fehl (False)."""
+    if os.name != "posix":
+        return False
+    try:
+        r = subprocess.run(["systemctl", "--user", "is-active", unit],
+                           capture_output=True, text=True, timeout=3)
+        return r.stdout.strip() == "active"
+    except Exception:
+        return False
+
+
+@router.get("/system/services")
+def services() -> dict:
+    """Aggregierte Erreichbarkeit aller Stack-Dienste — die EINE Quelle für Cockpit-Kachel,
+    Schubladen-Liste und Log-Auswahl (Frontend rendert diese Liste, keine UI-Kopie mehr).
+    `scope`: user|system (Restart-Weg), `unit`: echter systemd-Name (Restart/Logs/Matching)."""
+    a = agent_status()
+    gw_url = f"{GATEWAY_URL}/v1"
+    rows = [
+        {"name": "Engine (llama-swap)", "unit": "llama-swap", "url": LLAMA_SWAP_URL,
+         "ok": engine_reachable(), "scope": "system"},
+    ]
+    # Seit UMBAU v3 P1 ist der LLM-Gateway ein EIGENER Prozess — ohne diese Zeile war er
+    # in der Dienste-Ampel unsichtbar (Kachel "6/6 grün" bei totem Denkpfad).
+    if V1_UPSTREAM:
+        rows.append({"name": "LLM-Gateway (Denkpfad)", "unit": "mc2-gateway", "url": V1_UPSTREAM,
+                     "ok": gateway_reachable(), "scope": "user"})
+        # MC2 selbst antwortet gerade auf diesen Request — ok=True ist hier ehrlich;
+        # die Zeile existiert für Restart/Logs, nicht als Erreichbarkeits-Orakel.
+        rows.append({"name": "Steuerpult (MC2)", "unit": "mission-control-2", "url": gw_url,
+                     "ok": True, "scope": "user"})
+    else:
+        rows.append({"name": "Gateway (integriert)", "unit": "mission-control-2", "url": gw_url,
+                     "ok": gateway_reachable(), "scope": "user"})
+    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,
+         "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,
+        # das Konsole-Overlay schickte den User deshalb ins SSH statt zum Restart-Knopf.
+        {"name": "Box-Konsole (ttyd)", "unit": "box-console", "url": "/console/",
+         "ok": bool(a.get("box_console_reachable")), "scope": "user"},
+    ]
+    return {
+        "services": rows,
+        "links": {
+            "engine_ui": f"{LLAMA_SWAP_URL}/ui",
+            "gateway": gw_url,
+            "hermes_ui": a["hermes_ui_url"],
+        },
+    }
+
+
+@router.post("/system/backup")
+def backup() -> dict:
+    return backup_svc.backup_now()
+
+
+@router.get("/system/backups")
+def backups() -> dict:
+    return {"backups": backup_svc.list_backups()}
+
+
+def _run(cmd: list[str], cwd: str | None = None) -> dict:
+    try:
+        p = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, timeout=180)
+        return {"ok": p.returncode == 0, "code": p.returncode,
+                "out": (p.stdout or "")[-2000:], "err": (p.stderr or "")[-2000:]}
+    except Exception as exc:
+        return {"ok": False, "code": -1, "out": "", "err": str(exc)}
+
+
+class RestartReq(BaseModel):
+    service: str
+
+
+@router.post("/system/restart")
+def restart(req: RestartReq) -> dict:
+    """Dienst neustarten. Delegiert an den Wartungs-Service (EINE Allowlist-Wahrheit):
+    der kennt System-Dienste (llama-swap, via sudo -n) UND User-Dienste und wird auch von
+    der UI (/api/maintenance/restart) genutzt. Vorher lag hier eine zweite, veraltete Liste
+    (ohne llama-swap/hermes-terminal, mit Geist-Eintrag hermes-webui) → Engine-Neustart per
+    Sprache/MCP schlug fehl."""
+    return maintenance.restart_service(req.service)
+
+
+@router.post("/system/self-update")
+def self_update() -> dict:
+    """git pull (Source) → venv-Deps → Dienst-Restart. Auf der Box; lokal Fehler."""
+    pull = _run(["git", "fetch", "--all"], cwd=SOURCE_DIR)
+    reset = _run(["git", "reset", "--hard", "origin/main"], cwd=SOURCE_DIR)
+    restart_res = _run(["systemctl", "--user", "restart", "mission-control-2"])
+    return {"pull": pull, "reset": reset, "restart": restart_res}
+
+
+@router.get("/system/token-stats")
+def token_stats() -> dict:
+    """Token-Verbrauch + Cloud-Ersparnis. Logik im pricing-Service (SSoT)."""
+    # Rolle je Modell/Alias (lowercase) für die Tarif-Auflösung auflösen.
+    role_map: dict[str, str | None] = {}
+    try:
+        for m in list_models():
+            role_map[m["name"].lower()] = m.get("role")
+            for alias in m.get("aliases", []):
+                role_map[alias.lower()] = m.get("role")
+    except Exception:
+        log.warning("token_stats: list_models fehlgeschlagen, Tarife per Name", exc_info=True)
+    return compute_savings(get_stats(), role_map)

backend/routers/voice.py

@@ -1,272 +1,357 @@
-"""
-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
-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.
-"""
-
-import logging
-import os
-import time
-
-import httpx
-from fastapi import APIRouter, File, Form, HTTPException, UploadFile
-from fastapi.responses import Response, StreamingResponse
-from pydantic import BaseModel
-
-from config import HERMES_API_KEY, HERMES_API_MODEL, HERMES_API_URL, LLAMA_SWAP_URL, VOICE_SERVICE_URL
-from services.voice_metrics import Timer, get_metrics, record_stage  # Per-Stage-Latenz (C2)
-
-# Injection-Schutz (Stufe 0): guard.py liegt im mcp/-Verzeichnis. Per Pfad laden (eigene MC2-Venv).
-import sys as _sys
-_GUARD_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "mcp")
-if _GUARD_DIR not in _sys.path:
-    _sys.path.insert(0, _GUARD_DIR)
-try:
-    from guard import wrap_untrusted
-except Exception:  # den Voice-Pfad nie wegen des Filters lahmlegen
-    def wrap_untrusted(text: str, label: str = "") -> str:
-        return text
-
-log = logging.getLogger(__name__)
-router = APIRouter(prefix="/api")
-
-# Bildschirm-Sicht: das DEDIZIERTE Vision-Modell (Qwen3-VL-8B) beschreibt das Bild; die Beschreibung
-# geht als TEXT an Hermes -> Lucy behält ihr volles Hirn/Gedächtnis UND nutzt das bessere VL-Modell
-# (statt der schwächeren Vision der fast-MoE). Per Env abschaltbar/umstellbar.
-VISION_MODEL = os.environ.get("MC_VISION_MODEL", "vision")
-# Knappe Beschreibung = schnellere VL-Generierung UND weniger Hermes-Kontext-Bloat (B2).
-VISION_MAX_TOKENS = int(os.environ.get("MC_VISION_MAX_TOKENS", "280"))
-
-
-async def _describe_images(image_urls: list[str], hint: str) -> str:
-    """Lässt das Vision-Modell die Screenshots (1 je Monitor) knapp beschreiben (Deutsch).
-    Mehrere Bilder gehen in EINER Nachricht ans VL-Modell. Leerer String bei Fehler."""
-    multi = len(image_urls) > 1
-    intro = (f"Hier sind {len(image_urls)} Screenshots (je ein Monitor). Beschreibe auf Deutsch in höchstens "
-             "5 kurzen Sätzen das Wesentliche (pro Monitor: App/Fenster, wichtige Inhalte, sichtbarer Text/Code). "
-             "Keine Einleitung, keine Wiederholung der Frage. "
-             if multi else
-             "Beschreibe auf Deutsch in höchstens 5 kurzen Sätzen das Wesentliche auf diesem Screenshot "
-             "(App/Fenster, wichtige Inhalte, sichtbarer Text/Code). Keine Einleitung. ")
-    content: list = [{"type": "text", "text": intro + "Frage des Nutzers dazu: " + hint}]
-    for u in image_urls:
-        content.append({"type": "image_url", "image_url": {"url": u}})
-    try:
-        # 45 s statt 120 s: Qwen3-VL braucht warm ~5 s; wenn es 45 s nicht schafft, ist etwas
-        # kaputt und Lucy soll lieber ohne Bildschirm-Kontext antworten als ewig hängen.
-        async with httpx.AsyncClient(timeout=httpx.Timeout(float(os.environ.get("MC_VISION_TIMEOUT", "45")), connect=5.0)) as client:
-            r = await client.post(f"{LLAMA_SWAP_URL}/v1/chat/completions", json={
-                "model": VISION_MODEL, "max_tokens": VISION_MAX_TOKENS, "stream": False,
-                "messages": [{"role": "user", "content": content}],
-            })
-            r.raise_for_status()
-            return (r.json().get("choices") or [{}])[0].get("message", {}).get("content", "").strip()
-    except Exception as exc:
-        log.warning("Vision-Beschreibung fehlgeschlagen: %s", exc)
-        return ""
-
-_TIMEOUT = httpx.Timeout(120.0, connect=5.0)   # Chatterbox-TTS auf CPU darf dauern
-
-
-class TTSIn(BaseModel):
-    text: str
-    engine: str = "piper"
-    voice: str = ""
-    language: str = ""
-    ref_path: str = ""
-
-
-class ChatIn(BaseModel):
-    text: str                       # die neue User-Äußerung (STT-Ergebnis)
-    session_id: str                 # stabiler Voice-Faden → server-seitiger Transcript
-    session_key: str = ""           # optional: Langzeit-Memory-Scope
-    system: str = ""                # optionaler ephemerer System-Prompt (z.B. „antworte knapp/gesprochen")
-    model: str = ""
-    images: list[str] = []          # optionale Bildschirm-Sicht: ein data:-URL je Monitor (Lucys „Augen")
-
-
-@router.get("/voice/metrics")
-def voice_metrics() -> dict:
-    """Per-Stage-Latenz (STT/Vision/Chat-TTFB/TTS) — rollende Statistik, macht die Voice-Pipeline
-    messbar (C2). Anzeige im Frontend-Overhaul (E)."""
-    return get_metrics()
-
-
-@router.get("/voice/health")
-def voice_health() -> dict:
-    """Erreichbarkeit des Voice-Sidecars + ob der Hermes-API-Key gesetzt ist."""
-    out: dict = {"sidecar": False, "hermes_key": bool(HERMES_API_KEY)}
-    try:
-        r = httpx.get(f"{VOICE_SERVICE_URL}/health", timeout=httpx.Timeout(5.0))
-        out["sidecar"] = r.status_code == 200
-        out["detail"] = r.json() if r.status_code == 200 else None
-    except Exception as exc:  # noqa: BLE001
-        out["error"] = str(exc)
-    return out
-
-
-@router.get("/voice/voices")
-def voice_voices() -> dict:
-    try:
-        r = httpx.get(f"{VOICE_SERVICE_URL}/voices", timeout=httpx.Timeout(10.0))
-        r.raise_for_status()
-        return r.json()
-    except Exception as exc:  # noqa: BLE001
-        raise HTTPException(502, f"Voice-Sidecar nicht erreichbar: {exc}")
-
-
-@router.post("/voice/stt")
-async def voice_stt(audio: UploadFile = File(...), language: str = Form(default="")) -> dict:
-    """Mikro-Audio → Text (Proxy auf Sidecar /stt)."""
-    data = await audio.read()
-    if not data:
-        raise HTTPException(400, "Leeres Audio.")
-    files = {"audio": (audio.filename or "rec.webm", data, audio.content_type or "audio/webm")}
-    try:
-        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
-            with Timer("stt"):
-                r = await client.post(f"{VOICE_SERVICE_URL}/stt", files=files, data={"language": language})
-            r.raise_for_status()
-            return r.json()
-    except httpx.HTTPError as exc:
-        raise HTTPException(502, f"STT fehlgeschlagen: {exc}")
-
-
-@router.post("/voice/turn")
-async def voice_turn(audio: UploadFile = File(...)) -> dict:
-    """Semantische Turn-Detection (Smart Turn v3): war die Äußerung fertig? Proxy → Sidecar."""
-    data = await audio.read()
-    if not data:
-        raise HTTPException(400, "Leeres Audio.")
-    files = {"audio": (audio.filename or "rec.wav", data, audio.content_type or "audio/wav")}
-    try:
-        async with httpx.AsyncClient(timeout=httpx.Timeout(10.0, connect=3.0)) as client:
-            with Timer("turn"):
-                r = await client.post(f"{VOICE_SERVICE_URL}/turn", files=files)
-            r.raise_for_status()
-            return r.json()
-    except httpx.HTTPError as exc:
-        # Turn-Check ist eine Optimierung — bei Ausfall lieber sofort antworten als hängen.
-        log.warning("Turn-Check fehlgeschlagen: %s", exc)
-        return {"complete": True, "probability": 1.0, "engine": "fallback"}
-
-
-@router.post("/voice/reference")
-async def voice_set_reference(audio: UploadFile = File(...)) -> dict:
-    """Klon-Referenz (z.B. ElevenLabs-Erzeugnis) hochladen → Chatterbox nutzt sie. Proxy → Sidecar."""
-    data = await audio.read()
-    if not data:
-        raise HTTPException(400, "Leeres Audio.")
-    files = {"audio": (audio.filename or "ref.wav", data, audio.content_type or "audio/mpeg")}
-    try:
-        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
-            r = await client.post(f"{VOICE_SERVICE_URL}/reference", files=files)
-            r.raise_for_status()
-            return r.json()
-    except httpx.HTTPError as exc:
-        raise HTTPException(502, f"Referenz-Upload fehlgeschlagen: {exc}")
-
-
-@router.get("/voice/reference")
-def voice_get_reference() -> dict:
-    try:
-        r = httpx.get(f"{VOICE_SERVICE_URL}/reference", timeout=httpx.Timeout(8.0))
-        r.raise_for_status()
-        return r.json()
-    except Exception as exc:  # noqa: BLE001
-        return {"active": False, "error": str(exc)}
-
-
-@router.delete("/voice/reference")
-def voice_clear_reference() -> dict:
-    try:
-        r = httpx.delete(f"{VOICE_SERVICE_URL}/reference", timeout=httpx.Timeout(8.0))
-        r.raise_for_status()
-        return r.json()
-    except httpx.HTTPError as exc:
-        raise HTTPException(502, f"Löschen fehlgeschlagen: {exc}")
-
-
-@router.post("/voice/tts")
-async def voice_tts(body: TTSIn) -> Response:
-    """Text → Sprache (Proxy auf Sidecar /tts), liefert WAV-Bytes."""
-    try:
-        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
-            with Timer("tts"):
-                r = await client.post(f"{VOICE_SERVICE_URL}/tts", json=body.model_dump())
-            r.raise_for_status()
-            return Response(content=r.content, media_type=r.headers.get("content-type", "audio/wav"))
-    except httpx.HTTPError as exc:
-        raise HTTPException(502, f"TTS fehlgeschlagen: {exc}")
-
-
-@router.post("/voice/chat")
-async def voice_chat(body: ChatIn) -> StreamingResponse:
-    """Neue User-Äußerung → Hermes-Agent (api_server, streamend). SSE wird 1:1 durchgereicht.
-
-    Mit `X-Hermes-Session-Id` hält die Plattform den Verlauf — wir senden nur die neue Nachricht.
-    Auth per Bearer (API_SERVER_KEY); ohne Key liefert :8642 ein 401."""
-    if not HERMES_API_KEY:
-        raise HTTPException(503, "HERMES_API_KEY/API_SERVER_KEY nicht gesetzt — Agent-Auth fehlt.")
-
-    headers = {
-        "Authorization": f"Bearer {HERMES_API_KEY}",
-        "X-Hermes-Session-Id": body.session_id,
-    }
-    if body.session_key:
-        headers["X-Hermes-Session-Key"] = body.session_key
-
-    async def gen():
-        t0 = time.perf_counter()
-        first = True
-        first_content = True
-        # Bildschirm-Sicht INNERHALB des Streams (C2-Fix): so startet die SSE-Antwort sofort und
-        # der Client bekommt ein Progress-Event (-> Lucy kann eine Warte-Ansage sprechen), statt
-        # dass der Request bis zu 120 s "tot" hängt, während das Vision-Modell beschreibt.
-        user_text = body.text
-        imgs = [u for u in (body.images or []) if u]
-        if imgs:
-            yield b'event: hermes.vision.progress\ndata: {"note": "Bildschirm wird angeschaut"}\n\n'
-            with Timer("vision"):
-                desc = await _describe_images(imgs, body.text)
-            if desc:
-                safe_desc = wrap_untrusted(desc, "BILDSCHIRM")
-                user_text = f"[Bildschirm-Sicht — das ist gerade auf dem/den Schirm(en) zu sehen:\n{safe_desc}\n]\n\n{body.text}"
-        messages = []
-        if body.system:
-            messages.append({"role": "system", "content": body.system})
-        messages.append({"role": "user", "content": user_text})
-        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.
-        if os.environ.get("MC_VOICE_NO_THINK", "1") not in ("0", "false", "False"):
-            payload["chat_template_kwargs"] = {"enable_thinking": False}
-        try:
-            async with httpx.AsyncClient(timeout=httpx.Timeout(None, connect=5.0)) as client:
-                async with client.stream(
-                    "POST", f"{HERMES_API_URL}/v1/chat/completions", json=payload, headers=headers,
-                ) as r:
-                    if r.status_code != 200:
-                        detail = (await r.aread()).decode("utf-8", "replace")[:500]
-                        yield f"data: {{\"error\": \"Hermes {r.status_code}: {detail}\"}}\n\n".encode()
-                        return
-                    async for chunk in r.aiter_raw():
-                        if first:  # Time-To-First-Byte des Hermes-Streams (Verbindungs-Overhead)
-                            record_stage("chat_ttfb", (time.perf_counter() - t0) * 1000.0)
-                            first = False
-                        # Erster CONTENT-Delta = echte Hirn-Latenz (Agent-Overhead + LLM-TTFT) —
-                        # chat_ttfb misst nur den SSE-Start (~5 ms) und ist dafür blind.
-                        if first_content and b'"content"' in chunk:
-                            record_stage("chat_first_content", (time.perf_counter() - t0) * 1000.0)
-                            first_content = False
-                        yield chunk
-        except httpx.HTTPError as exc:
-            yield f"data: {{\"error\": \"Verbindung zu Hermes fehlgeschlagen: {exc}\"}}\n\n".encode()
-
-    return StreamingResponse(gen(), media_type="text/event-stream")
+"""
+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
+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.
+"""
+
+import logging
+import os
+
+# Injection-Schutz (Stufe 0): guard.py liegt im mcp/-Verzeichnis. Per Pfad laden (eigene MC2-Venv).
+import sys as _sys
+import time
+
+import httpx
+from config import HERMES_API_KEY, HERMES_API_MODEL, HERMES_API_URL, LLAMA_SWAP_URL, VOICE_SERVICE_URL
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+from fastapi.responses import Response, StreamingResponse
+from pydantic import BaseModel
+from services import announce
+from services.voice_metrics import (  # Per-Stage-Latenz + Per-Turn-Trace (intern)
+    Timer,
+    TurnTrace,
+    get_metrics,
+    get_trace,
+    park,
+    record_stage,
+)
+
+_GUARD_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "mcp")
+if _GUARD_DIR not in _sys.path:
+    _sys.path.insert(0, _GUARD_DIR)
+try:
+    from guard import wrap_untrusted
+except Exception:  # den Voice-Pfad nie wegen des Filters lahmlegen
+    def wrap_untrusted(text: str, label: str = "") -> str:
+        return text
+
+log = logging.getLogger(__name__)
+router = APIRouter(prefix="/api")
+
+# Bildschirm-Sicht: das DEDIZIERTE Vision-Modell (Qwen3-VL-8B) beschreibt das Bild; die Beschreibung
+# geht als TEXT an Hermes -> Lucy behält ihr volles Hirn/Gedächtnis UND nutzt das bessere VL-Modell
+# (statt der schwächeren Vision der fast-MoE). Per Env abschaltbar/umstellbar.
+VISION_MODEL = os.environ.get("MC_VISION_MODEL", "vision")
+# Knappe Beschreibung = schnellere VL-Generierung UND weniger Hermes-Kontext-Bloat (B2).
+VISION_MAX_TOKENS = int(os.environ.get("MC_VISION_MAX_TOKENS", "280"))
+
+
+async def _describe_images(image_urls: list[str], hint: str) -> str:
+    """Lässt das Vision-Modell die Screenshots (1 je Monitor) knapp beschreiben (Deutsch).
+    Mehrere Bilder gehen in EINER Nachricht ans VL-Modell. Leerer String bei Fehler."""
+    multi = len(image_urls) > 1
+    intro = (f"Hier sind {len(image_urls)} Screenshots (je ein Monitor). Beschreibe auf Deutsch in höchstens "
+             "5 kurzen Sätzen das Wesentliche (pro Monitor: App/Fenster, wichtige Inhalte, sichtbarer Text/Code). "
+             "Keine Einleitung, keine Wiederholung der Frage. "
+             if multi else
+             "Beschreibe auf Deutsch in höchstens 5 kurzen Sätzen das Wesentliche auf diesem Screenshot "
+             "(App/Fenster, wichtige Inhalte, sichtbarer Text/Code). Keine Einleitung. ")
+    content: list = [{"type": "text", "text": intro + "Frage des Nutzers dazu: " + hint}]
+    for u in image_urls:
+        content.append({"type": "image_url", "image_url": {"url": u}})
+    try:
+        # 45 s statt 120 s: Qwen3-VL braucht warm ~5 s; wenn es 45 s nicht schafft, ist etwas
+        # kaputt und Lucy soll lieber ohne Bildschirm-Kontext antworten als ewig hängen.
+        async with httpx.AsyncClient(timeout=httpx.Timeout(float(os.environ.get("MC_VISION_TIMEOUT", "45")), connect=5.0)) as client:
+            r = await client.post(f"{LLAMA_SWAP_URL}/v1/chat/completions", json={
+                "model": VISION_MODEL, "max_tokens": VISION_MAX_TOKENS, "stream": False,
+                "messages": [{"role": "user", "content": content}],
+            })
+            r.raise_for_status()
+            return (r.json().get("choices") or [{}])[0].get("message", {}).get("content", "").strip()
+    except Exception as exc:
+        log.warning("Vision-Beschreibung fehlgeschlagen: %s", exc)
+        return ""
+
+_TIMEOUT = httpx.Timeout(120.0, connect=5.0)   # Chatterbox-TTS auf CPU darf dauern
+
+
+class TTSIn(BaseModel):
+    text: str
+    engine: str = "piper"
+    voice: str = ""
+    language: str = ""
+    ref_path: str = ""
+
+
+class ChatIn(BaseModel):
+    text: str                       # die neue User-Äußerung (STT-Ergebnis)
+    session_id: str                 # stabiler Voice-Faden → server-seitiger Transcript
+    session_key: str = ""           # optional: Langzeit-Memory-Scope
+    system: str = ""                # optionaler ephemerer System-Prompt (z.B. „antworte knapp/gesprochen")
+    model: str = ""
+    images: list[str] = []          # optionale Bildschirm-Sicht: ein data:-URL je Monitor (Lucys „Augen")
+
+
+class AnnounceIn(BaseModel):
+    text: str                       # die Meldung (wird von Lucy gesprochen)
+    subject: str = ""               # kurze Betreffzeile (z.B. "[Update]")
+    source: str = ""                # Absender (sentry/notify/cron …) — nur fürs Log/Panel
+    priority: str = "normal"        # 'silent' = nur im Verlauf zeigen, nicht sprechen
+
+
+class AlarmIn(BaseModel):
+    text: str                       # die Alarm-Meldung
+    subject: str = "[Alarm]"        # Betreff (Telegram-Präfix)
+    source: str = "alarm"           # Absender fürs Log/Panel (z.B. "lucy-watchdog")
+
+
+@router.post("/alarm")
+def alarm(body: AlarmIn) -> dict:
+    """Lucy-UNABHÄNGIGER Alarm-Weg: schickt direkt auf Telegram (und legt die Meldung in den
+    Briefkasten). Für Absender, die NICHT auf die sprechende Lucy zählen können — allen voran
+    der PC-seitige Lucy-Watchdog, wenn die Desktop-App selbst hängt (dann nützt der Briefkasten
+    nichts, weil niemand ihn vorliest → Telegram ist der einzige verlässliche Kanal). LAN-only
+    wie alle MC2-Endpoints."""
+    text = (body.text or "").strip()
+    if not text:
+        raise HTTPException(400, "Leere Meldung.")
+    subject = (body.subject or "[Alarm]").strip()
+    try:
+        item = announce.add(text, subject, body.source or "alarm", "normal")
+    except ValueError as exc:
+        raise HTTPException(400, str(exc))
+    announce.notify_telegram(subject, text)   # best-effort Telegram (posix/bash; Windows = No-op)
+    return {"ok": True, "item": item}
+
+
+@router.post("/voice/announce")
+def voice_announce(body: AnnounceIn) -> dict:
+    """Meldung in den Briefkasten legen (Lucy-Proaktivität). Absender: Health-Wächter,
+    notify.sh (Updates/Radar/Telegram-Spiegel), Hermes-cron. LAN-only wie alle MC2-Endpoints."""
+    try:
+        return {"ok": True, "item": announce.add(body.text, body.subject, body.source, body.priority)}
+    except ValueError as exc:
+        raise HTTPException(400, str(exc))
+
+
+@router.get("/voice/announcements")
+def voice_announcements(after: int | None = None, limit: int = 20) -> dict:
+    """Neue Meldungen nach Cursor `after` abholen (Lucy pollt). Ohne `after` nur den
+    aktuellen Cursor-Stand (latest) — Erststart plappert so keine alten Meldungen nach."""
+    return announce.list_after(after, limit)
+
+
+@router.get("/voice/health")
+def voice_health() -> dict:
+    """Erreichbarkeit des Voice-Sidecars + ob der Hermes-API-Key gesetzt ist."""
+    out: dict = {"sidecar": False, "hermes_key": bool(HERMES_API_KEY)}
+    try:
+        r = httpx.get(f"{VOICE_SERVICE_URL}/health", timeout=httpx.Timeout(5.0))
+        out["sidecar"] = r.status_code == 200
+        out["detail"] = r.json() if r.status_code == 200 else None
+    except Exception as exc:
+        out["error"] = str(exc)
+    return out
+
+
+@router.get("/voice/metrics")
+def voice_metrics() -> dict:
+    """Rollende Latenz-Stats je Stufe (avg/p50/p95/last, ms). Quelle u.a. für selbstkritik-feed.sh."""
+    return get_metrics()
+
+
+@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 —
+    damit man den EINEN langsamen Turn sieht, den ein Durchschnitt verschluckt."""
+    return {"turns": get_trace(limit)}
+
+
+@router.get("/voice/voices")
+def voice_voices() -> dict:
+    try:
+        r = httpx.get(f"{VOICE_SERVICE_URL}/voices", timeout=httpx.Timeout(10.0))
+        r.raise_for_status()
+        return r.json()
+    except Exception as exc:
+        raise HTTPException(502, f"Voice-Sidecar nicht erreichbar: {exc}")
+
+
+@router.post("/voice/stt")
+async def voice_stt(audio: UploadFile = File(...), language: str = Form(default="")) -> dict:
+    """Mikro-Audio → Text (Proxy auf Sidecar /stt)."""
+    data = await audio.read()
+    if not data:
+        raise HTTPException(400, "Leeres Audio.")
+    files = {"audio": (audio.filename or "rec.webm", data, audio.content_type or "audio/webm")}
+    try:
+        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
+            _t0 = time.perf_counter()
+            r = await client.post(f"{VOICE_SERVICE_URL}/stt", files=files, data={"language": language})
+            _ms = (time.perf_counter() - _t0) * 1000.0
+            record_stage("stt", _ms)
+            park("stt", _ms)  # der folgende /voice/chat-Turn sammelt die STT-Dauer für seinen Trace ein
+            r.raise_for_status()
+            return r.json()
+    except httpx.HTTPError as exc:
+        raise HTTPException(502, f"STT fehlgeschlagen: {exc}")
+
+
+@router.post("/voice/turn")
+async def voice_turn(audio: UploadFile = File(...)) -> dict:
+    """Semantische Turn-Detection (Smart Turn v3): war die Äußerung fertig? Proxy → Sidecar."""
+    data = await audio.read()
+    if not data:
+        raise HTTPException(400, "Leeres Audio.")
+    files = {"audio": (audio.filename or "rec.wav", data, audio.content_type or "audio/wav")}
+    try:
+        async with httpx.AsyncClient(timeout=httpx.Timeout(10.0, connect=3.0)) as client:
+            with Timer("turn"):
+                r = await client.post(f"{VOICE_SERVICE_URL}/turn", files=files)
+            r.raise_for_status()
+            return r.json()
+    except httpx.HTTPError as exc:
+        # Turn-Check ist eine Optimierung — bei Ausfall lieber sofort antworten als hängen.
+        log.warning("Turn-Check fehlgeschlagen: %s", exc)
+        return {"complete": True, "probability": 1.0, "engine": "fallback"}
+
+
+@router.post("/voice/reference")
+async def voice_set_reference(audio: UploadFile = File(...)) -> dict:
+    """Klon-Referenz (z.B. ElevenLabs-Erzeugnis) hochladen → Chatterbox nutzt sie. Proxy → Sidecar."""
+    data = await audio.read()
+    if not data:
+        raise HTTPException(400, "Leeres Audio.")
+    files = {"audio": (audio.filename or "ref.wav", data, audio.content_type or "audio/mpeg")}
+    try:
+        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
+            r = await client.post(f"{VOICE_SERVICE_URL}/reference", files=files)
+            r.raise_for_status()
+            return r.json()
+    except httpx.HTTPError as exc:
+        raise HTTPException(502, f"Referenz-Upload fehlgeschlagen: {exc}")
+
+
+@router.get("/voice/reference")
+def voice_get_reference() -> dict:
+    try:
+        r = httpx.get(f"{VOICE_SERVICE_URL}/reference", timeout=httpx.Timeout(8.0))
+        r.raise_for_status()
+        return r.json()
+    except Exception as exc:
+        return {"active": False, "error": str(exc)}
+
+
+@router.delete("/voice/reference")
+def voice_clear_reference() -> dict:
+    try:
+        r = httpx.delete(f"{VOICE_SERVICE_URL}/reference", timeout=httpx.Timeout(8.0))
+        r.raise_for_status()
+        return r.json()
+    except httpx.HTTPError as exc:
+        raise HTTPException(502, f"Löschen fehlgeschlagen: {exc}")
+
+
+@router.post("/voice/tts")
+async def voice_tts(body: TTSIn) -> Response:
+    """Text → Sprache (Proxy auf Sidecar /tts), liefert WAV-Bytes."""
+    try:
+        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
+            with Timer("tts"):
+                r = await client.post(f"{VOICE_SERVICE_URL}/tts", json=body.model_dump())
+            r.raise_for_status()
+            return Response(content=r.content, media_type=r.headers.get("content-type", "audio/wav"))
+    except httpx.HTTPError as exc:
+        raise HTTPException(502, f"TTS fehlgeschlagen: {exc}")
+
+
+@router.post("/voice/chat")
+async def voice_chat(body: ChatIn) -> StreamingResponse:
+    """Neue User-Äußerung → Hermes-Agent (api_server, streamend). SSE wird 1:1 durchgereicht.
+
+    Mit `X-Hermes-Session-Id` hält die Plattform den Verlauf — wir senden nur die neue Nachricht.
+    Auth per Bearer (API_SERVER_KEY); ohne Key liefert :8642 ein 401."""
+    if not HERMES_API_KEY:
+        raise HTTPException(503, "HERMES_API_KEY/API_SERVER_KEY nicht gesetzt — Agent-Auth fehlt.")
+
+    headers = {
+        "Authorization": f"Bearer {HERMES_API_KEY}",
+        "X-Hermes-Session-Id": body.session_id,
+    }
+    if body.session_key:
+        headers["X-Hermes-Session-Key"] = body.session_key
+
+    async def gen():
+        # Per-Turn-Trace: sammelt STT (davor, geparkt) + Vision + Hirn-TTFT + Generierung + Mem0
+        # (Rückruf während) zu EINEM Datensatz -> die Latenz-Ansicht zeigt den einzelnen Hänger.
+        trace = TurnTrace(session_id=body.session_id, kind="voice")
+        first = True
+        first_content = True
+        committed = False
+
+        def _commit() -> None:
+            nonlocal committed
+            if not committed:
+                committed = True
+                trace.commit()
+
+        try:
+            # Bildschirm-Sicht INNERHALB des Streams (C2-Fix): so startet die SSE-Antwort sofort und
+            # der Client bekommt ein Progress-Event (-> Lucy kann eine Warte-Ansage sprechen), statt
+            # dass der Request bis zu 120 s "tot" hängt, während das Vision-Modell beschreibt.
+            user_text = body.text
+            imgs = [u for u in (body.images or []) if u]
+            trace.had_images = bool(imgs)
+            if imgs:
+                yield b'event: hermes.vision.progress\ndata: {"note": "Bildschirm wird angeschaut"}\n\n'
+                _tv = time.perf_counter()
+                desc = await _describe_images(imgs, body.text)
+                trace.note_vision((time.perf_counter() - _tv) * 1000.0)
+                if desc:
+                    safe_desc = wrap_untrusted(desc, "BILDSCHIRM")
+                    user_text = f"[Bildschirm-Sicht — das ist gerade auf dem/den Schirm(en) zu sehen:\n{safe_desc}\n]\n\n{body.text}"
+            messages = []
+            if body.system:
+                messages.append({"role": "system", "content": body.system})
+            messages.append({"role": "user", "content": user_text})
+            trace.mark_brain_start()  # ab hier zählt die Hirn-Zeit (Vision ist schon abgeschlossen)
+            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.
+            if os.environ.get("MC_VOICE_NO_THINK", "1") not in ("0", "false", "False"):
+                payload["chat_template_kwargs"] = {"enable_thinking": False}
+            try:
+                async with httpx.AsyncClient(timeout=httpx.Timeout(None, connect=5.0)) as client:
+                    async with client.stream(
+                        "POST", f"{HERMES_API_URL}/v1/chat/completions", json=payload, headers=headers,
+                    ) as r:
+                        if r.status_code != 200:
+                            detail = (await r.aread()).decode("utf-8", "replace")[:500]
+                            trace.error = f"Hermes {r.status_code}"
+                            yield f"data: {{\"error\": \"Hermes {r.status_code}: {detail}\"}}\n\n".encode()
+                            return
+                        async for chunk in r.aiter_raw():
+                            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) —
+                            # 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()
+                                first_content = False
+                            yield chunk
+            except httpx.HTTPError as exc:
+                trace.error = "verbindung"
+                yield f"data: {{\"error\": \"Verbindung zu Hermes fehlgeschlagen: {exc}\"}}\n\n".encode()
+        finally:
+            _commit()  # Turn immer verbuchen (auch bei Fehler/Abbruch)
+
+    return StreamingResponse(gen(), media_type="text/event-stream")

backend/routers/wissen.py

@@ -0,0 +1,151 @@
+"""Wissens-Vault-Reader: die nächtlichen Traum-Notizen (~/wissens-vault) als klickbares
+Wiki in der Zentrale. Bewusst READ-ONLY — geschrieben wird der Vault nur vom Traum-Cron
+(und via Auftragsbuch-Entscheidungen); hier wird nur gelesen und navigiert."""
+
+import os
+import re
+import time
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api")
+
+VAULT = Path(os.environ.get("MC_VAULT_DIR", "~/wissens-vault")).expanduser()
+
+
+def _available() -> bool:
+    return VAULT.is_dir()
+
+
+def _title_of(p: Path) -> str:
+    """Erste nicht-leere Zeile (ohne Markdown-#) als Anzeigename."""
+    try:
+        with p.open(encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                s = line.strip()
+                if s:
+                    return s.lstrip("# ").strip()[:160]
+    except OSError:
+        pass
+    return p.stem
+
+
+class VaultFile(BaseModel):
+    path: str
+    name: str
+    dir: str
+    title: str
+    mtime: float
+    neu: bool
+
+
+class WissenListResponse(BaseModel):
+    available: bool
+    files: list[VaultFile]
+
+
+class WissenFileResponse(BaseModel):
+    path: str
+    content: str
+    mtime: float
+
+
+@router.get("/wissen", response_model=WissenListResponse)
+def list_vault() -> dict:
+    """Alle Markdown-Notizen des Vaults (relativer Pfad, Titel, Ordner, Alter)."""
+    if not _available():
+        return {"available": False, "files": []}
+    files = []
+    now = time.time()
+    for p in sorted(VAULT.rglob("*.md")):
+        if ".git" in p.parts or "traeume" in p.parts:
+            continue
+        rel = p.relative_to(VAULT).as_posix()
+        st = p.stat()
+        files.append({
+            "path": rel,
+            "name": p.stem,
+            "dir": p.parent.relative_to(VAULT).as_posix() if p.parent != VAULT else "",
+            "title": _title_of(p),
+            "mtime": st.st_mtime,
+            "neu": (now - st.st_mtime) < 36 * 3600,  # „neu seit gestern Nacht"
+        })
+    files.sort(key=lambda f: f["mtime"], reverse=True)
+    return {"available": True, "files": files}
+
+
+@router.get("/wissen/datei", response_model=WissenFileResponse)
+def read_file(pfad: str) -> dict:
+    """Inhalt einer Vault-Notiz — Traversal hart geblockt (resolve + is_relative_to)."""
+    if not _available():
+        raise HTTPException(404, "Wissens-Vault liegt auf der Box (hier nicht verfügbar).")
+    try:
+        target = (VAULT / pfad).resolve()
+        if not target.is_relative_to(VAULT.resolve()) or target.suffix != ".md" or not target.is_file():
+            raise HTTPException(404, "Notiz nicht gefunden.")
+        return {"path": pfad, "content": target.read_text(encoding="utf-8", errors="replace")[:400_000],
+                "mtime": target.stat().st_mtime}
+    except HTTPException:
+        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}

backend/routers/zeitmaschine.py

@@ -0,0 +1,70 @@
+"""Zeitmaschine — Snapshots ansehen und per Klick zu einem Stand zurückkehren.
+
+Die Maschinerie existiert komplett (deploy/backup.sh Timer 03:30, Off-Box-Kopie,
+deploy/restore.sh mit Pre-Restore-Sicherung); hier kommt nur der letzte Meter dazu:
+Liste + Inhalt in der UI und ein Restore-Start als EIGENE systemd-Unit — restore.sh
+stoppt mission-control-2 selbst, als Kind des Backends stürbe der Lauf mittendrin."""
+
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from services import backup as backup_svc
+
+router = APIRouter(prefix="/api")
+
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+RESTORE_SH = _REPO_ROOT / "deploy" / "restore.sh"
+_FILE_RX = re.compile(r"^mc2-state-[0-9T:_-]+\.tar\.gz$")
+
+
+class RestoreIn(BaseModel):
+    file: str
+
+
+@router.get("/zeitmaschine")
+def list_snapshots() -> dict:
+    return {"available": os.name == "posix", "backups": backup_svc.list_backups()}
+
+
+@router.get("/zeitmaschine/inhalt")
+def snapshot_contents(file: str) -> dict:
+    """Top-Level-Komponenten eines Snapshots (mem0, hermes, llama-swap, MANIFEST …)."""
+    if not _FILE_RX.match(file):
+        raise HTTPException(400, "Ungültiger Snapshot-Name.")
+    p = backup_svc.BACKUP_DIR / file
+    if not p.is_file():
+        raise HTTPException(404, "Snapshot nicht gefunden.")
+    return {"file": file, "components": backup_svc.snapshot_components(p)}
+
+
+@router.post("/zeitmaschine/restore")
+def restore(body: RestoreIn) -> dict:
+    """Wiederherstellung starten (detached). restore.sh macht VORHER selbst ein
+    Sicherheits-Backup des aktuellen Zustands — der Schritt ist also reversibel."""
+    if os.name != "posix":
+        raise HTTPException(400, "Wiederherstellen geht nur auf der Box.")
+    if not _FILE_RX.match(body.file):
+        raise HTTPException(400, "Ungültiger Snapshot-Name.")
+    if not (backup_svc.BACKUP_DIR / body.file).is_file():
+        raise HTTPException(404, "Snapshot nicht gefunden.")
+
+    try:
+        from services import announce
+        announce.add(f"Zeitmaschine: Wiederherstellung von {body.file} gestartet — "
+                     "die Dienste starten gleich neu.", "[Zeitmaschine]", "zeitmaschine", "silent")
+    except Exception:
+        pass
+
+    unit = f"mc2-restore-{int(time.time())}"
+    r = subprocess.run(
+        ["systemd-run", "--user", "--collect", f"--unit={unit}",
+         "/bin/bash", str(RESTORE_SH), "--yes", body.file],
+        capture_output=True, text=True, timeout=20)
+    if r.returncode != 0:
+        raise HTTPException(500, f"Start fehlgeschlagen: {(r.stderr or r.stdout).strip()[:300]}")
+    return {"ok": True, "unit": unit}

backend/scripts/parse_mc2_timeout.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Parse systemd timeout errors for mission-control-2.service from journalctl.
+
+Captures lines containing "State 'stop-sigterm' timed out" and appends them
+to ~/logs/mc2-timeout.log with ISO timestamps.
+
+Permission errors are handled gracefully.
+
+Uses user journal (systemctl --user) to query logs.
+"""
+
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+
+LOG_DIR = Path.home() / "logs"
+LOG_FILE = LOG_DIR / "mc2-timeout.log"
+SERVICE_NAME = "mission-control-2.service"
+SEARCH_PATTERN = "State 'stop-sigterm' timed out"
+JOURNALCTL_LIMIT = 1000
+
+
+def ensure_log_dir() -> None:
+    """Create log directory if it doesn't exist."""
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def get_timeout_entries() -> list[str]:
+    """Run journalctl --user and return lines matching the timeout pattern."""
+    cmd = [
+        "journalctl",
+        "--user",
+        "-u", SERVICE_NAME,
+        "--no-pager",
+        "-n", str(JOURNALCTL_LIMIT),
+    ]
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+    except subprocess.TimeoutExpired:
+        print("journalctl timed out")
+        return []
+    except PermissionError:
+        print("Permission denied: journalctl requires access to user logs")
+        return []
+
+    if result.returncode != 0:
+        if "Permission denied" in result.stderr:
+            print("Permission denied: journalctl requires access to user logs")
+        else:
+            print(f"journalctl failed: {result.stderr.strip()}")
+        return []
+
+    return [
+        line
+        for line in result.stdout.splitlines()
+        if SEARCH_PATTERN in line
+    ]
+
+
+def write_to_log(entries: list[str]) -> int:
+    """Append entries to log file with ISO timestamps. Returns count written."""
+    ensure_log_dir()
+
+    timestamp = datetime.now(timezone.utc).isoformat()
+    written = 0
+
+    with LOG_FILE.open("a", encoding="utf-8") as f:
+        for entry in entries:
+            f.write(f"[{timestamp}] {entry}\n")
+            written += 1
+
+    return written
+
+
+def main() -> None:
+    entries = get_timeout_entries()
+    if not entries:
+        print("No timeout entries found.")
+        return
+
+    count = write_to_log(entries)
+    print(f"Appended {count} timeout entry/ies to {LOG_FILE}")
+
+
+if __name__ == "__main__":
+    main()

backend/services/agent.py

@@ -1,252 +1,268 @@
-"""
-Hermes-Agent-Status (Control-Plane-Read). MC betreibt Hermes NICHT — es zeigt nur
-Status + verlinkt das standalone hermes-webui. Voller Zugriff + Tools/MCP werden in
-Hermes' eigener Config verdrahtet (siehe docs/HERMES_SETUP.md).
-"""
-
-import logging
-import os
-import re
-
-import httpx
-import psutil
-
-from config import HERMES_TERMINAL_URL, HERMES_API_URL, HERMES_HOME, PC_EXECUTOR_URL
-
-log = logging.getLogger(__name__)
-
-
-def _hermes_version(name: str) -> float | None:
-    """Versionszahl aus 'Hermes-4.3', 'Hermes-4', 'Nous-Hermes-2' → 4.3/4.0/2.0."""
-    low = (name or "").lower()
-    if "hermes" not in low:
-        return None
-    m = re.search(r"hermes[-_ ]?(\d+(?:\.\d+)?)", low)
-    return float(m.group(1)) if m else None
-
-
-def _active_brain_name() -> str:
-    """Aktives Agent-Hirn aus Hermes' Config: model.default (sonst model.model)."""
-    try:
-        from ruamel.yaml import YAML
-        p = HERMES_HOME / "config.yaml"
-        if p.exists():
-            with p.open(encoding="utf-8") as f:
-                cfg = YAML().load(f) or {}
-            m = (cfg.get("model") or {}) if isinstance(cfg, dict) else {}
-            return str(m.get("default") or m.get("model") or "auto")
-    except Exception:
-        log.debug("_active_brain_name: Lesefehler", exc_info=True)
-    return "auto"
-
-
-def hermes_brain_info() -> dict:
-    """Aktuelles Agent-Hirn = Modell/Alias, das Hermes laut Config nutzt (model.default),
-    plus Budget-Check. Zeigt das REAL genutzte Hirn — unabhängig von einer 'hermes'-Rolle."""
-    from services import llamaswap
-
-    models = llamaswap.list_models()
-    brain = _active_brain_name()              # z.B. "fast" (Alias) oder ein Modellname
-    bl = brain.lower()
-    cur = next((m for m in models if (m.get("role") or "").lower() == bl), None) \
-        or next((m for m in models if bl in (m["name"] or "").lower()), None)
-    cur_params = (cur.get("capabilities") or {}).get("params_b") if cur else None
-    current = None
-    if cur:
-        current = {"name": cur["name"], "alias": brain, "filename": cur.get("filename"),
-                   "params_b": cur_params, "quant": cur.get("quant"),
-                   "size_bytes": cur.get("size_bytes"),
-                   "gguf_path": cur.get("gguf_path"), "incomplete": cur.get("incomplete")}
-
-    # Fit-Check: passt das (immer warme) Hirn + das größte on-demand-Modell zusammen ins Budget?
-    budget = None
-    try:
-        from services.budget import footprint_gb, gtt_budget_gb
-        groups = llamaswap.list_groups()
-        persist = set()
-        for g in groups.values():
-            if isinstance(g, dict) and g.get("persist"):
-                persist.update(g.get("members") or [])
-
-        cur_name = cur["name"] if cur else None
-        brain_gb = footprint_gb(cur) if cur else 0.0
-        # voller Always-Warm-Footprint (alle persist, Brain=Empfehlung) — nur Info
-        warm = brain_gb + sum(footprint_gb(m) for m in models
-                              if m["name"] in persist and m["name"] != cur_name)
-        largest_od = max((footprint_gb(m) for m in models if m["name"] not in persist), default=0.0)
-        gtt = gtt_budget_gb()
-        # Brain muss immer resident sein → passt Brain + größtes on-demand zusammen?
-        # (fast/vision dürfen beim Laden eines großen Modells verdrängt werden.)
-        budget = {
-            "gtt_gb": gtt,
-            "brain_gb": round(brain_gb, 1),
-            "warm_projected_gb": round(warm, 1),
-            "largest_ondemand_gb": round(largest_od, 1),
-            "fits": (brain_gb + largest_od) <= gtt,
-            "free_after_gb": round(gtt - brain_gb - largest_od, 1),
-        }
-    except Exception:
-        log.debug("hermes_brain_info: Budget-Berechnung fehlgeschlagen", exc_info=True)
-
-    return {"current": current, "recommended": None, "update_available": False, "budget": budget}
-
-
-def _reach(url: str, path: str = "") -> bool:
-    try:
-        with httpx.Client(timeout=3.0) as c:
-            return c.get(f"{url}{path}").status_code < 500
-    except httpx.HTTPError:
-        return False
-
-
-def _count_enabled_mcp_servers() -> int:
-    config_path = HERMES_HOME / "config.yaml"
-    if not config_path.exists():
-        return 0
-    try:
-        from ruamel.yaml import YAML
-        r_yaml = YAML()
-        with config_path.open("r", encoding="utf-8") as f:
-            cfg = r_yaml.load(f) or {}
-        mcp_servers = cfg.get("mcp_servers", {}) if isinstance(cfg, dict) else {}
-        if not isinstance(mcp_servers, dict):
-            return 0
-        return sum(1 for v in mcp_servers.values() if isinstance(v, dict) and v.get("enabled", True))
-    except Exception:
-        log.debug("_count_enabled_mcp_servers: Fehler", exc_info=True)
-        return 0
-
-
-def agent_status() -> dict:
-    """Erreichbarkeit von Gateway (:8642) + WebUI (:8787) + lokale Hinweise."""
-    home = HERMES_HOME
-    brain_model = "auto"
-    config_path = home / "config.yaml"
-    if config_path.exists():
-        try:
-            from ruamel.yaml import YAML
-            r_yaml = YAML()
-            with config_path.open("r", encoding="utf-8") as f:
-                cfg = r_yaml.load(f) or {}
-                if isinstance(cfg, dict):
-                    # Hermes nutzt model.default als aktives Modell (model.model = Provider-Param).
-                    m = cfg.get("model", {}) or {}
-                    brain_model = m.get("default") or m.get("model") or "auto"
-        except Exception:
-            log.debug("agent_status: Hermes-config.yaml nicht lesbar", exc_info=True)
-
-
-    return {
-        "gateway_url": HERMES_API_URL,
-        # Interaktives Web-Terminal (ttyd → `hermes chat`), eingebettet in MC2.
-        "terminal_url": HERMES_TERMINAL_URL,
-        "gateway_reachable": _reach(HERMES_API_URL, "/health"),
-        "terminal_reachable": _reach(HERMES_TERMINAL_URL, "/"),
-        "home_exists": home.exists(),
-        "brain_model": brain_model,
-        # Best-effort: welche Verdrahtung lokal sichtbar ist (auf der Box aussagekräftig).
-        "has_config": (home / "config.yaml").exists() or (home / "config.json").exists(),
-        "has_skills": (home / "skills").exists(),
-        "has_memories": (home / "memories").exists(),
-        # Neue Felder: Telegram, MCP-Server-Anzahl, PC-Executor-Erreichbarkeit.
-        "telegram_enabled": bool(os.environ.get("TELEGRAM_BOT_TOKEN", "")),
-        "mcp_server_count": _count_enabled_mcp_servers(),
-        "pc_executor_reachable": _reach(PC_EXECUTOR_URL, "/health"),
-    }
-
-
-def set_agent_brain(model_id: str) -> dict:
-    """Setzt ein (bereits installiertes) Modell als Agent-Hirn — WARM-bewusst:
-    1) vergibt den 'hermes'-Alias (das Agent-Hirn-Slot),
-    2) tauscht es in die residente brains-Gruppe (altes Hirn raus, fast/vision bleiben),
-    3) zeigt die Hermes-Config auf den 'hermes'-Alias + Gateway-Restart.
-    So bleibt das neue Hirn warm und der Agent nutzt es sofort."""
-    from services import llamaswap
-    models = {m["name"]: m for m in llamaswap.list_models()}
-    if model_id not in models:
-        return {"ok": False, "reason": "Modell nicht installiert — erst über Modelle-finden laden."}
-    old = next((m["name"] for m in models.values() if m.get("role") == "hermes"), None)
-    if model_id == old:
-        # Idempotent härten: auch wenn schon Hirn, warm (brains) + ttl 0 sicherstellen.
-        try:
-            from services.llamaswap import set_ttl
-            brains = (llamaswap.list_groups().get("brains") or {}).get("members") or []
-            if model_id not in brains:
-                llamaswap.set_group("brains", brains + [model_id], swap=False, persist=True)
-            set_ttl(model_id, 0)
-        except PermissionError as exc:
-            return {"ok": False, "reason": str(exc)}
-        return {"ok": True, "old": old, "new": model_id, "note": "ist bereits das Agent-Hirn"}
-    try:
-        llamaswap.set_role(model_id, "hermes")                       # 1) Alias
-        brains = (llamaswap.list_groups().get("brains") or {}).get("members") or []
-        new_members = [x for x in brains if x not in (old, model_id)] + [model_id]
-        llamaswap.set_group("brains", new_members, swap=False, persist=True)   # 2) warm
-        # 2b) TTL härten: neues Hirn nie auto-entladen; altes Hirn auf Default entspannen.
-        from services.llamaswap import set_ttl, DEFAULT_TTL
-        set_ttl(model_id, 0)
-        if old:
-            set_ttl(old, DEFAULT_TTL)
-    except PermissionError as exc:
-        return {"ok": False, "reason": str(exc)}
-    update_brain_model("hermes")                                     # 3) Config + Restart
-    # Weiche Budget-Warnung (kein Hard-Block): passt Hirn + größtes on-demand zusammen ins GTT?
-    warning = None
-    try:
-        b = hermes_brain_info().get("budget") or {}
-        if b and not b.get("fits", True):
-            warning = (f"Speicher-Warnung: Hirn (~{b.get('brain_gb')} GB) + größtes on-demand-"
-                       f"Modell (~{b.get('largest_ondemand_gb')} GB) übersteigen das GTT-Budget "
-                       f"(~{b.get('gtt_gb')} GB) — heavy/coder würden das Hirn verdrängen.")
-    except Exception:
-        log.debug("set_agent_brain: Budget-Check fehlgeschlagen", exc_info=True)
-    return {"ok": True, "old": old, "new": model_id, "warning": warning}
-
-
-def update_brain_model(new_model: str) -> bool:
-    from config import HERMES_HOME
-    home = HERMES_HOME
-    config_path = home / "config.yaml"
-    
-    # Ensure home directory exists
-    home.mkdir(parents=True, exist_ok=True)
-    
-    cfg = {}
-    if config_path.exists():
-        try:
-            from ruamel.yaml import YAML
-            r_yaml = YAML()
-            with config_path.open("r", encoding="utf-8") as f:
-                cfg = r_yaml.load(f) or {}
-        except Exception:
-            log.debug("update_brain_model: bestehende config.yaml nicht lesbar", exc_info=True)
-            cfg = {}
-            
-    if not isinstance(cfg, dict):
-        cfg = {}
-        
-    if "model" not in cfg or not isinstance(cfg["model"], dict):
-        cfg["model"] = {}
-        
-    # Hermes liest model.default als aktives Modell; model.model ist der Provider-Param.
-    # Beide setzen, sonst greift die Umschaltung nicht (latenter Bug: nur model.model gesetzt).
-    cfg["model"]["default"] = new_model
-    cfg["model"]["model"] = new_model
-
-    try:
-        from ruamel.yaml import YAML
-        r_yaml = YAML()
-        with config_path.open("w", encoding="utf-8") as f:
-            r_yaml.dump(cfg, f)
-            
-        # Restart the user-space service to apply changes
-        try:
-            import services.maintenance as maintenance
-            maintenance.restart_service("hermes-gateway")
-        except Exception:
-            log.warning("update_brain_model: hermes-gateway-Restart fehlgeschlagen", exc_info=True)
-
-        return True
-    except Exception:
-        log.warning("update_brain_model: Schreiben der config.yaml fehlgeschlagen", exc_info=True)
-        return False
+"""
+Hermes-Agent-Status (Control-Plane-Read). MC betreibt Hermes NICHT — es zeigt nur
+Status + verlinkt das standalone hermes-webui. Voller Zugriff + Tools/MCP werden in
+Hermes' eigener Config verdrahtet (siehe docs/HERMES_SETUP.md).
+"""
+
+import logging
+import os
+import re
+
+import httpx
+from config import (
+    BOX_CONSOLE_PATH,
+    BOX_CONSOLE_UPSTREAM,
+    HERMES_API_URL,
+    HERMES_BUILTIN_UI_PATH,
+    HERMES_BUILTIN_UI_UPSTREAM,
+    HERMES_HOME,
+    PC_EXECUTOR_URL,
+)
+
+log = logging.getLogger(__name__)
+
+
+def _hermes_version(name: str) -> float | None:
+    """Versionszahl aus 'Hermes-4.3', 'Hermes-4', 'Nous-Hermes-2' → 4.3/4.0/2.0."""
+    low = (name or "").lower()
+    if "hermes" not in low:
+        return None
+    m = re.search(r"hermes[-_ ]?(\d+(?:\.\d+)?)", low)
+    return float(m.group(1)) if m else None
+
+
+def _active_brain_name() -> str:
+    """Aktives Agent-Hirn aus Hermes' Config: model.default (sonst model.model)."""
+    try:
+        from ruamel.yaml import YAML
+        p = HERMES_HOME / "config.yaml"
+        if p.exists():
+            with p.open(encoding="utf-8") as f:
+                cfg = YAML().load(f) or {}
+            m = (cfg.get("model") or {}) if isinstance(cfg, dict) else {}
+            return str(m.get("default") or m.get("model") or "auto")
+    except Exception:
+        log.debug("_active_brain_name: Lesefehler", exc_info=True)
+    return "auto"
+
+
+def hermes_brain_info() -> dict:
+    """Aktuelles Agent-Hirn = Modell/Alias, das Hermes laut Config nutzt (model.default),
+    plus Budget-Check. Zeigt das REAL genutzte Hirn — unabhängig von einer 'hermes'-Rolle."""
+    from services import llamaswap
+
+    models = llamaswap.list_models()
+    brain = _active_brain_name()              # z.B. "fast" (Alias) oder ein Modellname
+    bl = brain.lower()
+    cur = next((m for m in models if (m.get("role") or "").lower() == bl), None) \
+        or next((m for m in models if bl in (m["name"] or "").lower()), None)
+    cur_params = (cur.get("capabilities") or {}).get("params_b") if cur else None
+    current = None
+    if cur:
+        current = {"name": cur["name"], "alias": brain, "filename": cur.get("filename"),
+                   "params_b": cur_params, "quant": cur.get("quant"),
+                   "size_bytes": cur.get("size_bytes"),
+                   "gguf_path": cur.get("gguf_path"), "incomplete": cur.get("incomplete")}
+
+    # Fit-Check: passt das (immer warme) Hirn + das größte on-demand-Modell zusammen ins Budget?
+    budget = None
+    try:
+        from services.budget import footprint_gb, gtt_budget_gb
+        groups = llamaswap.list_groups()
+        persist = set()
+        for g in groups.values():
+            if isinstance(g, dict) and (g.get("persist") or g.get("persistent")):
+                persist.update(g.get("members") or [])
+
+        cur_name = cur["name"] if cur else None
+        brain_gb = footprint_gb(cur) if cur else 0.0
+        # voller Always-Warm-Footprint (alle persist, Brain=Empfehlung) — nur Info
+        warm = brain_gb + sum(footprint_gb(m) for m in models
+                              if m["name"] in persist and m["name"] != cur_name)
+        largest_od = max((footprint_gb(m) for m in models if m["name"] not in persist), default=0.0)
+        gtt = gtt_budget_gb()
+        # Seit dem `persistent`-Fix (03.07.) bleibt das GANZE Warmset (Hirn+embed+vision)
+        # resident, wenn ein on-demand-Modell DANEBEN lädt → der reale Peak ist Warmset +
+        # größtes on-demand, nicht nur Hirn + größtes. Genau daran wird `fits` gemessen.
+        budget = {
+            "gtt_gb": gtt,
+            "brain_gb": round(brain_gb, 1),
+            "warm_projected_gb": round(warm, 1),
+            "largest_ondemand_gb": round(largest_od, 1),
+            "fits": (warm + largest_od) <= gtt,
+            "free_after_gb": round(gtt - warm - largest_od, 1),
+        }
+    except Exception:
+        log.debug("hermes_brain_info: Budget-Berechnung fehlgeschlagen", exc_info=True)
+
+    return {"current": current, "recommended": None, "update_available": False, "budget": budget}
+
+
+def _reach(url: str, path: str = "") -> bool:
+    try:
+        with httpx.Client(timeout=3.0) as c:
+            return c.get(f"{url}{path}").status_code < 500
+    except httpx.HTTPError:
+        return False
+
+
+def _count_enabled_mcp_servers() -> int:
+    config_path = HERMES_HOME / "config.yaml"
+    if not config_path.exists():
+        return 0
+    try:
+        from ruamel.yaml import YAML
+        r_yaml = YAML()
+        with config_path.open("r", encoding="utf-8") as f:
+            cfg = r_yaml.load(f) or {}
+        mcp_servers = cfg.get("mcp_servers", {}) if isinstance(cfg, dict) else {}
+        if not isinstance(mcp_servers, dict):
+            return 0
+        return sum(1 for v in mcp_servers.values() if isinstance(v, dict) and v.get("enabled", True))
+    except Exception:
+        log.debug("_count_enabled_mcp_servers: Fehler", exc_info=True)
+        return 0
+
+
+def agent_status() -> dict:
+    """Erreichbarkeit von Gateway (:8642) + WebUI (:8787) + lokale Hinweise."""
+    home = HERMES_HOME
+    brain_model = "auto"
+    config_path = home / "config.yaml"
+    if config_path.exists():
+        try:
+            from ruamel.yaml import YAML
+            r_yaml = YAML()
+            with config_path.open("r", encoding="utf-8") as f:
+                cfg = r_yaml.load(f) or {}
+                if isinstance(cfg, dict):
+                    # Hermes nutzt model.default als aktives Modell (model.model = Provider-Param).
+                    m = cfg.get("model", {}) or {}
+                    brain_model = m.get("default") or m.get("model") or "auto"
+        except Exception:
+            log.debug("agent_status: Hermes-config.yaml nicht lesbar", exc_info=True)
+
+
+    return {
+        "gateway_url": HERMES_API_URL,
+        # Box-Konsole (ttyd → Login-Shell): same-origin über MC2 geproxyt (/console/).
+        "box_console_url": BOX_CONSOLE_PATH,
+        # Eingebaute Hermes-Web-GUI (hermes serve): same-origin über MC2 geproxyt (/hermes-ui/).
+        # Seit dem Umzug auf Hermes Desktop ist :9119 zugleich das Desktop-Gateway.
+        "hermes_ui_url": HERMES_BUILTIN_UI_PATH,
+        "gateway_reachable": _reach(HERMES_API_URL, "/health"),
+        # Erreichbarkeit des lokalen ttyd-Upstreams (Loopback, base-path /console).
+        "box_console_reachable": _reach(BOX_CONSOLE_UPSTREAM, "/console/"),
+        # Erreichbarkeit der eingebauten Hermes-GUI / des Desktop-Gateways (Loopback :9119).
+        "hermes_ui_reachable": _reach(HERMES_BUILTIN_UI_UPSTREAM, "/"),
+        "home_exists": home.exists(),
+        "brain_model": brain_model,
+        # Best-effort: welche Verdrahtung lokal sichtbar ist (auf der Box aussagekräftig).
+        "has_config": (home / "config.yaml").exists() or (home / "config.json").exists(),
+        "has_skills": (home / "skills").exists(),
+        "has_memories": (home / "memories").exists(),
+        # Neue Felder: Telegram, MCP-Server-Anzahl, PC-Executor-Erreichbarkeit.
+        "telegram_enabled": bool(os.environ.get("TELEGRAM_BOT_TOKEN", "")),
+        "mcp_server_count": _count_enabled_mcp_servers(),
+        "pc_executor_reachable": _reach(PC_EXECUTOR_URL, "/health"),
+        # Konfigurierte Adresse mitliefern, damit die UI sie ANZEIGT statt hartcodiert (Review 15.07.).
+        "pc_executor_url": PC_EXECUTOR_URL,
+    }
+
+
+def set_agent_brain(model_id: str) -> dict:
+    """Setzt ein (bereits installiertes) Modell als Agent-Hirn — WARM-bewusst:
+    1) vergibt den 'hermes'-Alias (das Agent-Hirn-Slot),
+    2) tauscht es in die residente brains-Gruppe (altes Hirn raus, fast/vision bleiben),
+    3) zeigt die Hermes-Config auf den 'hermes'-Alias + Gateway-Restart.
+    So bleibt das neue Hirn warm und der Agent nutzt es sofort."""
+    from services import llamaswap
+    models = {m["name"]: m for m in llamaswap.list_models()}
+    if model_id not in models:
+        return {"ok": False, "reason": "Modell nicht installiert — erst über Modelle-finden laden."}
+    old = next((m["name"] for m in models.values() if m.get("role") == "hermes"), None)
+    if model_id == old:
+        # Idempotent härten: auch wenn schon Hirn, warm (brains) + ttl 0 sicherstellen.
+        try:
+            from services.llamaswap import set_ttl
+            brains = (llamaswap.list_groups().get("brains") or {}).get("members") or []
+            if model_id not in brains:
+                llamaswap.set_group("brains", brains + [model_id], swap=False, persist=True)
+            set_ttl(model_id, 0)
+        except PermissionError as exc:
+            return {"ok": False, "reason": str(exc)}
+        return {"ok": True, "old": old, "new": model_id, "note": "ist bereits das Agent-Hirn"}
+    try:
+        llamaswap.set_role(model_id, "hermes")                       # 1) Alias
+        brains = (llamaswap.list_groups().get("brains") or {}).get("members") or []
+        new_members = [x for x in brains if x not in (old, model_id)] + [model_id]
+        llamaswap.set_group("brains", new_members, swap=False, persist=True)   # 2) warm
+        # 2b) TTL härten: neues Hirn nie auto-entladen; altes Hirn auf Default entspannen.
+        from services.llamaswap import DEFAULT_TTL, set_ttl
+        set_ttl(model_id, 0)
+        if old:
+            set_ttl(old, DEFAULT_TTL)
+    except PermissionError as exc:
+        return {"ok": False, "reason": str(exc)}
+    update_brain_model("hermes")                                     # 3) Config + Restart
+    # Weiche Budget-Warnung (kein Hard-Block): passt Hirn + größtes on-demand zusammen ins GTT?
+    warning = None
+    try:
+        b = hermes_brain_info().get("budget") or {}
+        if b and not b.get("fits", True):
+            warning = (f"Speicher-Warnung: Hirn (~{b.get('brain_gb')} GB) + größtes on-demand-"
+                       f"Modell (~{b.get('largest_ondemand_gb')} GB) übersteigen das GTT-Budget "
+                       f"(~{b.get('gtt_gb')} GB) — das Hirn ist persistent, heavy/coder laden "
+                       f"DANEBEN: Überlauf droht (Lade-Crash/Swapping statt Verdrängung).")
+    except Exception:
+        log.debug("set_agent_brain: Budget-Check fehlgeschlagen", exc_info=True)
+    return {"ok": True, "old": old, "new": model_id, "warning": warning}
+
+
+def update_brain_model(new_model: str) -> bool:
+    from config import HERMES_HOME
+    home = HERMES_HOME
+    config_path = home / "config.yaml"
+    
+    # Ensure home directory exists
+    home.mkdir(parents=True, exist_ok=True)
+    
+    cfg = {}
+    if config_path.exists():
+        try:
+            from ruamel.yaml import YAML
+            r_yaml = YAML()
+            with config_path.open("r", encoding="utf-8") as f:
+                cfg = r_yaml.load(f) or {}
+        except Exception:
+            log.debug("update_brain_model: bestehende config.yaml nicht lesbar", exc_info=True)
+            cfg = {}
+            
+    if not isinstance(cfg, dict):
+        cfg = {}
+        
+    if "model" not in cfg or not isinstance(cfg["model"], dict):
+        cfg["model"] = {}
+        
+    # Hermes liest model.default als aktives Modell; model.model ist der Provider-Param.
+    # Beide setzen, sonst greift die Umschaltung nicht (latenter Bug: nur model.model gesetzt).
+    cfg["model"]["default"] = new_model
+    cfg["model"]["model"] = new_model
+
+    try:
+        from ruamel.yaml import YAML
+        r_yaml = YAML()
+        with config_path.open("w", encoding="utf-8") as f:
+            r_yaml.dump(cfg, f)
+            
+        # Restart the user-space service to apply changes
+        try:
+            from services import maintenance
+            maintenance.restart_service("hermes-gateway")
+        except Exception:
+            log.warning("update_brain_model: hermes-gateway-Restart fehlgeschlagen", exc_info=True)
+
+        return True
+    except Exception:
+        log.warning("update_brain_model: Schreiben der config.yaml fehlgeschlagen", exc_info=True)
+        return False

backend/services/announce.py

@@ -0,0 +1,130 @@
+"""
+Melde-Briefkasten der Box (Lucy-Proaktivität, Faden A3).
+
+Alles, was die Box dem Commander aktiv sagen will (Health-Wächter, Auto-Updates,
+Radar, Hermes-cron via notify.sh), landet als Eintrag hier. Die Lucy-Desktop-App
+pollt `/api/voice/announcements` und SPRICHT neue Einträge von sich aus.
+
+Persistenz als JSON neben den Modellen (übersteht Deploys/Neustarts, wie der
+Discover-Cache). Bewusst klein: fortlaufende IDs als Cursor, Ring der letzten
+MAX_ITEMS Einträge, ein Lock für die FastAPI-Threadpool-Worker.
+"""
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+import httpx
+from config import MODELS_DIR
+
+log = logging.getLogger(__name__)
+
+NOTIFY_SH = str(Path(__file__).resolve().parent.parent.parent / "deploy" / "notify.sh")
+
+STORE_PATH = Path(os.environ.get("MC_ANNOUNCE_STORE", str(MODELS_DIR / "mc2-announce.json")))
+MAX_ITEMS = int(os.environ.get("MC_ANNOUNCE_MAX", "200"))
+
+# Steward-Auszug (UMBAU v3 P2): Läuft der Absender AUSSERHALB des MC2-Prozesses
+# (mc2-steward), darf er den Store NICHT direkt schreiben — Datei + In-Memory-Cache
+# gehören exklusiv dem Steuerpult. Gesetzt (Unit-Env, z. B. http://127.0.0.1:9001)
+# liefert add() die Meldung stattdessen per HTTP am /api/voice/announce-Endpunkt ab.
+ANNOUNCE_HTTP = os.environ.get("MC_ANNOUNCE_HTTP", "").rstrip("/")
+
+_lock = threading.Lock()
+_state: dict | None = None   # {"next_id": int, "items": [...]}
+
+
+def _load() -> dict:
+    global _state
+    if _state is None:
+        try:
+            _state = json.loads(STORE_PATH.read_text(encoding="utf-8"))
+            assert isinstance(_state.get("next_id"), int) and isinstance(_state.get("items"), list)
+        except Exception:
+            _state = {"next_id": 1, "items": []}
+    return _state
+
+
+def _save(state: dict) -> None:
+    try:
+        tmp = STORE_PATH.with_suffix(".tmp")
+        tmp.write_text(json.dumps(state, ensure_ascii=False), encoding="utf-8")
+        tmp.replace(STORE_PATH)
+    except OSError:
+        # Briefkasten darf den Absender nie blockieren — dann eben nur in-memory.
+        log.warning("announce: Store %s nicht schreibbar", STORE_PATH, exc_info=True)
+
+
+def add(text: str, subject: str = "", source: str = "", priority: str = "normal") -> dict:
+    """Eintrag anhängen. priority: 'normal' (sprechen) | 'silent' (nur Verlauf/Panel)."""
+    text = (text or "").strip()
+    if not text:
+        raise ValueError("Leere Meldung.")
+    if ANNOUNCE_HTTP:
+        # Fremdprozess-Modus (mc2-steward): per HTTP beim Steuerpult abliefern.
+        payload = {"text": text[:4000], "subject": (subject or "").strip()[:120],
+                   "source": (source or "").strip()[:60], "priority": priority}
+        try:
+            with httpx.Client(timeout=5.0) as c:
+                r = c.post(f"{ANNOUNCE_HTTP}/api/voice/announce", json=payload)
+            if r.status_code == 200:
+                return (r.json() or {}).get("item") or payload
+        except Exception:
+            pass
+        # MC2 down/Endpunkt weg: Alarm ist nicht verloren — der Telegram-Direktweg des
+        # Aufrufers (notify.sh) läuft separat; hier bleibt nur der Log-Nachweis.
+        log.warning("announce: HTTP-Abgabe an %s fehlgeschlagen — nur im Log: [%s] %.120s",
+                    ANNOUNCE_HTTP, subject or "-", text)
+        return payload
+    with _lock:
+        state = _load()
+        item = {
+            "id": state["next_id"],
+            "ts": time.time(),
+            "subject": (subject or "").strip()[:120],
+            "text": text[:4000],
+            "source": (source or "").strip()[:60],
+            "priority": priority if priority in ("normal", "silent") else "normal",
+        }
+        state["next_id"] += 1
+        state["items"].append(item)
+        del state["items"][:-MAX_ITEMS]
+        _save(state)
+    log.info("announce #%s [%s] %s: %.80s", item["id"], item["source"] or "-", item["subject"] or "-", text)
+    return item
+
+
+def notify_telegram(subject: str, text: str) -> None:
+    """Best-effort auch auf Telegram (User ist evtl. nicht am PC). MC_NOTIFY_NO_ANNOUNCE=1
+    verhindert, dass notify.sh die Meldung ZURÜCK in den Briefkasten spiegelt — der Absender
+    (Wächter/Erinnerung) hat sie dort schon selbst abgelegt. Auf Windows (Dev) ein No-op."""
+    if not (os.name == "posix" and shutil.which("bash")):
+        return
+    try:
+        subprocess.run(["bash", NOTIFY_SH, "-s", subject, text],
+                       timeout=30, capture_output=True, env={**os.environ, "MC_NOTIFY_NO_ANNOUNCE": "1"})
+    except Exception:
+        log.warning("notify_telegram: notify.sh fehlgeschlagen", exc_info=True)
+
+
+def list_recent(limit: int = 150) -> list[dict]:
+    """Die jüngsten Einträge (neueste zuerst) — Datenquelle der Chronik: alles, was die Box
+    dem Commander je aktiv gemeldet hat (Health-Wächter, Updates, Radar, Träume, Alarme)."""
+    with _lock:
+        state = _load()
+        return list(reversed(state["items"][-max(1, min(limit, MAX_ITEMS)):]))
+
+
+def list_after(after: int | None, limit: int = 20) -> dict:
+    """Einträge NACH Cursor `after` (aufsteigend). Ohne Cursor nur den aktuellen
+    Stand liefern (latest) — so initialisiert Lucy ihren Cursor, ohne Altes nachzuplappern."""
+    with _lock:
+        state = _load()
+        latest = state["next_id"] - 1
+        items = [] if after is None else [i for i in state["items"] if i["id"] > after][: max(1, min(limit, 100))]
+    return {"latest": latest, "items": items}

backend/services/auftragsbuch.py

@@ -0,0 +1,525 @@
+"""
+Auftragsbuch — die Vorschlags-Inbox der Box (das Mensch-Gate als Klick statt Git-Handarbeit).
+
+Quellen der Karten:
+  • Vorschlags-Branches auf Gitea (wartung/*, orchestrator/*, doku/*) — die Werkstatt und der
+    Orchestrator arbeiten propose-only und lassen ihre Ergebnisse dort liegen.
+    Seit S3 (lucy-pipeline) aus ZWEI Repos: mission-control-v2 (Box-Stack) UND lucy (Desktop-App).
+  • Skill-Kandidaten aus dem Wissens-Vault (~/wissens-vault/skill-kandidaten/) — Vorschläge des
+    nächtlichen Traum-Crons, Gate war bisher „Commander sagt mach".
+
+Annehmen (Branch) startet den Repo-eigenen Runner als EIGENE systemd-Unit (detached):
+  • mc2:  deploy/auftrag-annehmen.sh — Merge im Worktree → Push main → Deploy → Health → Revert bei Rot.
+  • lucy: deploy/lucy-annahme.sh — Merge im Worktree → Push main → PC baut dist (via PC-Executor)
+    und startet Lucy neu, wenn sie lief → bei Rot Revert auf main (die laufende Lucy bleibt die alte).
+Detached, weil deploy.sh mission-control-2 neu startet — ein Kind des Backends stürbe mittendrin.
+Der Fortschritt landet in STATUS_PATH (JSON), das Skript schreibt, die API liest nur.
+Status-Schlüssel: mc2 = Branch-Name pur (Bestand), lucy = "lucy:<branch>" (kollisionsfrei).
+
+Lokal (Windows-Dev) ist alles harmlos: available=False, Aktionen geben Fehler statt zu crashen.
+"""
+
+import json
+import logging
+import os
+import re
+import shutil
+import subprocess
+import time
+import urllib.request
+from pathlib import Path
+
+from config import MODELS_DIR
+
+log = logging.getLogger(__name__)
+
+REPO = Path(os.environ.get("MC2_SOURCE_DIR", "~/mission-control-v2")).expanduser()
+LUCY = Path(os.environ.get("MC2_LUCY_DIR", "~/lucy")).expanduser()
+VAULT = Path(os.environ.get("MC_VAULT_DIR", "~/wissens-vault")).expanduser()
+STATUS_PATH = Path(os.environ.get("MC2_AUFTRAG_STATUS", str(MODELS_DIR / "mc2-auftragsbuch.json")))
+# Empfehlungs-Stempel des nächtlichen Karten-Gutachters (deploy/karten-gutachter.sh schreibt,
+# die API liest nur) und das Lern-Gedächtnis der Ablehnungen (Radar/Specifier lesen es).
+GUTACHTEN_PATH = Path(os.environ.get("MC2_KARTEN_GUTACHTEN", str(MODELS_DIR / "mc2-karten-gutachten.json")))
+ABLEHNUNGEN_PATH = Path(os.environ.get("MC2_ABLEHNUNGEN", str(MODELS_DIR / "mc2-ablehnungen.jsonl")))
+
+# Karten-Quellen. Die Runner-Skripte liegen IMMER im MC2-Checkout (deploy/) — auch der
+# Lucy-Runner, denn er läuft auf der Box; nur der Build passiert am PC.
+REPOS: dict[str, dict] = {
+    "mc2": {"path": REPO, "runner": "auftrag-annehmen.sh", "key": ""},
+    "lucy": {"path": LUCY, "runner": "lucy-annahme.sh", "key": "lucy:"},
+}
+
+# Persistenz für gemeldete Branches (Idempotenz: nur EINMAL pro Branch pingen).
+# Muster wie mc2-announce.json unter MODELS_DIR.
+ANNOUNCE_BRANCHES_PATH = Path(os.environ.get("MC2_ANNOUNCE_BRANCHES", str(MODELS_DIR / "mc2-announce-branches.json")))
+
+# Nur diese Branch-Familien sind Vorschläge (main/HEAD & Fremdes bleiben draußen).
+PREFIXES = ("wartung/", "orchestrator/", "doku/", "feature/")
+# Branch-Namen kommen vom Client zurück → hart validieren (keine Shell-/Git-Injektion).
+_BRANCH_RX = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._/-]{0,120}$")
+_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:
+    return os.name == "posix" and (REPO / ".git").exists()
+
+
+def _repo_ok(repo: str) -> bool:
+    r = REPOS.get(repo)
+    return bool(r) and os.name == "posix" and (r["path"] / ".git").exists()
+
+
+def _git(repo: str, args: list[str], timeout: int = 20) -> subprocess.CompletedProcess:
+    return subprocess.run(["git", "-C", str(REPOS[repo]["path"]), *args],
+                          capture_output=True, text=True, timeout=timeout)
+
+
+def _status_key(repo: str, branch: str) -> str:
+    return f"{REPOS[repo]['key']}{branch}"
+
+
+def _fetch_throttled(repo: str) -> None:
+    now = time.time()
+    if now - _fetch_cache.get(repo, 0.0) < _FETCH_EVERY:
+        return
+    _fetch_cache[repo] = now
+    try:
+        _git(repo, ["fetch", "-q", "--prune", "origin"], timeout=30)
+    except Exception:
+        log.warning("auftragsbuch: git fetch (%s) fehlgeschlagen", repo, exc_info=True)
+
+
+def _load_announce_branches() -> set:
+    """Liefert die Menge der bereits gemeldeten Branch-Namen (Idempotenz)."""
+    try:
+        data = json.loads(ANNOUNCE_BRANCHES_PATH.read_text(encoding="utf-8"))
+        return set(data) if isinstance(data, list) else set()
+    except Exception:
+        return set()
+
+
+def _save_announce_branches(branches: set) -> None:
+    """Speichert die Menge gemelder Branch-Namen."""
+    try:
+        tmp = ANNOUNCE_BRANCHES_PATH.with_suffix(".tmp")
+        tmp.write_text(json.dumps(sorted(branches), ensure_ascii=False), encoding="utf-8")
+        tmp.replace(ANNOUNCE_BRANCHES_PATH)
+    except OSError:
+        log.warning("auftragsbuch: Announce-Branches %s nicht schreibbar", ANNOUNCE_BRANCHES_PATH, exc_info=True)
+
+
+def _statuses() -> dict:
+    try:
+        return (json.loads(STATUS_PATH.read_text(encoding="utf-8")) or {}).get("branches", {})
+    except Exception:
+        return {}
+
+
+def _set_status(key: str, state: str, detail: str) -> None:
+    try:
+        try:
+            data = json.loads(STATUS_PATH.read_text(encoding="utf-8"))
+        except Exception:
+            data = {}
+        data.setdefault("branches", {})[key] = {"state": state, "detail": detail, "ts": time.time()}
+        tmp = STATUS_PATH.with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+        tmp.replace(STATUS_PATH)
+    except OSError:
+        log.warning("auftragsbuch: Status %s nicht schreibbar", STATUS_PATH, exc_info=True)
+
+
+def _gutachten() -> dict:
+    """Alle Karten-Stempel ("<repo>:<branch>" → {empfehlung, satz, richter, commit_ts, ts})."""
+    try:
+        data = json.loads(GUTACHTEN_PATH.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _remote_branches(repo: str) -> list[str]:
+    r = _git(repo, ["for-each-ref", "--format=%(refname:short)", "refs/remotes/origin"])
+    out = []
+    for line in (r.stdout or "").splitlines():
+        name = line.strip().removeprefix("origin/")
+        if name and name != "HEAD" and name.startswith(PREFIXES):
+            out.append(name)
+    return out
+
+
+def _valid_branch(branch: str) -> bool:
+    return bool(_BRANCH_RX.match(branch)) and ".." not in branch and branch.startswith(PREFIXES)
+
+
+def _repo_items(repo: str, statuses: dict, gutachten: dict) -> list[dict]:
+    items = []
+    for branch in _remote_branches(repo):
+        ref = f"origin/{branch}"
+        status = statuses.get(_status_key(repo, branch))
+        try:
+            ahead = int((_git(repo, ["rev-list", "--count", f"origin/main..{ref}"]).stdout or "0").strip() or 0)
+            if ahead == 0 and ((status or {}).get("state") not in ("laeuft", "rollback")):
+                continue  # bereits in main enthalten → keine offene Entscheidung mehr
+            behind = int((_git(repo, ["rev-list", "--count", f"{ref}..origin/main"]).stdout or "0").strip() or 0)
+            # Kaputt aufgesetzte Branches entlarven (Worker machte git init/Shallow statt zu
+            # klonen): ohne gemeinsamen Vorfahren kann git NIE mergen — Annehmen wäre ein
+            # garantierter Fehllauf („refusing to merge unrelated histories").
+            verwaist = _git(repo, ["merge-base", "origin/main", ref]).returncode != 0
+            show = _git(repo, ["show", "-s", "--format=%s%x1f%b%x1f%ct%x1f%an", ref])
+            subject, body, cts, author = ((show.stdout or "").split("\x1f") + ["", "", "", ""])[:4]
+            ts_val = int(cts) if cts.strip().isdigit() else None
+            # Stempel nur zeigen, wenn er zum AKTUELLEN Commit gehört (nachgeschobener
+            # Commit macht das alte Gutachten ungültig — der Nacht-Lauf stempelt neu).
+            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 = []
+            for line in files_raw[:60]:
+                parts = line.split("\t")
+                if len(parts) >= 2:
+                    files.append({"status": parts[0][:2], "path": parts[-1]})
+            paths = [f["path"] for f in files]
+            frontend_src = any(p.startswith("frontend/src") for p in paths)
+            frontend_dist = any(p.startswith("frontend/dist") for p in paths)
+            items.append({
+                "repo": repo,
+                "branch": branch,
+                "kind": branch.split("/", 1)[0],
+                "subject": subject.strip(),
+                "body": body.strip()[:2000],
+                "author": author.strip(),
+                "ts": ts_val,
+                "empfehlung": stempel,
+                "ahead": ahead,
+                "behind": behind,
+                "verwaist": verwaist,
+                # Diff gegen main ist leer → der Branch brächte nichts (Inhalt schon in main
+                # oder Worker hat am Repo vorbei gearbeitet). Bei verwaist ist der Diff
+                # technisch leer (kein merge-base) — dann zählt nur das verwaist-Flag.
+                "leer": not verwaist and ahead > 0 and not files_raw,
+                "shortstat": stat,
+                "files": files,
+                "files_truncated": len(files_raw) > 60,
+                # Nur mc2: Frontend-Quelltext ohne gebautes Bundle — die Box deployt dist so, wie
+                # 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)
+    return items
+
+
+def list_proposals() -> dict:
+    """Alle offenen Vorschläge: Branches aus beiden Repos (mit Commit-/Diff-Zusammenfassung +
+    Status) und Skill-Kandidaten aus dem Vault. Eine Antwort für die ganze Auftragsbuch-Seite.
+    
+    Nebenbei: Pinge neu auftauchende Vorschlags-Branches per Telegram und füge sie dem
+    Briefkasten hinzu (Idempotenz: nur EINMAL pro Branch)."""
+    if not _available():
+        return {"available": False, "items": [], "skill_kandidaten": [], "open_count": 0}
+
+    statuses = _statuses()
+    gutachten = _gutachten()
+    items = []
+    for repo in REPOS:
+        if not _repo_ok(repo):
+            continue  # z. B. ~/lucy (noch) nicht geklont → Karten dieses Repos einfach weglassen
+        _fetch_throttled(repo)
+        items.extend(_repo_items(repo, statuses, gutachten))
+    items.sort(key=lambda i: i.get("ts") or 0, reverse=True)
+
+    # --- Telegram-Ping für NEUE Vorschlags-Branches (Idempotenz) ---
+    # Alle aktuellen Branch-Namen aus beiden Repos sammeln
+    aktuelle_branches = set()
+    for repo in REPOS:
+        if _repo_ok(repo):
+            aktuelle_branches.update(_remote_branches(repo))
+    
+    # Bereits gemeldete Branches laden
+    gemeldet = _load_announce_branches()
+    
+    # Nur wirklich NEUE Branches pingen
+    neue = aktuelle_branches - gemeldet
+    for branch in neue:
+        # NotifyTelegram best-effort, niemals crashen
+        try:
+            from services import announce
+            subject = "[Auftragsbuch]"
+            text = f"Neue Karte wartet auf deinen Klick: {branch}"
+            announce.notify_telegram(subject, text)
+            # Und ein Eintrag für den Briefkasten (damit Lucy es spricht)
+            announce.add(text, subject, "auftragsbuch", "normal")
+        except Exception:
+            log.warning("auftragsbuch: Telegram-Ping für %s fehlgeschlagen", branch, exc_info=True)
+    
+    # Als gemeldet speichern — aber NUR bei echter Änderung. Ein unbedingtes Schreiben
+    # bumpte die mtime bei jedem Aufruf, der SSE-Sammler (events.py, Fingerabdruck =
+    # Datei-mtime) meldete daraufhin „geändert", die UI holte neu, schrieb wieder …
+    # → 3-s-Endlosschleife auf /api/auftragsbuch je offenem Client (gefunden 15.07. nachts).
+    if aktuelle_branches != gemeldet:
+        _save_announce_branches(aktuelle_branches)
+
+    kandidaten = list_skill_kandidaten()
+    open_count = sum(1 for i in items
+                     if (i.get("status") or {}).get("state") not in ("eingespielt",)) + len(kandidaten)
+    return {"available": True, "items": items, "skill_kandidaten": kandidaten, "open_count": open_count}
+
+
+def diff_of(branch: str, repo: str = "mc2") -> dict:
+    if not _repo_ok(repo):
+        return {"ok": False, "error": "Nur auf der Box verfügbar."}
+    if not _valid_branch(branch) or branch not in _remote_branches(repo):
+        return {"ok": False, "error": f"Unbekannter Vorschlags-Branch: {branch}"}
+    r = _git(repo, ["diff", f"origin/main...origin/{branch}"], timeout=30)
+    text = r.stdout or ""
+    truncated = len(text) > 200_000
+    return {"ok": True, "diff": text[:200_000], "truncated": truncated}
+
+
+def accept(branch: str, repo: str = "mc2") -> dict:
+    """Annehmen: detached Runner starten. mc2: Merge→Push→Deploy→Health→ggf. Rollback.
+    lucy: Merge→Push→PC-Build+Neustart→ggf. Revert (der Runner spricht den PC-Executor an)."""
+    if not _repo_ok(repo):
+        return {"ok": False, "error": "Annehmen geht nur auf der Box."}
+    if not _valid_branch(branch) or branch not in _remote_branches(repo):
+        return {"ok": False, "error": f"Unbekannter Vorschlags-Branch: {branch}"}
+    key = _status_key(repo, branch)
+    state = (_statuses().get(key) or {}).get("state")
+    if state in ("laeuft", "rollback"):
+        return {"ok": False, "error": "Für diesen Vorschlag läuft bereits ein Annahme-Lauf."}
+    # Kaputt aufgesetzter Branch (kein gemeinsamer Vorfahre) → Merge kann NIE gelingen;
+    # gar nicht erst einen Runner starten (die UI blendet den Knopf aus, die API hält dicht).
+    if _git(repo, ["merge-base", "origin/main", f"origin/{branch}"]).returncode != 0:
+        return {"ok": False, "error": "Dieser Branch hat keinen gemeinsamen Ursprung mit main "
+                "(kaputt aufgesetzt, z. B. git init statt Klonen) — Annehmen ist technisch unmöglich. "
+                "Bitte ablehnen (gern mit Grund) und die Idee neu in die Queue geben."}
+
+    # Runner als /tmp-Kopie starten: deploy.sh resettet das Repo hart — das Original-Skript
+    # würde einem laufenden bash unter den Füßen getauscht (bekannte Selbst-Reset-Falle).
+    src = REPO / "deploy" / REPOS[repo]["runner"]
+    if not src.is_file():
+        return {"ok": False, "error": f"Runner fehlt im Checkout: {src.name}"}
+    runner = Path(f"/tmp/mc2-auftrag-runner-{int(time.time())}.sh")
+    try:
+        shutil.copyfile(src, runner)
+    except OSError as exc:
+        return {"ok": False, "error": f"Runner nicht kopierbar: {exc}"}
+
+    slug = re.sub(r"[^a-z0-9-]+", "-", f"{repo}-{branch}".lower())[:40].strip("-")
+    unit = f"mc2-auftrag-{slug}-{int(time.time())}"
+    r = subprocess.run(
+        ["systemd-run", "--user", "--collect", f"--unit={unit}",
+         "/bin/bash", str(runner), branch],
+        capture_output=True, text=True, timeout=20)
+    if r.returncode != 0:
+        return {"ok": False, "error": f"Start fehlgeschlagen: {(r.stderr or r.stdout).strip()[:300]}"}
+    _set_status(key, "laeuft", "Annahme-Lauf gestartet")
+    return {"ok": True, "unit": unit}
+
+
+def reject(branch: str, repo: str = "mc2", grund: str = "") -> dict:
+    """Ablehnen: Remote-Branch löschen (die Arbeit bleibt in der Gitea-Historie referenzierbar,
+    aber die Entscheidung ist gefallen). Der optionale GRUND ist das Lern-Gedächtnis des
+    Kreislaufs: er landet in ABLEHNUNGEN_PATH (jsonl), und Idle-Radar/Analysten bekommen
+    ihn als „NIE wieder vorschlagen"-Material vorgelegt. Meldung in den Briefkasten."""
+    if not _repo_ok(repo):
+        return {"ok": False, "error": "Ablehnen geht nur auf der Box."}
+    if not _valid_branch(branch) or branch not in _remote_branches(repo):
+        return {"ok": False, "error": f"Unbekannter Vorschlags-Branch: {branch}"}
+    grund = (grund or "").strip()[:400]
+    # Betreff VOR dem Löschen sichern — danach ist der Ref weg.
+    subject = (_git(repo, ["show", "-s", "--format=%s", f"origin/{branch}"]).stdout or "").strip()[:200]
+    r = _git(repo, ["push", "origin", "--delete", branch], timeout=30)
+    if r.returncode != 0:
+        return {"ok": False, "error": f"Löschen fehlgeschlagen: {(r.stderr or '').strip()[:300]}"}
+    _git(repo, ["fetch", "-q", "--prune", "origin"], timeout=30)
+    detail = "Vom Commander abgelehnt — Branch gelöscht"
+    if grund:
+        detail += f" (Grund: {grund})"
+    _set_status(_status_key(repo, branch), "abgelehnt", detail)
+    try:
+        with ABLEHNUNGEN_PATH.open("a", encoding="utf-8") as f:
+            f.write(json.dumps({"ts": int(time.time()), "repo": repo, "branch": branch,
+                                "subject": subject, "grund": grund}, ensure_ascii=False) + "\n")
+    except OSError:
+        log.warning("auftragsbuch: Ablehn-Gedächtnis %s nicht schreibbar", ABLEHNUNGEN_PATH, exc_info=True)
+    try:
+        from services import announce
+        wo = "im Lucy-Repo " if repo == "lucy" else ""
+        warum = f" Grund: {grund}" if grund else ""
+        announce.add(f"Vorschlag '{branch}' {wo}wurde abgelehnt und der Branch gelöscht.{warum}",
+                     "[Auftragsbuch]", "auftragsbuch", "silent")
+    except Exception:
+        pass
+    return {"ok": True}
+
+
+# ── Skill-Kandidaten (Wissens-Vault) ─────────────────────────────────────────
+
+def _kandidaten_dir() -> Path:
+    return VAULT / "skill-kandidaten"
+
+
+def list_skill_kandidaten() -> list[dict]:
+    d = _kandidaten_dir()
+    if os.name != "posix" or not d.is_dir():
+        return []
+    out = []
+    for p in sorted(d.glob("*.md"), key=lambda x: x.stat().st_mtime, reverse=True):
+        try:
+            text = p.read_text(encoding="utf-8", errors="replace")
+            first = next((ln.strip().lstrip("# ") for ln in text.splitlines() if ln.strip()), p.stem)
+            out.append({"file": p.name, "title": first[:160],
+                        "preview": text[:3000], "mtime": p.stat().st_mtime})
+        except OSError:
+            continue
+    return out
+
+
+def _vault_git(args: list[str]) -> None:
+    try:
+        subprocess.run(["git", "-C", str(VAULT), *args], capture_output=True, text=True, timeout=15)
+    except Exception:
+        pass
+
+
+def _kandidat_path(fname: str) -> Path | None:
+    if not _KANDIDAT_RX.match(fname):
+        return None
+    p = (_kandidaten_dir() / fname).resolve()
+    if not p.is_relative_to(_kandidaten_dir().resolve()) or not p.is_file():
+        return None
+    return p
+
+
+def skill_accept(fname: str) -> dict:
+    """Skill-Kandidat beauftragen: Inhalt als Werkstatt-Auftrag an die bewährte
+    `hermes -z`-CLI-Lane (detached — der Lauf dauert Minuten und braucht das Backend nicht).
+    Ergebnis ist wieder propose-only: ein neuer Branch, der hier als Karte auftaucht."""
+    if not _available():
+        return {"ok": False, "error": "Beauftragen geht nur auf der Box."}
+    p = _kandidat_path(fname)
+    if not p:
+        return {"ok": False, "error": f"Kandidat nicht gefunden: {fname}"}
+
+    beauftragt = _kandidaten_dir() / "beauftragt"
+    beauftragt.mkdir(parents=True, exist_ok=True)
+    target = beauftragt / p.name
+    try:
+        content = p.read_text(encoding="utf-8", errors="replace")
+        p.rename(target)
+    except OSError as exc:
+        return {"ok": False, "error": f"Kandidat nicht verschiebbar: {exc}"}
+    _vault_git(["add", "-A"])
+    _vault_git(["commit", "-q", "-m", f"Skill-Kandidat beauftragt: {p.name}"])
+
+    order = ("Nutze den orchestrator-Skill (propose-only, Zwei-Kritiker-Gate). "
+             "Auftrag aus dem Wissens-Vault (vom Commander im Auftragsbuch freigegeben):\n\n"
+             + content)
+    order_file = Path(f"/tmp/mc2-skill-auftrag-{int(time.time())}.txt")
+    try:
+        order_file.write_text(order, encoding="utf-8")
+    except OSError as exc:
+        return {"ok": False, "error": f"Auftrag nicht schreibbar: {exc}"}
+    unit = f"mc2-skill-auftrag-{int(time.time())}"
+    r = subprocess.run(
+        ["systemd-run", "--user", "--collect", f"--unit={unit}",
+         "/bin/bash", "-lc", f'hermes -z "$(cat {order_file})"'],
+        capture_output=True, text=True, timeout=20)
+    if r.returncode != 0:
+        return {"ok": False, "error": f"Start fehlgeschlagen: {(r.stderr or r.stdout).strip()[:300]}"}
+    try:
+        from services import announce
+        announce.add(f"Skill-Kandidat '{fname}' wurde beauftragt — die Werkstatt arbeitet, "
+                     "das Ergebnis erscheint als neuer Vorschlag im Auftragsbuch.",
+                     "[Auftragsbuch]", "auftragsbuch", "silent")
+    except Exception:
+        pass
+    return {"ok": True, "unit": unit}
+
+
+def skill_reject(fname: str) -> dict:
+    if not _available():
+        return {"ok": False, "error": "Verwerfen geht nur auf der Box."}
+    p = _kandidat_path(fname)
+    if not p:
+        return {"ok": False, "error": f"Kandidat nicht gefunden: {fname}"}
+    verworfen = _kandidaten_dir() / "verworfen"
+    verworfen.mkdir(parents=True, exist_ok=True)
+    try:
+        p.rename(verworfen / p.name)
+    except OSError as exc:
+        return {"ok": False, "error": f"Kandidat nicht verschiebbar: {exc}"}
+    _vault_git(["add", "-A"])
+    _vault_git(["commit", "-q", "-m", f"Skill-Kandidat verworfen: {p.name}"])
+    return {"ok": True}

backend/services/backup.py

@@ -27,6 +27,11 @@ def _latest() -> Path | None:
     return snaps[0] if snaps else None
 
 
+def snapshot_components(tarball: Path) -> list[str]:
+    """Öffentliche Sicht auf die Snapshot-Komponenten (Zeitmaschine-Detail in der UI)."""
+    return _components(tarball)
+
+
 def _components(tarball: Path) -> list[str]:
     """Top-Level-Einträge im Tarball (zur Anzeige im UI)."""
     try:
@@ -46,7 +51,7 @@ def backup_now() -> dict:
         r = subprocess.run(["/bin/bash", str(BACKUP_SH)], capture_output=True, text=True, timeout=180)
         if r.returncode != 0:
             return {"ok": False, "snapshot": "", "files": [], "error": (r.stderr or r.stdout).strip()[-300:]}
-    except Exception as exc:  # noqa: BLE001
+    except Exception as exc:
         return {"ok": False, "snapshot": "", "files": [], "error": str(exc)}
 
     latest = _latest()

backend/services/budget.py

@@ -1,143 +1,205 @@
-"""
-Speicher-Budget & SETUP-BEWUSSTE ctx-Vergabe — EINE Quelle der Wahrheit.
-
-Modelliert die auf der Box VERIFIZIERTE Residenz-Realität (llama-swap, Ein-Gruppen-
-Residenz, GTT ~124 GB):
-  • Das Agent-Hirn (Rolle `hermes`) ist IMMER resident.
-  • Weitere persist-Mitglieder (fast/vision) dürfen verdrängt werden, wenn ein großes
-    on-demand-Modell lädt.
-Daraus folgt, wie viel Speicher NEBEN einem Zielmodell reserviert bleiben muss —
-und damit der größte Kontext, der wirklich passt (nicht nur für das Modell allein).
-
-Vorher rechnete nur der Hirn-Wechsel (agent.py) setup-bewusst; die allgemeine
-ctx-Vergabe nahm den Gesamt-RAM in Isolation. Dieses Modul vereint beides.
-"""
-
-import re
-
-import psutil
-
-from services.fit import (
-    QUANT_BYTES_PER_PARAM,
-    estimate_memory_gb,
-    extract_params_b,
-    max_ctx_in_budget,
-)
-
-HEADROOM_GB = 4.0   # OS/Treiber/Fragmentierung
-
-
-def gtt_budget_gb() -> float:
-    """GPU-adressierbarer Speicher (GTT) in GB — die harte Obergrenze. Liest
-    amdgpu.gttsize aus /proc/cmdline, sonst RAM minus OS-Reserve."""
-    try:
-        with open("/proc/cmdline") as f:
-            m = re.search(r"amdgpu\.gttsize=(\d+)", f.read())
-            if m:
-                return round(int(m.group(1)) / 1024.0, 1)
-    except Exception:
-        pass
-    return round(psutil.virtual_memory().total / (1024 ** 3) - 6.0, 1)
-
-
-def params_of_model(model: dict) -> float:
-    """Robuste Params (Mrd.) eines INSTALLIERTEN Modells: MAXIMUM aus Caps-Schätzung und
-    Dateigröße. Deckt 'Coder-Next' ohne Größe im Namen (→ aus Datei) und Split-GGUFs
-    (size_bytes = nur erster Teil → ignoriert) ab."""
-    caps = model.get("capabilities") or {}
-    quant = model.get("quant") or "Q4_K_M"
-    bpp = QUANT_BYTES_PER_PARAM.get(quant.upper(), 0.55)
-    size_gb = (model.get("size_bytes") or 0) / (1024 ** 3)
-    pb_size = (size_gb / bpp) if size_gb > 1.0 else 0.0
-    return max(float(caps.get("params_b") or 0), pb_size, 7.0)
-
-
-def footprint_gb(model: dict) -> float:
-    """Loaded-Footprint eines Modells = Gewichte + kalibrierter KV-Anteil (bei seinem
-    aktuellen ctx)."""
-    quant = model.get("quant") or "Q4_K_M"
-    ctx = int(model.get("ctx") or 32768)
-    bpp = QUANT_BYTES_PER_PARAM.get(quant.upper(), 0.55)
-    size_gb = (model.get("size_bytes") or 0) / (1024 ** 3)
-    pb = params_of_model(model)
-    weights = max(pb * bpp, size_gb)
-    kv = estimate_memory_gb(pb, quant, ctx) - pb * bpp
-    return weights + max(kv, 0.0)
-
-
-def params_b_for(name: str) -> float:
-    """Parameter (Mrd.) für einen Modell-/Repo-Namen: KATALOG (echte Metadaten) zuerst,
-    sonst Namens-Schätzung. Gemeinsam für Fit-Vorschau und ctx-Vergabe."""
-    from services import catalog
-    meta = catalog.meta_for_name(name) if name else None
-    if meta and meta.get("total_params_b"):
-        return float(meta["total_params_b"])
-    return extract_params_b(name)
-
-
-def _coresident_members(groups: dict) -> set:
-    """Modelle, die GLEICHZEITIG warm sind: Mitglieder aller `swap:false`-Gruppen
-    (Ko-Residenz, z.B. brains = Hirn+embed+vision). Ein Modell AUSSERHALB dieser Gruppen
-    ist on-demand und verdrängt beim Laden die GANZE Gruppe — llama-swap swappt Gruppen
-    (live verifiziert: heavy laden → brains-Gruppe komplett raus, heavy läuft allein)."""
-    out: set = set()
-    for g in (groups or {}).values():
-        if isinstance(g, dict) and g.get("swap") is False:
-            out.update(g.get("members") or [])
-    return out
-
-
-def reserved_gb(role: str | None) -> dict:
-    """Speicher, der NEBEN einem Zielmodell der gegebenen Rolle resident bleibt — gemäß der
-    VERIFIZIERTEN llama-swap-Gruppen-Swap-Semantik (NICHT der früheren Annahme „Hirn bleibt
-    immer"). Nur die ko-residente `swap:false`-Gruppe läuft gemeinsam; ein on-demand-Modell
-    verdrängt die Gruppe und läuft ALLEIN mit dem vollen GTT.
-
-    - Modell IN der Ko-Residenz-Gruppe (Hirn/embed/vision): koexistiert mit den ÜBRIGEN
-      Gruppen-Mitgliedern → reserviert deren Summe.
-    - Modell AUSSERHALB (heavy/coder/coder-lite/fast/scout): läuft allein (Gruppe wird beim
-      Laden rausgeswappt) → reserviert NICHTS, darf den vollen GTT für Kontext nutzen.
-    """
-    from services import llamaswap
-    models = llamaswap.list_models()
-    groups = llamaswap.list_groups()
-    cores = _coresident_members(groups)
-    brain = next((m for m in models if (m.get("role") == "hermes")), None)
-    brain_gb = footprint_gb(brain) if brain else 0.0
-    role = (role or "").strip().lower()
-
-    holder = next((m for m in models if (m.get("role") == role)), None) if role else None
-    holder_name = holder["name"] if holder else None
-    # Hirn (hermes) ist per Definition Teil der Ko-Residenz-Gruppe; sonst Gruppen-Mitgliedschaft prüfen.
-    in_group = role == "hermes" or bool(holder_name and holder_name in cores)
-
-    if in_group:
-        others = sum(footprint_gb(m) for m in models
-                     if m["name"] in cores and m["name"] != holder_name)
-        return {"reserved_gb": others, "mode": "co-resident", "brain_gb": brain_gb}
-    # on-demand: verdrängt die Ko-Residenz-Gruppe → läuft allein, voller GTT für Kontext.
-    return {"reserved_gb": 0.0, "mode": "ondemand-alone", "brain_gb": brain_gb}
-
-
-def setup_aware_ctx(params_b: float, quant: str, role: str | None = None) -> dict:
-    """Größter Kontext, der für ein Modell (params_b/quant) der gegebenen Rolle NEBEN dem
-    bestehenden Setup passt. Gibt ctx + die Budget-Herleitung zurück (für UI/Transparenz)."""
-    gtt = gtt_budget_gb()
-    r = reserved_gb(role)
-    budget = max(gtt - r["reserved_gb"] - HEADROOM_GB, 0.0)
-    ctx = max_ctx_in_budget(params_b, quant, budget)
-    return {
-        "ctx": ctx,
-        "gtt_gb": gtt,
-        "reserved_gb": round(r["reserved_gb"], 1),
-        "budget_gb": round(budget, 1),
-        "mode": r["mode"],
-    }
-
-
-def setup_aware_ctx_for_model(model: dict) -> dict:
-    """Setup-bewusster Optimal-ctx für ein INSTALLIERTES Modell (aus seiner Rolle,
-    Params & Quant). Für den 'Auto'-Button an der Modellkarte."""
-    return setup_aware_ctx(params_of_model(model),
-                           model.get("quant") or "Q4_K_M",
-                           role=model.get("role"))
+"""
+Speicher-Budget & SETUP-BEWUSSTE ctx-Vergabe — EINE Quelle der Wahrheit.
+
+Modelliert die auf der Box VERIFIZIERTE Residenz-Realität (llama-swap, GTT ~124 GB):
+  • Die `persistent`-Gruppe (brains = Hirn+embed+vision) bleibt IMMER resident —
+    seit dem Key-Fix 03.07.2026 greift der Schutz wirklich (vorher stand `persist`
+    in der Config, das llama-swap stillschweigend ignorierte; on-demand-Last
+    verdrängte damals die ganze Gruppe).
+  • Ein on-demand-Modell (heavy/coder/…) lädt NEBEN die brains-Gruppe und muss
+    deren Footprint mit einplanen.
+Daraus folgt, wie viel Speicher NEBEN einem Zielmodell reserviert bleiben muss —
+und damit der größte Kontext, der wirklich passt (nicht nur für das Modell allein).
+
+Vorher rechnete nur der Hirn-Wechsel (agent.py) setup-bewusst; die allgemeine
+ctx-Vergabe nahm den Gesamt-RAM in Isolation. Dieses Modul vereint beides.
+"""
+
+import re
+
+import psutil
+
+from services.fit import (
+    QUANT_BYTES_PER_PARAM,
+    estimate_memory_gb,
+    extract_params_b,
+    max_ctx_in_budget,
+)
+
+HEADROOM_GB = 4.0   # OS/Treiber/Fragmentierung
+
+
+def gtt_budget_gb() -> float:
+    """GPU-adressierbarer Speicher (GTT) in GB — die harte Obergrenze. Liest
+    amdgpu.gttsize aus /proc/cmdline, sonst RAM minus OS-Reserve."""
+    try:
+        with open("/proc/cmdline") as f:
+            m = re.search(r"amdgpu\.gttsize=(\d+)", f.read())
+            if m:
+                return round(int(m.group(1)) / 1024.0, 1)
+    except Exception:
+        pass
+    return round(psutil.virtual_memory().total / (1024 ** 3) - 6.0, 1)
+
+
+def params_of_model(model: dict) -> float:
+    """Robuste Params (Mrd.) eines INSTALLIERTEN Modells: MAXIMUM aus Caps-Schätzung und
+    Dateigröße. Deckt 'Coder-Next' ohne Größe im Namen (→ aus Datei) und Split-GGUFs
+    (size_bytes = nur erster Teil → ignoriert) ab."""
+    caps = model.get("capabilities") or {}
+    quant = model.get("quant") or "Q4_K_M"
+    bpp = QUANT_BYTES_PER_PARAM.get(quant.upper(), 0.55)
+    size_gb = (model.get("size_bytes") or 0) / (1024 ** 3)
+    pb_size = (size_gb / bpp) if size_gb > 1.0 else 0.0
+    return max(float(caps.get("params_b") or 0), pb_size, 7.0)
+
+
+_CTK_RE = re.compile(r"(?:--cache-type-k|(?<![\w-])-ctk)\s+(\S+)")
+_CTV_RE = re.compile(r"(?:--cache-type-v|(?<![\w-])-ctv)\s+(\S+)")
+
+
+def _cache_types(cmd: str) -> tuple[str | None, str | None]:
+    """K/V-Cache-Quantisierung aus dem llama-server-Cmd (Default f16 → None)."""
+    ck = m.group(1) if (m := _CTK_RE.search(cmd or "")) else None
+    cv = m.group(1) if (m := _CTV_RE.search(cmd or "")) else None
+    return ck, cv
+
+
+def _real_kv_gb(model: dict, ctx: int) -> float | None:
+    """ECHTE KV-Cache-Größe (GiB) aus den GGUF-Architektur-Metadaten (Layer × KV-Heads ×
+    Head-Dim) + der cache-type-Quantisierung des Cmds. None, wenn das GGUF nicht lesbar ist
+    → Aufrufer fällt auf die params-basierte Heuristik zurück."""
+    from services import gguf_meta
+    path = model.get("gguf_path")
+    if not path:
+        return None
+    meta = gguf_meta.arch_meta(path)
+    if not meta:
+        return None
+    ck, cv = _cache_types(model.get("cmd") or "")
+    return gguf_meta.kv_cache_gb(meta, ctx, ck, cv)
+
+
+def footprint_gb(model: dict) -> float:
+    """Loaded-Footprint eines Modells = Gewichte + KV-Cache (bei seinem aktuellen ctx).
+    KV kommt aus den ECHTEN Architektur-Metadaten des GGUF (nicht mehr params-geschätzt) —
+    entscheidend bei MoE (A3B): die alte Schätzung hing an den Gesamt-Params und überschätzte
+    grob (z.B. „68 GB reserviert" statt real ~25 GB). Heuristik bleibt Fallback."""
+    quant = model.get("quant") or "Q4_K_M"
+    ctx = int(model.get("ctx") or 32768)
+    bpp = QUANT_BYTES_PER_PARAM.get(quant.upper(), 0.55)
+    size_gb = (model.get("size_bytes") or 0) / (1024 ** 3)
+    pb = params_of_model(model)
+    weights = max(pb * bpp, size_gb)
+    kv = _real_kv_gb(model, ctx)
+    if kv is None:
+        kv = estimate_memory_gb(pb, quant, ctx) - pb * bpp
+    return weights + max(kv, 0.0)
+
+
+def params_b_for(name: str) -> float:
+    """Parameter (Mrd.) für einen Modell-/Repo-Namen: KATALOG (echte Metadaten) zuerst,
+    sonst Namens-Schätzung. Gemeinsam für Fit-Vorschau und ctx-Vergabe."""
+    from services import catalog
+    meta = catalog.meta_for_name(name) if name else None
+    if meta and meta.get("total_params_b"):
+        return float(meta["total_params_b"])
+    return extract_params_b(name)
+
+
+def _coresident_members(groups: dict) -> set:
+    """Modelle, die GLEICHZEITIG warm sind: Mitglieder aller `swap:false`-Gruppen
+    (Ko-Residenz, z.B. brains = Hirn+embed+vision). Seit dem `persistent`-Fix (03.07.2026)
+    überlebt die Gruppe auch on-demand-Last: Coder/heavy laden DANEBEN, nicht an ihre
+    Stelle (live verifiziert: Coder + Qwen3.6 gleichzeitig `ready`). Die frühere
+    Beobachtung „heavy verdrängt die Gruppe" war der ignorierte `persist`-Key."""
+    out: set = set()
+    for g in (groups or {}).values():
+        if isinstance(g, dict) and g.get("swap") is False:
+            out.update(g.get("members") or [])
+    return out
+
+
+def reserved_gb(role: str | None) -> dict:
+    """Speicher, der NEBEN einem Zielmodell der gegebenen Rolle resident bleibt — gemäß der
+    seit dem `persistent`-Fix (03.07.2026) geltenden Semantik: die ko-residente
+    `swap:false`-Gruppe (brains) bleibt IMMER geladen, on-demand-Modelle laden daneben.
+
+    - Modell IN der Ko-Residenz-Gruppe (Hirn/embed/vision): koexistiert mit den ÜBRIGEN
+      Gruppen-Mitgliedern → reserviert deren Summe.
+    - Modell AUSSERHALB (heavy/coder/coder-lite/scout): lädt NEBEN die Gruppe →
+      reserviert deren GESAMTE Summe (früher 0.0, weil der kaputte `persist`-Key die
+      Gruppe verdrängen ließ — diese Rechnung erlaubte zu große Kontexte).
+    """
+    from services import llamaswap
+    models = llamaswap.list_models()
+    groups = llamaswap.list_groups()
+    cores = _coresident_members(groups)
+    brain = next((m for m in models if (m.get("role") == "hermes")), None)
+    brain_gb = footprint_gb(brain) if brain else 0.0
+    role = (role or "").strip().lower()
+
+    holder = next((m for m in models if (m.get("role") == role)), None) if role else None
+    holder_name = holder["name"] if holder else None
+    # Hirn (hermes) ist per Definition Teil der Ko-Residenz-Gruppe; sonst Gruppen-Mitgliedschaft prüfen.
+    in_group = role == "hermes" or bool(holder_name and holder_name in cores)
+
+    if in_group:
+        others = sum(footprint_gb(m) for m in models
+                     if m["name"] in cores and m["name"] != holder_name)
+        return {"reserved_gb": others, "mode": "co-resident", "brain_gb": brain_gb}
+    # on-demand: lädt neben die (persistente) Ko-Residenz-Gruppe → deren Summe reservieren.
+    warm = sum(footprint_gb(m) for m in models if m["name"] in cores)
+    return {"reserved_gb": warm, "mode": "ondemand-beside-warmset", "brain_gb": brain_gb}
+
+
+def setup_aware_ctx(params_b: float, quant: str, role: str | None = None) -> dict:
+    """Größter Kontext, der für ein Modell (params_b/quant) der gegebenen Rolle NEBEN dem
+    bestehenden Setup passt. Gibt ctx + die Budget-Herleitung zurück (für UI/Transparenz)."""
+    gtt = gtt_budget_gb()
+    r = reserved_gb(role)
+    budget = max(gtt - r["reserved_gb"] - HEADROOM_GB, 0.0)
+    ctx = max_ctx_in_budget(params_b, quant, budget)
+    return {
+        "ctx": ctx,
+        "gtt_gb": gtt,
+        "reserved_gb": round(r["reserved_gb"], 1),
+        "budget_gb": round(budget, 1),
+        "mode": r["mode"],
+    }
+
+
+def _snap_ctx(raw_ctx: float, cap: int | None = None) -> int:
+    """Größter 'schöner' Kontext ≤ raw_ctx (und ≤ Trainings-Kontext des Modells, falls bekannt)."""
+    from services.fit import _NICE_CTX
+    if cap:
+        raw_ctx = min(raw_ctx, cap)
+    best = _NICE_CTX[0]
+    for c in _NICE_CTX:
+        if c <= raw_ctx:
+            best = c
+    return best
+
+
+def setup_aware_ctx_for_model(model: dict) -> dict:
+    """Setup-bewusster Optimal-ctx für ein INSTALLIERTES Modell. Für den 'Auto'-Button an der
+    Modellkarte. Nutzt die ECHTE KV-Größe des GGUF (gleiche Zahlensprache wie footprint_gb) —
+    Fallback auf die params-Heuristik nur, wenn das GGUF nicht lesbar ist."""
+    from services import gguf_meta
+    quant = model.get("quant") or "Q4_K_M"
+    path = model.get("gguf_path")
+    meta = gguf_meta.arch_meta(path) if path else None
+    if not meta:
+        return setup_aware_ctx(params_of_model(model), quant, role=model.get("role"))
+
+    gtt = gtt_budget_gb()
+    r = reserved_gb(model.get("role"))
+    budget = max(gtt - r["reserved_gb"] - HEADROOM_GB, 0.0)
+    bpp = QUANT_BYTES_PER_PARAM.get(quant.upper(), 0.55)
+    size_gb = (model.get("size_bytes") or 0) / (1024 ** 3)
+    weights = max(params_of_model(model) * bpp, size_gb)
+    ck, cv = _cache_types(model.get("cmd") or "")
+    per_tok = gguf_meta.kv_gb_per_token(meta, ck, cv)
+    ctx = _snap_ctx((budget - weights) / per_tok, cap=meta.get("n_ctx_train")) if per_tok > 0 else 2048
+    return {"ctx": ctx, "gtt_gb": gtt, "reserved_gb": round(r["reserved_gb"], 1),
+            "budget_gb": round(budget, 1), "mode": r["mode"]}

backend/services/connect.py

@@ -1,7 +1,7 @@
 """
 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
-(Lanes `coding`/`chat`, Cockpit-Port :9001/v1) + den **Shared-Memory-MCP** (MC :9001).
+(reale Modelle coder/heavy/vision, Cockpit-Port :9001/v1) + den **Shared-Memory-MCP** (MC :9001).
 
 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,18 +10,33 @@ die häufigste Fehlerquelle. Der Aufrufer übergibt den Host explizit.
 import json
 
 import httpx
-
-from config import LLAMA_SWAP_URL, MEM0_SERVICE_URL, PORT
+from config import HERMES_BUILTIN_UI_UPSTREAM, LLAMA_SWAP_URL, MEM0_SERVICE_URL, PORT, V1_UPSTREAM
 
 DEFAULT_HOST = "192.168.178.151"
 
-# IDEs bekommen NUR die 'coding'-Lane zu sehen — die Lane routet intern selbst auf das
-# passende Modell (Coder/Heavy/…). Ein einziger Eintrag, kein manuelles Modell-Wählen mehr.
-IDE_MODEL = "coding"
+# IDEs/Agenten bekommen die ECHTEN Box-Modelle direkt (kein Lane-Routing): Coder (bauen), Planer (denken),
+# Augen (Bilder, Vision). Der User wechselt im Modellwähler — spiegelt das reale Hermes-Desktop-Setup 1:1.
+PRIMARY_MODEL = "coder"
+
+
+def _caps(tools: bool = True, images: bool = False) -> dict:
+    """Volle 7-Feld-Capabilities — braucht sie für die Modellwahl."""
+    return {"tools": tools, "images": images, "parallel_tool_calls": False,
+            "prompt_cache_key": False, "chat_completions": True,
+            "interleaved_reasoning": False, "max_tokens_parameter": False}
+
+
+# Reale Box-Modelle für die IDE-Welt (getrennt von Lucy): bauen · denken · sehen.
+IDE_MODELS = [
+    {"name": "coder", "display_name": "Box / Coder (bauen)", "max_tokens": 131072, "capabilities": _caps(True, False)},
+    {"name": "heavy", "display_name": "Box / Planer (denken)", "max_tokens": 32768, "capabilities": _caps(True, False)},
+    {"name": "vision", "display_name": "Box / Augen (Bilder)", "max_tokens": 32768, "capabilities": _caps(False, True)},
+]
 
 
 def _gw(host: str) -> str:
-    # Eingebauter Gateway: MC2 serviert /v1 selbst (gleicher Port wie das Cockpit).
+    # Client-Endpunkt bleibt :9001/v1 (MC2-Port) — seit UMBAU v3 P1 reicht MC2 dort
+    # nur noch roh an den eigenständigen mc2-gateway (:9010) durch.
     return f"http://{host}:{PORT}/v1"
 
 
@@ -31,56 +46,31 @@ def build_snippets(host: str = DEFAULT_HOST,
     gw = _gw(host)
     mc_url = f"http://{host}:{PORT}"
 
-    cline = json.dumps({
+    # Kilo Code = aktiver Nachfolger der Roo/Cline-Linie (Roo im April 2026 eingestellt).
+    # Gleiche Provider-Settings-Struktur; Multi-Agent kommt aus dem Tool (Orchestrator-Modus).
+    kilo = json.dumps({
         "apiProvider": "openai",
         "openAiBaseUrl": gw,
         "openAiApiKey": "local",
-        "openAiModelId": "coding",
+        "openAiModelId": PRIMARY_MODEL,
     }, indent=2)
 
-    opencode = json.dumps({
-        "provider": {
-            "bosgame": {
-                "npm": "@ai-sdk/openai-compatible",
-                "name": "Bosgame Gateway",
-                "options": {"baseURL": gw, "apiKey": "local"},
-                "models": {IDE_MODEL: {"name": IDE_MODEL}},
-            }
-        }
-    }, indent=2)
-
-    cursor = json.dumps({
-        "Base URL": gw,
-        "API Key": "local",
-        "Active Model": "coding"
-    }, indent=2)
-
-    zed = json.dumps({
-        "language_models": {
-            "openai_compatible": {
-                "bosgame": {
-                    "api_url": gw,
-                    "available_models": [
-                        {"name": IDE_MODEL, "display_name": IDE_MODEL, "max_tokens": 131072,
-                         "capabilities": {"tools": True}}
-                    ],
-                }
-            }
-        },
-        "assistant": {
-            "default_model": {
-                "provider": "openai_compatible",
-                "model": IDE_MODEL
-            }
-        }
-    }, indent=2)
-
-    cont = json.dumps({
-        "models": [
-            {"title": f"Bosgame / {IDE_MODEL}", "provider": "openai", "model": IDE_MODEL,
-             "apiBase": gw, "apiKey": "local"}
-        ]
-    }, indent=2)
+    # Hermes Desktop = Remote-IDE, die auf dem Gateway läuft.
+    # Anleitung: Browser aufweisen → Token aus Datei laden → loslegen.
+    hermes_desktop = (
+        f"# Hermes Desktop — Remote-IDE auf der Box\n"\
+        f"#\n"\
+        f"# 1. Browser öffnen: http://{host}:9001/hermes-ui\n"\
+        f"#    (MC2-Proxy auf dem Gateway)\n"\
+        f"#\n"\
+        f"# 2. Session-Token: auf der Box liegen in\n"\
+        f"#    ~/.hermes/desktop-gateway-token\n"\
+        f"#    (den Dateiname kopieren, den TOKEN-WERT NICHT hardcoden!)\n"\
+        f"#\n"\
+        f"# 3. Token im Browser-Login einfügen — fertig.\n"\
+        f"#\n"\
+        f"# Modelle im Hermes Desktop: {PRIMARY_MODEL} (bauen), heavy (denken), vision (Bilder)."
+    )
 
     # Claude Code spricht das Anthropic-Format; der Gateway ist OpenAI-kompatibel und
     # bietet KEIN /v1/messages (verifiziert). Daher braucht es einen kleinen Übersetzer
@@ -90,12 +80,12 @@ def build_snippets(host: str = DEFAULT_HOST,
         f"# und hat kein /v1/messages. Dazwischen muss ein Übersetzer (Anthropic ⇄ OpenAI) laufen:\n"
         f"#   • claude-code-router   (leichtgewichtig, npm)\n"
         f"#   • oder LiteLLM mit /v1/messages-Bridge\n"
-        f"# Den Übersetzer auf den Gateway zeigen lassen: baseURL={gw}, model=coding, apiKey=local.\n"
+        f"# Den Übersetzer auf den Gateway zeigen lassen: baseURL={gw}, model=coder, apiKey=local.\n"
         f"# Dann Claude Code auf den lokalen Übersetzer richten (Beispiel-Port 3456):\n"
         f"\n"
         f'export ANTHROPIC_BASE_URL="http://localhost:3456"\n'
         f'export ANTHROPIC_AUTH_TOKEN="local"\n'
-        f'export ANTHROPIC_MODEL="coding"'
+        f'export ANTHROPIC_MODEL="coder"'
     )
 
     memory_mcp = json.dumps({
@@ -112,20 +102,21 @@ def build_snippets(host: str = DEFAULT_HOST,
         "host": host,
         "gateway_url": gw,
         "mc_url": mc_url,
-        # Leitung 1 — das MODELL. Alle Snippets zeigen auf den OpenAI-kompatiblen Gateway.
+        # Leitung 1 — das MODELL. Bewusst NUR 3 Tools (Verdikt 09.07.2026): Hermes Desktop
+        # (Remote-IDE im Browser), Kilo Code (VS-Code-Fallback mit Orchestrator-Modus),
+        # Claude Code (starke Sessions).
+        # Cursor/Continue/Roo/OpenCode entfernt — Roo eingestellt, Rest cloud-first, Terminal
+        # oder von Kilo abgedeckt. Das Evolution-Radar (AUTONOMIE_PLAN E4) überwacht die Kategorie.
         "tools": {
-            "cline": {"label": "Roo Code / Cline", "lang": "json", "snippet": cline,
-                      "note": "OpenAI-Provider → Gateway. Nur Lane 'coding' — die Box routet intern selbst."},
-            "cursor": {"label": "Cursor", "lang": "json", "snippet": cursor,
-                       "note": "Einstellungen ➔ Models ➔ OpenAI API key + Base URL."},
-            "opencode": {"label": "OpenCode", "lang": "jsonc", "snippet": opencode,
-                         "note": "Datei opencode.jsonc, Key 'provider'."},
-            "zed": {"label": "Zed", "lang": "json", "snippet": zed,
-                    "note": "settings.json → language_models.openai_compatible."},
-            "continue": {"label": "Continue", "lang": "json", "snippet": cont,
-                         "note": "~/.continue/config.json (oder config.yaml mit identischen Keys)."},
+            "hermes_desktop": {"label": "Hermes Desktop (empfohlen)", "lang": "bash", "snippet": hermes_desktop,
+                    "note": "Remote-IDE im Browser — Gateway-URL + Token aus Datei laden. Drei Modelle: "
+                            "Coder (bauen) · Planer (denken) · Augen (Bilder) — oben im Wähler umschalten."},
+            "kilo": {"label": "Kilo Code", "lang": "json", "snippet": kilo,
+                     "note": "VS Code/JetBrains (schwergewichtiger). OpenAI-Provider → Gateway. "
+                             "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": "Braucht einen Anthropic⇄OpenAI-Übersetzer vor dem Gateway."},
+                            "note": "Für die starken Sessions. Lokal-Betrieb bräuchte einen Anthropic⇄OpenAI-Übersetzer vor dem Gateway; Gedächtnis-Anbindung via Memory-MCP unten."},
         },
         # 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,
@@ -134,18 +125,20 @@ def build_snippets(host: str = DEFAULT_HOST,
 
 
 def check_health() -> dict:
-    """Live-Erreichbarkeit der beiden Leitungen, aus Sicht der Box:
-    Leitung 1 = Gateway/Engine (llama-swap), Leitung 2 = Gedächtnis-Sidecar (Mem0)."""
+    """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),
+    Leitung 3 = Desktop-Gateway (Hermes-Builtin-UI)."""
     gateway = {"ok": False, "detail": "nicht erreichbar"}
     try:
         with httpx.Client(timeout=3.0) as c:
-            r = c.get(f"{LLAMA_SWAP_URL}/v1/models")
+            r = c.get(f"{V1_UPSTREAM or LLAMA_SWAP_URL}/v1/models")
             if r.status_code == 200:
                 n = len(r.json().get("data", []))
                 gateway = {"ok": True, "detail": f"{n} Modelle verfügbar" if n else "bereit"}
             else:
                 gateway = {"ok": False, "detail": f"HTTP {r.status_code}"}
-    except Exception:  # noqa: BLE001
+    except Exception:
         pass
 
     memory = {"ok": False, "detail": "nicht erreichbar"}
@@ -154,7 +147,16 @@ def check_health() -> dict:
             r = c.get(f"{MEM0_SERVICE_URL}/health")
             memory = ({"ok": True, "detail": "bereit"} if r.status_code == 200
                       else {"ok": False, "detail": f"HTTP {r.status_code}"})
-    except Exception:  # noqa: BLE001
+    except Exception:
         pass
 
-    return {"gateway": gateway, "memory": memory}
+    desktop_gateway = {"ok": False, "detail": "nicht erreichbar"}
+    try:
+        with httpx.Client(timeout=3.0) as c:
+            r = c.get(f"{HERMES_BUILTIN_UI_UPSTREAM}/api/status")
+            desktop_gateway = ({"ok": True, "detail": "bereit"} if r.status_code == 200
+                               else {"ok": False, "detail": f"HTTP {r.status_code}"})
+    except Exception:
+        pass
+
+    return {"gateway": gateway, "memory": memory, "desktop_gateway": desktop_gateway}

backend/services/discover.py

@@ -1,179 +1,178 @@
-"""
-Automatische Modell-Entdeckung ("aktuell beste Modelle"): fragt vertrauenswürdige
-HF-Orgs live ab, kategorisiert per Stichwort, rankt nach Hardware-Fit + Beliebtheit
-und cached. Portiert aus Mission Control v1 (cookbook.py-Discover).
-
-Wichtig (Greenfield-Fix gegen v1): EIN gemeinsamer Ranking-Helfer `rank_runnable`
-ist die Quelle der Wahrheit — sowohl die „beste Empfehlung" je Kategorie als auch
-spätere Auto-Setups nutzen ihn, damit sie nie auseinanderlaufen.
-"""
-
-import json
-import math
-import os
-import time
-from datetime import datetime
-
-import httpx
-
-import logging
-
-from config import DISCOVER_CACHE_PATH, DISCOVER_TTL
-from services import catalog
-from services.caps import capabilities
-from services.fit import evaluate_fit, extract_params_b, max_ctx_for
-from services.sources import CATEGORIES, SKIP_TOKENS, TRUSTED_AUTHORS
-
-log = logging.getLogger(__name__)
-
-_FIT_ORDER = {"perfect": 0, "marginal": 1, "too_tight": 2}
-
-
-def _categorize(repo_id: str) -> str:
-    low = repo_id.lower()
-    for cat in CATEGORIES:
-        if any(k in low for k in cat["kw"]):
-            return cat["role"]
-    return "scout"
-
-
-def _fetch_author_models(author: str) -> list:
-    url = (f"https://huggingface.co/api/models?author={author}"
-           f"&filter=gguf&sort=downloads&direction=-1&limit=40")
-    try:
-        with httpx.Client(timeout=12.0) as c:
-            data = c.get(url).json()
-        return data if isinstance(data, list) else []
-    except Exception:
-        log.debug("discover: Abfrage für Autor %s fehlgeschlagen", author, exc_info=True)
-        return []
-
-
-def _age_days(last_modified, now_ts: float) -> float:
-    """Alter eines HF-Modells in Tagen (lastModified ISO). Unbekannt → ~1.5 Jahre."""
-    if not last_modified:
-        return 540.0
-    try:
-        dt = datetime.fromisoformat(str(last_modified).replace("Z", "+00:00"))
-        return max((now_ts - dt.timestamp()) / 86400.0, 0.0)
-    except Exception:
-        return 540.0
-
-
-def _score(m: dict, now_ts: float) -> float:
-    """Zukunftssicherer Rang-Score für DIESE Hardware. Kombiniert:
-    - Fit: perfect dominiert (Bonus 3.0 > Summe der übrigen Terme → passt-komfortabel zuerst),
-    - Recency: neuere Generationen bevorzugt (Halbwertszeit ~9 Monate über lastModified),
-    - Capability: mehr Parameter (log-skaliert),
-    - Popularity: Downloads (log-skaliert).
-    So gewinnt bei vergleichbarer Größe die NEUERE Generation (z.B. Qwen3-Coder vor
-    Qwen2.5-Coder), ohne dass kleine Populär-Modelle große verdrängen."""
-    fit_bonus = 3.0 if m["fit"]["level"] == "perfect" else 0.0
-    recency = 0.5 ** (_age_days(m.get("lastModified"), now_ts) / 270.0)
-    cap = math.log2(max(float(m.get("params_b") or 1.0), 1.0) + 1.0) / 8.0
-    pop = math.log10(float(m.get("downloads") or 0) + 1.0) / 7.0
-    return fit_bonus + 1.2 * recency + 1.2 * cap + 0.5 * pop
-
-
-def rank_runnable(models: list[dict]) -> list[dict]:
-    """EINE Quelle der Wahrheit fürs Ranking lauffähiger Modelle für DIESE Hardware.
-    Nur was passt (too_tight fliegt raus), dann nach `_score` (Fit + Recency + Capability
-    + Popularity). Bevorzugt neuere, fähige Modelle → zukunftssicher; „Modelle finden"
-    schlägt nie ein Downgrade vor (Downgrade-Sperre zusätzlich in maintenance)."""
-    now_ts = time.time()
-    return sorted(
-        [m for m in models if m["fit"]["level"] != "too_tight"],
-        key=lambda m: -_score(m, now_ts),
-    )
-
-
-def refresh_discover(ram_gb: float) -> dict:
-    """Quellen live abfragen, kategorisieren, ranken, cachen. Wirft nur, wenn KEINE
-    Quelle erreichbar war."""
-    raw, seen, ok = [], set(), 0
-    for author in TRUSTED_AUTHORS:
-        models = _fetch_author_models(author)
-        if models:
-            ok += 1
-        for m in models:
-            rid = m.get("id")
-            if not rid or rid in seen:
-                continue
-            seen.add(rid)
-            raw.append(m)
-    if ok == 0 and not catalog.entries():
-        raise RuntimeError("Keine Quelle erreichbar.")
-
-    by_cat: dict[str, list] = {c["role"]: [] for c in CATEGORIES}
-    for m in raw:
-        rid = m["id"]
-        low = rid.lower()
-        if any(tok in low for tok in SKIP_TOKENS):
-            continue
-        role = _categorize(rid)
-        params_b = extract_params_b(rid)
-        quant = "Q4_K_M"  # Referenz-Quant für die Fit-Einschätzung
-        fit = evaluate_fit(params_b, quant, 8192, ram_gb, name=rid)
-        tags = [str(t) for t in (m.get("tags") or [])]
-        by_cat[role].append({
-            "name": rid.split("/")[-1], "author": rid.split("/")[0], "repo": rid,
-            "role": role, "params_b": params_b, "quant": quant, "tags": tags,
-            "downloads": int(m.get("downloads") or 0), "likes": int(m.get("likes") or 0),
-            "lastModified": m.get("lastModified"),
-            "fit": fit, "optimal_ctx": max_ctx_for(params_b, quant, ram_gb),
-            "caps": capabilities(name=rid, hf={"tags": tags}),
-        })
-
-    cats = []
-    for c in CATEGORIES:
-        role = c["role"]
-        # 1) KATALOG zuerst (kuratierte, korrekte Metadaten, MoE-bewusst gerankt) —
-        #    macht die Empfehlung präzise statt Namens-Raterei.
-        cat_entries = sorted(catalog.entries_for_role(role),
-                             key=lambda e: -catalog.stack_score(e, ram_gb))
-        cat_models = [m for m in (catalog.to_model_dict(e, ram_gb) for e in cat_entries)
-                      if m["fit"]["level"] != "too_tight"]
-        # 2) HF-Dynamik als Ergänzung (nicht-kuratierte Funde), dedupliziert.
-        hf_ranked = rank_runnable(by_cat[role])
-        seen = {catalog._norm(m["repo"]) for m in cat_models}
-        extra = [h for h in hf_ranked if catalog._norm(h["repo"]) not in seen]
-        combined = cat_models + extra
-        if combined:
-            cats.append({
-                "role": role, "title": c["title"], "icon": c["icon"],
-                "models": combined[:6],
-                # Empfehlung = bester KURATIERTER Eintrag, sonst beste HF-Fundstelle.
-                "recommended": (cat_models[0]["repo"] if cat_models
-                                else (hf_ranked[0]["repo"] if hf_ranked else None)),
-            })
-
-    data = {"updated": time.time(), "categories": cats}
-    try:
-        DISCOVER_CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
-        tmp = DISCOVER_CACHE_PATH.with_name(DISCOVER_CACHE_PATH.name + ".tmp")
-        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-        os.replace(tmp, DISCOVER_CACHE_PATH)
-    except Exception:
-        log.debug("discover: Cache-Schreiben fehlgeschlagen (nur Beschleunigung)", exc_info=True)
-    return data
-
-
-def load_discover() -> dict | None:
-    try:
-        if DISCOVER_CACHE_PATH.exists():
-            return json.loads(DISCOVER_CACHE_PATH.read_text(encoding="utf-8"))
-    except Exception:
-        log.debug("discover: Cache-Lesen fehlgeschlagen", exc_info=True)
-    return None
-
-
-def safe_discover(ram_gb: float) -> dict | None:
-    """Aus Cache (wenn frisch) oder live; wirft nie — None wenn nichts da."""
-    cached = load_discover()
-    if cached and (time.time() - cached.get("updated", 0) < DISCOVER_TTL):
-        return cached
-    try:
-        return refresh_discover(ram_gb)
-    except Exception:
-        log.warning("discover: Live-Refresh fehlgeschlagen, nutze Cache", exc_info=True)
-        return cached
+"""
+Automatische Modell-Entdeckung ("aktuell beste Modelle"): fragt vertrauenswürdige
+HF-Orgs live ab, kategorisiert per Stichwort, rankt nach Hardware-Fit + Beliebtheit
+und cached. Portiert aus Mission Control v1 (cookbook.py-Discover).
+
+Wichtig (Greenfield-Fix gegen v1): EIN gemeinsamer Ranking-Helfer `rank_runnable`
+ist die Quelle der Wahrheit — sowohl die „beste Empfehlung" je Kategorie als auch
+spätere Auto-Setups nutzen ihn, damit sie nie auseinanderlaufen.
+"""
+
+import json
+import logging
+import math
+import os
+import time
+from datetime import datetime
+
+import httpx
+from config import DISCOVER_CACHE_PATH, DISCOVER_TTL
+
+from services import catalog
+from services.caps import capabilities
+from services.fit import evaluate_fit, extract_params_b, max_ctx_for
+from services.sources import CATEGORIES, SKIP_TOKENS, TRUSTED_AUTHORS
+
+log = logging.getLogger(__name__)
+
+_FIT_ORDER = {"perfect": 0, "marginal": 1, "too_tight": 2}
+
+
+def _categorize(repo_id: str) -> str:
+    low = repo_id.lower()
+    for cat in CATEGORIES:
+        if any(k in low for k in cat["kw"]):
+            return cat["role"]
+    return "scout"
+
+
+def _fetch_author_models(author: str) -> list:
+    url = (f"https://huggingface.co/api/models?author={author}"
+           f"&filter=gguf&sort=downloads&direction=-1&limit=40")
+    try:
+        with httpx.Client(timeout=12.0) as c:
+            data = c.get(url).json()
+        return data if isinstance(data, list) else []
+    except Exception:
+        log.debug("discover: Abfrage für Autor %s fehlgeschlagen", author, exc_info=True)
+        return []
+
+
+def _age_days(last_modified, now_ts: float) -> float:
+    """Alter eines HF-Modells in Tagen (lastModified ISO). Unbekannt → ~1.5 Jahre."""
+    if not last_modified:
+        return 540.0
+    try:
+        dt = datetime.fromisoformat(str(last_modified).replace("Z", "+00:00"))
+        return max((now_ts - dt.timestamp()) / 86400.0, 0.0)
+    except Exception:
+        return 540.0
+
+
+def _score(m: dict, now_ts: float) -> float:
+    """Zukunftssicherer Rang-Score für DIESE Hardware. Kombiniert:
+    - Fit: perfect dominiert (Bonus 3.0 > Summe der übrigen Terme → passt-komfortabel zuerst),
+    - Recency: neuere Generationen bevorzugt (Halbwertszeit ~9 Monate über lastModified),
+    - Capability: mehr Parameter (log-skaliert),
+    - Popularity: Downloads (log-skaliert).
+    So gewinnt bei vergleichbarer Größe die NEUERE Generation (z.B. Qwen3-Coder vor
+    Qwen2.5-Coder), ohne dass kleine Populär-Modelle große verdrängen."""
+    fit_bonus = 3.0 if m["fit"]["level"] == "perfect" else 0.0
+    recency = 0.5 ** (_age_days(m.get("lastModified"), now_ts) / 270.0)
+    cap = math.log2(max(float(m.get("params_b") or 1.0), 1.0) + 1.0) / 8.0
+    pop = math.log10(float(m.get("downloads") or 0) + 1.0) / 7.0
+    return fit_bonus + 1.2 * recency + 1.2 * cap + 0.5 * pop
+
+
+def rank_runnable(models: list[dict]) -> list[dict]:
+    """EINE Quelle der Wahrheit fürs Ranking lauffähiger Modelle für DIESE Hardware.
+    Nur was passt (too_tight fliegt raus), dann nach `_score` (Fit + Recency + Capability
+    + Popularity). Bevorzugt neuere, fähige Modelle → zukunftssicher; „Modelle finden"
+    schlägt nie ein Downgrade vor (Downgrade-Sperre zusätzlich in maintenance)."""
+    now_ts = time.time()
+    return sorted(
+        [m for m in models if m["fit"]["level"] != "too_tight"],
+        key=lambda m: -_score(m, now_ts),
+    )
+
+
+def refresh_discover(ram_gb: float) -> dict:
+    """Quellen live abfragen, kategorisieren, ranken, cachen. Wirft nur, wenn KEINE
+    Quelle erreichbar war."""
+    raw, seen, ok = [], set(), 0
+    for author in TRUSTED_AUTHORS:
+        models = _fetch_author_models(author)
+        if models:
+            ok += 1
+        for m in models:
+            rid = m.get("id")
+            if not rid or rid in seen:
+                continue
+            seen.add(rid)
+            raw.append(m)
+    if ok == 0 and not catalog.entries():
+        raise RuntimeError("Keine Quelle erreichbar.")
+
+    by_cat: dict[str, list] = {c["role"]: [] for c in CATEGORIES}
+    for m in raw:
+        rid = m["id"]
+        low = rid.lower()
+        if any(tok in low for tok in SKIP_TOKENS):
+            continue
+        role = _categorize(rid)
+        params_b = extract_params_b(rid)
+        quant = "Q4_K_M"  # Referenz-Quant für die Fit-Einschätzung
+        fit = evaluate_fit(params_b, quant, 8192, ram_gb, name=rid)
+        tags = [str(t) for t in (m.get("tags") or [])]
+        by_cat[role].append({
+            "name": rid.split("/")[-1], "author": rid.split("/")[0], "repo": rid,
+            "role": role, "params_b": params_b, "quant": quant, "tags": tags,
+            "downloads": int(m.get("downloads") or 0), "likes": int(m.get("likes") or 0),
+            "lastModified": m.get("lastModified"),
+            "fit": fit, "optimal_ctx": max_ctx_for(params_b, quant, ram_gb),
+            "caps": capabilities(name=rid, hf={"tags": tags}),
+        })
+
+    cats = []
+    for c in CATEGORIES:
+        role = c["role"]
+        # 1) KATALOG zuerst (kuratierte, korrekte Metadaten, MoE-bewusst gerankt) —
+        #    macht die Empfehlung präzise statt Namens-Raterei.
+        cat_entries = sorted(catalog.entries_for_role(role),
+                             key=lambda e: -catalog.stack_score(e, ram_gb))
+        cat_models = [m for m in (catalog.to_model_dict(e, ram_gb) for e in cat_entries)
+                      if m["fit"]["level"] != "too_tight"]
+        # 2) HF-Dynamik als Ergänzung (nicht-kuratierte Funde), dedupliziert.
+        hf_ranked = rank_runnable(by_cat[role])
+        seen = {catalog._norm(m["repo"]) for m in cat_models}
+        extra = [h for h in hf_ranked if catalog._norm(h["repo"]) not in seen]
+        combined = cat_models + extra
+        if combined:
+            cats.append({
+                "role": role, "title": c["title"], "icon": c["icon"],
+                "models": combined[:6],
+                # Empfehlung = bester KURATIERTER Eintrag, sonst beste HF-Fundstelle.
+                "recommended": (cat_models[0]["repo"] if cat_models
+                                else (hf_ranked[0]["repo"] if hf_ranked else None)),
+            })
+
+    data = {"updated": time.time(), "categories": cats}
+    try:
+        DISCOVER_CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+        tmp = DISCOVER_CACHE_PATH.with_name(DISCOVER_CACHE_PATH.name + ".tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        os.replace(tmp, DISCOVER_CACHE_PATH)
+    except Exception:
+        log.debug("discover: Cache-Schreiben fehlgeschlagen (nur Beschleunigung)", exc_info=True)
+    return data
+
+
+def load_discover() -> dict | None:
+    try:
+        if DISCOVER_CACHE_PATH.exists():
+            return json.loads(DISCOVER_CACHE_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        log.debug("discover: Cache-Lesen fehlgeschlagen", exc_info=True)
+    return None
+
+
+def safe_discover(ram_gb: float) -> dict | None:
+    """Aus Cache (wenn frisch) oder live; wirft nie — None wenn nichts da."""
+    cached = load_discover()
+    if cached and (time.time() - cached.get("updated", 0) < DISCOVER_TTL):
+        return cached
+    try:
+        return refresh_discover(ram_gb)
+    except Exception:
+        log.warning("discover: Live-Refresh fehlgeschlagen, nutze Cache", exc_info=True)
+        return cached

backend/services/gateway.py

@@ -1,10 +1,12 @@
 """
-Routing-Gateway-Status (eingebauter Modus). MC2 IST der Gateway: serviert
-`/v1/*` mit `model: auto`-Komplexitäts-Routing vor llama-swap. Kein externer
-LiteLLM-Dienst nötig (baut auf Python 3.14 nicht); bleibt später austauschbar.
+Routing-Gateway-Status. Seit UMBAU v3 P1 bedient der EIGENSTÄNDIGE mc2-gateway-
+Prozess den /v1-Pfad (MC_V1_UPSTREAM gesetzt, MC2 reicht nur roh durch); ohne
+V1_UPSTREAM gilt der alte eingebaute Modus (MC2 serviert /v1 selbst).
 """
 
-from config import PORT
+import httpx
+from config import PORT, V1_UPSTREAM
+
 from services.llamaswap import engine_reachable
 from services.routing_policy import load_policy
 
@@ -13,7 +15,7 @@ def routing_summary() -> dict:
     p = load_policy()
     coding_default = p["coder_lite"] or p["coder"]
     return {
-        "mode": "builtin",
+        "mode": "gateway (eigener Prozess)" if V1_UPSTREAM else "builtin",
         "endpoint": f":{PORT}/v1  (OpenAI-kompatibel)",
         # Virtuelle Lanes, die Clients/IDEs als „Modell" wählen (Router pickt das echte Alias).
         "lanes": [
@@ -42,5 +44,13 @@ def routing_summary() -> dict:
 
 
 def gateway_reachable() -> bool:
-    # Der eingebaute Gateway lebt in MC und proxyt llama-swap → erreichbar, wenn Engine läuft.
+    """Erreichbarkeit des ECHTEN Denkpfads. Mit V1_UPSTREAM ist das der eigenständige
+    mc2-gateway-Prozess (:9010) — vorher meldete diese Funktion nur die Engine, d. h.
+    ein toter Gateway blieb in Health/Diensten/Cockpit unsichtbar (Review 15.07.)."""
+    if V1_UPSTREAM:
+        try:
+            return httpx.get(f"{V1_UPSTREAM}/v1/models", timeout=2.0).status_code == 200
+        except Exception:
+            return False
+    # Eingebauter Modus: der Gateway lebt in MC selbst und proxyt llama-swap.
     return engine_reachable()

backend/services/gateway_stream.py

@@ -1,41 +1,78 @@
-"""Token-Erfassung für den Builtin-Gateway.
-
-Parst die `usage`-Felder aus llama-swap-Antworten (Stream + Non-Stream) und meldet
-sie an token_stats. Hält den gateway_proxy-Router dünn und ersetzt die zuvor inline
-verstreute, still scheiternde String-Suche durch einen testbaren SSE-Zeilenparser.
-"""
-
-import json
-import logging
-
-from services.token_stats import increment_tokens
-
-log = logging.getLogger(__name__)
-
-
-def record_usage(usage: dict | None, model: str) -> None:
-    """Ein usage-Objekt verbuchen (no-op bei None/leer)."""
-    if not usage:
-        return
-    prompt = usage.get("prompt_tokens", 0)
-    completion = usage.get("completion_tokens", 0)
-    if prompt or completion:
-        increment_tokens(prompt, completion, model=model)
-
-
-def record_stream_chunk(chunk: bytes, model: str) -> None:
-    """Rohen SSE-Chunk auf `usage` prüfen und Tokens verbuchen. Fehler werden
-    geloggt (debug) statt verschluckt — ein defekter Chunk bricht den Stream nicht."""
-    if b'"usage"' not in chunk:
-        return
-    text = chunk.decode("utf-8", errors="ignore")
-    for line in text.splitlines():
-        if not line.startswith("data:"):
-            continue
-        data_str = line[5:].strip()
-        if not data_str or data_str == "[DONE]":
-            continue
-        try:
-            record_usage(json.loads(data_str).get("usage"), model)
-        except json.JSONDecodeError:
-            log.debug("gateway stream: usage-Parsing fehlgeschlagen: %s", data_str[:120])
+"""Token-Erfassung für den Builtin-Gateway.
+
+Parst die `usage`-Felder aus llama-swap-Antworten (Stream + Non-Stream) und meldet
+sie an token_stats. Hält den gateway_proxy-Router dünn und ersetzt die zuvor inline
+verstreute, still scheiternde String-Suche durch einen testbaren SSE-Zeilenparser.
+"""
+
+import json
+import logging
+import time
+
+from services.token_stats import increment_tokens
+
+log = logging.getLogger(__name__)
+
+# Kontext-Limit-Warnung (User-Wunsch 15.07.: „es sollte eine Warnung geben — Kontext ist
+# nicht unendlich"): finish_reason=length heißt, eine Antwort ist am Token-/Kontext-Budget
+# ABGERISSEN — bei Nacht-Workern stirbt damit still die halbe Arbeit (4 Worker am 15.07.).
+# Statt still: Eintrag in den Briefkasten (silent → Chronik/Panel, kein Sprach-Spam),
+# je Modell höchstens alle 10 min. Läuft im mc2-gateway-Prozess → announce liefert per
+# MC_ANNOUNCE_HTTP beim Steuerpult ab (Unit-Env), nie direkt in die Store-Datei.
+_trunc_last: dict[str, float] = {}
+_TRUNC_EVERY = 600.0  # s
+
+# Warm-Pings (Lucys Augen-Wärmer alle 10 min, warmup.sh, models/load) halten Modelle
+# ABSICHTLICH mit max_tokens=1 warm — deren finish_reason=length ist konstruktionsbedingt
+# und kein abgerissener Worker (Fehlalarm-Serie 16.07. abends, ~alle 20 min im Briefkasten).
+# Wer freiwillig so knapp deckelt, will keine echte Antwort → keine Warnung.
+_PING_MAXTOK = 16
+
+
+def warn_truncation(model: str, max_tokens: int | None = None) -> None:
+    if isinstance(max_tokens, int) and max_tokens <= _PING_MAXTOK:
+        return
+    now = time.time()
+    if now - _trunc_last.get(model, 0.0) < _TRUNC_EVERY:
+        return
+    _trunc_last[model] = now
+    log.warning("gateway: finish_reason=length bei %s — Antwort am Kontext-/Token-Limit abgerissen", model)
+    try:
+        from services import announce
+        announce.add(
+            f"Eine Antwort von „{model}“ ist am Token-/Kontext-Limit abgerissen "
+            f"(finish_reason=length). War das ein Nacht-Worker, ist seine Aufgabe zu groß "
+            f"geschnitten — besser in Etappen teilen (eine Etappe = ein Worker-Lauf).",
+            "[Kontext-Limit]", "gateway", "silent")
+    except Exception:
+        log.warning("gateway: Kontext-Limit-Warnung nicht zustellbar", exc_info=True)
+
+
+def record_usage(usage: dict | None, model: str) -> None:
+    """Ein usage-Objekt verbuchen (no-op bei None/leer)."""
+    if not usage:
+        return
+    prompt = usage.get("prompt_tokens", 0)
+    completion = usage.get("completion_tokens", 0)
+    if prompt or completion:
+        increment_tokens(prompt, completion, model=model)
+
+
+def record_stream_chunk(chunk: bytes, model: str, max_tokens: int | None = None) -> None:
+    """Rohen SSE-Chunk auf `usage` prüfen und Tokens verbuchen. Fehler werden
+    geloggt (debug) statt verschluckt — ein defekter Chunk bricht den Stream nicht."""
+    if b'"finish_reason":"length"' in chunk or b'"finish_reason": "length"' in chunk:
+        warn_truncation(model, max_tokens)
+    if b'"usage"' not in chunk:
+        return
+    text = chunk.decode("utf-8", errors="ignore")
+    for line in text.splitlines():
+        if not line.startswith("data:"):
+            continue
+        data_str = line[5:].strip()
+        if not data_str or data_str == "[DONE]":
+            continue
+        try:
+            record_usage(json.loads(data_str).get("usage"), model)
+        except json.JSONDecodeError:
+            log.debug("gateway stream: usage-Parsing fehlgeschlagen: %s", data_str[:120])

backend/services/gguf_meta.py

@@ -1,161 +1,266 @@
-"""
-GGUF-Tokenizer-Fingerprint — liest die Tokenizer-Identität direkt aus dem
-GGUF-Header (ohne das Modell zu laden), um zu entscheiden, ob ein Draft-Modell
-**vocab-kompatibel** mit einem Ziel-Modell ist (Voraussetzung für Speculative
-Decoding in llama.cpp — sonst: "draft model vocab type must match target").
-
-Wir lesen nur die Metadaten-KV-Sektion am Dateianfang und brechen ab, sobald
-`tokenizer.ggml.tokens` erreicht ist (dessen Länge = n_vocab). model+pre+n_vocab
-identifizieren den Tokenizer eindeutig genug, um die in der Praxis relevanten
-Fälle zu unterscheiden (Qwen2.5 vs Qwen3 vs Qwen3.6 etc.). Die llama.cpp-Prüfung
-beim Laden bleibt der letzte Schiedsrichter.
-"""
-
-import hashlib
-import struct
-from functools import lru_cache
-
-# GGUF value types (https://github.com/ggml-org/ggml/blob/master/docs/gguf.md)
-_T_UINT8, _T_INT8, _T_UINT16, _T_INT16, _T_UINT32, _T_INT32, _T_FLOAT32, \
-    _T_BOOL, _T_STRING, _T_ARRAY, _T_UINT64, _T_INT64, _T_FLOAT64 = range(13)
-
-_SCALAR_FMT = {
-    _T_UINT8: "<B", _T_INT8: "<b", _T_UINT16: "<H", _T_INT16: "<h",
-    _T_UINT32: "<I", _T_INT32: "<i", _T_FLOAT32: "<f", _T_BOOL: "<?",
-    _T_UINT64: "<Q", _T_INT64: "<q", _T_FLOAT64: "<d",
-}
-_SCALAR_SIZE = {t: struct.calcsize(f) for t, f in _SCALAR_FMT.items()}
-
-_WANT_STRINGS = {"tokenizer.ggml.model", "tokenizer.ggml.pre", "general.architecture"}
-
-
-class _Reader:
-    def __init__(self, f):
-        self.f = f
-
-    def read(self, n: int) -> bytes:
-        b = self.f.read(n)
-        if len(b) != n:
-            raise EOFError("unerwartetes Dateiende beim GGUF-Parsen")
-        return b
-
-    def u32(self) -> int:
-        return struct.unpack("<I", self.read(4))[0]
-
-    def u64(self) -> int:
-        return struct.unpack("<Q", self.read(8))[0]
-
-    def gstr(self) -> str:
-        n = self.u64()
-        return self.read(n).decode("utf-8", "replace")
-
-    def skip_value(self, vtype: int) -> None:
-        """Liest einen Wert und verwirft ihn (um den Datei-Pointer korrekt
-        weiterzuschieben). Arrays werden elementweise konsumiert."""
-        if vtype == _T_STRING:
-            self.f.seek(self.u64(), 1)
-        elif vtype in _SCALAR_SIZE:
-            self.f.seek(_SCALAR_SIZE[vtype], 1)
-        elif vtype == _T_ARRAY:
-            etype = self.u32()
-            count = self.u64()
-            if etype == _T_STRING:
-                for _ in range(count):
-                    self.f.seek(self.u64(), 1)
-            elif etype in _SCALAR_SIZE:
-                self.f.seek(_SCALAR_SIZE[etype] * count, 1)
-            else:
-                raise ValueError(f"unbekannter Array-Elementtyp {etype}")
-        else:
-            raise ValueError(f"unbekannter GGUF-Wertetyp {vtype}")
-
-
-def _read_fingerprint(path: str) -> dict | None:
-    """Liest model/pre/n_vocab aus dem GGUF-Header. None bei Fehler/kein GGUF."""
-    try:
-        with open(path, "rb") as fh:
-            r = _Reader(fh)
-            if r.read(4) != b"GGUF":
-                return None
-            r.u32()                 # version
-            r.u64()                 # tensor_count
-            kv_count = r.u64()
-            fp: dict = {"model": None, "pre": None, "arch": None, "n_vocab": None,
-                        "tokens_sha": None}
-            for _ in range(kv_count):
-                key = r.gstr()
-                vtype = r.u32()
-                if key == "tokenizer.ggml.tokens" and vtype == _T_ARRAY:
-                    etype = r.u32()
-                    count = r.u64()
-                    fp["n_vocab"] = count
-                    if etype != _T_STRING:
-                        return None
-                    # ECHTE Vocab-Identität: sha256 über die tatsächliche Token-Liste
-                    # (familienunabhängig — funktioniert für Qwen, Llama, Mistral, …).
-                    h = hashlib.sha256()
-                    h.update(count.to_bytes(8, "little"))
-                    for _ in range(count):
-                        n = r.u64()
-                        h.update(r.read(n))
-                    fp["tokens_sha"] = h.hexdigest()
-                    # model/pre kommen vor tokens → wir haben alles. Abbrechen.
-                    break
-                if key in _WANT_STRINGS and vtype == _T_STRING:
-                    val = r.gstr()
-                    if key == "tokenizer.ggml.model":
-                        fp["model"] = val
-                    elif key == "tokenizer.ggml.pre":
-                        fp["pre"] = val
-                    else:
-                        fp["arch"] = val
-                else:
-                    r.skip_value(vtype)
-            if fp["model"] is None and fp["n_vocab"] is None:
-                return None
-            return fp
-    except (OSError, EOFError, ValueError, struct.error):
-        return None
-
-
-@lru_cache(maxsize=256)
-def _cached(path: str, mtime: float, size: int) -> tuple | None:
-    fp = _read_fingerprint(path)
-    if fp is None:
-        return None
-    return (fp.get("model"), fp.get("pre"), fp.get("n_vocab"), fp.get("arch"), fp.get("tokens_sha"))
-
-
-def fingerprint(path: str) -> dict | None:
-    """Tokenizer-Fingerprint eines GGUF (gecacht nach Pfad+mtime+size).
-    Returns dict(model, pre, n_vocab, arch, tokens_sha) oder None wenn nicht lesbar."""
-    import os
-    try:
-        st = os.stat(path)
-    except OSError:
-        return None
-    t = _cached(path, st.st_mtime, st.st_size)
-    if t is None:
-        return None
-    return {"model": t[0], "pre": t[1], "n_vocab": t[2], "arch": t[3], "tokens_sha": t[4]}
-
-
-def vocab_key(path: str) -> tuple | None:
-    """ECHTER Vergleichsschlüssel für Vocab-Kompatibilität: (model, pre, n_vocab, sha256
-    der vollständigen Token-Liste). Vergleicht den TATSÄCHLICHEN Vokabular-Inhalt, nicht
-    nur Metadaten — familienunabhängig (Qwen, Llama, Mistral, …). Genau diese Identität
-    verlangt llama.cpp für Speculative Decoding."""
-    fp = fingerprint(path)
-    if not fp or fp["n_vocab"] is None or not fp.get("tokens_sha"):
-        return None
-    return (fp["model"], fp["pre"], fp["n_vocab"], fp["tokens_sha"])
-
-
-def compatible(target_path: str, draft_path: str) -> bool | None:
-    """True/False ob draft vocab-kompatibel zum target ist. None = unbestimmbar
-    (eine Datei nicht lesbar) → UI behandelt das als 'nicht bestätigt'."""
-    a = vocab_key(target_path)
-    b = vocab_key(draft_path)
-    if a is None or b is None:
-        return None
-    return a == b
+"""
+GGUF-Tokenizer-Fingerprint — liest die Tokenizer-Identität direkt aus dem
+GGUF-Header (ohne das Modell zu laden), um zu entscheiden, ob ein Draft-Modell
+**vocab-kompatibel** mit einem Ziel-Modell ist (Voraussetzung für Speculative
+Decoding in llama.cpp — sonst: "draft model vocab type must match target").
+
+Wir lesen nur die Metadaten-KV-Sektion am Dateianfang und brechen ab, sobald
+`tokenizer.ggml.tokens` erreicht ist (dessen Länge = n_vocab). model+pre+n_vocab
+identifizieren den Tokenizer eindeutig genug, um die in der Praxis relevanten
+Fälle zu unterscheiden (Qwen2.5 vs Qwen3 vs Qwen3.6 etc.). Die llama.cpp-Prüfung
+beim Laden bleibt der letzte Schiedsrichter.
+"""
+
+import hashlib
+import struct
+from functools import lru_cache
+
+# GGUF value types (https://github.com/ggml-org/ggml/blob/master/docs/gguf.md)
+_T_UINT8, _T_INT8, _T_UINT16, _T_INT16, _T_UINT32, _T_INT32, _T_FLOAT32, \
+    _T_BOOL, _T_STRING, _T_ARRAY, _T_UINT64, _T_INT64, _T_FLOAT64 = range(13)
+
+_SCALAR_FMT = {
+    _T_UINT8: "<B", _T_INT8: "<b", _T_UINT16: "<H", _T_INT16: "<h",
+    _T_UINT32: "<I", _T_INT32: "<i", _T_FLOAT32: "<f", _T_BOOL: "<?",
+    _T_UINT64: "<Q", _T_INT64: "<q", _T_FLOAT64: "<d",
+}
+_SCALAR_SIZE = {t: struct.calcsize(f) for t, f in _SCALAR_FMT.items()}
+
+_WANT_STRINGS = {"tokenizer.ggml.model", "tokenizer.ggml.pre", "general.architecture"}
+
+
+class _Reader:
+    def __init__(self, f):
+        self.f = f
+
+    def read(self, n: int) -> bytes:
+        b = self.f.read(n)
+        if len(b) != n:
+            raise EOFError("unerwartetes Dateiende beim GGUF-Parsen")
+        return b
+
+    def u32(self) -> int:
+        return struct.unpack("<I", self.read(4))[0]
+
+    def u64(self) -> int:
+        return struct.unpack("<Q", self.read(8))[0]
+
+    def gstr(self) -> str:
+        n = self.u64()
+        return self.read(n).decode("utf-8", "replace")
+
+    def scalar(self, vtype: int):
+        """Liest einen Skalar-Wert (für die Architektur-Metadaten). None bei Nicht-Skalar."""
+        fmt = _SCALAR_FMT.get(vtype)
+        if not fmt:
+            self.skip_value(vtype)
+            return None
+        return struct.unpack(fmt, self.read(_SCALAR_SIZE[vtype]))[0]
+
+    def skip_value(self, vtype: int) -> None:
+        """Liest einen Wert und verwirft ihn (um den Datei-Pointer korrekt
+        weiterzuschieben). Arrays werden elementweise konsumiert."""
+        if vtype == _T_STRING:
+            self.f.seek(self.u64(), 1)
+        elif vtype in _SCALAR_SIZE:
+            self.f.seek(_SCALAR_SIZE[vtype], 1)
+        elif vtype == _T_ARRAY:
+            etype = self.u32()
+            count = self.u64()
+            if etype == _T_STRING:
+                for _ in range(count):
+                    self.f.seek(self.u64(), 1)
+            elif etype in _SCALAR_SIZE:
+                self.f.seek(_SCALAR_SIZE[etype] * count, 1)
+            else:
+                raise ValueError(f"unbekannter Array-Elementtyp {etype}")
+        else:
+            raise ValueError(f"unbekannter GGUF-Wertetyp {vtype}")
+
+
+def _read_fingerprint(path: str) -> dict | None:
+    """Liest model/pre/n_vocab aus dem GGUF-Header. None bei Fehler/kein GGUF."""
+    try:
+        with open(path, "rb") as fh:
+            r = _Reader(fh)
+            if r.read(4) != b"GGUF":
+                return None
+            r.u32()                 # version
+            r.u64()                 # tensor_count
+            kv_count = r.u64()
+            fp: dict = {"model": None, "pre": None, "arch": None, "n_vocab": None,
+                        "tokens_sha": None}
+            for _ in range(kv_count):
+                key = r.gstr()
+                vtype = r.u32()
+                if key == "tokenizer.ggml.tokens" and vtype == _T_ARRAY:
+                    etype = r.u32()
+                    count = r.u64()
+                    fp["n_vocab"] = count
+                    if etype != _T_STRING:
+                        return None
+                    # ECHTE Vocab-Identität: sha256 über die tatsächliche Token-Liste
+                    # (familienunabhängig — funktioniert für Qwen, Llama, Mistral, …).
+                    h = hashlib.sha256()
+                    h.update(count.to_bytes(8, "little"))
+                    for _ in range(count):
+                        n = r.u64()
+                        h.update(r.read(n))
+                    fp["tokens_sha"] = h.hexdigest()
+                    # model/pre kommen vor tokens → wir haben alles. Abbrechen.
+                    break
+                if key in _WANT_STRINGS and vtype == _T_STRING:
+                    val = r.gstr()
+                    if key == "tokenizer.ggml.model":
+                        fp["model"] = val
+                    elif key == "tokenizer.ggml.pre":
+                        fp["pre"] = val
+                    else:
+                        fp["arch"] = val
+                else:
+                    r.skip_value(vtype)
+            if fp["model"] is None and fp["n_vocab"] is None:
+                return None
+            return fp
+    except (OSError, EOFError, ValueError, struct.error):
+        return None
+
+
+@lru_cache(maxsize=256)
+def _cached(path: str, mtime: float, size: int) -> tuple | None:
+    fp = _read_fingerprint(path)
+    if fp is None:
+        return None
+    return (fp.get("model"), fp.get("pre"), fp.get("n_vocab"), fp.get("arch"), fp.get("tokens_sha"))
+
+
+def fingerprint(path: str) -> dict | None:
+    """Tokenizer-Fingerprint eines GGUF (gecacht nach Pfad+mtime+size).
+    Returns dict(model, pre, n_vocab, arch, tokens_sha) oder None wenn nicht lesbar."""
+    import os
+    try:
+        st = os.stat(path)
+    except OSError:
+        return None
+    t = _cached(path, st.st_mtime, st.st_size)
+    if t is None:
+        return None
+    return {"model": t[0], "pre": t[1], "n_vocab": t[2], "arch": t[3], "tokens_sha": t[4]}
+
+
+def vocab_key(path: str) -> tuple | None:
+    """ECHTER Vergleichsschlüssel für Vocab-Kompatibilität: (model, pre, n_vocab, sha256
+    der vollständigen Token-Liste). Vergleicht den TATSÄCHLICHEN Vokabular-Inhalt, nicht
+    nur Metadaten — familienunabhängig (Qwen, Llama, Mistral, …). Genau diese Identität
+    verlangt llama.cpp für Speculative Decoding."""
+    fp = fingerprint(path)
+    if not fp or fp["n_vocab"] is None or not fp.get("tokens_sha"):
+        return None
+    return (fp["model"], fp["pre"], fp["n_vocab"], fp["tokens_sha"])
+
+
+def compatible(target_path: str, draft_path: str) -> bool | None:
+    """True/False ob draft vocab-kompatibel zum target ist. None = unbestimmbar
+    (eine Datei nicht lesbar) → UI behandelt das als 'nicht bestätigt'."""
+    a = vocab_key(target_path)
+    b = vocab_key(draft_path)
+    if a is None or b is None:
+        return None
+    return a == b
+
+
+# ── Architektur-Metadaten für EHRLICHE KV-Cache-Größen ──────────────────────────────
+# Der KV-Cache hängt an (Layer × KV-Heads × Head-Dim), NICHT an den Gesamt-Parametern.
+# Bei MoE (z.B. Qwen3.6-35B-A3B) ist das entscheidend: die alte params-basierte Schätzung
+# überschätzte grob (aktive vs. gesamte Params + GQA), reale KV liest man direkt hier.
+# Schlüssel sind arch-präfixiert ('qwen3moe.block_count', 'llama.attention.head_count_kv' …),
+# gegen echte GGUFs verifiziert. Wir sammeln die gewünschten Skalar-Schlüssel per Suffix.
+_ARCH_WANT = (
+    ".block_count", ".attention.head_count_kv", ".attention.head_count",
+    ".attention.key_length", ".attention.value_length", ".embedding_length",
+    ".context_length",
+)
+
+
+def _read_arch_meta(path: str) -> dict | None:
+    try:
+        with open(path, "rb") as fh:
+            r = _Reader(fh)
+            if r.read(4) != b"GGUF":
+                return None
+            r.u32()                 # version
+            r.u64()                 # tensor_count
+            kv_count = r.u64()
+            raw: dict = {}
+            arch = None
+            for _ in range(kv_count):
+                key = r.gstr()
+                vtype = r.u32()
+                if key == "general.architecture" and vtype == _T_STRING:
+                    arch = r.gstr()
+                    continue
+                if key == "tokenizer.ggml.tokens":
+                    break            # Arch-Metadaten stehen davor → fertig, Rest überspringen
+                suf = next((s for s in _ARCH_WANT if key.endswith(s)), None)
+                if suf is not None and vtype in _SCALAR_SIZE:
+                    raw[suf] = r.scalar(vtype)
+                else:
+                    r.skip_value(vtype)
+            n_layers = raw.get(".block_count")
+            n_head = raw.get(".attention.head_count")
+            n_head_kv = raw.get(".attention.head_count_kv") or n_head   # GQA fehlt → MHA
+            n_embd = raw.get(".embedding_length")
+            hd_k = raw.get(".attention.key_length") \
+                or (int(n_embd / n_head) if (n_embd and n_head) else None)
+            hd_v = raw.get(".attention.value_length") or hd_k
+            if not (n_layers and n_head_kv and hd_k and hd_v):
+                return None          # unvollständig → Aufrufer nutzt Heuristik-Fallback
+            return {"arch": arch, "n_layers": int(n_layers), "n_head_kv": int(n_head_kv),
+                    "head_dim_k": int(hd_k), "head_dim_v": int(hd_v),
+                    "n_ctx_train": int(raw[".context_length"]) if raw.get(".context_length") else None}
+    except (OSError, EOFError, ValueError, struct.error):
+        return None
+
+
+@lru_cache(maxsize=128)
+def _arch_cached(path: str, mtime: float, size: int) -> dict | None:
+    return _read_arch_meta(path)
+
+
+def arch_meta(path: str) -> dict | None:
+    """Architektur-Metadaten eines GGUF (gecacht nach Pfad+mtime+size):
+    {arch, n_layers, n_head_kv, head_dim_k, head_dim_v, n_ctx_train}. None wenn nicht lesbar
+    oder unvollständig."""
+    import os
+    try:
+        st = os.stat(path)
+    except OSError:
+        return None
+    return _arch_cached(path, st.st_mtime, st.st_size)
+
+
+# Bytes pro KV-Cache-Element je cache-type (inkl. Block-Overhead der k-Quants).
+_KV_BPE = {
+    "f32": 4.0, "f16": 2.0, "bf16": 2.0,
+    "q8_0": 1.0625, "q5_1": 0.75, "q5_0": 0.6875,
+    "q4_1": 0.625, "q4_0": 0.5625, "iq4_nl": 0.5625,
+}
+_GIB = 1024 ** 3
+
+
+def _bpe(cache_type: str | None) -> float:
+    return _KV_BPE.get((cache_type or "f16").lower(), 2.0)
+
+
+def kv_cache_gb(meta: dict, ctx: int, ck: str | None = None, cv: str | None = None) -> float:
+    """Echte KV-Cache-Größe (GiB) für ctx Tokens, K/V ggf. quantisiert. Formel wie llama.cpp:
+    je Layer & Token hält der Cache n_head_kv × head_dim Elemente für K und für V."""
+    per_tok = meta["n_layers"] * meta["n_head_kv"] * ctx
+    k = per_tok * meta["head_dim_k"] * _bpe(ck)
+    v = per_tok * meta["head_dim_v"] * _bpe(cv)
+    return (k + v) / _GIB
+
+
+def kv_gb_per_token(meta: dict, ck: str | None = None, cv: str | None = None) -> float:
+    """KV-GiB pro Kontext-Token — für den analytischen ctx-Solver (linear in ctx)."""
+    return kv_cache_gb(meta, 1, ck, cv)

backend/services/jobengine.py

@@ -90,7 +90,7 @@ def _run_job(job_id: str, args: list[str], env: dict | None = None, sudo_passwor
             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:  # noqa: BLE001
+    except Exception as exc:
         _append_log(job, f"[mc] Fehler: {exc}")
         job["state"] = "failed"
         job["returncode"] = -1
@@ -101,7 +101,7 @@ def _run_job(job_id: str, args: list[str], env: dict | None = None, sudo_passwor
         if cb and job["state"] == "done":
             try:
                 cb()
-            except Exception as exc:  # noqa: BLE001
+            except Exception as exc:
                 _append_log(job, f"[mc] Nachbearbeitung-Fehler: {exc}")
 
 
@@ -136,7 +136,7 @@ def attach_download_progress(job_id: str, local_dir: str, total_bytes: int) -> N
                             j["rate_bps"] = rate
                             j["eta_s"] = int((total_bytes - cur) / rate)
                     prev_t, prev_b = now, cur
-            except Exception:  # noqa: BLE001
+            except Exception:
                 pass
             time.sleep(1.0)
         j = JOBS.get(job_id)
@@ -182,7 +182,7 @@ def cancel_job(job_id: str) -> bool:
     if proc is not None:
         try:
             proc.terminate()
-        except Exception:  # noqa: BLE001
+        except Exception:
             pass
     else:
         job["state"] = "canceled"

backend/services/memory.py

@@ -1,147 +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 re
-from difflib import SequenceMatcher
-
-import httpx
-
-from config import MEM0_SERVICE_URL
-
-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}

backend/services/metrics_history.py

@@ -0,0 +1,128 @@
+"""24-h-Metrik-Verlauf für die Cockpit-Zeitachse (User-Wunsch 16.07.: „WANN war Last?").
+
+Ein leichter Sammler (Lifespan-Task in app.py) legt alle SAMPLE_S Sekunden einen
+kompakten Punkt in einen Ringpuffer: CPU/RAM/GPU/Disk in Prozent + die Token-
+GESAMTZÄHLER (das Frontend rechnet Raten aus den Deltas). Der Puffer hält exakt
+24 h — Älteres fällt automatisch raus (deque maxlen), nichts wächst unbegrenzt.
+Periodisch wird auf Platte persistiert (übersteht MC2-Restarts/Deploys); beim
+Laden fliegt alles raus, was älter als 24 h ist.
+
+Bewusst NICHT im Steward: die Historie ist reine UI-Ware, und ein paar Sekunden
+Lücke pro Deploy sind egal.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+from collections import deque
+
+from config import MODELS_DIR
+
+log = logging.getLogger(__name__)
+
+SAMPLE_S = 10                      # Abtast-Takt
+RETENTION_S = 24 * 3600            # 24 h — danach löschen und neu bauen (Ringpuffer)
+MAXLEN = RETENTION_S // SAMPLE_S   # 8640 Punkte
+FLUSH_S = 300                      # höchstens alle 5 min auf Platte
+MAX_RETURN_POINTS = 300            # Endpoint downsampled auf ~diese Punktzahl
+
+HISTORY_PATH = MODELS_DIR / "mc2-metrics-history.json"
+
+# Punkt = [t, cpu, ram, gpu, disk, tp, tc] (t = Epoch-Sekunden; tp/tc = Token-Totale)
+_points: deque = deque(maxlen=MAXLEN)
+_loaded = False
+_last_flush = 0.0
+
+
+def _load() -> None:
+    global _loaded
+    if _loaded:
+        return
+    _loaded = True
+    try:
+        raw = json.loads(HISTORY_PATH.read_text(encoding="utf-8"))
+        cutoff = time.time() - RETENTION_S
+        for p in raw if isinstance(raw, list) else []:
+            if isinstance(p, list) and len(p) == 7 and isinstance(p[0], (int, float)) and p[0] >= cutoff:
+                _points.append(p)
+        if _points:
+            log.info("metrics_history: %d Punkte aus %s geladen", len(_points), HISTORY_PATH)
+    except FileNotFoundError:
+        pass
+    except Exception:
+        log.warning("metrics_history: %s nicht lesbar — starte leer", HISTORY_PATH, exc_info=True)
+
+
+def _flush() -> None:
+    global _last_flush
+    _last_flush = time.time()
+    try:
+        tmp = HISTORY_PATH.with_suffix(".tmp")
+        tmp.write_text(json.dumps(list(_points), separators=(",", ":")), encoding="utf-8")
+        tmp.replace(HISTORY_PATH)
+    except OSError:
+        log.warning("metrics_history: %s nicht schreibbar", HISTORY_PATH, exc_info=True)
+
+
+def _sample() -> None:
+    import psutil
+
+    from services.system import _gpu_sysfs
+    from services.token_stats import get_stats
+
+    vm = psutil.virtual_memory()
+    disk = None
+    try:
+        du = psutil.disk_usage(str(MODELS_DIR) if MODELS_DIR.exists() else os.getcwd())
+        disk = du.percent
+    except Exception:
+        pass
+    gpu = None
+    try:
+        g = _gpu_sysfs()
+        gpu = g.get("busy_percent") if g else None
+    except Exception:
+        pass
+    tp = tc = None
+    try:
+        ts = get_stats()
+        tp, tc = ts.get("prompt_tokens"), ts.get("completion_tokens")
+    except Exception:
+        pass
+    # interval=None: nicht-blockierende CPU-Messung seit dem letzten Aufruf (10 s her — ideal).
+    _points.append([int(time.time()), psutil.cpu_percent(interval=None), vm.percent, gpu, disk, tp, tc])
+
+
+async def sampler_loop() -> None:
+    """Dauer-Sammler fürs App-Lifespan. Fehler eines Ticks reißen die Schleife nie."""
+    _load()
+    while True:
+        try:
+            await asyncio.to_thread(_sample)
+        except Exception:
+            log.debug("metrics_history: Sample fehlgeschlagen", exc_info=True)
+        if time.time() - _last_flush >= FLUSH_S:
+            try:
+                await asyncio.to_thread(_flush)
+            except Exception:
+                pass
+        await asyncio.sleep(SAMPLE_S)
+
+
+def history(minutes: int = 60) -> dict:
+    """Punkte der letzten N Minuten, auf ≤ MAX_RETURN_POINTS ausgedünnt (Stride)."""
+    _load()
+    minutes = max(1, min(int(minutes), RETENTION_S // 60))
+    cutoff = time.time() - minutes * 60
+    pts = [p for p in _points if p[0] >= cutoff]
+    stride = max(1, len(pts) // MAX_RETURN_POINTS)
+    pts = pts[::stride]
+    return {
+        "sample_s": SAMPLE_S * stride,
+        "points": [
+            {"t": p[0], "cpu": p[1], "ram": p[2], "gpu": p[3], "disk": p[4], "tp": p[5], "tc": p[6]}
+            for p in pts
+        ],
+    }

backend/services/pricing.py

@@ -1,58 +1,58 @@
-"""Kosten-/Ersparnis-Berechnung für die Token-Statistik (eine Quelle der Wahrheit).
-
-Vergleicht die lokal verbrauchten Tokens gegen die Cloud-Listenpreise vergleichbarer
-Modellklassen (Stand Juni 2026, USD pro 1M Tokens, in/out) und liefert die so
-eingesparte Summe. Wird vom System-Router dünn aufgerufen.
-"""
-
-import os
-
-# Cloud-Listenpreise je Rolle/Modellklasse: (input_usd_per_1M, output_usd_per_1M).
-PRICING: dict[str, tuple[float, float]] = {
-    "heavy": (15.0, 75.0),
-    "coder": (3.0, 15.0),
-    "hermes": (1.0, 5.0),
-    "fast": (0.15, 0.60),
-    "scout": (0.15, 0.60),
-    "vision": (0.15, 0.60),
-    "reasoning": (0.15, 0.60),
-}
-# Tarif für nicht zuordenbare Tokens (Default-/Fallback-Klasse).
-DEFAULT_RATE: tuple[float, float] = (0.15, 0.60)
-# Baseline/Legacy-Tokens (vor modellspezifischem Logging) am Premium-Tarif bewerten,
-# damit historische Ersparnis erhalten bleibt.
-BASELINE_RATE: tuple[float, float] = PRICING["heavy"]
-USD_TO_EUR = float(os.environ.get("MC_USD_TO_EUR", "0.92"))
-
-
-def compute_savings(stats: dict, role_map: dict[str, str | None]) -> dict:
-    """Aggregiert Tokens und berechnet die Cloud-Ersparnis.
-
-    role_map: Modell-/Alias-Name (lowercase) -> Rolle, zur Tarif-Auflösung.
-    """
-    prompt = stats.get("prompt_tokens", 0)
-    completion = stats.get("completion_tokens", 0)
-
-    modeled_p = modeled_c = 0
-    saved_usd = 0.0
-    for m_name, m_tokens in (stats.get("models") or {}).items():
-        mp = m_tokens.get("prompt", 0)
-        mc = m_tokens.get("completion", 0)
-        modeled_p += mp
-        modeled_c += mc
-        role = role_map.get(m_name, m_name)
-        rate_in, rate_out = PRICING.get(role, DEFAULT_RATE)
-        saved_usd += (mp * rate_in + mc * rate_out) / 1_000_000.0
-
-    baseline_p = max(0, prompt - modeled_p)
-    baseline_c = max(0, completion - modeled_c)
-    saved_usd += (baseline_p * BASELINE_RATE[0] + baseline_c * BASELINE_RATE[1]) / 1_000_000.0
-
-    return {
-        "prompt_tokens": prompt,
-        "completion_tokens": completion,
-        "total_tokens": prompt + completion,
-        "saved_usd": round(saved_usd, 2),
-        "saved_eur": round(saved_usd * USD_TO_EUR, 2),
-        "pricing": {role: {"in": r[0], "out": r[1]} for role, r in PRICING.items()},
-    }
+"""Kosten-/Ersparnis-Berechnung für die Token-Statistik (eine Quelle der Wahrheit).
+
+Vergleicht die lokal verbrauchten Tokens gegen die Cloud-Listenpreise vergleichbarer
+Modellklassen (Stand Juni 2026, USD pro 1M Tokens, in/out) und liefert die so
+eingesparte Summe. Wird vom System-Router dünn aufgerufen.
+"""
+
+import os
+
+# Cloud-Listenpreise je Rolle/Modellklasse: (input_usd_per_1M, output_usd_per_1M).
+PRICING: dict[str, tuple[float, float]] = {
+    "heavy": (15.0, 75.0),
+    "coder": (3.0, 15.0),
+    "hermes": (1.0, 5.0),
+    "fast": (0.15, 0.60),
+    "scout": (0.15, 0.60),
+    "vision": (0.15, 0.60),
+    "reasoning": (0.15, 0.60),
+}
+# Tarif für nicht zuordenbare Tokens (Default-/Fallback-Klasse).
+DEFAULT_RATE: tuple[float, float] = (0.15, 0.60)
+# Baseline/Legacy-Tokens (vor modellspezifischem Logging) am Premium-Tarif bewerten,
+# damit historische Ersparnis erhalten bleibt.
+BASELINE_RATE: tuple[float, float] = PRICING["heavy"]
+USD_TO_EUR = float(os.environ.get("MC_USD_TO_EUR", "0.92"))
+
+
+def compute_savings(stats: dict, role_map: dict[str, str | None]) -> dict:
+    """Aggregiert Tokens und berechnet die Cloud-Ersparnis.
+
+    role_map: Modell-/Alias-Name (lowercase) -> Rolle, zur Tarif-Auflösung.
+    """
+    prompt = stats.get("prompt_tokens", 0)
+    completion = stats.get("completion_tokens", 0)
+
+    modeled_p = modeled_c = 0
+    saved_usd = 0.0
+    for m_name, m_tokens in (stats.get("models") or {}).items():
+        mp = m_tokens.get("prompt", 0)
+        mc = m_tokens.get("completion", 0)
+        modeled_p += mp
+        modeled_c += mc
+        role = role_map.get(m_name, m_name)
+        rate_in, rate_out = PRICING.get(role, DEFAULT_RATE)
+        saved_usd += (mp * rate_in + mc * rate_out) / 1_000_000.0
+
+    baseline_p = max(0, prompt - modeled_p)
+    baseline_c = max(0, completion - modeled_c)
+    saved_usd += (baseline_p * BASELINE_RATE[0] + baseline_c * BASELINE_RATE[1]) / 1_000_000.0
+
+    return {
+        "prompt_tokens": prompt,
+        "completion_tokens": completion,
+        "total_tokens": prompt + completion,
+        "saved_usd": round(saved_usd, 2),
+        "saved_eur": round(saved_usd * USD_TO_EUR, 2),
+        "pricing": {role: {"in": r[0], "out": r[1]} for role, r in PRICING.items()},
+    }

backend/services/reminders.py

@@ -0,0 +1,171 @@
+"""
+Erinnerungen & Routinen (Lucy-Proaktivität, Faden A3).
+
+„Lucy, erinner mich morgen um 9 an …" — der Hermes-Agent legt per Tool (mcp_mc.py:
+reminder_create) einen Eintrag an; der Wecker-Loop hier feuert ihn zur Zeit in den
+Melde-Briefkasten (announce.py → Lucy spricht) und parallel auf Telegram.
+
+Bewusst OHNE Hermes-cron: der Wecker läuft deterministisch im MC2-Backend (systemd,
+überlebt Gateway-Ausfälle) und bleibt in UNSEREN Schichten (Hermes-Quellcode/Config
+bleibt Auto-Update-Kanal, Verdikt Faden 11c).
+
+Zeiten: ISO-8601. Ohne Offset gilt die Zeitzone des Commanders (MC_LOCAL_TZ,
+Default Europe/Berlin) — die Box selbst läuft auf UTC, naive Zeiten dürfen daher
+NIE als Box-Lokalzeit interpretiert werden. Wiederholung: daily | weekdays | weekly.
+"""
+
+import json
+import logging
+import os
+import threading
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+from config import MODELS_DIR
+
+from services import announce
+
+log = logging.getLogger(__name__)
+
+STORE_PATH = Path(os.environ.get("MC_REMINDERS_STORE", str(MODELS_DIR / "mc2-reminders.json")))
+LOCAL_TZ = ZoneInfo(os.environ.get("MC_LOCAL_TZ", "Europe/Berlin"))
+INTERVAL = int(os.environ.get("MC_REMINDERS_INTERVAL", "20"))   # Wecker-Tick (Sekunden)
+MAX_ITEMS = int(os.environ.get("MC_REMINDERS_MAX", "100"))
+REPEATS = ("", "daily", "weekdays", "weekly")
+LATE_NOTE_S = 600   # feuert >10 min zu spät (Box war aus) → ehrlich dazusagen
+
+_lock = threading.Lock()
+_state: dict | None = None   # {"next_id": int, "items": [...]}
+
+
+def _load() -> dict:
+    global _state
+    if _state is None:
+        try:
+            _state = json.loads(STORE_PATH.read_text(encoding="utf-8"))
+            assert isinstance(_state.get("next_id"), int) and isinstance(_state.get("items"), list)
+        except Exception:
+            _state = {"next_id": 1, "items": []}
+    return _state
+
+
+def _save(state: dict) -> None:
+    try:
+        tmp = STORE_PATH.with_suffix(".tmp")
+        tmp.write_text(json.dumps(state, ensure_ascii=False), encoding="utf-8")
+        tmp.replace(STORE_PATH)
+    except OSError:
+        log.warning("reminders: Store %s nicht schreibbar", STORE_PATH, exc_info=True)
+
+
+def _parse_when(when: str) -> datetime:
+    """ISO-8601 → bewusste Zeit. Naive Angaben = Commander-Zeitzone (NICHT Box-UTC)."""
+    try:
+        dt = datetime.fromisoformat(when.strip())
+    except ValueError:
+        raise ValueError("Zeit nicht lesbar — bitte ISO-8601 mit Datum UND Uhrzeit, z.B. 2026-07-04T09:00.")
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=LOCAL_TZ)
+    return dt
+
+
+def _fmt(ts: float) -> str:
+    """Menschlich lesbare Commander-Lokalzeit (fürs Tool-Echo/Listing)."""
+    return datetime.fromtimestamp(ts, LOCAL_TZ).strftime("%a %d.%m.%Y %H:%M")
+
+
+def _advance(ts: float, repeat: str) -> float:
+    """Nächste Wiederholung NACH jetzt (holt verpasste Termine ohne Mehrfach-Feuern auf)."""
+    dt = datetime.fromtimestamp(ts, LOCAL_TZ)
+    now = time.time()
+    while dt.timestamp() <= now:
+        dt += timedelta(days=7 if repeat == "weekly" else 1)
+        if repeat == "weekdays":
+            while dt.weekday() > 4:   # Sa/So überspringen
+                dt += timedelta(days=1)
+    return dt.timestamp()
+
+
+def create(text: str, when: str, repeat: str = "") -> dict:
+    text = (text or "").strip()
+    if not text:
+        raise ValueError("Leerer Erinnerungs-Text.")
+    repeat = (repeat or "").strip().lower()
+    if repeat == "once":
+        repeat = ""
+    if repeat not in REPEATS:
+        raise ValueError("repeat muss leer, daily, weekdays oder weekly sein.")
+    ts = _parse_when(when).timestamp()
+    if repeat:
+        if ts <= time.time():   # Startpunkt vorbei → auf die nächste Wiederholung rücken (Uhrzeit bleibt exakt)
+            ts = _advance(ts, repeat)
+    elif ts <= time.time() - 60:
+        raise ValueError(f"Die Zeit liegt in der Vergangenheit ({_fmt(ts)}) — bitte neu umrechnen "
+                         f"(jetzt ist {_fmt(time.time())}).")
+    with _lock:
+        state = _load()
+        if len(state["items"]) >= MAX_ITEMS:
+            raise ValueError(f"Zu viele offene Erinnerungen (max {MAX_ITEMS}).")
+        item = {"id": state["next_id"], "text": text[:500], "next_ts": ts,
+                "repeat": repeat, "created_ts": time.time()}
+        state["next_id"] += 1
+        state["items"].append(item)
+        _save(state)
+    log.info("reminder #%s angelegt: %s → %s%s", item["id"], _fmt(ts), text[:60],
+             f" (Routine {repeat})" if repeat else "")
+    return {**item, "when_local": _fmt(ts)}
+
+
+def list_all() -> list[dict]:
+    with _lock:
+        items = sorted(_load()["items"], key=lambda i: i["next_ts"])
+        return [{**i, "when_local": _fmt(i["next_ts"])} for i in items]
+
+
+def delete(reminder_id: int) -> dict:
+    with _lock:
+        state = _load()
+        for i, item in enumerate(state["items"]):
+            if item["id"] == reminder_id:
+                state["items"].pop(i)
+                _save(state)
+                return {**item, "when_local": _fmt(item["next_ts"])}
+    raise KeyError(f"Erinnerung {reminder_id} nicht gefunden.")
+
+
+def _fire_due() -> None:
+    now = time.time()
+    with _lock:
+        state = _load()
+        due = [i for i in state["items"] if i["next_ts"] <= now]
+        if not due:
+            return
+        for item in due:
+            if item["repeat"]:
+                item["next_ts"] = _advance(item["next_ts"], item["repeat"])
+            else:
+                state["items"].remove(item)
+        _save(state)
+    for item in due:
+        late = now - item["next_ts"] > LATE_NOTE_S if not item["repeat"] else False
+        text = f"Erinnerung, Commander: {item['text']}"
+        if late:
+            text += f" (Eigentlich fällig um {_fmt(item['next_ts'])} — die Box war wohl aus.)"
+        announce.add(text, subject="[Erinnerung]", source="reminder")
+        announce.notify_telegram("[Erinnerung]", item["text"])
+        log.info("reminder #%s gefeuert%s", item["id"], " (Routine)" if item["repeat"] else "")
+
+
+async def reminders_loop() -> None:
+    """Wecker (Hintergrund-Task im MC2-Lifespan). Verpasste einmalige Erinnerungen
+    (Box war aus) feuern beim nächsten Tick nach — ehrlich als verspätet markiert."""
+    import asyncio
+    log.info("reminders: Wecker aktiv (Tick %ss, Zeitzone %s)", INTERVAL, LOCAL_TZ)
+    while True:
+        try:
+            await asyncio.to_thread(_fire_due)
+        except Exception:
+            log.debug("reminders: Tick fehlgeschlagen", exc_info=True)
+        await asyncio.sleep(INTERVAL)

backend/services/router_logic.py

@@ -50,9 +50,41 @@ _CODE_HINT = re.compile(
 )
 
 
+# Bild-Weiche (Faden 11): Aliase, die selbst Bilder koennen — die werden NIE umgeroutet.
+VISION_CAPABLE = {"vision", "scout"}
+IMAGE_PART_TYPES = {"image_url", "input_image", "image"}
+
+
+def has_image(body: dict) -> bool:
+    """True, wenn irgendeine Nachricht einen Bild-Part enthaelt (OpenAI-multimodaler
+    content: eine Liste mit einem {"type": "image_url"|"input_image"|"image", ...}-Teil)."""
+    for m in body.get("messages") or []:
+        if not isinstance(m, dict):
+            continue
+        content = m.get("content")
+        if isinstance(content, list):
+            for part in content:
+                if isinstance(part, dict) and part.get("type") in IMAGE_PART_TYPES:
+                    return True
+    return False
+
+
 def _text_of(body: dict) -> str:
     msgs = body.get("messages") or []
-    return "\n".join(str(m.get("content") or "") for m in msgs)
+    # Multimodaler content ist eine Liste — nur die Text-Parts fuers Komplexitaets-Routing
+    # zusammenziehen (ein dict/Liste als str() wuerde die Zeichen-Schwelle verfaelschen).
+    out = []
+    for m in msgs:
+        if not isinstance(m, dict):
+            continue
+        c = m.get("content")
+        if isinstance(c, str):
+            out.append(c)
+        elif isinstance(c, list):
+            for part in c:
+                if isinstance(part, dict) and part.get("type") == "text":
+                    out.append(str(part.get("text") or ""))
+    return "\n".join(out)
 
 
 def _route_chat(text: str, n: int) -> tuple[str, str]:

backend/services/routing_policy.py

@@ -1,127 +1,131 @@
-"""
-UI-editierbare Routing-Policy für die Gateway-Lanes (coding/chat).
-
-Persistiert als JSON unter MC_ROUTING_POLICY_PATH (Default MODELS_DIR/mc2-routing.json —
-gleiche Konvention wie mc2-discover.json). **Hot-reload:** load_policy() liest die Datei nur
-bei Änderung neu (mtime-Cache) → UI-Edits greifen ohne Dienst-Neustart. Die Env-Vars (bisher
-einzige Stellschraube in router_logic.py) bleiben als Defaults/Fallback erhalten.
-
-Bewusst NICHT editierbar (v1): die Regex-Keyword-Listen (heavy/coding-heavy/code-hint) — die
-bleiben in router_logic.py im Code.
-"""
-
-import json
-import os
-import threading
-from pathlib import Path
-
-from config import MODELS_DIR
-
-POLICY_PATH = Path(os.environ.get("MC_ROUTING_POLICY_PATH", str(MODELS_DIR / "mc2-routing.json")))
-
-
-def _env_bool(name: str, default: str) -> bool:
-    return os.environ.get(name, default) not in ("0", "false", "")
-
-
-# Defaults aus den Env-Vars — Quelle der Wahrheit, solange keine Policy-Datei existiert.
-DEFAULTS: dict = {
-    "fast": os.environ.get("MC_ROUTE_FAST", "fast"),
-    "heavy": os.environ.get("MC_ROUTE_HEAVY", "heavy"),
-    "coder": os.environ.get("MC_ROUTE_CODER", "coder"),
-    "coder_lite": os.environ.get("MC_ROUTE_CODER_LITE", "").strip(),
-    "heavy_chars": int(os.environ.get("MC_GATEWAY_HEAVY_CHARS", "8000")),
-    "coding_escalate_chars": int(os.environ.get("MC_CODING_ESCALATE_CHARS", "120000")),
-    "fast_no_think": _env_bool("MC_FAST_NO_THINK", "1"),
-}
-
-# Feld-Spezifikation für die UI (Typ + Grenzen + Label). Treibt Editor & Validierung.
-FIELDS: list[dict] = [
-    {"key": "fast", "label": "fast-Alias (chat: Standard)", "type": "str"},
-    {"key": "heavy", "label": "heavy-Alias (chat: lang/komplex)", "type": "str"},
-    {"key": "coder", "label": "coder-Alias (coding: stark / Eskalation)", "type": "str"},
-    {"key": "coder_lite", "label": "coder-lite-Alias (coding: schneller Default; leer = aus)", "type": "str"},
-    {"key": "heavy_chars", "label": "chat → heavy ab N Zeichen", "type": "int", "min": 500, "max": 1_000_000},
-    {"key": "coding_escalate_chars", "label": "coding → starker Coder ab N Zeichen", "type": "int", "min": 1000, "max": 4_000_000},
-    {"key": "fast_no_think", "label": "fast-Spur: Thinking aus (flotte Antworten)", "type": "bool"},
-]
-
-_LOCK = threading.Lock()
-_CACHE: dict = {"mtime": None, "policy": None}
-
-
-def _read_file() -> dict:
-    try:
-        with open(POLICY_PATH, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        return data if isinstance(data, dict) else {}
-    except (FileNotFoundError, json.JSONDecodeError, OSError):
-        return {}
-
-
-def _coerce(patch: dict) -> dict:
-    """Nur bekannte Keys, typ-/bereichsvalidiert. Wirft ValueError bei ungültigen Werten."""
-    spec = {f["key"]: f for f in FIELDS}
-    out: dict = {}
-    for k, v in (patch or {}).items():
-        f = spec.get(k)
-        if not f:
-            continue  # unbekannte Keys still verwerfen
-        if f["type"] == "int":
-            iv = int(v)
-            lo, hi = f.get("min", 1), f.get("max", 10**9)
-            if not (lo <= iv <= hi):
-                raise ValueError(f"{k}={iv} außerhalb [{lo}, {hi}]")
-            out[k] = iv
-        elif f["type"] == "bool":
-            out[k] = bool(v)
-        else:  # str
-            sv = str(v).strip()
-            if k != "coder_lite" and not sv:
-                raise ValueError(f"{k} darf nicht leer sein")
-            out[k] = sv
-    return out
-
-
-def _coerce_safe(patch: dict) -> dict:
-    """Wie _coerce, aber schluckt Fehler — kaputte Datei darf den Betrieb nicht stoppen."""
-    try:
-        return _coerce(patch)
-    except (ValueError, TypeError):
-        return {}
-
-
-def load_policy() -> dict:
-    """Aktuelle Policy (Datei über DEFAULTS gemerged). Hot-reload via mtime-Cache, pro Request billig."""
-    try:
-        mtime = POLICY_PATH.stat().st_mtime
-    except OSError:
-        mtime = None
-    with _LOCK:
-        if _CACHE["policy"] is None or _CACHE["mtime"] != mtime:
-            merged = {**DEFAULTS}
-            if mtime is not None:
-                merged.update(_coerce_safe(_read_file()))
-            _CACHE["mtime"] = mtime
-            _CACHE["policy"] = merged
-        return dict(_CACHE["policy"])
-
-
-def save_policy(patch: dict) -> dict:
-    """Validiert + persistiert atomar. Gibt die neue, vollständige Policy zurück."""
-    clean = _coerce(patch)  # wirft bei ungültigem Input
-    with _LOCK:
-        current = {**DEFAULTS, **_coerce_safe(_read_file()), **clean}
-        POLICY_PATH.parent.mkdir(parents=True, exist_ok=True)
-        tmp = POLICY_PATH.with_suffix(".json.tmp")
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump(current, f, ensure_ascii=False, indent=2)
-        os.replace(tmp, POLICY_PATH)
-        _CACHE["mtime"] = None  # nächster load_policy() lädt frisch
-        _CACHE["policy"] = None
-    return current
-
-
-def policy_meta() -> dict:
-    """Für den UI-Editor: aktuelle Werte + Defaults (für „Zurücksetzen“) + Feld-Spezifikation."""
-    return {"policy": load_policy(), "defaults": dict(DEFAULTS), "fields": FIELDS}
+"""
+UI-editierbare Routing-Policy für die Gateway-Lanes (coding/chat).
+
+Persistiert als JSON unter MC_ROUTING_POLICY_PATH (Default MODELS_DIR/mc2-routing.json —
+gleiche Konvention wie mc2-discover.json). **Hot-reload:** load_policy() liest die Datei nur
+bei Änderung neu (mtime-Cache) → UI-Edits greifen ohne Dienst-Neustart. Die Env-Vars (bisher
+einzige Stellschraube in router_logic.py) bleiben als Defaults/Fallback erhalten.
+
+Bewusst NICHT editierbar (v1): die Regex-Keyword-Listen (heavy/coding-heavy/code-hint) — die
+bleiben in router_logic.py im Code.
+"""
+
+import json
+import os
+import threading
+from pathlib import Path
+
+from config import MODELS_DIR
+
+POLICY_PATH = Path(os.environ.get("MC_ROUTING_POLICY_PATH", str(MODELS_DIR / "mc2-routing.json")))
+
+
+def _env_bool(name: str, default: str) -> bool:
+    return os.environ.get(name, default) not in ("0", "false", "")
+
+
+# Defaults aus den Env-Vars — Quelle der Wahrheit, solange keine Policy-Datei existiert.
+DEFAULTS: dict = {
+    "fast": os.environ.get("MC_ROUTE_FAST", "fast"),
+    "heavy": os.environ.get("MC_ROUTE_HEAVY", "heavy"),
+    "coder": os.environ.get("MC_ROUTE_CODER", "coder"),
+    "coder_lite": os.environ.get("MC_ROUTE_CODER_LITE", ""),
+    # Bild-Weiche (Faden 11): Requests mit Bild-Anhang werden automatisch hierhin geroutet
+    # (die MTP-Hirn-Config kann keine Bilder). "" schaltet die Weiche ab (Passthrough).
+    "vision": os.environ.get("MC_ROUTE_VISION", "vision"),
+    "heavy_chars": int(os.environ.get("MC_GATEWAY_HEAVY_CHARS", "8000")),
+    "coding_escalate_chars": int(os.environ.get("MC_CODING_ESCALATE_CHARS", "120000")),
+    "fast_no_think": _env_bool("MC_FAST_NO_THINK", "1"),
+}
+
+# Feld-Spezifikation für die UI (Typ + Grenzen + Label). Treibt Editor & Validierung.
+FIELDS: list[dict] = [
+    {"key": "fast", "label": "fast-Alias (chat: Standard)", "type": "str"},
+    {"key": "heavy", "label": "heavy-Alias (chat: lang/komplex)", "type": "str"},
+    {"key": "coder", "label": "coder-Alias (coding: stark / Eskalation)", "type": "str"},
+    {"key": "coder_lite", "label": "coder-lite-Alias (coding: schneller Default; leer = aus)", "type": "str"},
+    {"key": "vision", "label": "vision-Alias (Bild-Weiche: Requests mit Bild; leer = aus)", "type": "str"},
+    {"key": "heavy_chars", "label": "chat → heavy ab N Zeichen", "type": "int", "min": 500, "max": 1_000_000},
+    {"key": "coding_escalate_chars", "label": "coding → starker Coder ab N Zeichen", "type": "int", "min": 1000, "max": 4_000_000},
+    {"key": "fast_no_think", "label": "fast-Spur: Thinking aus (flotte Antworten)", "type": "bool"},
+]
+
+_LOCK = threading.Lock()
+_CACHE: dict = {"mtime": None, "policy": None}
+
+
+def _read_file() -> dict:
+    try:
+        with open(POLICY_PATH, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {}
+
+
+def _coerce(patch: dict) -> dict:
+    """Nur bekannte Keys, typ-/bereichsvalidiert. Wirft ValueError bei ungültigen Werten."""
+    spec = {f["key"]: f for f in FIELDS}
+    out: dict = {}
+    for k, v in (patch or {}).items():
+        f = spec.get(k)
+        if not f:
+            continue  # unbekannte Keys still verwerfen
+        if f["type"] == "int":
+            iv = int(v)
+            lo, hi = f.get("min", 1), f.get("max", 10**9)
+            if not (lo <= iv <= hi):
+                raise ValueError(f"{k}={iv} außerhalb [{lo}, {hi}]")
+            out[k] = iv
+        elif f["type"] == "bool":
+            out[k] = bool(v)
+        else:  # str
+            sv = str(v).strip()
+            if k not in ("coder_lite", "vision") and not sv:
+                raise ValueError(f"{k} darf nicht leer sein")
+            out[k] = sv
+    return out
+
+
+def _coerce_safe(patch: dict) -> dict:
+    """Wie _coerce, aber schluckt Fehler — kaputte Datei darf den Betrieb nicht stoppen."""
+    try:
+        return _coerce(patch)
+    except (ValueError, TypeError):
+        return {}
+
+
+def load_policy() -> dict:
+    """Aktuelle Policy (Datei über DEFAULTS gemerged). Hot-reload via mtime-Cache, pro Request billig."""
+    try:
+        mtime = POLICY_PATH.stat().st_mtime
+    except OSError:
+        mtime = None
+    with _LOCK:
+        if _CACHE["policy"] is None or _CACHE["mtime"] != mtime:
+            merged = {**DEFAULTS}
+            if mtime is not None:
+                merged.update(_coerce_safe(_read_file()))
+            _CACHE["mtime"] = mtime
+            _CACHE["policy"] = merged
+        return dict(_CACHE["policy"])
+
+
+def save_policy(patch: dict) -> dict:
+    """Validiert + persistiert atomar. Gibt die neue, vollständige Policy zurück."""
+    clean = _coerce(patch)  # wirft bei ungültigem Input
+    with _LOCK:
+        current = {**DEFAULTS, **_coerce_safe(_read_file()), **clean}
+        POLICY_PATH.parent.mkdir(parents=True, exist_ok=True)
+        tmp = POLICY_PATH.with_suffix(".json.tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(current, f, ensure_ascii=False, indent=2)
+        os.replace(tmp, POLICY_PATH)
+        _CACHE["mtime"] = None  # nächster load_policy() lädt frisch
+        _CACHE["policy"] = None
+    return current
+
+
+def policy_meta() -> dict:
+    """Für den UI-Editor: aktuelle Werte + Defaults (für „Zurücksetzen“) + Feld-Spezifikation."""
+    return {"policy": load_policy(), "defaults": dict(DEFAULTS), "fields": FIELDS}

backend/services/sentry.py

@@ -0,0 +1,155 @@
+"""
+Health-Wächter der Box (Lucy-Proaktivität, Faden A3).
+
+Prüft periodisch die Kern-Dienste (Engine, Agent-Hirn, Hermes-Gateway, Mem0,
+Voice-Sidecar, Platte) und meldet ZUSTANDSWECHSEL in den Melde-Briefkasten
+(services/announce.py → Lucy spricht es) und via notify.sh (Telegram).
+
+Flankenerkennung statt Dauerfeuer: Alarm erst nach FAIL_AFTER Fehl-Ticks in
+Folge (überlebt Neustarts/Update-Fenster), Entwarnung beim ersten grünen Tick
+nach einem Alarm. Hält ein Problem an, wird frühestens nach REMIND_S erinnert.
+
+Braucht KEIN sudo, keine neuen Dienste — läuft als asyncio-Task im MC2-Backend
+(wie der Re-Warm-Wächter). Abschaltbar via MC_SENTRY_ENABLED=0.
+"""
+
+import asyncio
+import logging
+import os
+import time
+
+import httpx
+import psutil
+from config import HERMES_API_URL, MEM0_SERVICE_URL, MODELS_DIR, VOICE_SERVICE_URL
+
+from services import announce, llamaswap
+
+log = logging.getLogger(__name__)
+
+ENABLED = os.environ.get("MC_SENTRY_ENABLED", "1") != "0"
+INTERVAL = int(os.environ.get("MC_SENTRY_INTERVAL", "120"))        # Sekunden zwischen Ticks
+START_DELAY = int(os.environ.get("MC_SENTRY_START_DELAY", "90"))   # Dienste nach Boot setzen lassen
+FAIL_AFTER = int(os.environ.get("MC_SENTRY_FAIL_AFTER", "3"))      # Fehl-Ticks bis Alarm (3×120s = 6 min)
+REMIND_S = int(os.environ.get("MC_SENTRY_REMIND_S", "21600"))      # Erinnerung bei Dauerproblem: 6 h
+DISK_ALARM_PCT = float(os.environ.get("MC_SENTRY_DISK_PCT", "90"))
+
+
+def _reach(url: str, path: str = "/health") -> bool:
+    try:
+        with httpx.Client(timeout=5.0) as c:
+            return c.get(f"{url}{path}").status_code < 500
+    except Exception:
+        return False
+
+
+def _check_engine() -> bool:
+    return llamaswap.engine_reachable()
+
+
+def _check_brain() -> bool:
+    """Hirn tot? Verdrängung durch ein ANDERES laufendes Modell (IDE-Last) ist NORMAL —
+    Alarm nur, wenn gar nichts läuft und das Hirn trotz Re-Warm-Wächter kalt bleibt."""
+    st = llamaswap.brain_status()
+    if st.get("ready"):
+        return True
+    return bool(llamaswap.get_running_models())   # anderes Modell aktiv → Verdrängung, kein Defekt
+
+
+def _check_disk() -> bool:
+    try:
+        return psutil.disk_usage(str(MODELS_DIR) if MODELS_DIR.exists() else os.getcwd()).percent < DISK_ALARM_PCT
+    except Exception:
+        return True   # kein Messwert ≠ Alarm
+
+
+# name → (Checker, Alarm-Text, Entwarnungs-Text) — Texte sind Lucy-sprechbar (kurz, Alltagssprache).
+CHECKS: dict[str, tuple] = {
+    "engine": (_check_engine,
+               "Die Modell-Engine antwortet nicht mehr. Ohne sie laufen keine KI-Modelle.",
+               "Die Modell-Engine ist wieder da."),
+    "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),
+               "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."),
+    "disk": (_check_disk,
+             f"Die Platte der Box ist zu über {DISK_ALARM_PCT:.0f} Prozent voll. Es wird eng für Modelle und Backups.",
+             "Die Platte hat wieder genug Luft."),
+}
+
+
+# Steward-Modus (UMBAU v3 P2): Läuft der Wächter als EIGENER Prozess (mc2-steward),
+# beobachtet er zusätzlich das Steuerpult selbst und den mc2-gateway — genau die zwei
+# Ausfälle, die der alte In-Process-Wächter prinzipbedingt nie melden konnte (er starb mit).
+if os.environ.get("MC_SENTRY_WATCH_MC2", "") == "1":
+    _MC2_URL = os.environ.get("MC_SENTRY_MC2_URL", "http://127.0.0.1:9001")
+    _GW_URL = os.environ.get("MC_SENTRY_GATEWAY_URL", "http://127.0.0.1:9010")
+    CHECKS["mc2"] = (lambda: _reach(_MC2_URL, "/api/health"),
+                     "Das Steuerpult ist ausgefallen — Dashboard, Briefkasten und Auftragsbuch gehen gerade nicht.",
+                     "Das Steuerpult ist wieder da.")
+    CHECKS["gateway"] = (lambda: _reach(_GW_URL, "/gw/health"),
+                         "Der Modell-Gateway ist ausgefallen — meine Denk-Anfragen und die der Worker hängen gerade.",
+                         "Der Modell-Gateway läuft wieder.")
+
+
+class _Watch:
+    __slots__ = ("alert_ts", "alerted", "fails")
+
+    def __init__(self) -> None:
+        self.fails = 0          # Fehl-Ticks in Folge
+        self.alerted = False    # Alarm ist raus, Entwarnung steht aus
+        self.alert_ts = 0.0     # Zeitpunkt des letzten Alarms (für REMIND_S)
+
+
+_watches: dict[str, _Watch] = {name: _Watch() for name in CHECKS}
+
+
+def _notify_telegram(subject: str, text: str) -> None:
+    """Telegram-Direktweg (gemeinsamer Helper in announce.py); Briefkasten-Eintrag
+    legt der Wächter selbst ab."""
+    announce.notify_telegram(subject, text + " (Diese Meldung kam auch an Lucy.)")
+
+
+def _tick() -> None:
+    now = time.time()
+    for name, (check, fail_msg, ok_msg) in CHECKS.items():
+        w = _watches[name]
+        try:
+            ok = bool(check())
+        except Exception:
+            ok = False
+        if ok:
+            w.fails = 0
+            if w.alerted:
+                w.alerted = False
+                announce.add(ok_msg, subject="[Box wieder ok]", source="sentry")
+                _notify_telegram("[Box wieder ok]", ok_msg)
+            continue
+        w.fails += 1
+        due = (not w.alerted and w.fails >= FAIL_AFTER) or (w.alerted and now - w.alert_ts >= REMIND_S)
+        if due:
+            prefix = "" if not w.alerted else "Immer noch: "
+            w.alerted = True
+            w.alert_ts = now
+            announce.add(prefix + fail_msg, subject="[Box-Problem]", source="sentry")
+            _notify_telegram("[Box-Problem]", prefix + fail_msg)
+            log.warning("sentry: %s ALARM (%s Fehl-Ticks)", name, w.fails)
+
+
+async def sentry_loop() -> None:
+    """Endlos-Schleife (Hintergrund-Task im MC2-Lifespan)."""
+    await asyncio.sleep(START_DELAY)
+    log.info("sentry: Health-Wächter aktiv (Intervall %ss, Alarm nach %s Fehl-Ticks)", INTERVAL, FAIL_AFTER)
+    while True:
+        try:
+            await asyncio.to_thread(_tick)
+        except Exception:
+            log.debug("sentry: Tick fehlgeschlagen", exc_info=True)
+        await asyncio.sleep(INTERVAL)

backend/services/sources.py

@@ -10,7 +10,7 @@ TRUSTED_AUTHORS = ["unsloth", "bartowski", "ggml-org", "lmstudio-community"]
 # Kanonische Rollen — eine Quelle der Wahrheit (deckt sich mit llamaswap.ROLE_IDS,
 # maintenance.ROLE_MAP, frontend ModelBadges.ROLES + Discover.ROLE_METADATA).
 # `hermes` = Lucys Agent-Hirn (warm + ko-resident); UI-Label „Hirn".
-ROLE_IDS = ["fast", "heavy", "coder", "vision", "hermes", "scout"]
+ROLE_IDS = ["fast", "heavy", "coder", "vision", "hermes", "scout", "kritiker", "reranker"]
 
 # Kategorien (Reihenfolge = Anzeige + Zuordnungs-Priorität). Ein Modell wird der
 # ERSTEN Kategorie zugeordnet, deren Stichwort im Repo-Namen vorkommt; sonst „scout".

backend/services/system.py

@@ -9,9 +9,9 @@ der Box, daher sysfs). Verschachtelte Struktur wie v1 (cpu.percent, ram.used Byt
 import glob
 import os
 import subprocess
+import threading
 
 import psutil
-
 from config import MODELS_DIR
 
 
@@ -116,7 +116,6 @@ def find_hermes_agent_git() -> dict | None:
     candidates = [
         "~/hermes-agent",
         "~/.hermes/hermes-agent",
-        "~/hermes-webui/hermes-agent",
         "~/.hermes"
     ]
     for c in candidates:
@@ -157,6 +156,7 @@ def get_engine_version() -> dict:
 
 
 _VERSION_CACHE = {"ts": 0.0, "data": {}}
+_VERSION_LOCK = threading.Lock()
 
 
 def check_versions_cached() -> dict:
@@ -164,18 +164,24 @@ def check_versions_cached() -> dict:
     now = time.time()
     if now - _VERSION_CACHE["ts"] < 30.0:
         return _VERSION_CACHE["data"]
-    
-    mc2_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
-    
-    data = {
-        "mc2": get_git_info(mc2_path),
-        "engine": get_engine_version(),
-        "hermes_ui": get_git_info("~/hermes-webui"),
-        "hermes_agent": find_hermes_agent_git()
-    }
-    _VERSION_CACHE["ts"] = now
-    _VERSION_CACHE["data"] = data
-    return data
+
+    # Lock gegen Scan-Stampede: FastAPI führt sync-Routen im Threadpool aus → ohne Lock würden
+    # parallele Dashboard-/Agent-Aufrufe die git-/Versions-Scans mehrfach gleichzeitig anwerfen.
+    # Doppelt geprüft, damit ein zweiter Thread den frisch gefüllten Cache nimmt statt neu zu scannen.
+    with _VERSION_LOCK:
+        now = time.time()
+        if now - _VERSION_CACHE["ts"] < 30.0:
+            return _VERSION_CACHE["data"]
+
+        mc2_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+        data = {
+            "mc2": get_git_info(mc2_path),
+            "engine": get_engine_version(),
+            "hermes_agent": find_hermes_agent_git()
+        }
+        _VERSION_CACHE["ts"] = now
+        _VERSION_CACHE["data"] = data
+        return data
 
 
 def system_status() -> dict:

backend/services/token_stats.py

@@ -1,99 +1,123 @@
-"""Token-Statistik (Verbrauch je Modell) mit gedrosseltem Persistieren.
-
-Früher wurde bei JEDEM Request die komplette JSON-Datei gelesen und geschrieben
-(Disk-Thrash). Jetzt: einmaliges Laden in einen In-Memory-Cache, Inkremente laufen
-gegen den Cache, Persistieren passiert höchstens alle FLUSH_INTERVAL Sekunden sowie
-beim Prozess-Ende (atexit). Lesen liefert immer den aktuellen (auch ungeflushten) Stand.
-"""
-
-import atexit
-import json
-import logging
-import threading
-import time
-from pathlib import Path
-
-from config import HERMES_HOME
-
-STATS_FILE = HERMES_HOME / "token_stats.json"
-FLUSH_INTERVAL = 5.0  # Sekunden zwischen Disk-Writes
-# Baseline (repräsentiert Verbrauch vor dem modellspezifischen Logging).
-_BASELINE = {"prompt_tokens": 718400, "completion_tokens": 324200, "models": {}}
-
-log = logging.getLogger(__name__)
-
-_lock = threading.Lock()
-_stats: dict | None = None
-_dirty = False
-_last_flush = 0.0
-
-
-def _load_from_disk() -> dict:
-    if not STATS_FILE.exists():
-        return dict(_BASELINE)
-    try:
-        with open(STATS_FILE, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        data.setdefault("prompt_tokens", 0)
-        data.setdefault("completion_tokens", 0)
-        data.setdefault("models", {})
-        return data
-    except (OSError, json.JSONDecodeError):
-        log.warning("token_stats: Laden fehlgeschlagen, nutze Baseline", exc_info=True)
-        return dict(_BASELINE)
-
-
-def _ensure_loaded() -> dict:
-    global _stats
-    if _stats is None:
-        _stats = _load_from_disk()
-    return _stats
-
-
-def _write(stats: dict) -> None:
-    try:
-        STATS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        tmp = STATS_FILE.with_suffix(".tmp")
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump(stats, f)
-        tmp.replace(STATS_FILE)
-    except OSError:
-        log.warning("token_stats: Schreiben fehlgeschlagen", exc_info=True)
-
-
-def get_stats() -> dict:
-    """Aktueller Stand (inkl. noch nicht geflushter Inkremente) als Kopie."""
-    with _lock:
-        return json.loads(json.dumps(_ensure_loaded()))
-
-
-def increment_tokens(prompt: int, completion: int, model: str | None = None) -> None:
-    """Tokens im Cache verbuchen; gedrosselt auf Disk persistieren."""
-    global _dirty, _last_flush
-    with _lock:
-        stats = _ensure_loaded()
-        stats["prompt_tokens"] += prompt
-        stats["completion_tokens"] += completion
-        if model:
-            m = stats.setdefault("models", {}).setdefault(
-                model.lower(), {"prompt": 0, "completion": 0})
-            m["prompt"] += prompt
-            m["completion"] += completion
-        _dirty = True
-        now = time.monotonic()
-        if now - _last_flush >= FLUSH_INTERVAL:
-            _write(stats)
-            _dirty = False
-            _last_flush = now
-
-
-def flush() -> None:
-    """Ungeschriebene Inkremente sofort persistieren (z.B. beim Shutdown)."""
-    global _dirty
-    with _lock:
-        if _dirty and _stats is not None:
-            _write(_stats)
-            _dirty = False
-
-
-atexit.register(flush)
+"""Token-Statistik (Verbrauch je Modell) mit gedrosseltem Persistieren.
+
+Früher wurde bei JEDEM Request die komplette JSON-Datei gelesen und geschrieben
+(Disk-Thrash). Jetzt: einmaliges Laden in einen In-Memory-Cache, Inkremente laufen
+gegen den Cache, Persistieren passiert höchstens alle FLUSH_INTERVAL Sekunden sowie
+beim Prozess-Ende (atexit). Lesen liefert immer den aktuellen (auch ungeflushten) Stand.
+"""
+
+import atexit
+import json
+import logging
+import threading
+import time
+
+from config import HERMES_HOME
+
+STATS_FILE = HERMES_HOME / "token_stats.json"
+FLUSH_INTERVAL = 5.0  # Sekunden zwischen Disk-Writes
+# Baseline (repräsentiert Verbrauch vor dem modellspezifischen Logging).
+_BASELINE = {"prompt_tokens": 718400, "completion_tokens": 324200, "models": {}}
+
+log = logging.getLogger(__name__)
+
+_lock = threading.Lock()
+_stats: dict | None = None
+_dirty = False
+_last_flush = 0.0
+# mtime der Datei beim letzten eigenen Laden/Schreiben — seit dem Gateway-Auszug
+# (UMBAU v3 P1) schreibt der mc2-gateway-Prozess die Datei, das Steuerpult liest nur
+# noch: ohne mtime-Vergleich zeigte es ab Prozessstart eingefrorene Zahlen.
+_disk_mtime: float | None = None
+
+
+def _stat_mtime() -> float | None:
+    try:
+        return STATS_FILE.stat().st_mtime
+    except OSError:
+        return None
+
+
+def _load_from_disk() -> dict:
+    global _disk_mtime
+    _disk_mtime = _stat_mtime()
+    if not STATS_FILE.exists():
+        return dict(_BASELINE)
+    try:
+        with open(STATS_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        data.setdefault("prompt_tokens", 0)
+        data.setdefault("completion_tokens", 0)
+        data.setdefault("models", {})
+        return data
+    except (OSError, json.JSONDecodeError):
+        log.warning("token_stats: Laden fehlgeschlagen, nutze Baseline", exc_info=True)
+        return dict(_BASELINE)
+
+
+def _ensure_loaded() -> dict:
+    global _stats
+    if _stats is None:
+        _stats = _load_from_disk()
+    return _stats
+
+
+def _write(stats: dict) -> None:
+    global _disk_mtime
+    try:
+        STATS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = STATS_FILE.with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(stats, f)
+        tmp.replace(STATS_FILE)
+        _disk_mtime = _stat_mtime()  # eigener Write ist kein Fremd-Update
+    except OSError:
+        log.warning("token_stats: Schreiben fehlgeschlagen", exc_info=True)
+
+
+def get_stats() -> dict:
+    """Aktueller Stand (inkl. noch nicht geflushter Inkremente) als Kopie.
+
+    Multi-Prozess-fähig: Hat ein ANDERER Prozess (mc2-gateway) die Datei inzwischen
+    geschrieben und liegen hier keine ungeflushten Inkremente, wird frisch geladen.
+    Im Gateway-Prozess selbst ist nach jedem Flush Datei == Speicher → der
+    mtime-Vergleich lädt dort nie unnötig nach."""
+    global _stats
+    with _lock:
+        if _stats is not None and not _dirty:
+            mtime = _stat_mtime()
+            if mtime is not None and mtime != _disk_mtime:
+                _stats = _load_from_disk()
+        return json.loads(json.dumps(_ensure_loaded()))
+
+
+def increment_tokens(prompt: int, completion: int, model: str | None = None) -> None:
+    """Tokens im Cache verbuchen; gedrosselt auf Disk persistieren."""
+    global _dirty, _last_flush
+    with _lock:
+        stats = _ensure_loaded()
+        stats["prompt_tokens"] += prompt
+        stats["completion_tokens"] += completion
+        if model:
+            m = stats.setdefault("models", {}).setdefault(
+                model.lower(), {"prompt": 0, "completion": 0})
+            m["prompt"] += prompt
+            m["completion"] += completion
+        _dirty = True
+        now = time.monotonic()
+        if now - _last_flush >= FLUSH_INTERVAL:
+            _write(stats)
+            _dirty = False
+            _last_flush = now
+
+
+def flush() -> None:
+    """Ungeschriebene Inkremente sofort persistieren (z.B. beim Shutdown)."""
+    global _dirty
+    with _lock:
+        if _dirty and _stats is not None:
+            _write(_stats)
+            _dirty = False
+
+
+atexit.register(flush)

backend/services/voice_metrics.py

@@ -1,24 +1,44 @@
 """
-Per-Stage-Latenz-Metriken für die Voice/Lucy-Pipeline.
+Per-Stage-Latenz-Metriken + Per-Turn-Trace für die Voice/Lucy-Pipeline.
 
-Misst die Server-seitige Dauer jeder Stufe (STT, Vision-Beschreibung, Chat-TTFB, TTS) und hält
-rollende Statistiken (avg/p50/p95/last) im Speicher. Macht aus Latenz-VERMUTUNGEN gemessene Fakten
-— die eigentliche Voraussetzung, um gezielt zu optimieren (Stufe 5/C2 des Reviews). Anzeige im
-Frontend-Overhaul (E) analog zur TokenPerformanceCard.
+Zwei Sichten auf dieselben Messungen:
+
+1. **Rollende Stats** (`record_stage`/`Timer`/`get_metrics`) — avg/p50/p95/last je Stufe über die
+   letzten N Messungen. Gut für Trends („Wie schnell ist STT im Schnitt?").
+2. **Per-Turn-Trace** (`TurnTrace`/`get_trace`) — jeder einzelne Chat-Turn als eigener Datensatz mit
+   seinem Stufen-Breakdown. Nur so sieht man den EINEN langsamen Turn (der 30-s-Hänger), den ein
+   Durchschnitt verschluckt. Das war der eigentliche Anlass (Telegram-/Voice-Hänger diagnostizieren).
+
+**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
+Unter-Detail INNERHALB der Hirn-Zeit ausgewiesen (kein Doppelzählen). Die **Tool-Runden** dagegen laufen
+im Hermes-LLM-Loop ohne Callback an MC2 → für MC2 unsichtbar, sie stecken im „Generierung"-Bucket.
+
+STT (davor) und Mem0-Retrieve (währenddessen) sind separate HTTP-Requests ohne Turn-ID. Auf einem
+EIN-Nutzer-Gerät genügt eine schlanke Best-Effort-Korrelation: die zuletzt gemessene STT-Dauer bzw. der
+letzte Retrieve werden global „geparkt" und vom nächsten Chat-Turn eingesammelt (mit Frist-/Reihenfolge-
+Check). Kein Turn-ID-Durchreichen durch den Lucy-Client nötig.
 
 In-Memory + thread-safe (keine Datei-I/O — Latenz-Telemetrie ist transient, Restart = Reset).
 """
 
 import threading
 import time
+import uuid
 from collections import deque
 
 _LOCK = threading.Lock()
 _MAX = 200
 _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", "chat_ttfb", "tts")
+STAGES = ("stt", "vision", "memory_retrieve", "chat_ttfb", "chat_first_content", "tts")
+
+# Best-effort-Korrelation (Ein-Nutzer-Gerät): zuletzt gemessene STT-Dauer / Mem0-Retrieve, je
+# (ms, perf_counter-Zeitstempel). Der nächste passende Chat-Turn sammelt sie ein und leert sie.
+_PARKED: dict[str, tuple[float, float] | None] = {"stt": None, "retrieve": None}
 
 
 def record_stage(stage: str, ms: float) -> None:
@@ -32,6 +52,36 @@ def record_stage(stage: str, ms: float) -> None:
         dq.append(float(ms))
 
 
+def park(kind: str, ms: float) -> None:
+    """Eine Messung, die NICHT im Chat-Request selbst passiert (STT davor, Mem0-Retrieve als
+    Rückruf während), global parken, damit der nächste Chat-Turn sie einsammeln kann."""
+    if ms is None or ms < 0 or kind not in _PARKED:
+        return
+    with _LOCK:
+        _PARKED[kind] = (float(ms), time.perf_counter())
+
+
+def _take_stt(max_age: float = 20.0) -> float | None:
+    """Geparkte STT-Dauer einsammeln, wenn frisch (STT liegt VOR dem Turn-Start)."""
+    with _LOCK:
+        v = _PARKED.get("stt")
+        if v and (time.perf_counter() - v[1]) <= max_age:
+            _PARKED["stt"] = None
+            return round(v[0], 1)
+    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)."""
@@ -48,6 +98,68 @@ class Timer:
         record_stage(self.stage, (time.perf_counter() - self._t0) * 1000.0)
 
 
+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.
+    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]
+        self.ts = time.time()
+        self.perf0 = time.perf_counter()
+        self._brain0 = self.perf0                # Referenz für die Hirn-Zeit (nach Vision neu gesetzt)
+        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.had_images = False
+        self.error: str | None = None
+
+    def note_vision(self, ms: float) -> None:
+        self.vision_ms = round(ms, 1)
+        record_stage("vision", ms)
+
+    def mark_brain_start(self) -> None:
+        """Startpunkt der Hirn-Zeit — direkt VOR dem Hermes-Request, damit die Vision-Zeit NICHT
+        in die Hirn-Zeit gezählt wird (sonst Doppelzählung mit dem Vision-Segment)."""
+        self._brain0 = time.perf_counter()
+
+    def note_ttfb(self) -> None:
+        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)."""
+        ms = (time.perf_counter() - self._brain0) * 1000.0
+        self.hirn_ms = round(ms, 1)
+        record_stage("chat_first_content", ms)
+
+    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 = {
+            "id": self.id,
+            "ts": round(self.ts, 3),
+            "session": self.session_id,
+            "kind": self.kind,
+            "had_images": self.had_images,
+            "stt_ms": stt,
+            "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,
+        }
+        with _LOCK:
+            _TURNS.append(rec)
+        return rec
+
+
 def _summary(vals: list[float]) -> dict:
     if not vals:
         return {"count": 0}
@@ -66,3 +178,10 @@ def get_metrics() -> dict:
     """Rollende Zusammenfassung je Stufe."""
     with _LOCK:
         return {stage: _summary(list(dq)) for stage, dq in _STAGES.items()}
+
+
+def get_trace(limit: int = 20) -> list[dict]:
+    """Die letzten `limit` Chat-Turns (neueste zuerst) mit Stufen-Breakdown."""
+    limit = max(1, min(int(limit or 20), _TURNS.maxlen or 60))
+    with _LOCK:
+        return list(_TURNS)[-limit:][::-1]

backend/services/warmer.py

@@ -1,77 +1,140 @@
-"""
-Hält das Agent-Hirn (Rolle `hermes`) dauerhaft warm.
-
-Hintergrund: llama-swap ist EIN-Gruppen-resident — lädt ein on-demand-Modell außerhalb
-der `brains`-Gruppe, wird die ganze Gruppe (inkl. Hirn) verdrängt. `persist: true`
-verhindert nur Idle-Unload, NICHT die Gruppen-Verdrängung; neu vorgewärmt wird sonst erst
-beim nächsten llama-swap-(Re)Start. Dieser Wächter schließt die Lücke: ist die Box idle
-(nichts geladen), pingt er das Hirn vor. Während aktiver Last (irgendetwas geladen) hält
-er sich raus, verdrängt also nie ein gerade genutztes Modell.
-
-Abschaltbar/justierbar via Env: MC_REWARM_ENABLED=0, MC_REWARM_INTERVAL, MC_REWARM_MODEL.
-"""
-
-import asyncio
-import logging
-import os
-
-import httpx
-
-from config import LLAMA_SWAP_URL
-
-log = logging.getLogger(__name__)
-
-ENABLED = os.environ.get("MC_REWARM_ENABLED", "1") != "0"
-INTERVAL = int(os.environ.get("MC_REWARM_INTERVAL", "90"))     # Sekunden zwischen Checks
-START_DELAY = int(os.environ.get("MC_REWARM_START_DELAY", "25"))
-
-
-def _brain_model() -> str:
-    """Aktives Agent-Hirn = Hermes' model.default (sonst model.model). So wärmt der Wächter
-    immer das WIRKLICH genutzte Hirn (passt sich Hirn-Wechseln an). Override: MC_REWARM_MODEL."""
-    forced = os.environ.get("MC_REWARM_MODEL")
-    if forced:
-        return forced
-    try:
-        from ruamel.yaml import YAML
-        from config import HERMES_HOME
-        p = HERMES_HOME / "config.yaml"
-        if p.exists():
-            with p.open(encoding="utf-8") as f:
-                cfg = YAML().load(f) or {}
-            m = (cfg.get("model") or {}) if isinstance(cfg, dict) else {}
-            v = m.get("default") or m.get("model")
-            if v:
-                return str(v)
-    except Exception:
-        log.debug("rewarm: Hirn-Lookup fehlgeschlagen", exc_info=True)
-    return "fast"
-
-
-async def _running_empty() -> bool:
-    async with httpx.AsyncClient(timeout=8.0) as c:
-        r = await c.get(f"{LLAMA_SWAP_URL}/running")
-        data = r.json() or {}
-    return not (data.get("running") or [])
-
-
-async def _warm(model: str) -> None:
-    async with httpx.AsyncClient(timeout=180.0) as c:
-        await c.post(f"{LLAMA_SWAP_URL}/v1/chat/completions", json={
-            "model": model, "max_tokens": 1,
-            "messages": [{"role": "user", "content": "ping"}],
-        })
-
-
-async def rewarm_loop() -> None:
-    """Endlos-Schleife (Hintergrund-Task): prüft periodisch, wärmt bei Idle vor."""
-    await asyncio.sleep(START_DELAY)   # Box/Engine nach MC-Start setzen lassen
-    while True:
-        try:
-            if await _running_empty():
-                model = _brain_model()
-                log.info("rewarm: Box idle → Hirn '%s' wird vorgewärmt", model)
-                await _warm(model)
-        except Exception:
-            log.debug("rewarm: Tick fehlgeschlagen", exc_info=True)
-        await asyncio.sleep(INTERVAL)
+"""
+Hält das ganze WARM-SET (Hirn + Gedächtnis/embed) dauerhaft warm. Die Augen (vision/VL-30B)
+sind seit 07.07. ON-DEMAND (ttl 900, User-Entscheid) und gehören NICHT mehr zum Warm-Set.
+
+Hintergrund: llama-swap ist EIN-Gruppen-resident — lädt ein on-demand-Modell außerhalb
+der `brains`-Gruppe, wird die ganze Gruppe verdrängt. `persist: true` verhindert nur
+Idle-Unload, NICHT die Gruppen-Verdrängung; auch ein `-watch-config`-Reload (jede Config-
+Änderung/Deploy) verwirft das Set, ohne llama-swaps ExecStartPost-Warmup neu auszulösen.
+Dieser Wächter schließt die Lücke: ist die Box idle (nichts geladen), lädt er das ganze
+Set über deploy/warmup.sh nach — Hirn UND embed (sonst bliebe embed kalt, live vom
+Review-Wächter beobachtet). Während aktiver Last (irgendetwas geladen) hält er sich
+raus, verdrängt also nie ein gerade genutztes Modell.
+
+warmup.sh deckt korrekt ab: fast über /v1/chat/completions, embed über /v1/embeddings
+(anderer Endpunkt!) und das Vorkauen des ~70-KB-Agent-Prompts. Es ist selbst-detachend.
+
+Abschaltbar/justierbar via Env: MC_REWARM_ENABLED=0, MC_REWARM_INTERVAL. Welche Modelle
+warmup.sh lädt: MC_WARMUP_MODELS (Default 'fast') + MC_WARMUP_EMBED (Default 'embed').
+"""
+
+import asyncio
+import logging
+import os
+import subprocess
+
+import httpx
+from config import LLAMA_SWAP_URL
+
+log = logging.getLogger(__name__)
+
+ENABLED = os.environ.get("MC_REWARM_ENABLED", "1") != "0"
+INTERVAL = int(os.environ.get("MC_REWARM_INTERVAL", "90"))     # Sekunden zwischen Checks
+START_DELAY = int(os.environ.get("MC_REWARM_START_DELAY", "25"))
+NUDGE_GRACE = int(os.environ.get("MC_REWARM_NUDGE_GRACE", "3"))  # llama-swap den Reload abschließen lassen
+
+# Das geteilte Warm-Skript (auch llama-swaps ExecStartPost) — EINE Quelle für „was ist das
+# Warm-Set und wie wärmt man es korrekt", statt hier eine zweite, ärmere Logik zu pflegen.
+_WARMUP_SH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "deploy", "warmup.sh"))
+
+# Wecksignal für einen sofortigen Vorwärm-Check (statt bis zum nächsten INTERVAL-Tick zu warten).
+# Wird von write_config() nach einer Config-Änderung gesetzt: llama-swap (-watch-config) lädt die
+# neue Config und verwirft dabei ALLE Modelle inkl. Hirn — ohne Nudge bliebe es bis zu INTERVAL
+# Sekunden kalt liegen, bis der nächste Tick oder eine Anfrage es wieder lädt.
+_loop: asyncio.AbstractEventLoop | None = None
+_wake: asyncio.Event | None = None
+
+
+def nudge() -> None:
+    """Threadsicher: bittet den Wächter, nach einem Config-Reload bald vorzuwärmen. No-op,
+    solange der Wächter (noch) nicht läuft."""
+    if _loop is not None and _wake is not None and not _loop.is_closed():
+        try:
+            _loop.call_soon_threadsafe(_wake.set)
+        except RuntimeError:
+            pass
+
+
+def _run_warmup() -> bool:
+    """Volles Warm-Set via deploy/warmup.sh nachladen (fast+vision über /v1/chat/completions,
+    embed über /v1/embeddings, plus Agent-Prompt-Prefill). Selbst-detachend, blockiert nicht.
+    False, wenn das Skript fehlt."""
+    if not os.path.exists(_WARMUP_SH):
+        log.warning("rewarm: warmup.sh nicht gefunden (%s) — kein Nachwärmen möglich", _WARMUP_SH)
+        return False
+    try:
+        subprocess.Popen(["bash", _WARMUP_SH],
+                         env={**os.environ, "MC_LLAMA_SWAP_URL": LLAMA_SWAP_URL},
+                         stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return True
+    except Exception:
+        log.debug("rewarm: warmup.sh-Start fehlgeschlagen", exc_info=True)
+        return False
+
+
+def _warmset_members() -> set[str]:
+    """Soll-Warm-Set. `MC_WARMSET` (leerzeichengetrennt) schlägt die Gruppen-Ableitung.
+
+    Warum ein Override (26.07.2026): Seit die ko-residente Gruppe auch Modelle MIT TTL
+    enthält (Coder 90 min, Kritiker 30 min), ist „alle Gruppen-Mitglieder" das falsche Ziel.
+    Der Wächter würde gegen die TTLs arbeiten und nachts 62 GB wieder hochladen, die
+    absichtlich freigegeben wurden. Ko-Residenz („dürfen gleichzeitig liegen") und
+    Warm-Pflicht („müssen immer liegen") sind zwei verschiedene Aussagen — die Gruppe kann
+    nur die erste ausdrücken.
+    """
+    explizit = os.environ.get("MC_WARMSET", "").split()
+    if explizit:
+        return set(explizit)
+    try:
+        from services import llamaswap
+        groups = llamaswap.list_groups() or {}
+    except Exception:
+        return set()
+    want: set[str] = set()
+    for g in groups.values():
+        if isinstance(g, dict) and (g.get("swap") is False or g.get("persist") or g.get("persistent")):
+            want.update(g.get("members") or [])
+    return want
+
+
+async def _warmset_missing() -> list[str] | None:
+    """Warm-Set-Mitglieder, die NICHT 'ready' in /running sind. [] = alles warm, None = /running
+    nicht lesbar. Erkennt auch TEIL-Kälte (nur Hirn warm, Augen/embed rausgefallen) — genau der
+    Fall, der nach einem watch-config-Reload/Deploy auftritt."""
+    try:
+        async with httpx.AsyncClient(timeout=8.0) as c:
+            r = await c.get(f"{LLAMA_SWAP_URL}/running")
+            data = r.json() or {}
+    except Exception:
+        return None
+    ready = {str(x.get("model")) for x in (data.get("running") or []) if x.get("state") == "ready"}
+    want = _warmset_members()
+    if not want:                                   # Set unbekannt → alte Heuristik: nur bei ganz leer
+        return [] if ready else ["<leer>"]
+    return [m for m in want if m not in ready]
+
+
+async def rewarm_loop() -> None:
+    """Endlos-Schleife (Hintergrund-Task): hält das ganze Warm-Set warm. Prüft periodisch, ob ein
+    Mitglied fehlt (Teil-Kälte!), und sofort nach einem Config-Reload-Nudge — lädt via warmup.sh nach."""
+    global _loop, _wake
+    _loop = asyncio.get_running_loop()
+    _wake = asyncio.Event()
+    await asyncio.sleep(START_DELAY)   # Box/Engine nach MC-Start setzen lassen
+    while True:
+        try:
+            missing = await _warmset_missing()
+            if missing:
+                log.info("rewarm: Warm-Set unvollständig (%s) → warmup.sh", ", ".join(missing))
+                _run_warmup()
+        except Exception:
+            log.debug("rewarm: Tick fehlgeschlagen", exc_info=True)
+        # Bis zum nächsten Tick warten ODER sofort auf einen Config-Reload-Nudge reagieren.
+        try:
+            await asyncio.wait_for(_wake.wait(), timeout=INTERVAL)
+            _wake.clear()
+            await asyncio.sleep(NUDGE_GRACE)   # llama-swap den Reload abschließen lassen
+            log.info("rewarm: Config-Reload → warmup.sh (volles Warm-Set nachladen)")
+            _run_warmup()
+        except asyncio.TimeoutError:
+            pass

backend/steward.py

@@ -0,0 +1,80 @@
+"""
+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
+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
+Module) als eigener Mini-Dienst (mc2-steward.service, Restart=always):
+
+  • warmer.rewarm_loop      — Warm-Set nachladen (+ Config-Watch ersetzt den
+                              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)
+
+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)
+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.
+"""
+
+import asyncio
+import logging
+import os
+
+from config import CONFIG_PATH
+from services import memory as memory_svc
+from services import sentry, warmer
+
+logging.basicConfig(
+    level=os.environ.get("MC_LOG_LEVEL", "INFO").upper(),
+    format="%(asctime)s %(levelname)-7s %(name)s: %(message)s",
+)
+log = logging.getLogger("steward")
+
+# Wie oft nach einer llama-swap-Config-Änderung geschaut wird (mtime-Watch). Ersetzt
+# warmer.nudge() aus dem MC2-Prozess: ein -watch-config-Reload verwirft das Warm-Set,
+# wir sehen die Änderung binnen Sekunden statt erst beim nächsten 90s-Tick.
+CONFIG_WATCH_S = int(os.environ.get("MC_STEWARD_CONFIG_WATCH_S", "5"))
+
+
+async def config_watch() -> None:
+    last: float | None = None
+    while True:
+        try:
+            mtime = CONFIG_PATH.stat().st_mtime
+        except OSError:
+            mtime = None
+        if last is not None and mtime is not None and mtime != last:
+            log.info("steward: %s geändert → Warm-Set-Nudge", CONFIG_PATH)
+            warmer.nudge()
+        last = mtime
+        await asyncio.sleep(CONFIG_WATCH_S)
+
+
+async def main() -> None:
+    tasks: list[asyncio.Task] = []
+    if warmer.ENABLED:
+        tasks.append(asyncio.create_task(warmer.rewarm_loop()))
+        tasks.append(asyncio.create_task(config_watch()))
+        log.info("Re-Warm-Wächter aktiv (Intervall %ss, Config-Watch %ss)",
+                 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
+    await asyncio.gather(*tasks)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

client/hermes-pc/executor.py

@@ -51,6 +51,10 @@ async def run_shell(req: dict):
             ["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd],
             capture_output=True, text=True, timeout=60,
             encoding="utf-8", errors="replace",
+            # Der Executor läuft unter pythonw (kein eigenes Konsolenfenster) — ohne dieses
+            # Flag bekäme JEDE gespawnte powershell ein sichtbares Fenster (beim 10-s-Polling
+            # der Lucy-Annahme blitzte das im Sekundentakt auf dem Desktop, 12.07.).
+            creationflags=subprocess.CREATE_NO_WINDOW,
         )
         return {
             "stdout": result.stdout.strip(),
@@ -108,13 +112,49 @@ async def press_keys(req: dict):
         raise HTTPException(500, str(e))
 
 
+# ── Medien & Lautstärke (A3: Lucy steuert den PC per Sprache) ──────────────
+# Media-Keys wirken auf den AKTIVEN Player (Spotify, YouTube, VLC …) — genau wie
+# die Tasten auf einer Multimedia-Tastatur. Lautstärke = System-Master (2 % je Schritt).
+MEDIA_KEYS = {"play_pause": "playpause", "next": "nexttrack", "prev": "prevtrack", "stop": "stop"}
+VOLUME_KEYS = {"up": "volumeup", "down": "volumedown", "mute": "volumemute"}
+
+
+@app.post("/media", dependencies=[Depends(require_auth)])
+async def media_control(req: dict):
+    action = (req.get("action") or "").strip().lower()
+    key = MEDIA_KEYS.get(action)
+    if not key:
+        raise HTTPException(400, f"Unbekannte Aktion '{action}'. Erlaubt: {', '.join(MEDIA_KEYS)}")
+    try:
+        import pyautogui
+        pyautogui.press(key)
+        return {"ok": True, "action": action}
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@app.post("/volume", dependencies=[Depends(require_auth)])
+async def volume_control(req: dict):
+    action = (req.get("action") or "").strip().lower()
+    key = VOLUME_KEYS.get(action)
+    if not key:
+        raise HTTPException(400, f"Unbekannte Aktion '{action}'. Erlaubt: {', '.join(VOLUME_KEYS)}")
+    steps = 1 if action == "mute" else max(1, min(25, int(req.get("steps", 5))))
+    try:
+        import pyautogui
+        pyautogui.press(key, presses=steps, interval=0.02)
+        return {"ok": True, "action": action, "steps": steps}
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
 # ── Apps / Browser ─────────────────────────────────────────────────────────
 
 @app.post("/open", dependencies=[Depends(require_auth)])
 async def open_target(req: dict):
     target = req.get("target", "")
     try:
-        if target.startswith("http://") or target.startswith("https://"):
+        if target.startswith(("http://", "https://")):
             webbrowser.open(target)
         else:
             os.startfile(target)

client/hermes-voice/agent_client.py

@@ -1,31 +0,0 @@
-"""Spricht mit dem Hermes Agent Daemon auf der AI Box."""
-import httpx
-
-TIMEOUT = 120
-
-
-def ask_agent(text: str, screenshot_b64: str | None, settings: dict) -> tuple[str, list]:
-    """Schickt Nachricht an den Daemon, gibt (response, tool_calls) zurück."""
-    daemon_url = settings.get("agent_daemon_url", "http://192.168.178.151:8765")
-    try:
-        with httpx.Client(timeout=TIMEOUT) as c:
-            resp = c.post(f"{daemon_url}/chat", json={
-                "message": text,
-                "screenshot": screenshot_b64,
-            })
-            resp.raise_for_status()
-            data = resp.json()
-            return data.get("response", ""), data.get("tool_calls", [])
-    except httpx.TimeoutException:
-        return "Antwort hat zu lange gedauert.", []
-    except Exception as e:
-        return f"Agent nicht erreichbar: {e}", []
-
-
-def get_agent_status(settings: dict) -> dict:
-    daemon_url = settings.get("agent_daemon_url", "http://192.168.178.151:8765")
-    try:
-        with httpx.Client(timeout=5) as c:
-            return c.get(f"{daemon_url}/status").json()
-    except Exception:
-        return {"alive": False}

client/hermes-voice/ai_client.py

@@ -1,47 +0,0 @@
-import httpx
-
-SYSTEM_PROMPT = (
-    "Du bist Hermes, ein hilfreicher KI-Assistent. "
-    "Antworte kurz und präzise, da deine Antwort vorgelesen wird. "
-    "Maximal 3-4 Sätze, kein Markdown."
-)
-REQUEST_TIMEOUT = 30
-
-
-def ask(text: str, screenshot_b64: str | None, settings: dict) -> str:
-    """Schickt Text (+ optionalen Screenshot) an MC2 und gibt die Antwort zurück."""
-    use_vision = screenshot_b64 is not None
-    model = settings.get("vision_model", "Qwen3-VL-2B-Instruct") if use_vision \
-        else settings.get("chat_model", "Hermes-4-14B")
-    base_url = settings.get("mc2_url", "http://192.168.178.151:9001/v1")
-    max_tokens = int(settings.get("max_response_tokens", 200))
-
-    if use_vision:
-        user_content = [
-            {"type": "text", "text": text},
-            {"type": "image_url", "image_url": {
-                "url": f"data:image/jpeg;base64,{screenshot_b64}"
-            }},
-        ]
-    else:
-        user_content = text
-
-    payload = {
-        "model": model,
-        "messages": [
-            {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": user_content},
-        ],
-        "max_tokens": max_tokens,
-        "stream": False,
-    }
-
-    try:
-        with httpx.Client(timeout=REQUEST_TIMEOUT) as client:
-            response = client.post(f"{base_url}/chat/completions", json=payload)
-            response.raise_for_status()
-            return response.json()["choices"][0]["message"]["content"].strip()
-    except httpx.TimeoutException:
-        return "Entschuldigung, die Antwort hat zu lange gedauert."
-    except Exception as e:
-        return f"Verbindungsfehler: {e}"

client/hermes-voice/audio_input.py

@@ -1,91 +0,0 @@
-"""
-Audio-Input: Aufnahme + Whisper STT.
-Kein Wake-Word-Loop — Aufnahme startet direkt auf Hotkey-Signal.
-"""
-import os
-import tempfile
-import threading
-import numpy as np
-import sounddevice as sd
-import scipy.io.wavfile as wav
-from faster_whisper import WhisperModel
-from pathlib import Path
-
-SAMPLE_RATE = 16000
-CHUNK = 1024
-ENERGY_THRESHOLD = 0.008
-
-_model: WhisperModel | None = None
-_model_size: str = ""
-_recording = False
-_frames: list[np.ndarray] = []
-_stream: sd.InputStream | None = None
-_lock = threading.Lock()
-
-
-def load_model(model_size: str):
-    global _model, _model_size
-    if _model is None or _model_size != model_size:
-        model_dir = Path.home() / ".hermes-voice" / "whisper-models"
-        model_dir.mkdir(parents=True, exist_ok=True)
-        _model = WhisperModel(
-            model_size,
-            device="cpu",
-            compute_type="int8",
-            download_root=str(model_dir),
-        )
-        _model_size = model_size
-
-
-def start_recording():
-    global _recording, _frames, _stream
-    with _lock:
-        _recording = True
-        _frames = []
-
-    def callback(indata, frames, time, status):
-        if _recording:
-            _frames.append(indata[:, 0].copy())
-
-    _stream = sd.InputStream(
-        samplerate=SAMPLE_RATE,
-        channels=1,
-        dtype="float32",
-        blocksize=CHUNK,
-        callback=callback,
-    )
-    _stream.start()
-
-
-def stop_recording() -> np.ndarray:
-    global _recording, _stream
-    with _lock:
-        _recording = False
-    if _stream:
-        _stream.stop()
-        _stream.close()
-        _stream = None
-    if not _frames:
-        return np.array([], dtype=np.float32)
-    return np.concatenate(_frames)
-
-
-def transcribe(audio: np.ndarray, model_size: str, language: str) -> str:
-    if len(audio) < SAMPLE_RATE * 0.3:
-        return ""
-    load_model(model_size)
-
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-        tmp = f.name
-    try:
-        wav.write(tmp, SAMPLE_RATE, (audio * 32767).astype(np.int16))
-        lang = language if language != "auto" else None
-        segments, _ = _model.transcribe(
-            tmp,
-            language=lang,
-            beam_size=3,
-            vad_filter=True,
-        )
-        return " ".join(s.text for s in segments).strip()
-    finally:
-        os.unlink(tmp)

client/hermes-voice/audio_output.py

@@ -1,70 +0,0 @@
-import asyncio
-import os
-import tempfile
-import threading
-import time
-import pygame
-import edge_tts
-
-pygame.mixer.init()
-_stop_event = threading.Event()
-_speak_lock = threading.Lock()
-
-
-def stop_speaking():
-    _stop_event.set()
-    pygame.mixer.music.stop()
-
-
-def speak(text: str, voice: str = "de-DE-SeraphinaMultilingualNeural", rate: str = "+0%"):
-    """Text → Edge TTS → Lautsprecher. Blockiert bis fertig oder unterbrochen."""
-    with _speak_lock:
-        _stop_event.clear()
-
-        tmp_path = None
-        try:
-            with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
-                tmp_path = f.name
-
-            # Edge TTS in eigenem Event-Loop (Thread-sicher)
-            loop = asyncio.new_event_loop()
-            try:
-                communicate = edge_tts.Communicate(text, voice, rate=rate)
-                loop.run_until_complete(communicate.save(tmp_path))
-            finally:
-                loop.close()
-
-            if _stop_event.is_set():
-                return
-
-            pygame.mixer.music.load(tmp_path)
-            pygame.mixer.music.play()
-
-            # Polling ohne pygame.time.wait (blockiert Event-Loop nicht)
-            while pygame.mixer.music.get_busy():
-                if _stop_event.is_set():
-                    pygame.mixer.music.stop()
-                    break
-                time.sleep(0.05)
-
-        except Exception:
-            pass
-        finally:
-            if tmp_path and os.path.exists(tmp_path):
-                try:
-                    os.unlink(tmp_path)
-                except OSError:
-                    pass
-
-
-def play_ding():
-    """Kurzer Aktivierungs-Ton (440 Hz, 120ms)."""
-    import numpy as np
-    sample_rate = 44100
-    duration = 0.12
-    t = np.linspace(0, duration, int(sample_rate * duration), False)
-    wave = (np.sin(2 * np.pi * 440 * t) * 0.3 * 32767).astype(np.int16)
-    stereo = np.column_stack([wave, wave])
-    sound = pygame.sndarray.make_sound(stereo)
-    sound.play()
-    time.sleep(duration + 0.02)

client/hermes-voice/build.bat

@@ -1,46 +0,0 @@
-@echo off
-cd /d "%~dp0"
-
-echo ========================================
-echo  Hermes Voice Client -- Build (.exe)
-echo ========================================
-echo.
-
-:: Venv pruefen
-if not exist ".venv\Scripts\activate.bat" (
-    echo [FEHLER] Bitte erst setup.bat ausfuehren.
-    pause
-    exit /b 1
-)
-
-:: PyInstaller installieren falls noetig
-.venv\Scripts\pip install pyinstaller -q
-
-echo [1/2] Baue HermesVoice.exe ...
-.venv\Scripts\pyinstaller ^
-    --onefile ^
-    --windowed ^
-    --name HermesVoice ^
-    --add-data "assets;assets" ^
-    --hidden-import "customtkinter" ^
-    --hidden-import "pynput.keyboard._win32" ^
-    --hidden-import "pynput.mouse._win32" ^
-    --collect-all "customtkinter" ^
-    main.py
-
-echo.
-if exist "dist\HermesVoice.exe" (
-    echo [2/2] Fertig!
-    echo.
-    echo  dist\HermesVoice.exe ^(%.0f MB^)
-    echo.
-    echo  Die .exe benoetigt beim ersten Start Internet fuer:
-    echo  - Whisper-Modell-Download ^(~150MB fuer "small"^)
-    echo  - Edge TTS ^(online^)
-    echo.
-    for %%I in ("dist\HermesVoice.exe") do echo  Groesse: %%~zI Bytes
-) else (
-    echo [FEHLER] Build fehlgeschlagen. Siehe build-Log oben.
-)
-echo ========================================
-pause

client/hermes-voice/config.py

@@ -1,62 +0,0 @@
-# Hermes Voice Client — Konfiguration
-# Alle Einstellungen hier anpassen, kein Code-Edit nötig.
-
-# ── AI-Box ──────────────────────────────────────────────────────────────
-MC2_BASE_URL = "http://192.168.178.151:9001/v1"
-
-# Modell für reine Text-Anfragen (kein Screenshot)
-CHAT_MODEL = "Hermes-4-14B"
-
-# Modell wenn ein Screenshot mitgeschickt wird
-VISION_MODEL = "Qwen3-VL-2B-Instruct"
-
-# ── Wake Word ────────────────────────────────────────────────────────────
-# Einfach den gewünschten Trigger-Text hier eintragen — kein Account, kein Download.
-# Whisper transkribiert Sprache und prüft ob eines der Wörter enthalten ist.
-# Mehrere Varianten möglich: ["hey hermes", "hermes", "hey jarvis"]
-WAKE_WORDS = ["hey hermes", "hermes"]
-
-# Whisper-Modell für die schnelle Wake-Detection (tiny = 39MB, sehr schnell)
-WAKE_WHISPER_MODEL = "tiny"
-
-# ── Spracheingabe ────────────────────────────────────────────────────────
-# faster-whisper Modellgröße: "tiny", "base", "small", "medium"
-# "small" läuft gut auf CPU (~244 MB), "base" ist schneller aber ungenauer
-WHISPER_MODEL_SIZE = "small"
-WHISPER_LANGUAGE = "de"  # "de" für Deutsch, "en" für Englisch, None = auto
-
-# Sekunden Stille bis Aufnahme endet
-SILENCE_TIMEOUT = 1.5
-# Maximale Aufnahmedauer in Sekunden (Sicherheitsnetz)
-MAX_RECORD_SECONDS = 20
-
-# ── Sprachausgabe ────────────────────────────────────────────────────────
-# Edge TTS Stimmen: https://speech.microsoft.com/portal/voicegallery
-# Deutsch: "de-DE-KillianNeural", "de-DE-SeraphinaMultilingualNeural"
-# Englisch: "en-US-AndrewNeural", "en-US-AriaNeural"
-TTS_VOICE = "de-DE-KillianNeural"
-TTS_RATE = "+0%"    # Geschwindigkeit: "+10%" schneller, "-10%" langsamer
-TTS_PITCH = "+0Hz"  # Tonhöhe
-
-# ── Screen Capture ───────────────────────────────────────────────────────
-# Screenshot bei jeder Anfrage mitschicken?
-SCREENSHOT_ON_QUERY = True
-# Monitor-Index (0 = alle, 1 = primär, 2 = zweiter Monitor)
-SCREENSHOT_MONITOR = 1
-# Auflösung für Screenshot (kleinere = schnellere Übertragung)
-SCREENSHOT_WIDTH = 1280
-SCREENSHOT_HEIGHT = 720
-
-# ── Agent-Verhalten ──────────────────────────────────────────────────────
-MAX_RESPONSE_TOKENS = 200  # kurze gesprochene Antworten
-REQUEST_TIMEOUT = 30       # Sekunden bis Timeout
-
-SYSTEM_PROMPT = """Du bist Hermes, ein KI-Assistent der direkt in den lokalen AI-Homelab integriert ist.
-Du hörst die Stimme des Nutzers und siehst seinen Bildschirm.
-
-Regeln für Antworten:
-- Kurz und präzise (2–4 Sätze maximum)
-- Kein Markdown, keine Aufzählungen, keine Codeblöcke — du wirst gesprochen
-- Wenn du einen offensichtlichen Fehler auf dem Bildschirm siehst, weise kurz darauf hin
-- Antworte auf Deutsch wenn der Nutzer Deutsch spricht, auf Englisch wenn Englisch
-- Sei direkt und hilfreich, kein unnötiges Smalltalk"""

client/hermes-voice/config_manager.py

@@ -1,39 +0,0 @@
-import json
-from pathlib import Path
-
-CONFIG_DIR = Path.home() / ".hermes-voice"
-SETTINGS_FILE = CONFIG_DIR / "settings.json"
-
-DEFAULTS = {
-    "mc2_url": "http://192.168.178.151:9001/v1",
-    "chat_model": "Hermes-4-14B",
-    "vision_model": "Qwen3-VL-2B-Instruct",
-    "hotkey": "ctrl_r",
-    "tts_voice": "de-DE-SeraphinaMultilingualNeural",
-    "tts_rate": "+0%",
-    "whisper_model": "small",
-    "language": "de",
-    "screenshot_enabled": True,
-    "screenshot_monitor": 1,
-    "max_response_tokens": 200,
-    "silence_timeout": 1.5,
-}
-
-
-def load() -> dict:
-    CONFIG_DIR.mkdir(exist_ok=True)
-    if SETTINGS_FILE.exists():
-        try:
-            saved = json.loads(SETTINGS_FILE.read_text(encoding="utf-8"))
-            return {**DEFAULTS, **saved}
-        except Exception:
-            pass
-    return dict(DEFAULTS)
-
-
-def save(settings: dict):
-    CONFIG_DIR.mkdir(exist_ok=True)
-    SETTINGS_FILE.write_text(
-        json.dumps(settings, indent=2, ensure_ascii=False),
-        encoding="utf-8",
-    )

client/hermes-voice/hotkey_listener.py

@@ -1,103 +0,0 @@
-"""
-Globaler Push-to-Talk Hotkey via pynput.
-Funktioniert auch wenn das Fenster minimiert/im Hintergrund ist.
-"""
-import threading
-from pynput import keyboard
-
-# Mapping: config-String → pynput Key/KeyCode
-_SPECIAL = {
-    "ctrl_r": keyboard.Key.ctrl_r,
-    "ctrl_l": keyboard.Key.ctrl_l,
-    "alt_r": keyboard.Key.alt_r,
-    "alt_l": keyboard.Key.alt_l,
-    "shift_r": keyboard.Key.shift_r,
-    "shift_l": keyboard.Key.shift_l,
-    "f13": keyboard.Key.f13,
-    "f14": keyboard.Key.f14,
-    "f15": keyboard.Key.f15,
-    "f16": keyboard.Key.f16,
-    "caps_lock": keyboard.Key.caps_lock,
-    "scroll_lock": keyboard.Key.scroll_lock,
-    "pause": keyboard.Key.pause,
-}
-
-DISPLAY_NAMES = {
-    "ctrl_r": "Rechte Strg",
-    "ctrl_l": "Linke Strg",
-    "alt_r": "Rechte Alt",
-    "alt_l": "Linke Alt",
-    "shift_r": "Rechte Shift",
-    "shift_l": "Linke Shift",
-    "f13": "F13", "f14": "F14", "f15": "F15", "f16": "F16",
-    "caps_lock": "Caps Lock",
-    "scroll_lock": "Scroll Lock",
-    "pause": "Pause",
-}
-
-
-def key_to_str(key) -> str:
-    """Konvertiert pynput Key → config-String."""
-    for name, k in _SPECIAL.items():
-        if key == k:
-            return name
-    if hasattr(key, "char") and key.char:
-        return key.char.lower()
-    return str(key).replace("Key.", "")
-
-
-def str_to_display(key_str: str) -> str:
-    return DISPLAY_NAMES.get(key_str, key_str.upper())
-
-
-class HotkeyListener:
-    def __init__(self, key_str: str, on_press_cb, on_release_cb):
-        self._key_str = key_str
-        self._on_press = on_press_cb
-        self._on_release = on_release_cb
-        self._pressed = False
-        self._listener: keyboard.Listener | None = None
-
-    def _target_key(self):
-        return _SPECIAL.get(self._key_str) or keyboard.KeyCode.from_char(self._key_str)
-
-    def _on_press_raw(self, key):
-        if not self._pressed and key == self._target_key():
-            self._pressed = True
-            self._on_press()
-
-    def _on_release_raw(self, key):
-        if self._pressed and key == self._target_key():
-            self._pressed = False
-            self._on_release()
-
-    def start(self):
-        self._listener = keyboard.Listener(
-            on_press=self._on_press_raw,
-            on_release=self._on_release_raw,
-        )
-        self._listener.start()
-
-    def stop(self):
-        if self._listener:
-            self._listener.stop()
-
-    def update_key(self, key_str: str):
-        self._key_str = key_str
-        self._pressed = False
-
-
-class KeyCapturer:
-    """Einmalig den nächsten Tastendruck abfangen für Hotkey-Konfiguration."""
-
-    def __init__(self, callback):
-        self._callback = callback
-        self._listener: keyboard.Listener | None = None
-
-    def start(self):
-        def on_press(key):
-            key_str = key_to_str(key)
-            self._listener.stop()
-            self._callback(key_str)
-        self._listener = keyboard.Listener(on_press=on_press)
-        self._listener.start()

client/hermes-voice/main.py

@@ -1,325 +0,0 @@
-"""
-Hermes Voice Client — GUI
-Push-to-Talk: Hotkey halten → sprechen → loslassen → Hermes antwortet
-"""
-import queue
-import threading
-import sys
-import customtkinter as ctk
-from PIL import Image, ImageDraw
-
-import config_manager as cfg
-from audio_input import start_recording, stop_recording, transcribe
-from audio_output import speak, stop_speaking, play_ding
-from screen_capture import capture_screen
-from agent_client import ask_agent, get_agent_status
-from hotkey_listener import HotkeyListener, KeyCapturer, str_to_display
-
-ctk.set_appearance_mode("dark")
-ctk.set_default_color_theme("blue")
-
-# ── UI-Event-Queue (thread-safe) ─────────────────────────────────────────
-_ui_queue: queue.Queue = queue.Queue()
-
-def ui_event(event: str, data=None):
-    _ui_queue.put((event, data))
-
-
-# ── Hauptfenster ─────────────────────────────────────────────────────────
-class HermesApp(ctk.CTk):
-    def __init__(self):
-        super().__init__()
-        self.settings = cfg.load()
-        self._hotkey: HotkeyListener | None = None
-        self._worker: threading.Thread | None = None
-
-        self.title("Hermes Voice")
-        self.geometry("400x520")
-        self.resizable(False, False)
-        self.protocol("WM_DELETE_WINDOW", self._on_close)
-
-        self._build_ui()
-        self._start_hotkey()
-        self.after(100, self._poll_queue)
-
-    # ── Layout ───────────────────────────────────────────────────────────
-    def _build_ui(self):
-        self.grid_columnconfigure(0, weight=1)
-        self.grid_rowconfigure(2, weight=1)
-
-        # Header
-        header = ctk.CTkFrame(self, height=50, corner_radius=0)
-        header.grid(row=0, column=0, sticky="ew")
-        header.grid_columnconfigure(0, weight=1)
-        ctk.CTkLabel(header, text="⚡ Hermes Voice",
-                     font=ctk.CTkFont(size=16, weight="bold")).grid(
-            row=0, column=0, padx=16, pady=12, sticky="w")
-        ctk.CTkButton(header, text="⚙", width=36, height=36,
-                      command=self._open_settings).grid(
-            row=0, column=1, padx=8, pady=8)
-
-        # Status
-        status_frame = ctk.CTkFrame(self, corner_radius=12)
-        status_frame.grid(row=1, column=0, padx=16, pady=(16, 8), sticky="ew")
-        status_frame.grid_columnconfigure(0, weight=1)
-
-        self._status_dot = ctk.CTkLabel(status_frame, text="●",
-                                        font=ctk.CTkFont(size=32),
-                                        text_color="#22c55e")
-        self._status_dot.grid(row=0, column=0, pady=(12, 4))
-
-        self._status_label = ctk.CTkLabel(status_frame, text="Bereit",
-                                          font=ctk.CTkFont(size=14))
-        self._status_label.grid(row=1, column=0, pady=(0, 4))
-
-        self._hotkey_label = ctk.CTkLabel(
-            status_frame,
-            text=f"[ {str_to_display(self.settings['hotkey'])} ] gedrückt halten",
-            font=ctk.CTkFont(size=11),
-            text_color="gray",
-        )
-        self._hotkey_label.grid(row=2, column=0, pady=(0, 12))
-
-        # Conversation log
-        log_frame = ctk.CTkFrame(self, corner_radius=12)
-        log_frame.grid(row=2, column=0, padx=16, pady=8, sticky="nsew")
-        log_frame.grid_columnconfigure(0, weight=1)
-        log_frame.grid_rowconfigure(1, weight=1)
-
-        ctk.CTkLabel(log_frame, text="Letzte Konversation",
-                     font=ctk.CTkFont(size=11), text_color="gray").grid(
-            row=0, column=0, padx=12, pady=(8, 0), sticky="w")
-
-        self._log = ctk.CTkTextbox(log_frame, font=ctk.CTkFont(size=12),
-                                   state="disabled", wrap="word")
-        self._log.grid(row=1, column=0, padx=8, pady=(4, 8), sticky="nsew")
-
-        # Footer
-        footer = ctk.CTkFrame(self, height=40, corner_radius=0)
-        footer.grid(row=3, column=0, sticky="ew")
-        footer.grid_columnconfigure(0, weight=1)
-
-        self._screenshot_var = ctk.BooleanVar(
-            value=self.settings["screenshot_enabled"])
-        ctk.CTkCheckBox(footer, text="Screenshot mitsenden",
-                        variable=self._screenshot_var,
-                        command=self._toggle_screenshot).grid(
-            row=0, column=0, padx=16, pady=8, sticky="w")
-
-        ctk.CTkButton(footer, text="Stop", width=60, height=28,
-                      fg_color="#dc2626", hover_color="#b91c1c",
-                      command=stop_speaking).grid(
-            row=0, column=1, padx=8, pady=8)
-
-    # ── Hotkey ───────────────────────────────────────────────────────────
-    def _start_hotkey(self):
-        if self._hotkey:
-            self._hotkey.stop()
-        self._hotkey = HotkeyListener(
-            self.settings["hotkey"],
-            on_press_cb=self._hotkey_pressed,
-            on_release_cb=self._hotkey_released,
-        )
-        self._hotkey.start()
-
-    def _hotkey_pressed(self):
-        ui_event("status", ("recording", "🔴 Ich höre…", "#ef4444"))
-        play_ding()
-        start_recording()
-
-    def _hotkey_released(self):
-        audio = stop_recording()
-        ui_event("status", ("thinking", "💭 Denke…", "#3b82f6"))
-        self._worker = threading.Thread(
-            target=self._process, args=(audio,), daemon=True)
-        self._worker.start()
-
-    def _process(self, audio):
-        text = transcribe(audio,
-                          self.settings["whisper_model"],
-                          self.settings["language"])
-        if not text:
-            ui_event("status", ("idle", "Bereit", "#22c55e"))
-            return
-
-        ui_event("log_user", text)
-        screenshot = (capture_screen()
-                      if self.settings["screenshot_enabled"] else None)
-
-        ui_event("status", ("thinking", "💭 Denke…", "#3b82f6"))
-        response, tool_calls = ask_agent(text, screenshot, self.settings)
-
-        for tc in tool_calls:
-            ui_event("log_tool", tc)
-
-        ui_event("log_hermes", response)
-        ui_event("status", ("speaking", "🔊 Spricht…", "#a855f7"))
-        speak(response, self.settings["tts_voice"], self.settings["tts_rate"])
-        ui_event("status", ("idle", "Bereit", "#22c55e"))
-
-    # ── Queue-Polling ────────────────────────────────────────────────────
-    def _poll_queue(self):
-        while not _ui_queue.empty():
-            event, data = _ui_queue.get_nowait()
-            if event == "status":
-                _, label, color = data
-                self._status_label.configure(text=label)
-                self._status_dot.configure(text_color=color)
-            elif event == "log_user":
-                self._append_log(f"Du: {data}")
-            elif event == "log_hermes":
-                self._append_log(f"Hermes: {data}\n")
-        self.after(80, self._poll_queue)
-
-    def _append_log(self, text: str):
-        self._log.configure(state="normal")
-        self._log.insert("end", text + "\n")
-        self._log.see("end")
-        self._log.configure(state="disabled")
-
-    # ── Settings Dialog ──────────────────────────────────────────────────
-    def _open_settings(self):
-        SettingsWindow(self)
-
-    def _toggle_screenshot(self):
-        self.settings["screenshot_enabled"] = self._screenshot_var.get()
-        cfg.save(self.settings)
-
-    def apply_settings(self, new_settings: dict):
-        self.settings = new_settings
-        cfg.save(new_settings)
-        self._hotkey.update_key(new_settings["hotkey"])
-        self._hotkey_label.configure(
-            text=f"[ {str_to_display(new_settings['hotkey'])} ] gedrückt halten")
-        self._screenshot_var.set(new_settings["screenshot_enabled"])
-
-    def _on_close(self):
-        if self._hotkey:
-            self._hotkey.stop()
-        stop_speaking()
-        self.destroy()
-
-
-# ── Settings Window ───────────────────────────────────────────────────────
-class SettingsWindow(ctk.CTkToplevel):
-    def __init__(self, parent: HermesApp):
-        super().__init__(parent)
-        self._parent = parent
-        self.title("Einstellungen")
-        self.geometry("420x520")
-        self.resizable(False, False)
-        self.grab_set()
-        self._s = dict(parent.settings)
-        self._capturing = False
-        self._build()
-
-    def _build(self):
-        self.grid_columnconfigure(1, weight=1)
-        row = 0
-
-        def label(text):
-            nonlocal row
-            ctk.CTkLabel(self, text=text, anchor="w").grid(
-                row=row, column=0, padx=16, pady=6, sticky="w")
-
-        def entry(key, width=240):
-            nonlocal row
-            var = ctk.StringVar(value=str(self._s.get(key, "")))
-            e = ctk.CTkEntry(self, textvariable=var, width=width)
-            e.grid(row=row, column=1, padx=16, pady=6, sticky="ew")
-            row += 1
-            return var
-
-        def dropdown(key, options, width=200):
-            nonlocal row
-            var = ctk.StringVar(value=str(self._s.get(key, options[0])))
-            dd = ctk.CTkOptionMenu(self, values=options, variable=var, width=width)
-            dd.grid(row=row, column=1, padx=16, pady=6, sticky="w")
-            row += 1
-            return var
-
-        def toggle(key):
-            nonlocal row
-            var = ctk.BooleanVar(value=bool(self._s.get(key, False)))
-            sw = ctk.CTkSwitch(self, text="", variable=var)
-            sw.grid(row=row, column=1, padx=16, pady=6, sticky="w")
-            row += 1
-            return var
-
-        label("MC2 URL")
-        self._url = entry("mc2_url")
-
-        label("Hotkey")
-        self._hotkey_frame = ctk.CTkFrame(self, fg_color="transparent")
-        self._hotkey_frame.grid(row=row, column=1, padx=16, pady=6, sticky="w")
-        self._hotkey_display = ctk.CTkLabel(
-            self._hotkey_frame,
-            text=str_to_display(self._s.get("hotkey", "ctrl_r")),
-            width=100,
-        )
-        self._hotkey_display.grid(row=0, column=0, padx=(0, 8))
-        ctk.CTkButton(self._hotkey_frame, text="Aufnehmen", width=90,
-                      command=self._capture_hotkey).grid(row=0, column=1)
-        row += 1
-
-        label("TTS Stimme")
-        self._voice = dropdown("tts_voice", [
-            "de-DE-SeraphinaMultilingualNeural",
-            "de-DE-AmalaNeural",
-            "de-DE-KatjaNeural",
-            "de-DE-KillianNeural",
-            "de-DE-ConradNeural",
-            "en-US-AriaNeural",
-            "en-US-JennyNeural",
-        ])
-
-        label("Whisper Modell")
-        self._whisper = dropdown("whisper_model",
-                                  ["tiny", "base", "small", "medium"])
-
-        label("Sprache")
-        self._lang = dropdown("language",
-                               ["de", "en", "auto"])
-
-        label("Screenshot")
-        self._screenshot = toggle("screenshot_enabled")
-
-        label("Monitor")
-        self._monitor = dropdown("screenshot_monitor", ["1", "2", "3"])
-
-        label("Max. Tokens")
-        self._tokens = entry("max_response_tokens", width=100)
-
-        row += 1
-        ctk.CTkButton(self, text="Speichern", command=self._save).grid(
-            row=row, column=0, columnspan=2, pady=16, padx=16, sticky="ew")
-
-    def _capture_hotkey(self):
-        self._hotkey_display.configure(text="Taste drücken…")
-
-        def on_key(key_str):
-            self._s["hotkey"] = key_str
-            self.after(0, lambda: self._hotkey_display.configure(
-                text=str_to_display(key_str)))
-
-        KeyCapturer(on_key).start()
-
-    def _save(self):
-        self._s["mc2_url"] = self._url.get().strip()
-        self._s["tts_voice"] = self._voice.get()
-        self._s["whisper_model"] = self._whisper.get()
-        self._s["language"] = self._lang.get()
-        self._s["screenshot_enabled"] = self._screenshot.get()
-        self._s["screenshot_monitor"] = int(self._monitor.get())
-        try:
-            self._s["max_response_tokens"] = int(self._tokens.get())
-        except ValueError:
-            pass
-        self._parent.apply_settings(self._s)
-        self.destroy()
-
-
-# ── Entry Point ───────────────────────────────────────────────────────────
-if __name__ == "__main__":
-    app = HermesApp()
-    app.mainloop()

client/hermes-voice/requirements.txt

@@ -1,29 +0,0 @@
-# Hermes Voice Client — Dependencies
-# Installation: pip install -r requirements.txt
-
-# Speech-to-Text (lokal auf CPU)
-faster-whisper>=1.0.0
-
-# Audio I/O
-sounddevice>=0.4.6
-numpy>=1.24.0
-scipy>=1.11.0
-
-# Text-to-Speech
-edge-tts>=6.1.9
-
-# Screen Capture
-mss>=9.0.1
-Pillow>=10.0.0
-
-# HTTP Client
-httpx>=0.27.0
-
-# Audio Playback
-pygame>=2.5.0
-
-# GUI
-customtkinter>=5.2.0
-
-# Globaler Hotkey
-pynput>=1.7.6

client/hermes-voice/screen_capture.py

@@ -1,19 +0,0 @@
-import base64
-import io
-import mss
-from PIL import Image
-from config import SCREENSHOT_MONITOR, SCREENSHOT_WIDTH, SCREENSHOT_HEIGHT
-
-
-def capture_screen() -> str:
-    """Screenshot des primären Monitors als base64-JPEG."""
-    with mss.mss() as sct:
-        monitor = sct.monitors[SCREENSHOT_MONITOR]
-        raw = sct.grab(monitor)
-        img = Image.frombytes("RGB", raw.size, raw.bgra, "raw", "BGRX")
-
-    img = img.resize((SCREENSHOT_WIDTH, SCREENSHOT_HEIGHT), Image.LANCZOS)
-
-    buf = io.BytesIO()
-    img.save(buf, format="JPEG", quality=80)
-    return base64.b64encode(buf.getvalue()).decode("utf-8")

client/hermes-voice/setup.bat

@@ -1,44 +0,0 @@
-@echo off
-:: Immer aus dem eigenen Verzeichnis laufen
-cd /d "%~dp0"
-
-echo ========================================
-echo  Hermes Voice Client -- Setup
-echo ========================================
-echo.
-
-:: Python pruefen
-python --version >nul 2>&1
-if errorlevel 1 (
-    echo [FEHLER] Python nicht gefunden. Bitte Python 3.11+ installieren.
-    pause
-    exit /b 1
-)
-
-:: Venv anlegen falls nicht vorhanden
-if not exist ".venv" (
-    echo [1/3] Erstelle virtuelle Umgebung...
-    python -m venv .venv
-)
-
-:: Dependencies installieren
-echo [2/3] Installiere Dependencies...
-.venv\Scripts\pip install --upgrade pip -q
-.venv\Scripts\pip install -r requirements.txt
-
-:: Kurz-Check
-echo [3/3] Pruefe Konfiguration...
-.venv\Scripts\python -c "import customtkinter; import pynput; print('GUI + Hotkey OK')"
-
-echo.
-echo ========================================
-echo  Setup abgeschlossen!
-echo.
-echo  Naechste Schritte:
-echo  1. start.bat ausfuehren
-echo  2. Einstellungen (Zahnrad) pruefen:
-echo     - MC2 URL (Standard: 192.168.178.151:9001)
-echo     - Hotkey (Standard: Rechte Strg)
-echo  Optional: build.bat fuer .exe-Kompilierung
-echo ========================================
-pause

client/hermes-voice/start.bat

@@ -1,4 +0,0 @@
-@echo off
-:: Hermes Voice Client starten (kein Konsolenfenster im Hintergrund)
-cd /d "%~dp0"
-start "" .venv\Scripts\pythonw.exe main.py

client/ide-skills/projekt-uebernehmen/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: projekt-uebernehmen
+description: Ein von der AI-Box vorbereitetes Projekt in Zed uebernehmen und starten - Konzept und Roadmap einlesen, die offenen Punkte mit dem Commander klaeren, dann Etappe 1 planen und bauen. Nutze diesen Skill beim ERSTEN Chat in einem Projekt-Ordner, der KONZEPT.md und ROADMAP.md enthaelt, aber noch keinen (oder kaum) eigenen Code - also bei jedem frisch vorbereiteten Repo aus dem Auftragsbuch.
+metadata:
+  quelle: mission-control-2/client/ide-skills
+---
+
+# Vorbereitetes Projekt übernehmen
+
+Die Box hat gedacht, du baust. Das Konzept in diesem Ordner ist **bereits gehärtet** — mehrere
+Fach-Rollen und ein Advocatus Diaboli haben es auf der Box durchgearbeitet. Deine Aufgabe ist
+nicht, es neu zu denken, sondern es umzusetzen.
+
+**Zwei Modelle, ein Ablauf:** Stufe 1 und 2 (einlesen, nachfragen, planen) gehören in den
+**Planer**, Stufe 3 (bauen) in den **Coder**. Du kannst nicht selbst umschalten — wenn der Plan
+freigegeben ist, bitte den Commander ausdrücklich darum, oben im Modellwähler auf Coder zu
+wechseln. Läufst du schon im Coder, ist das auch in Ordnung: dann gilt trotzdem erst lesen,
+fragen, Plan zeigen — und **keine Datei vor seinem „los"**.
+
+Drei Stufen, in dieser Reihenfolge. **Vor Stufe 3 wird keine Datei angefasst.**
+
+## 1. Einlesen — still, ohne Rückfragen
+
+Lies, was da ist: `KONZEPT.md`, `ROADMAP.md`, `AGENTS.md`, `SAVEPOINT.md`, `README.md`.
+Verschaff dir den Ist-Zustand: `git log --oneline -5` und den Dateibaum.
+
+Zwei Abbruch-Fälle — prüfe sie ZUERST:
+
+- **Es gibt schon Code und Historie.** Dann ist das keine Übernahme, sondern Fortsetzung:
+  arbeite nach `SAVEPOINT.md` weiter und sag in zwei Sätzen, wo ihr steht. Dieser Skill ist
+  hier fertig.
+- **Nur `KONZEPT.md` + `README.md`, keine `ROADMAP.md`.** Das ist ein *geprüfte-Idee*-Repo, kein
+  startklares Projekt — die Box legt bei „Idee prüfen" bewusst kein Gerüst an. Sag dem Commander:
+  *„Das ist bisher nur ein durchdachtes Konzept, noch kein Projekt. Im Auftragsbuch gibt es auf
+  der Karte den Knopf ‚Gefällt mir — Projekt daraus machen'; danach hat das Repo eine Roadmap und
+  ich kann loslegen."* Dann **STOPP**, nichts bauen.
+
+Sonst: fasse in **höchstens 8 Zeilen** zusammen — was gebaut wird, für wen, welche Technik,
+und was laut Roadmap **Etappe 1** ist. Alltagssprache, keine Fachbegriffe ohne Übersetzung.
+
+## 2. Fragen stellen — der eigentliche Wert dieses Schritts
+
+Stell **3 bis 6 Fragen**. Nicht mehr, und nur solche, die den Start wirklich blockieren.
+
+- **Nichts fragen, was in den Dokumenten steht.** Wer das Konzept nicht gelesen hat, merkt man
+  genau hier.
+- Jede Frage: eine Zeile, Alltagssprache, **mit deiner Empfehlung** („ich würde X nehmen, weil …").
+  Der Commander ist kein Entwickler — frag nach Zielen, Vorlieben und Gegebenheiten, nie nach
+  Bau-Prinzipien oder Architektur-Geschmack. Das ist dein Job.
+- Die üblichen echten Lücken: Wo läuft es am Ende? Welche Zugänge/Geräte/Pfade brauchst du von
+  ihm? Was ist in Etappe 1 ausdrücklich **nicht** drin? Woran merkt ihr beide, dass Etappe 1
+  fertig ist?
+- Der Abschnitt „offene Punkte" / „Risiken" im Konzept ist deine Fundgrube — genau dafür steht er da.
+
+Dann **warten**. Keine Annahmen, kein Vorpreschen, kein „ich fange schon mal an".
+
+## 3. Plan → „los" → bauen
+
+1. **Etappe-1-Plan** vorlegen: Ziel · Vorgehen in kleinen Schritten · Technik und warum ·
+   Fertig-Kriterien · Risiken. Etappe 1 muss **für sich lauffähig** sein — eine halbe Baustelle ist
+   kein Meilenstein.
+2. **STOPP**, auf sein „los" warten. Danach der Satz, den er hören muss: *„Bitte oben im
+   Modellwähler auf **Coder** umschalten, dann lege ich los."* Umschalten kannst du nicht selbst.
+3. Bauen: kleine Schritte, ein Sicherungspunkt (Commit mit klarem Namen) je Meilenstein und vor
+   riskanten Änderungen. Am Ende **live testen** — beweisen statt behaupten.
+4. Nachführen: `SAVEPOINT.md` (Stand, nächster Schritt, offene Fragen) und die erledigte Etappe in
+   `ROADMAP.md` abhaken. Das ist das Gedächtnis für den nächsten Chat.
+
+## Merksätze
+
+- **Du denkst das Konzept nicht neu.** Findest du einen echten Widerspruch oder eine Lücke:
+  benenne sie und frag — bau nicht still etwas anderes.
+- **Nichts bauen, was nicht in Etappe 1 steht.** Ideen für später gehören in die Roadmap, nicht
+  in den Code.
+- Geheimnisse (Schlüssel, Passwörter, Tokens) nie in den Code — `.env` plus `.gitignore`.
+- Klemmt dieselbe Sache zweimal: anhalten, sichern, erklären, fragen.

client/lucy-desktop/.gitignore

@@ -1,7 +0,0 @@
-node_modules/
-out/
-dist/
-*.log
-# Avatar-VRM ist gross + Lizenz/Redistribution -> nicht committen (lokal/Box vorhalten)
-src/renderer/public/avatar.vrm
-src/renderer/public/vad/

client/lucy-desktop/Lucy-Check.bat

@@ -1,8 +0,0 @@
-@echo off
-chcp 65001 >nul
-cd /d "%~dp0"
-curl -s -m 5 http://127.0.0.1:8130/health > lucy_check.log 2>&1
-echo.>> lucy_check.log
-echo --- electron/vite/pocket laeuft? --->> lucy_check.log
-powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match 'pocket_server:app|electron-vite|lucy-desktop' } | ForEach-Object { $_.Name + ' ' + $_.ProcessId }" >> lucy_check.log 2>&1
-type lucy_check.log

client/lucy-desktop/Lucy-Dev-Debug.bat

@@ -1,13 +0,0 @@
-@echo off
-chcp 65001 >nul
-cd /d "F:\Coding Stuff\mission-control-2\client\lucy-desktop"
-echo Beende haengende Versuche (ohne mich selbst)...
-powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'electron.exe' -or $_.CommandLine -match 'electron-vite|pocket_server:app|start-lucy' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -EA SilentlyContinue }"
-timeout /t 2 >nul
-echo Starte 'npm run dev' mit Log-Capture...
-start /b "" cmd /c "npm run dev > dev.log 2>&1"
-timeout /t 22 >nul
-echo === dev.log ===
-type dev.log
-echo.
-echo (laeuft im Hintergrund weiter, falls erfolgreich)

client/lucy-desktop/Lucy-Neustart.bat

@@ -1,12 +0,0 @@
-@echo off
-chcp 65001 >nul
-REM Hygiene: Recon-Log mit Token entfernen
-del /q "F:\Coding Stuff\mission-control-2\box_recon.log" 2>nul
-echo Beende laufende Lucy-Instanz (pocket_server :8130 + Electron/Vite)...
-powershell -NoProfile -ExecutionPolicy Bypass -Command "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match 'pocket_server:app|lucy-desktop|electron-vite' } | ForEach-Object { Write-Output ('kill ' + $_.ProcessId + ' ' + $_.Name); Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }"
-timeout /t 2 >nul
-echo.
-echo Starte Lucy neu (frischer Voice-Server + Client mit erweitertem Umlaut-Fix)...
-start "" "F:\Coding Stuff\mission-control-2\client\lucy-desktop\start-lucy.cmd"
-timeout /t 3 >nul
-echo Fertig.

client/lucy-desktop/Verknuepfung-erstellen.bat

@@ -1,7 +0,0 @@
-@echo off
-chcp 65001 >nul
-powershell -NoProfile -ExecutionPolicy Bypass -Command "$ws=New-Object -ComObject WScript.Shell; $p=Join-Path ([Environment]::GetFolderPath('Desktop')) 'Lucy.lnk'; $l=$ws.CreateShortcut($p); $l.TargetPath='F:\Coding Stuff\mission-control-2\client\lucy-desktop\start-lucy.cmd'; $l.WorkingDirectory='F:\Coding Stuff\mission-control-2\client\lucy-desktop'; $l.IconLocation='F:\Coding Stuff\mission-control-2\client\lucy-desktop\lucy.ico'; $l.Description='Lucy - lokaler Sprach-Companion starten'; $l.Save(); Write-Output ('OK: ' + $p)" > lucy_shortcut.log 2>&1
-type lucy_shortcut.log
-echo.
-echo Fertig - "Lucy" liegt jetzt auf dem Desktop.
-pause

client/lucy-desktop/electron.vite.config.ts

@@ -1,20 +0,0 @@
-import { defineConfig } from "electron-vite"
-import react from "@vitejs/plugin-react"
-import { resolve } from "path"
-
-export default defineConfig({
-  main: {
-    build: { rollupOptions: { input: { index: resolve(__dirname, "src/main/index.ts") } } },
-  },
-  preload: {
-    build: { rollupOptions: { input: { index: resolve(__dirname, "src/preload/index.ts") } } },
-  },
-  renderer: {
-    root: resolve(__dirname, "src/renderer"),
-    build: { rollupOptions: { input: { index: resolve(__dirname, "src/renderer/index.html") } } },
-    // Silero-VAD-Assets (Worklet + ONNX + onnxruntime-WASM) liegen self-hosted in
-    // src/renderer/public/vad/ (scripts/copy-vad-assets.mjs, läuft via npm postinstall) —
-    // Pfade = baseAssetPath/onnxWASMBasePath in useVAD.ts.
-    plugins: [react()],
-  },
-})

client/lucy-desktop/package.json

@@ -1,39 +0,0 @@
-{
-  "name": "lucy-desktop",
-  "version": "0.1.0",
-  "description": "Lucy — lokaler Sprach-Companion (Hermes-Hirn auf der Box, lokale Stimme auf der 9070 XT)",
-  "main": "out/main/index.js",
-  "type": "module",
-  "scripts": {
-    "dev": "electron-vite dev",
-    "build": "electron-vite build",
-    "preview": "electron-vite preview",
-    "postinstall": "node scripts/copy-vad-assets.mjs"
-  },
-  "dependencies": {
-    "@pixiv/three-vrm": "^3.4.0",
-    "@pixiv/three-vrm-animation": "^3.5.4",
-    "@react-three/drei": "^9.114.0",
-    "@react-three/fiber": "^8.17.10",
-    "@ricky0123/vad-web": "^0.0.30",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-markdown": "^9.1.0",
-    "remark-gfm": "^4.0.1",
-    "three": "^0.169.0"
-  },
-  "devDependencies": {
-    "@types/react": "^18.3.12",
-    "@types/react-dom": "^18.3.1",
-    "@types/three": "^0.169.0",
-    "@vitejs/plugin-react": "^4.3.4",
-    "electron": "^43.0.0",
-    "electron-vite": "^3.0.0",
-    "typescript": "^5.6.3",
-    "vite": "^6.0.3"
-  },
-  "allowScripts": {
-    "electron": true,
-    "esbuild": true
-  }
-}

client/lucy-desktop/scripts/copy-vad-assets.mjs

@@ -1,23 +0,0 @@
-// Kopiert die Silero-VAD-Assets (Worklet + ONNX-Modell + onnxruntime-WASM) nach public/vad/,
-// damit die App sie self-hosted lädt (offlinefähig, kein CDN). Läuft via npm postinstall.
-// public/ wird von Vite in Dev UND Build verbatim ausgeliefert -> ein Pfad für beide Welten.
-import { copyFileSync, mkdirSync, readdirSync } from "node:fs"
-import { dirname, join } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const root = join(dirname(fileURLToPath(import.meta.url)), "..")
-const dest = join(root, "src", "renderer", "public", "vad")
-mkdirSync(dest, { recursive: true })
-
-const jobs = [
-  [join(root, "node_modules", "@ricky0123", "vad-web", "dist"), (f) => f === "vad.worklet.bundle.min.js" || f.endsWith(".onnx")],
-  [join(root, "node_modules", "onnxruntime-web", "dist"), (f) => f.endsWith(".wasm") || f.endsWith(".mjs")],
-]
-
-let n = 0
-for (const [src, match] of jobs) {
-  for (const f of readdirSync(src)) {
-    if (match(f)) { copyFileSync(join(src, f), join(dest, f)); n++ }
-  }
-}
-console.log(`[vad-assets] ${n} Dateien nach ${dest} kopiert.`)

client/lucy-desktop/src/main/index.ts

@@ -1,242 +0,0 @@
-import { app, BrowserWindow, ipcMain, Tray, Menu, globalShortcut, nativeImage, desktopCapturer, shell, screen, session } from "electron"
-import { spawn, ChildProcess } from "child_process"
-import { join } from "path"
-
-// Lucy — Main-Prozess. Spawnt die lokale Stimme (pocket-tts, :8130) + verwaltet Fenster/Tray/Hotkey.
-// Fenster ist frameless+transparent: eigene Titelleiste im Renderer. Zwei Modi: 'full' (Arbeitsfenster)
-// und 'overlay' (kleine schwebende Lucy, always-on-top). pocket-tts ist CPU-kühl -> kein /wake-/sleep.
-
-const PORT = process.env.LUCY_TTS_PORT || "8130"
-const TTS = `http://127.0.0.1:${PORT}`
-const TTS_DIR = process.env.LUCY_TTS_DIR || join(app.getAppPath(), "..", "lucy-tts")
-const PY = process.env.LUCY_TTS_PY || join(TTS_DIR, "ptts-venv", "Scripts", "python.exe")
-const HOTKEY = process.env.LUCY_HOTKEY || "CommandOrControl+Shift+Space"
-
-const FULL_SIZE = { width: 1100, height: 720 }
-const OVERLAY_SIZE = { width: 360, height: 480 }
-
-let win: BrowserWindow | null = null
-let tray: Tray | null = null
-let ttsProc: ChildProcess | null = null
-let mode: "full" | "overlay" = "full"
-let pinned = false
-let cursorTimer: ReturnType<typeof setInterval> | null = null
-
-// MateEngine-Idee: Lucy folgt dem Mauszeiger. Der Zeiger ist auch AUSSERHALB des Fensters (Geistmodus),
-// daher global pollen (screen.getCursorScreenPoint) und die Richtung relativ zu Lucys Kopf an den Renderer geben.
-function startCursorTracking() {
-  if (cursorTimer) return
-  cursorTimer = setInterval(() => {
-    if (!win || win.isDestroyed() || !win.isVisible()) return
-    const b = win.getBounds()
-    const p = screen.getCursorScreenPoint()
-    const cx = b.x + b.width / 2
-    const cy = b.y + b.height * 0.38   // ungefaehre Kopfhoehe im Fenster
-    win.webContents.send("lucy:cursor", { x: (p.x - cx) / Math.max(1, b.width), y: (p.y - cy) / Math.max(1, b.height) })
-    // Auto-Ducken: im Overlay nach Nicht-Naehe an den Rand; bei Annaeherung an den Rest hervorholen
-    if (mode === "overlay" && !pinned && !boundsAnim) {
-      const now = Date.now()
-      const inWin = p.x >= b.x && p.y >= b.y && p.x <= b.x + b.width && p.y <= b.y + b.height
-      if (inWin) lastNear = now
-      if (!tucked && now - lastNear > AUTO_TUCK_MS) tuckToEdge()
-      else if (tucked) {
-        const wa = screen.getDisplayNearestPoint({ x: b.x, y: b.y }).workArea
-        if (p.x >= wa.x + wa.width - SLIVER - 12 && p.y >= b.y - 12 && p.y <= b.y + b.height + 12) { lastNear = now; untuck() }
-      }
-    }
-  }, 40)   // ~25 Hz reicht fuers Blickfolgen, kostet kaum Last
-}
-function stopCursorTracking() { if (cursorTimer) { clearInterval(cursorTimer); cursorTimer = null } }
-
-// --- An den Rand ducken (MateEngine-Idee) ---
-type Rect = { x: number; y: number; width: number; height: number }
-let tucked = false
-let prevBounds: Rect | null = null
-let lastNear = Date.now()
-let boundsAnim: ReturnType<typeof setInterval> | null = null
-const SLIVER = 58              // sichtbarer Rest am Rand, wenn geduckt
-const AUTO_TUCK_MS = 15000     // nach so langer Nicht-Naehe im Overlay automatisch ducken
-
-function animateBounds(target: Rect, after?: () => void) {
-  if (!win) return
-  if (boundsAnim) { clearInterval(boundsAnim); boundsAnim = null }
-  const start = win.getBounds(); const t0 = Date.now(); const dur = 260
-  boundsAnim = setInterval(() => {
-    if (!win || win.isDestroyed()) { if (boundsAnim) clearInterval(boundsAnim); boundsAnim = null; return }
-    const k = Math.min(1, (Date.now() - t0) / dur)
-    const e = k < 0.5 ? 2 * k * k : 1 - Math.pow(-2 * k + 2, 2) / 2   // easeInOutQuad
-    win.setBounds({
-      x: Math.round(start.x + (target.x - start.x) * e),
-      y: Math.round(start.y + (target.y - start.y) * e),
-      width: target.width, height: target.height,
-    })
-    if (k >= 1) { if (boundsAnim) clearInterval(boundsAnim); boundsAnim = null; after?.() }
-  }, 16)
-}
-function tuckToEdge() {
-  if (!win || mode !== "overlay" || tucked) return
-  prevBounds = win.getBounds()
-  const wa = screen.getDisplayNearestPoint({ x: prevBounds.x, y: prevBounds.y }).workArea
-  animateBounds({ x: wa.x + wa.width - SLIVER, y: prevBounds.y, width: prevBounds.width, height: prevBounds.height })
-  tucked = true; setTrayMenu()
-}
-function untuck() {
-  if (!win || !tucked) return
-  const t = prevBounds || win.getBounds()
-  animateBounds({ x: t.x, y: t.y, width: t.width, height: t.height })
-  tucked = false; setTrayMenu()
-}
-function toggleTuck() { if (tucked) untuck(); else tuckToEdge() }
-
-async function ensureTtsServer() {
-  try {
-    const r = await fetch(`${TTS}/health`)
-    if (r.ok) { console.log("[lucy] TTS-Server läuft bereits auf", TTS); return }
-  } catch { /* selbst starten */ }
-  console.log("[lucy] starte pocket_server:", PY, "(cwd:", TTS_DIR + ")")
-  ttsProc = spawn(PY, ["-m", "uvicorn", "pocket_server:app", "--host", "127.0.0.1", "--port", PORT],
-    { cwd: TTS_DIR, windowsHide: true, env: { ...process.env } })
-  ttsProc.stdout?.on("data", (d) => console.log("[tts]", d.toString().trimEnd()))
-  ttsProc.stderr?.on("data", (d) => console.log("[tts]", d.toString().trimEnd()))
-  ttsProc.on("error", (e) => console.error("[lucy] pocket_server-Spawn fehlgeschlagen:", e))
-  ttsProc.on("exit", (code) => { console.log("[lucy] pocket_server beendet, code", code); ttsProc = null })
-}
-function stopTtsServer() {
-  if (ttsProc && !ttsProc.killed) { try { ttsProc.kill() } catch { /* */ }; ttsProc = null }
-}
-
-function applyMode(next: "full" | "overlay") {
-  if (!win) return
-  // beim Verlassen des Overlays ggf. Duck-Zustand zuruecksetzen (Position wiederherstellen)
-  if (tucked && next !== "overlay") { tucked = false; if (prevBounds) win.setPosition(prevBounds.x, prevBounds.y) }
-  mode = next
-  const overlay = next === "overlay"
-  const size = overlay ? OVERLAY_SIZE : FULL_SIZE
-  win.setAlwaysOnTop(overlay || pinned, "floating")
-  win.setSize(size.width, size.height, false)
-  win.setResizable(!overlay)
-  if (overlay) win.setMinimumSize(280, 360); else win.setMinimumSize(420, 420)
-  win.webContents.send("lucy:mode", next)
-  lastNear = Date.now(); setTrayMenu()
-}
-
-function createWindow() {
-  win = new BrowserWindow({
-    width: FULL_SIZE.width, height: FULL_SIZE.height, minWidth: 420, minHeight: 420,
-    frame: false, transparent: true, backgroundColor: "#00000000", resizable: true,
-    title: "Lucy", show: false,
-    webPreferences: {
-      preload: join(__dirname, "../preload/index.mjs"),
-      sandbox: false, webSecurity: false,
-    },
-  })
-  if (process.env.ELECTRON_RENDERER_URL) win.loadURL(process.env.ELECTRON_RENDERER_URL)
-  else win.loadFile(join(__dirname, "../renderer/index.html"))
-  win.once("ready-to-show", () => win?.show())
-  win.on("closed", () => { win = null })
-}
-
-function showWin() {
-  if (!win) { createWindow(); return }
-  if (win.isMinimized()) win.restore()
-  if (tucked) untuck()
-  win.show(); win.focus()
-}
-
-function lucyIcon() {
-  // 16x16 Icon zur Laufzeit (silberblauer Kreis) -> sichtbar im Tray, ohne Asset-Datei
-  const s = 16, buf = Buffer.alloc(s * s * 4)
-  for (let y = 0; y < s; y++) for (let x = 0; x < s; x++) {
-    const i = (y * s + x) * 4
-    const dx = x - 7.5, dy = y - 7.5, inside = dx * dx + dy * dy <= 56
-    buf[i] = 0xfc; buf[i + 1] = 0xd3; buf[i + 2] = 0x7d; buf[i + 3] = inside ? 0xff : 0x00  // BGRA
-  }
-  return nativeImage.createFromBitmap(buf, { width: s, height: s })
-}
-
-function setTrayMenu() {
-  if (!tray) return
-  tray.setContextMenu(Menu.buildFromTemplate([
-    { label: "Lucy zeigen", click: showWin },
-    { label: "Overlay-Modus", type: "checkbox", checked: mode === "overlay",
-      click: (mi) => { applyMode(mi.checked ? "overlay" : "full"); showWin() } },
-    { label: tucked ? "Hervorholen" : "An den Rand ducken", enabled: mode === "overlay", click: toggleTuck },
-    { type: "separator" },
-    { label: "Beenden", click: () => { app.quit() } },
-  ]))
-}
-function buildTray() {
-  tray = new Tray(lucyIcon())
-  tray.setToolTip("Lucy")
-  setTrayMenu()
-  tray.on("click", showWin)
-}
-
-function registerHotkey() {
-  globalShortcut.unregisterAll()
-  // Global: Sprach-Aufnahme an/aus (Toggle, da Global-Shortcuts kein key-up liefern)
-  const ok = globalShortcut.register(HOTKEY, () => { showWin(); win?.webContents.send("lucy:hotkey") })
-  if (!ok) console.error("[lucy] Global-Hotkey-Registrierung fehlgeschlagen:", HOTKEY)
-}
-
-// ---- IPC vom Renderer (Titelleiste/Modus) ----
-ipcMain.handle("win:minimize", () => win?.minimize())
-ipcMain.handle("win:close", () => win?.hide())  // in den Tray, bleibt warm; echtes Beenden über Tray
-ipcMain.handle("win:setMode", (_e, m: "full" | "overlay") => { applyMode(m); return mode })
-ipcMain.handle("win:getMode", () => mode)
-ipcMain.handle("win:togglePin", () => { pinned = !pinned; win?.setAlwaysOnTop(pinned || mode === "overlay", "floating"); return pinned })
-
-// Links im echten System-Browser oeffnen (nicht im App-Fenster); nur http(s) erlauben
-ipcMain.handle("open:external", (_e, url: string) => { if (/^https?:\/\//i.test(url)) void shell.openExternal(url) })
-
-// Geistmodus (Overlay v2): Fenster durchklickbar machen -> Lucy "sitzt" auf dem Desktop, du arbeitest
-// dahinter weiter. forward:true liefert weiter Hover-Events an den Renderer, damit er ueber Lucys
-// Bedienelementen kurzzeitig wieder klickbar schalten kann.
-ipcMain.handle("win:setClickThrough", (_e, on: boolean) => {
-  win?.setIgnoreMouseEvents(!!on, { forward: true }); return !!on
-})
-
-// ---- Bildschirm-Sicht (Lucys Augen) ----
-const CAP = { width: 1280, height: 720 }
-ipcMain.handle("screen:capture", async () => {
-  const sources = await desktopCapturer.getSources({ types: ["screen"], thumbnailSize: CAP })
-  return sources.map((s) => s.thumbnail.toDataURL())   // ALLE Bildschirme (Multi-Monitor) als PNG-DataURLs
-})
-ipcMain.handle("screen:listWindows", async () => {
-  const sources = await desktopCapturer.getSources({ types: ["window"], thumbnailSize: { width: 0, height: 0 } })
-  return sources.filter((s) => s.name && s.name !== "Lucy").map((s) => ({ id: s.id, name: s.name }))
-})
-ipcMain.handle("screen:captureWindow", async (_e, id: string) => {
-  const sources = await desktopCapturer.getSources({ types: ["window"], thumbnailSize: CAP })
-  return sources.find((s) => s.id === id)?.thumbnail.toDataURL() ?? null
-})
-// Fuzzy-Fenstersuche: bester Treffer für einen im Gesagten erkannten App-/Fensternamen
-ipcMain.handle("screen:captureByName", async (_e, query: string) => {
-  const q = query.toLowerCase().trim()
-  const sources = await desktopCapturer.getSources({ types: ["window"], thumbnailSize: CAP })
-  const cand = sources.filter((s) => s.name && s.name !== "Lucy")
-  const hit = cand.find((s) => s.name.toLowerCase().includes(q))
-    || cand.find((s) => q.split(/\s+/).some((w) => w.length > 2 && s.name.toLowerCase().includes(w)))
-  return hit ? { name: hit.name, image: hit.thumbnail.toDataURL() } : null
-})
-
-app.whenReady().then(() => {
-  void ensureTtsServer()
-  createWindow()
-  buildTray()
-  registerHotkey()
-  startCursorTracking()
-  // Tanzen zur Musik: System-Audio (Loopback) fuer getDisplayMedia bereitstellen, ohne System-Picker
-  session.defaultSession.setDisplayMediaRequestHandler((_req, callback) => {
-    desktopCapturer.getSources({ types: ["screen"] })
-      .then((sources) => callback({ video: sources[0], audio: "loopback" }))
-      .catch(() => { try { callback({}) } catch { /* */ } })
-  }, { useSystemPicker: false })
-  app.on("activate", () => { if (BrowserWindow.getAllWindows().length === 0) createWindow() })
-})
-
-app.on("window-all-closed", () => { /* im Tray weiterlaufen lassen; Beenden nur über Tray/Quit */ })
-app.on("before-quit", () => {
-  if (boundsAnim) clearInterval(boundsAnim)
-  stopCursorTracking(); stopTtsServer(); globalShortcut.unregisterAll(); tray?.destroy()
-})

client/lucy-desktop/src/preload/index.ts

@@ -1,34 +0,0 @@
-import { contextBridge, ipcRenderer } from "electron"
-
-// Schmale Bruecke Renderer -> Main: Fenster-Chrome (frameless), Modus-Umschaltung, Tray/Hotkey-Events.
-contextBridge.exposeInMainWorld("lucy", {
-  minimize: () => ipcRenderer.invoke("win:minimize"),
-  close: () => ipcRenderer.invoke("win:close"),
-  setMode: (m: "full" | "overlay") => ipcRenderer.invoke("win:setMode", m),
-  getMode: () => ipcRenderer.invoke("win:getMode"),
-  togglePin: () => ipcRenderer.invoke("win:togglePin"),
-  // Bildschirm-Sicht
-  captureScreen: () => ipcRenderer.invoke("screen:capture"),   // alle Monitore -> string[]
-  listWindows: () => ipcRenderer.invoke("screen:listWindows"),
-  captureWindow: (id: string) => ipcRenderer.invoke("screen:captureWindow", id),
-  captureByName: (q: string) => ipcRenderer.invoke("screen:captureByName", q),
-  openExternal: (url: string) => ipcRenderer.invoke("open:external", url),   // Link im System-Browser
-  setClickThrough: (on: boolean) => ipcRenderer.invoke("win:setClickThrough", on),   // Geistmodus (Overlay v2)
-  // Events aus dem Main-Prozess (Tray/Hotkey/Modus)
-  onMode: (cb: (m: "full" | "overlay") => void) => {
-    const h = (_e: unknown, m: "full" | "overlay") => cb(m)
-    ipcRenderer.on("lucy:mode", h)
-    return () => ipcRenderer.removeListener("lucy:mode", h)
-  },
-  onHotkey: (cb: () => void) => {
-    const h = () => cb()
-    ipcRenderer.on("lucy:hotkey", h)
-    return () => ipcRenderer.removeListener("lucy:hotkey", h)
-  },
-  // Mauszeiger-Position (relativ zu Lucys Kopf) -> Blickfolgen
-  onCursor: (cb: (p: { x: number; y: number }) => void) => {
-    const h = (_e: unknown, p: { x: number; y: number }) => cb(p)
-    ipcRenderer.on("lucy:cursor", h)
-    return () => ipcRenderer.removeListener("lucy:cursor", h)
-  },
-})

client/lucy-desktop/src/renderer/index.html

@@ -1,13 +0,0 @@
-<!doctype html>
-<html lang="de">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self' 'unsafe-inline' data: blob: http://127.0.0.1:8130 http://192.168.178.151:9001 ws://localhost:*; media-src 'self' blob: data: http://127.0.0.1:8130; img-src 'self' data: blob:; script-src 'self' 'unsafe-inline'" />
-    <title>Lucy</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

client/lucy-desktop/src/renderer/public/vrma/ATTRIBUTION.md

@@ -1,11 +0,0 @@
-# VRMA-Animationen — Quelle & Lizenz
-
-Die `.vrma`-Bewegungs-Clips in diesem Ordner stammen aus:
-
-**tk256ailab/vrm-viewer** — https://github.com/tk256ailab/vrm-viewer
-Lizenz: **MIT** · Copyright (c) 2025 TK256
-
-Die MIT-Lizenz erlaubt Nutzung, Modifikation und Weitergabe; der Copyright-
-Hinweis ist beizubehalten (= diese Datei).
-
-Genutzte Clips: Relax, Thinking, LookAround, Surprised, Sad, Clapping, Goodbye, Blush.