phase1b: Backend entruempelt und robuster (35 tote Routen raus, Sperren, ehrliche Update-Pruefung)

Ballast raus:
- 35 Routen ohne Nutzer entfernt (agent/*, fit, roles, ctx, drafts, groups, routing/policy,
  system/history, system/self-update, maintenance/reboot, zeitmaschine/inhalt, zeitplan,
  voice/health|metrics|trace|voices|reference|tts). Von 95 auf 60.
- Tote Module geloescht: agent-Router, roles, agent_aktivitaet, metrics_history (samt
  10-s-Sampler), voice_metrics, migrate_config, parse_mc2_timeout, scripts/.
- Unbenutzte Funktionen und Konstanten entfernt (Modell-Upgrade-Empfehlung, Draft-/Kontext-
  Setzer, Konsole, PC-Ausfuehrer-Probe, Routing-Policy-Editor ...).

Robuster:
- Jobs in eigener Prozessgruppe (Abbrechen beendet wirklich alles), Zeitlimit je Job-Art,
  start_job_exklusiv: zwei Klicks starten kein doppeltes Update mehr; alte Jobs raeumen sich auf.
- Update-Pruefung meldet Fehler (pruef_fehler, Lampe "Pruefung unklar") statt "aktuell".
- Nach jedem Update sofort neu pruefen (update_stand) statt 10 Minuten alten Stand zeigen.
- llama-swap-Config: Sperre (RLock + flock) fuer UI, Radar, Aufraeumen und Hirn-Umstellung.
- Hermes-Config: bei Lesefehler nichts schreiben, atomar, mit Sicherung.
- Live-Strom und Gateway-Warnung blockieren den Event-Loop nicht mehr (Lucy, OpenChamber).
- Gateway antwortet bei Engine-Ausfall im OpenAI-Fehlerformat (502) statt nacktem 500.
- Abgestuerzte Waechter-Pruefung wird ein gelber Hinweis statt still zu verschwinden.
- Download laedt nur den gewuenschten Quant (vorher bei Fehlen alle Teile aller Varianten),
  Download-Jobs in Gruppe "download"; HF-Suche kodiert den Suchbegriff.
- Herkunftspruefung: schreibende /api-Aufrufe fremder Webseiten werden abgelehnt (keine
  Anmeldung, User-Entscheid); Skripte, Desktop-Lucy und /v1 unveraendert.
- Modellpfade: Eintragen und Loeschen nur innerhalb von MODELS_DIR.
- Dienste-Liste fragt keine abgebauten Dienste mehr ab (PC-Ausfuehrer haette 3 s gekostet).
- SSE-Fehlerzeilen von /api/voice/chat als gueltiges JSON.
- mission-control-2.service: --timeout-graceful-shutdown 3 (Neustart ohne 10-s-Haenger).

Tests: 92 gruen (neu: Herkunft, Quant-Auswahl, abgestuerzte Pruefung).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

backend/services/agent.py

@@ -6,31 +6,18 @@ 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:
@@ -106,67 +93,18 @@ def _reach(url: str, path: str = "") -> bool:
         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)
-
+    """Erreichbarkeit des Hermes-Gateways (:8642) und des Hermes-Dashboards — für die Dienste-Liste.
 
+    Bis 24.09.2026 fragte die Funktion bei jedem Aufruf auch die abgebaute Konsole und den
+    PC-Ausführer ab (3 s Zeitlimit) und las die Hermes-Config, obwohl nur diese Felder gebraucht
+    werden. Seit der PC-Ausführer schläft, hätte das jede Dienste-Abfrage um 3 s verzögert."""
     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,
     }
 
 
@@ -220,49 +158,59 @@ def set_agent_brain(model_id: str) -> dict:
 
 
 def update_brain_model(new_model: str) -> bool:
+    """Setzt Lucys Hirn in Hermes' config.yaml (model.default + model.model) und startet den
+    Hermes-Gateway neu.
+
+    Seit 24.09.2026 vorsichtig: Ist die Datei nicht lesbar (halb geschrieben, Syntaxfehler), wird
+    NICHTS geschrieben — früher entstand dann eine neue Datei nur mit dem model-Block, und der Rest
+    von Hermes' Konfiguration wäre weg gewesen. Geschrieben wird atomar (tmp + os.replace), vorher
+    liegt eine Sicherung config.yaml.bak-hirn-<Zeitstempel> daneben."""
+    import shutil
+    import time as _time
+
     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 = {}
-            
+    from ruamel.yaml import YAML
+
+    config_path = HERMES_HOME / "config.yaml"
+    if not config_path.exists():
+        log.warning("update_brain_model: %s fehlt — Hirn wird nicht umgestellt", config_path)
+        return False
+    r_yaml = YAML()
+    r_yaml.preserve_quotes = True
+    r_yaml.width = 100
+    r_yaml.indent(mapping=2, sequence=4, offset=2)
+    try:
+        with config_path.open("r", encoding="utf-8") as f:
+            cfg = r_yaml.load(f)
+    except Exception:
+        log.warning("update_brain_model: config.yaml nicht lesbar — nichts geschrieben", exc_info=True)
+        return False
     if not isinstance(cfg, dict):
-        cfg = {}
-        
+        log.warning("update_brain_model: config.yaml hat unerwarteten Inhalt — nichts geschrieben")
+        return False
+
     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).
+    # Beide setzen, sonst greift die Umschaltung nicht.
     cfg["model"]["default"] = new_model
     cfg["model"]["model"] = new_model
 
+    tmp = config_path.with_suffix(".yaml.neu")
     try:
-        from ruamel.yaml import YAML
-        r_yaml = YAML()
-        with config_path.open("w", encoding="utf-8") as f:
+        shutil.copy2(config_path, config_path.with_name(f"config.yaml.bak-hirn-{_time.strftime('%Y%m%d-%H%M%S')}"))
+        with tmp.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
+        YAML(typ="safe").load(tmp.read_text(encoding="utf-8"))   # muss wieder lesbar sein
+        os.replace(tmp, config_path)
     except Exception:
         log.warning("update_brain_model: Schreiben der config.yaml fehlgeschlagen", exc_info=True)
+        tmp.unlink(missing_ok=True)
         return False
+
+    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

backend/services/agent_aktivitaet.py

@@ -1,176 +0,0 @@
-"""Werkzeug-Verlauf des Agenten (v3-Umbau P6).
-
-WARUM ES DAS GIBT: Lucys Arbeit war eine Blackbox mit Statuswort. Der Blueprint sah
-dafür eine „Live Agent Matrix" mit Denkstrom vor (§4.4) — die ist so nicht baubar: Die
-Denkschritte entstehen im Hermes-Prozess, und `AGENTS.md` verbietet es, dessen Quellcode
-zu patchen.
-
-Beim Nachsehen zeigte sich aber, dass die HÄLFTE davon längst offen daliegt: Hermes
-protokolliert jeden Werkzeug-Ruf nach `~/.hermes/logs/agent.log`. Eine Log-Datei zu lesen
-ist kein Patchen. Was dadurch sichtbar wird — welches Werkzeug, wie lange, mit welchem
-Ergebnis, in welchem Lauf — ist für die Frage „was tut sie gerade und wo hängt es" oft
-nützlicher als der Fließtext ihrer Gedanken.
-
-WAS NICHT GEHT (und hier auch nicht so tut): der Denkstrom selbst und die Argumente eines
-Werkzeug-Rufs. Beides steht nicht im Log. Die Ansicht verspricht deshalb nur, was sie
-halten kann.
-
-ES HAT SICH SOFORT GELOHNT: Beim ersten Lesen fiel auf, dass `web_extract` seit
-mindestens dem 25.08. JEDEN Morgen um 07:00 scheitert (der Suchanbieter kann keine
-Seiten abrufen). Vier Tage lang, ohne dass es irgendwo aufgefallen wäre.
-"""
-
-import logging
-import os
-import re
-from datetime import datetime
-from pathlib import Path
-from zoneinfo import ZoneInfo
-
-log = logging.getLogger(__name__)
-
-# Die Box läuft in Europe/Berlin (AGENTS.md). Hermes' Log trägt Ortszeit ohne Offset.
-LOCAL_TZ = ZoneInfo(os.environ.get("MC_LOCAL_TZ", "Europe/Berlin"))
-
-LOG_PFAD = Path(os.path.expanduser(
-    os.environ.get("MC_HERMES_AGENT_LOG", "~/.hermes/logs/agent.log")))
-
-# Nur das Ende der Datei lesen. Sie wächst auf mehrere MB und wird rotiert; für einen
-# Verlauf der letzten Stunden reicht der Schwanz — und er kostet nichts.
-LESE_BYTES = 512 * 1024
-
-# Die drei Formen, in denen Hermes einen Werkzeug-Ruf notiert (am Log gemessen, nicht
-# geraten). Die Lauf-Kennung in eckigen Klammern fehlt bei Nicht-Cron-Läufen.
-#
-#   INFO [cron_…] agent.tool_executor: tool terminal completed (1.40s, 53 chars)
-#   INFO          agent.tool_executor: tool web_search completed (2.61s, 2944 chars)
-#   WARNING [cron_…] agent.tool_executor: Tool web_extract returned error (0.17s): {…}
-#   INFO          agent.tool_executor: tool web_extract failed (0.17s): {…}
-_ZEIT = r"(?P<zeit>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}),\d+"
-_LAUF = r"(?:\[(?P<lauf>[^\]]+)\] )?"
-
-_FERTIG = re.compile(
-    _ZEIT + r" \w+ " + _LAUF + r"agent\.tool_executor: [Tt]ool (?P<werkzeug>\S+) completed "
-    r"\((?P<dauer>[\d.]+)s, (?P<zeichen>\d+) chars\)")
-
-_FEHLER = re.compile(
-    _ZEIT + r" \w+ " + _LAUF + r"agent\.tool_executor: [Tt]ool (?P<werkzeug>\S+) "
-    r"(?:failed|returned error) \((?P<dauer>[\d.]+)s\)(?::\s*(?P<detail>.*))?")
-
-
-def _schwanz(pfad: Path, n: int) -> list[str]:
-    """Die letzten n Bytes als Zeilen. Die erste Zeile kann angeschnitten sein und
-    wird verworfen — ein halber Zeitstempel passt auf kein Muster, aber sicher ist besser."""
-    try:
-        groesse = pfad.stat().st_size
-        with pfad.open("rb") as f:
-            f.seek(max(0, groesse - n))
-            roh = f.read()
-        zeilen = roh.decode("utf-8", errors="replace").splitlines()
-        return zeilen[1:] if groesse > n and zeilen else zeilen
-    except OSError:
-        return []
-
-
-def _kurz(detail: str | None) -> str | None:
-    """Fehlertext des Werkzeugs auf einen lesbaren Satz eindampfen. Hermes legt dort ein
-    JSON ab; interessant ist daran nur das `error`-Feld."""
-    if not detail:
-        return None
-    treffer = re.search(r'"error"\s*:\s*"([^"]{1,300})"', detail)
-    text = treffer.group(1) if treffer else detail.strip()
-    return (text[:297] + "…") if len(text) > 300 else text
-
-
-def rufe(limit: int = 60) -> list[dict]:
-    """Die jüngsten Werkzeug-Rufe, ältester zuerst."""
-    ergebnis: list[dict] = []
-    for zeile in _schwanz(LOG_PFAD, LESE_BYTES):
-        m = _FERTIG.match(zeile)
-        if m:
-            ergebnis.append({
-                "zeit": _iso(m.group("zeit")),
-                "lauf": m.group("lauf"),
-                "werkzeug": m.group("werkzeug"),
-                "dauer_s": float(m.group("dauer")),
-                "zeichen": int(m.group("zeichen")),
-                "ok": True,
-                "fehler": None,
-            })
-            continue
-        m = _FEHLER.match(zeile)
-        if m:
-            ergebnis.append({
-                "zeit": _iso(m.group("zeit")),
-                "lauf": m.group("lauf"),
-                "werkzeug": m.group("werkzeug"),
-                "dauer_s": float(m.group("dauer")),
-                "zeichen": None,
-                "ok": False,
-                "fehler": _kurz(m.group("detail")),
-            })
-    return ergebnis[-limit:]
-
-
-def _iso(s: str) -> str:
-    """`2026-08-28 07:03:18` → ISO MIT Zeitzone.
-
-    Hermes schreibt seine Log-Zeitstempel in Ortszeit ohne Offset. Die naiv zu lassen
-    wäre bequem (der Klient zeigt sie nur an) — aber genau daran hängt eine
-    Projektregel: Naive Zeiten werden über MC_LOCAL_TZ aufgelöst, nie geraten
-    (AGENTS.md; ruff DTZ007 erzwingt es). Sobald jemand später damit rechnet — Dauer
-    über Mitternacht, Vergleich mit einem Cron-Plan — wäre eine offsetlose Zeit eine
-    Falle, die erst zur Zeitumstellung zuschnappt."""
-    try:
-        return datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=LOCAL_TZ).isoformat()
-    except ValueError:
-        return s
-
-
-def uebersicht(limit: int = 60) -> dict:
-    """Was die Agent-Ansicht braucht: die Rufe selbst, je Werkzeug eine Bilanz und die
-    wiederkehrenden Fehler zusammengefasst.
-
-    Die Bilanz ist der eigentliche Nutzen: Ein Werkzeug, das IMMER scheitert, verschwindet
-    in einer Zeitleiste — in einer Zeile „web_extract · 4 Rufe · 4 Fehler" nicht."""
-    liste = rufe(limit)
-    if not LOG_PFAD.exists():
-        return {"verfuegbar": False, "pfad": str(LOG_PFAD), "rufe": [],
-                "werkzeuge": [], "laeufe": []}
-
-    bilanz: dict[str, dict] = {}
-    for r in liste:
-        b = bilanz.setdefault(r["werkzeug"], {
-            "werkzeug": r["werkzeug"], "rufe": 0, "fehler": 0,
-            "dauer_summe": 0.0, "letzter_fehler": None,
-        })
-        b["rufe"] += 1
-        b["dauer_summe"] += r["dauer_s"]
-        if not r["ok"]:
-            b["fehler"] += 1
-            b["letzter_fehler"] = r["fehler"]
-
-    werkzeuge = sorted(
-        ({**b, "dauer_schnitt_s": round(b["dauer_summe"] / max(b["rufe"], 1), 2)}
-         for b in bilanz.values()),
-        key=lambda b: (-b["fehler"], -b["rufe"]),
-    )
-
-    # Läufe in der Reihenfolge ihres ersten Auftretens (nicht sortiert nach Kennung —
-    # die trägt zwar ein Datum, aber darauf sollte sich niemand verlassen).
-    laeufe: list[dict] = []
-    gesehen: dict[str, dict] = {}
-    for r in liste:
-        schluessel = r["lauf"] or "(interaktiv)"
-        if schluessel not in gesehen:
-            gesehen[schluessel] = {"lauf": schluessel, "von": r["zeit"], "bis": r["zeit"],
-                                   "rufe": 0, "fehler": 0}
-            laeufe.append(gesehen[schluessel])
-        e = gesehen[schluessel]
-        e["bis"] = r["zeit"]
-        e["rufe"] += 1
-        if not r["ok"]:
-            e["fehler"] += 1
-
-    return {"verfuegbar": True, "pfad": str(LOG_PFAD), "rufe": liste,
-            "werkzeuge": werkzeuge, "laeufe": laeufe}

backend/services/announce.py

@@ -112,14 +112,6 @@ def notify_telegram(subject: str, text: str) -> None:
         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."""

backend/services/aufraeumen.py

@@ -129,14 +129,15 @@ def loeschen(art: str, name: str) -> dict:
         if art == "ordner":
             frei = _ordner_loeschen(name)
         else:
-            cfg = llamaswap.read_config()
-            models = cfg.get("models") or {}
-            vorher = _genutzte_ordner(models)
-            del models[name]
-            for gruppe in (cfg.get("groups") or {}).values():
-                if isinstance(gruppe, dict) and name in (gruppe.get("members") or []):
-                    gruppe["members"] = [m for m in gruppe["members"] if m != name]
-            llamaswap.write_config(cfg)
+            with llamaswap.config_sperre():
+                cfg = llamaswap.read_config()
+                models = cfg.get("models") or {}
+                vorher = _genutzte_ordner(models)
+                del models[name]
+                for gruppe in (cfg.get("groups") or {}).values():
+                    if isinstance(gruppe, dict) and name in (gruppe.get("members") or []):
+                        gruppe["members"] = [m for m in gruppe["members"] if m != name]
+                llamaswap.write_config(cfg)
             nachher = _genutzte_ordner(models)
             for ordner in sorted(set(vorher) - set(nachher)):     # nur Ordner, auf die jetzt nichts mehr zeigt
                 frei += _ordner_loeschen(ordner)

backend/services/backup.py

@@ -27,11 +27,6 @@ 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:

backend/services/budget.py

@@ -169,37 +169,3 @@ def setup_aware_ctx(params_b: float, quant: str, role: str | None = None) -> dic
     }
 
 
-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/discover.py

@@ -25,8 +25,6 @@ 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()

backend/services/fit.py

@@ -99,8 +99,3 @@ def max_ctx_for(params_b: float, quant: str, sys_ram_gb: float) -> int:
     return max_ctx_in_budget(params_b, quant, max(sys_ram_gb - 4.0, 0) * 0.8)
 
 
-def recommend_ctx(params_b: float, quant: str, sys_ram_gb: float) -> dict:
-    ctx = max_ctx_for(params_b, quant, sys_ram_gb)
-    k = ctx // 1024
-    return {"ctx": ctx, "k": k,
-            "note": f"Bis ~{k}k Kontext passt komfortabel auf deine Hardware ({round(sys_ram_gb)} GB)."}

backend/services/gateway_stream.py

@@ -7,6 +7,7 @@ verstreute, still scheiternde String-Suche durch einen testbaren SSE-Zeilenparse
 
 import json
 import logging
+import threading
 import time
 
 from services.token_stats import increment_tokens
@@ -37,12 +38,17 @@ def warn_truncation(model: str, max_tokens: int | None = None) -> None:
         return
     _trunc_last[model] = now
     log.warning("gateway: finish_reason=length bei %s — Antwort am Kontext-/Token-Limit abgerissen", model)
+    # Im eigenen Thread abliefern: announce.add spricht im Gateway-Prozess per HTTP mit MC2 (bis 5 s).
+    # Synchron hätte das den Event-Loop des Gateways und damit jeden LLM-Strom der Box angehalten.
+    threading.Thread(target=_melde_abriss, args=(model,), daemon=True).start()
+
+
+def _melde_abriss(model: str) -> None:
     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).",
+            f"Eine Antwort von „{model}“ ist am Token- oder Kontext-Limit abgerissen "
+            f"(finish_reason=length). Meist war die Aufgabe zu groß für einen Durchgang.",
             "[Kontext-Limit]", "gateway", "silent")
     except Exception:
         log.warning("gateway: Kontext-Limit-Warnung nicht zustellbar", exc_info=True)

backend/services/herkunft.py

@@ -0,0 +1,21 @@
+"""Herkunftsprüfung für Knöpfe (24.09.2026, User-Entscheid: keine Anmeldung).
+
+Knöpfe schicken POST/PUT/DELETE an /api. Ein Browser setzt dabei den Origin-Header — kommt er von
+einer fremden Webseite, wird die Anfrage abgelehnt. Das verhindert, dass eine fremde Seite im
+Browser eines Heimnetz-Geräts heimlich Updates, Neustarts oder Löschen auslöst.
+
+Unverändert erlaubt: Anfragen ohne Origin (Skripte, curl, Lucy-Watchdog), Origin „null“/„file://“
+(Desktop-Lucy aus Electron) und alles unter /v1 (OpenChamber, Hermes).
+"""
+
+ENTWICKLUNG = {"localhost:5173", "127.0.0.1:5173", "localhost:5180", "localhost:5181"}
+SCHREIBEND = {"POST", "PUT", "PATCH", "DELETE"}
+
+
+def erlaubt(methode: str, pfad: str, origin: str | None, host: str | None) -> bool:
+    if methode.upper() not in SCHREIBEND or not pfad.startswith("/api/"):
+        return True
+    if not origin or origin in ("null", "file://"):
+        return True
+    wirt = origin.split("://", 1)[-1].rstrip("/")
+    return wirt == (host or "") or wirt in ENTWICKLUNG

backend/services/hf.py

@@ -33,13 +33,12 @@ def list_quants(repo: str) -> list[str]:
 
 def search(q: str = "", limit: int = 24) -> list[dict]:
     """Freie HF-Suche nach GGUF-Repos. Ohne q → Top-GGUF nach Downloads (Stöbern)."""
-    url = (f"https://huggingface.co/api/models?filter=gguf"
-           f"&sort=downloads&direction=-1&limit={limit}")
+    params: dict[str, str | int] = {"filter": "gguf", "sort": "downloads", "direction": -1, "limit": limit}
     if q and q.strip():
-        url += f"&search={q.strip()}"
+        params["search"] = q.strip()   # von httpx kodiert (vorher roh an die URL gehängt)
     try:
         with httpx.Client(timeout=12.0) as c:
-            data = c.get(url).json()
+            data = c.get("https://huggingface.co/api/models", params=params).json()
     except Exception:
         return []
     out = []
@@ -80,15 +79,19 @@ def resolve_gguf(repo: str, quant: str = "Q4_K_M") -> dict:
     # mmproj separat (Vision-Projektor)
     mmproj = next((e["path"] for e in ggufs if "mmproj" in e["path"].lower()), None)
     model = [e for e in ggufs if "mmproj" not in e["path"].lower()]
-    # bevorzugt den gewünschten Quant
-    pref = [e for e in model if q in e["path"].lower()]
-    chosen = pref or model
+    # Nur der gewünschte Quant. Bis 24.09.2026 fiel die Auswahl sonst auf ALLE Modelldateien zurück —
+    # bei aufgeteilten Repos lud der Download dann alle Teile aller Varianten (hunderte GB).
+    chosen = [e for e in model if q in e["path"].lower()]
     if not chosen:
         return {"files": [], "first": None, "total_bytes": 0, "mmproj": mmproj, "split": False}
-    # Split? Wenn die gewählten Dateien -of- enthalten → alle Teile dieser Gruppe.
+    # Split? Wenn die gewählten Dateien -of- enthalten → alle Teile EINER Gruppe (gleicher Präfix).
     split = any("-of-" in e["path"].lower() for e in chosen)
     if split:
-        parts = sorted([e for e in chosen if "-of-" in e["path"].lower()], key=lambda e: e["path"])
+        def _gruppe(pfad: str) -> str:
+            return re.sub(r"-\d{5}-of-\d{5}\.gguf$", "", pfad, flags=re.IGNORECASE)
+        erste = min(e["path"] for e in chosen if "-of-" in e["path"].lower())
+        parts = sorted([e for e in chosen if "-of-" in e["path"].lower() and _gruppe(e["path"]) == _gruppe(erste)],
+                       key=lambda e: e["path"])
         files = [e["path"] for e in parts]
         first = files[0]
         total = sum(_size(e) for e in parts)

backend/services/jobengine.py

@@ -1,11 +1,22 @@
 """
 Mini-Job-System: Hintergrund-Prozesse mit Live-Log + Download-Fortschritt.
 Portiert aus Mission Control v1 (jobengine.py). In-Memory, ein Daemon-Thread je Job.
+
+Seit 24.09.2026:
+- Jobs laufen in einer eigenen Prozessgruppe; „Abbrechen“ beendet die ganze Gruppe (vorher nur
+  die bash-Hülle — sudo, apt und hf liefen weiter, während der Job schon „abgebrochen“ hieß).
+- Jede Job-Art hat ein Zeitlimit; ein hängendes apt hält den Wartungs-Riegel nicht mehr ewig.
+- `start_job_exklusiv` prüft und trägt unter EINER Sperre ein: zwei Klicks starten nicht mehr
+  zwei Updates derselben Gruppe.
+- Beendete Jobs werden nach einem Tag bzw. ab 40 Stück aufgeräumt.
+
+Noch offen (Phase 2): Jobs überleben keinen Neustart von MC2, sie gehören in einen eigenen Worker.
 """
 
 import glob
 import os
 import shlex
+import signal
 import subprocess
 import threading
 import time
@@ -14,6 +25,11 @@ import uuid
 JOBS: dict[str, dict] = {}
 _PROCS: dict[str, subprocess.Popen] = {}
 _LOG_CAP = 400
+_LOCK = threading.Lock()
+BEHALTEN_MAX = 40             # so viele beendete Jobs bleiben sichtbar
+BEHALTEN_S = 24 * 3600        # beendete Jobs verschwinden nach einem Tag
+STANDARD_ZEITLIMIT_S = 3 * 3600
+_ENDE = ("done", "failed", "canceled")
 
 
 def _append_log(job: dict, line: str) -> None:
@@ -57,34 +73,64 @@ def _pump_output(job: dict, stream) -> None:
         commit()
 
 
-def _run_job(job_id: str, args: list[str], env: dict | None = None):
+def _beende_gruppe(proc: subprocess.Popen) -> None:
+    """Den Job-Prozess samt Kindern beenden (posix: ganze Prozessgruppe, sonst nur den Prozess)."""
+    try:
+        if os.name == "posix":
+            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+        else:
+            proc.terminate()
+    except (ProcessLookupError, PermissionError, OSError):
+        pass
+
+
+def _run_job(job_id: str, args: list[str], env: dict | None = None, zeitlimit_s: int | None = None):
     """Job-Prozess starten und mitschreiben.
 
-    v3-Umbau P1 (28.08.2026): Hier wurde frueher ein Sudo-Passwort aus dem Browser an
-    stdin gefuettert (und dafuer `sudo -n` in den Argumenten zu `sudo -S` umgeschrieben).
-    Auf der Box laeuft sudo passwortlos (`NOPASSWD: ALL`), der Pfad war tot. Ohne ihn
-    braucht der Prozess auch keine stdin-Pipe mehr: DEVNULL sorgt dafuer, dass ein Job,
-    der wider Erwarten nach einem Passwort fragt, sofort scheitert statt still zu haengen."""
+    v3-Umbau P1 (28.08.2026): Auf der Box läuft sudo passwortlos (`NOPASSWD: ALL`), der Job
+    braucht keine stdin-Pipe. DEVNULL sorgt dafür, dass ein Job, der wider Erwarten nach einem
+    Passwort fragt, sofort scheitert statt still zu hängen."""
     job = JOBS[job_id]
     job["state"] = "running"
+    wecker: threading.Timer | None = None
     try:
         proc = subprocess.Popen(
             list(args), stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
             stdin=subprocess.DEVNULL,
             bufsize=0,
             env={**os.environ, **(env or {})},
+            start_new_session=(os.name == "posix"),
         )
         _PROCS[job_id] = proc
+        grenze = zeitlimit_s or STANDARD_ZEITLIMIT_S
+
+        def _zu_lang() -> None:
+            job["zeitlimit"] = True
+            _append_log(job, f"[mc] Zeitlimit ({grenze // 60} min) überschritten, Job wird beendet.")
+            _beende_gruppe(proc)
+
+        wecker = threading.Timer(grenze, _zu_lang)
+        wecker.daemon = True
+        wecker.start()
 
         _pump_output(job, proc.stdout)
         proc.wait()
         job["returncode"] = proc.returncode
-        job["state"] = "canceled" if job.get("canceled") else ("done" if proc.returncode == 0 else "failed")
+        if job.get("canceled"):
+            job["state"] = "canceled"
+        elif job.get("zeitlimit"):
+            job["state"] = "failed"
+            job["error"] = "Zeitlimit überschritten"
+        else:
+            job["state"] = "done" if proc.returncode == 0 else "failed"
     except Exception as exc:
         _append_log(job, f"[mc] Fehler: {exc}")
         job["state"] = "failed"
+        job["error"] = str(exc)
         job["returncode"] = -1
     finally:
+        if wecker is not None:
+            wecker.cancel()
         _PROCS.pop(job_id, None)
         job["finished_at"] = time.time()
         cb = job.pop("_on_done", None)
@@ -110,7 +156,7 @@ def attach_download_progress(job_id: str, local_dir: str, total_bytes: int) -> N
         rate = 0.0
         while True:
             j = JOBS.get(job_id)
-            if not j or j["state"] in ("done", "failed", "canceled"):
+            if not j or j["state"] in _ENDE:
                 break
             try:
                 inc = glob.glob(pat, recursive=True)
@@ -137,25 +183,54 @@ def attach_download_progress(job_id: str, local_dir: str, total_bytes: int) -> N
     threading.Thread(target=_watch, daemon=True).start()
 
 
-def start_job(args: list[str], label: str, env: dict | None = None, on_done=None,
-              group: str | None = None) -> str:
+def _aufraeumen() -> None:
+    """Alte beendete Jobs entfernen (unter _LOCK aufrufen)."""
+    jetzt = time.time()
+    fertig = sorted((j for j in JOBS.values() if j["state"] in _ENDE),
+                    key=lambda j: j.get("finished_at") or 0, reverse=True)
+    for i, j in enumerate(fertig):
+        if i >= BEHALTEN_MAX or jetzt - (j.get("finished_at") or jetzt) > BEHALTEN_S:
+            JOBS.pop(j["id"], None)
+
+
+def _eintragen(args: list[str], label: str, on_done, group: str | None) -> str:
     job_id = uuid.uuid4().hex[:12]
-    log_args = list(args)
     JOBS[job_id] = {
         "id": job_id, "label": label, "state": "queued", "group": group,
-        "log": ["$ " + " ".join(shlex.quote(a) for a in log_args)],
+        "log": ["$ " + " ".join(shlex.quote(a) for a in args)],
         "returncode": None, "started_at": time.time(), "finished_at": None,
     }
     if on_done:
         JOBS[job_id]["_on_done"] = on_done
-    threading.Thread(target=_run_job, args=(job_id, args, env), daemon=True).start()
     return job_id
 
 
+def start_job(args: list[str], label: str, env: dict | None = None, on_done=None,
+              group: str | None = None, zeitlimit_s: int | None = None) -> str:
+    with _LOCK:
+        _aufraeumen()
+        job_id = _eintragen(list(args), label, on_done, group)
+    threading.Thread(target=_run_job, args=(job_id, list(args), env, zeitlimit_s), daemon=True).start()
+    return job_id
+
+
+def start_job_exklusiv(group: str, args: list[str], label: str, env: dict | None = None, on_done=None,
+                       zeitlimit_s: int | None = None) -> tuple[str | None, dict | None]:
+    """Wie start_job, aber nur, wenn in der Gruppe nichts läuft — Prüfen und Eintragen unter einer
+    Sperre. Rückgabe: (neue Job-ID, None) oder (None, der schon laufende Job)."""
+    with _LOCK:
+        if (laeuft := active_in_group(group)) is not None:
+            return None, laeuft
+        _aufraeumen()
+        job_id = _eintragen(list(args), label, on_done, group)
+    threading.Thread(target=_run_job, args=(job_id, list(args), env, zeitlimit_s), daemon=True).start()
+    return job_id, None
+
+
 def active_in_group(group: str) -> dict | None:
     """Erster laufender/wartender Job einer Gruppe (z.B. 'maintenance'), sonst None.
     Basis für den Wartungs-Riegel: nur EIN System-Update gleichzeitig."""
-    for j in JOBS.values():
+    for j in list(JOBS.values()):
         if j.get("group") == group and j.get("state") in ("running", "queued"):
             return j
     return None
@@ -163,16 +238,13 @@ def active_in_group(group: str) -> dict | None:
 
 def cancel_job(job_id: str) -> bool:
     job = JOBS.get(job_id)
-    if not job or job["state"] in ("done", "failed", "canceled"):
+    if not job or job["state"] in _ENDE:
         return False
     job["canceled"] = True
     _append_log(job, "[mc] Abbruch angefordert…")
     proc = _PROCS.get(job_id)
     if proc is not None:
-        try:
-            proc.terminate()
-        except Exception:
-            pass
+        _beende_gruppe(proc)
     else:
         job["state"] = "canceled"
         job["finished_at"] = time.time()
@@ -181,4 +253,6 @@ def cancel_job(job_id: str) -> bool:
 
 def public_jobs() -> list[dict]:
     """Jobs ohne interne Felder (_on_done) für die API."""
-    return [{k: v for k, v in j.items() if not k.startswith("_")} for j in JOBS.values()]
+    with _LOCK:
+        _aufraeumen()
+        return [{k: v for k, v in j.items() if not k.startswith("_")} for j in JOBS.values()]

backend/services/llamaswap.py

@@ -6,9 +6,13 @@ NEU in 2.0: `groups` für Ko-Residenz (schnell + schwer gleichzeitig geladen,
 `swap:false`) → Multi-Model-Delegation ohne Nachlade-Latenz.
 """
 
+import functools
 import logging
 import os
 import re
+import threading
+from contextlib import contextmanager
+from pathlib import Path
 
 import httpx
 from config import (
@@ -17,12 +21,18 @@ from config import (
     DEFAULT_TTL,
     DRAFTS_DIR,
     LLAMA_SWAP_URL,
+    MODELS_DIR,
     SPEC_DRAFT_MODEL_PATH,
     SPEC_DRAFT_N_MAX,
     SPEC_TYPE,
 )
 from ruamel.yaml.scalarstring import LiteralScalarString
 
+try:
+    import fcntl
+except ImportError:      # Windows (Entwicklung): nur die Prozess-Sperre
+    fcntl = None
+
 log = logging.getLogger(__name__)
 
 # Kanonische Serving-Rollen — EINE Quelle der Wahrheit (identisch zu sources.ROLE_IDS,
@@ -53,6 +63,44 @@ def _gguf_total_size(path: str) -> int | None:
         return None
 
 
+# --- Sperre ------------------------------------------------------------------
+# Die llama-swap-Config hat mehrere Schreiber: die Oberfläche, das Radar, das Aufräumen und die
+# Hirn-Umstellung. Ohne Sperre gingen gleichzeitige Änderungen verloren (lesen, ändern, schreiben
+# überlappten). Seit 24.09.2026 läuft jedes Lesen-Ändern-Schreiben unter dieser Sperre: im
+# Prozess per RLock, zwischen Prozessen per flock auf einer Datei neben der Config.
+_SPERRE = threading.RLock()
+_SPERR_TIEFE = threading.local()
+
+
+@contextmanager
+def config_sperre():
+    with _SPERRE:
+        tiefe = getattr(_SPERR_TIEFE, "n", 0)
+        _SPERR_TIEFE.n = tiefe + 1
+        datei = None
+        try:
+            if tiefe == 0 and fcntl is not None:
+                try:
+                    datei = open(CONFIG_PATH.with_name(".mc2-config.lock"), "a+")
+                    fcntl.flock(datei, fcntl.LOCK_EX)
+                except OSError:
+                    datei = None          # ohne Sperrdatei (z. B. fehlende Rechte) bleibt die Prozess-Sperre
+            yield
+        finally:
+            _SPERR_TIEFE.n = tiefe
+            if datei is not None:
+                fcntl.flock(datei, fcntl.LOCK_UN)
+                datei.close()
+
+
+def _mit_sperre(fn):
+    @functools.wraps(fn)
+    def huelle(*args, **kwargs):
+        with config_sperre():
+            return fn(*args, **kwargs)
+    return huelle
+
+
 # --- Lesen -------------------------------------------------------------------
 def read_config() -> dict:
     if not CONFIG_PATH.exists():
@@ -236,7 +284,7 @@ def write_config(cfg: dict) -> None:
         ) from exc
 
 
-
+@_mit_sperre
 def register_model(model_path: str, role: str | None = None, ctx: int = 8192,
                    ttl: int | None = None, mmproj_path: str | None = None,
                    jinja: bool = False, set_alias: bool = True) -> str:
@@ -368,70 +416,8 @@ def spec_draft_flags(target_path: str) -> str:
     return _spec_flags_for_draft(d) if d else ""
 
 
-def drafts_for(target_path: str) -> dict:
-    """Für die UI: alle Drafts + ihre Kompatibilität zum Ziel-Modell. Schließt MTP-Köpfe
-    NEBEN dem Zielmodell ein (DRAFTS_DIR kennt sie nicht). `mtp:true` markiert MTP-Drafts.
-    compatible=None heißt 'nicht prüfbar' (Ziel- oder Draft-GGUF fehlt)."""
-    from services import gguf_meta
-    exists = bool(target_path and os.path.exists(target_path))
-    drafts = list_drafts()
-    seen = {d["path"] for d in drafts}
-    for p in _sibling_mtp_drafters(target_path):
-        if p not in seen:
-            drafts.append({"path": p, "filename": os.path.basename(p),
-                           "size_bytes": os.path.getsize(p) if os.path.exists(p) else None,
-                           "vocab": gguf_meta.fingerprint(p)})
-    for d in drafts:
-        d["compatible"] = gguf_meta.compatible(target_path, d["path"]) if exists else None
-        d["mtp"] = _is_mtp_draft(d["path"])
-    return {
-        "target_path": target_path,
-        "target_exists": exists,
-        "target_vocab": gguf_meta.fingerprint(target_path) if exists else None,
-        "drafts": drafts,
-    }
-
-
-def set_spec_draft(model_id: str, draft_path: str | None) -> dict:
-    """Setzt (oder entfernt mit draft_path=None) den Spec-Draft eines Modells.
-    Validiert die Vocab-Kompatibilität — ein inkompatibler/unprüfbarer Draft wird
-    abgelehnt (idiotensicher). Returns {ok, reason}."""
-    cfg = read_config()
-    spec = (cfg.get("models") or {}).get(model_id)
-    if not isinstance(spec, dict):
-        return {"ok": False, "reason": "Modell nicht gefunden"}
-    cmd = str(spec.get("cmd", ""))
-    # vorhandene Spec-Flags entfernen (idempotent) — klassisch UND MTP.
-    cmd = re.sub(r"\s+--(?:spec-draft-model|model-draft)\s+\S+", "", cmd)
-    cmd = re.sub(r"\s+-md\s+\S+", "", cmd)
-    cmd = re.sub(r"\s+--spec-type\s+\S+", "", cmd)
-    cmd = re.sub(r"\s+--spec-draft-n-(?:max|min)\s+\S+", "", cmd)
-
-    if draft_path:
-        # relative Angabe (nur Dateiname) gegen DRAFTS_DIR auflösen
-        if not os.path.isabs(draft_path) and "/" not in draft_path:
-            draft_path = str(DRAFTS_DIR / draft_path)
-        if not os.path.exists(draft_path):
-            return {"ok": False, "reason": "Draft-Datei nicht gefunden"}
-        from services import gguf_meta
-        target = ""
-        if (mt := _PATH_RE.search(cmd)):
-            target = mt.group(1).replace("'", "").replace('"', "")
-        comp = gguf_meta.compatible(target, draft_path) if os.path.exists(target) else None
-        if comp is not True:
-            reason = ("Draft ist NICHT vocab-kompatibel zum Modell — Speculative Decoding "
-                      "würde beim Laden scheitern."
-                      if comp is False else
-                      "Kompatibilität nicht prüfbar (Modell-GGUF fehlt) — Draft nicht gesetzt.")
-            return {"ok": False, "reason": reason}
-        cmd = cmd.rstrip() + _spec_flags_for_draft(draft_path)
-
-    spec["cmd"] = LiteralScalarString(cmd.rstrip() + "\n")
-    write_config(cfg)
-    return {"ok": True, "reason": ""}
-
-
 # --- Groups (Ko-Residenz) ----------------------------------------------------
+@_mit_sperre
 def set_group(group: str, members: list[str], swap: bool = False, persist: bool = False) -> None:
     """llama-swap-`groups`-Eintrag setzen. swap=False → alle Mitglieder dürfen
     GLEICHZEITIG laufen (Ko-Residenz, keine Nachlade-Latenz). persist=True →
@@ -467,6 +453,7 @@ def list_groups() -> dict:
     return read_config().get("groups") or {}
 
 
+@_mit_sperre
 def set_role(model_id: str, role: str | None) -> bool:
     """Rolle (llama-swap-Alias) eines bestehenden Modells setzen/ändern. So tauscht man
     z.B. das `fast`-Hirn: Rolle `fast` auf ein anderes Modell legen (Alias wandert)."""
@@ -478,6 +465,7 @@ def set_role(model_id: str, role: str | None) -> bool:
     return True
 
 
+@_mit_sperre
 def add_role(model_id: str, role: str) -> bool:
     """Wie set_role, aber die übrigen Aliase des Ziel-Modells bleiben — für Modelle mit zwei Rollen
     (Coder: coder UND heavy). set_role behielte nur die geschützten Aliase und würfe coder wieder weg."""
@@ -493,22 +481,7 @@ def add_role(model_id: str, role: str) -> bool:
     return True
 
 
-def set_ctx(model_id: str, ctx: int) -> bool:
-    """Kontextlänge (-c) eines bestehenden Modells ändern."""
-    cfg = read_config()
-    spec = (cfg.get("models") or {}).get(model_id)
-    if not spec:
-        return False
-    cmd = str(spec.get("cmd", ""))
-    if _CTX_RE.search(cmd):
-        cmd = re.sub(r"-(?:c|-ctx-size)\s+\d+", f"-c {ctx}", cmd)
-    else:
-        cmd = cmd.rstrip() + f" -c {ctx}"
-    spec["cmd"] = LiteralScalarString(cmd if cmd.endswith("\n") else cmd + "\n")
-    write_config(cfg)
-    return True
-
-
+@_mit_sperre
 def set_ttl(model_id: str, ttl: int) -> bool:
     """Idle-TTL (Sekunden) eines bestehenden Modells setzen. ttl=0 → nie automatisch
     entladen (für das Agent-Hirn, das dauerhaft warm bleiben muss)."""
@@ -521,6 +494,15 @@ def set_ttl(model_id: str, ttl: int) -> bool:
     return True
 
 
+@_mit_sperre
+def im_modellordner(pfad: str) -> bool:
+    """Liegt der Pfad (aufgelöst) unter MODELS_DIR? Grenze für Löschen und Eintragen (24.09.2026)."""
+    try:
+        return Path(pfad).resolve().is_relative_to(MODELS_DIR.resolve())
+    except (OSError, ValueError):
+        return False
+
+
 def delete_model(model_id: str) -> bool:
     """Entfernt einen Modell-Eintrag aus der config.yaml, löscht die zugehörigen
     GGUF-Dateien (auch Splits) vom Datenträger und bereinigt leere Ordner.
@@ -540,6 +522,9 @@ def delete_model(model_id: str) -> bool:
         m = None
     if m:
         path = m.group(1).replace("'", "").replace('"', "")
+        if path and not im_modellordner(path):
+            log.warning("delete_model: %s liegt außerhalb von %s — nur der Eintrag wird entfernt", path, MODELS_DIR)
+            path = ""
         if path:
             # 1. Haupt-GGUF-Datei löschen
             if os.path.exists(path):
@@ -567,7 +552,7 @@ def delete_model(model_id: str) -> bool:
                     mmproj_match = re.search(r'--mmproj\s+[\'"]?([^\s\'"]+)[\'"]?', cmd)
                     if mmproj_match:
                         m_path = mmproj_match.group(1)
-                        if os.path.exists(m_path) and m_path not in andere:
+                        if os.path.exists(m_path) and m_path not in andere and im_modellordner(m_path):
                             try:
                                 os.remove(m_path)
                             except Exception:
@@ -575,7 +560,7 @@ def delete_model(model_id: str) -> bool:
 
                 # 3. Eltern-Ordner löschen, falls er leer ist und nicht der Modelle-Wurzelordner selbst ist
                 try:
-                    if not os.listdir(dirname) and os.path.basename(dirname) != "models":
+                    if not os.listdir(dirname) and Path(dirname).resolve() != MODELS_DIR.resolve():
                         os.rmdir(dirname)
                 except Exception:
                     pass

backend/services/maintenance.py

@@ -14,9 +14,8 @@ from datetime import datetime
 from pathlib import Path
 
 import httpx
-import psutil
 
-from services import catalog, discover, jobengine, llamaswap, system
+from services import jobengine, system
 
 # System-Dienste (root, via sudo -n NOPASSWD) vs. User-Dienste (systemctl --user).
 SYSTEM_SERVICES = {"llama-swap"}
@@ -24,7 +23,16 @@ SYSTEM_SERVICES = {"llama-swap"}
 # erneut laufen lassen“ — der Wächter bietet das als Knopf an (services/waechter.py).
 USER_SERVICES = {"mission-control-2", "mc2-gateway", "mc2-steward", "box-console",
                  "hermes-gateway", "hermes-builtin-ui", "voice-service", "lucy-stimme",
-                 "projekte-sync", "mc2-backup", "mc2-radar"}
+                 "projekte-sync", "mc2-backup", "mc2-radar", "mc2-morgenmeldung", "mc2-autoupdate"}
+
+# Warum eine Update-Prüfung nicht klappte (None = geprüft). Bis 24.09.2026 verschluckten die
+# Prüfungen Netz-, API- und apt-Fehler und meldeten „kein Update“ — das Cockpit zeigte dann
+# „aktuell“, obwohl gar nicht geprüft werden konnte.
+PRUEF_FEHLER: dict[str, str | None] = {"os": None, "engine": None, "swap": None, "hermes": None}
+
+# Zählt abgeschlossene Updates hoch; Zwischenspeicher (z. B. im Box-Wart-Start) vergleichen ihn,
+# damit „Aktualisieren“ direkt nach einem Update verschwindet statt erst nach 10 Minuten.
+update_stand = 0
 
 # Engine-Update: lädt den neuesten Vulkan-Build (deploy/update-engine.sh, läuft als root).
 _REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
@@ -88,10 +96,6 @@ def _installed_engine_build() -> int | None:
     return None
 
 
-def _ram_gb() -> float:
-    return psutil.virtual_memory().total / (1024 ** 3)
-
-
 def _os_upgradable() -> int:
     try:
         # LC_ALL=C erzwingt englische apt-Ausgabe ("[upgradable from: ...]") — sonst zählt
@@ -99,8 +103,10 @@ def _os_upgradable() -> int:
         out = subprocess.run(
             ["bash", "-c", "LC_ALL=C apt list --upgradable 2>/dev/null | grep -c upgradable || true"],
             capture_output=True, text=True, timeout=10)
+        PRUEF_FEHLER["os"] = None
         return int((out.stdout or "0").strip() or 0)
-    except Exception:
+    except Exception as exc:
+        PRUEF_FEHLER["os"] = f"Paketliste nicht lesbar ({exc.__class__.__name__})"
         return 0
 
 
@@ -109,8 +115,12 @@ def _engine_update_available() -> bool:
     if now - _engine_cache["ts"] < 3600:
         return _engine_cache["avail"]
     avail = False
+    fehler = None
     try:
-        rel = _latest_engine_asset_release() or {}
+        rel = _latest_engine_asset_release()
+        if rel is None:
+            fehler = "Neueste Engine-Version bei GitHub nicht abrufbar"
+        rel = rel or {}
         tag = str(rel.get("tag_name", ""))
         latest = int(m.group(1)) if (m := re.search(r"(\d{3,})", tag)) else None
         installed = _installed_engine_build()
@@ -119,8 +129,12 @@ def _engine_update_available() -> bool:
         elif rel.get("published_at"):           # Fallback: Release-Datum vs. Engine-mtime
             pub = datetime.fromisoformat(rel["published_at"].replace("Z", "+00:00")).timestamp()
             avail = pub > os.path.getmtime(ENGINE_PATH) + 86400
-    except Exception:
+        elif fehler is None:
+            fehler = "Installierte Engine-Version nicht lesbar"
+    except Exception as exc:
         avail = False
+        fehler = f"Engine-Prüfung gescheitert ({exc.__class__.__name__})"
+    PRUEF_FEHLER["engine"] = fehler
     _engine_cache.update(ts=now, avail=avail)
     return avail
 
@@ -144,6 +158,7 @@ def _swap_update_available() -> bool:
     if now - _swap_cache["ts"] < 3600:
         return _swap_cache["avail"]
     avail = False
+    fehler = None
     try:
         rel = httpx.get(f"https://api.github.com/repos/{SWAP_REPO}/releases/latest",
                         timeout=6, headers={"User-Agent": "MissionControl2"}).json()
@@ -152,8 +167,14 @@ def _swap_update_available() -> bool:
         installed = _installed_swap_version()
         if latest is not None and installed is not None:
             avail = latest > installed
-    except Exception:
+        elif latest is None:
+            fehler = "Neueste llama-swap-Version bei GitHub nicht abrufbar"
+        else:
+            fehler = "Installierte llama-swap-Version nicht lesbar"
+    except Exception as exc:
         avail = False
+        fehler = f"llama-swap-Prüfung gescheitert ({exc.__class__.__name__})"
+    PRUEF_FEHLER["swap"] = fehler
     _swap_cache.update(ts=now, avail=avail)
     return avail
 
@@ -198,109 +219,12 @@ def _components_cached() -> list[dict]:
     if now - _comp_cache["ts"] < 3600 and _comp_cache["data"]:
         return _comp_cache["data"]
     data = [_hermes_agent_update()]
+    PRUEF_FEHLER["hermes"] = ("Hermes-Quelle nicht erreichbar (git fetch)"
+                              if data[0].get("reachable") is False else None)
     _comp_cache.update(ts=now, data=data)
     return data
 
 
-def _params_of(m: dict) -> float:
-    """Größen-bewusste Parameterzahl eines installierten Modells: max aus Namens-Schätzung
-    und Dateigröße (fängt namenlose wie 'Qwen3-Coder-Next' UND Split-GGUFs ab)."""
-    from services.fit import QUANT_BYTES_PER_PARAM
-    caps = m.get("capabilities") or {}
-    bpp = QUANT_BYTES_PER_PARAM.get((m.get("quant") or "Q4_K_M").upper(), 0.55)
-    size_gb = (m.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, 0.0)
-
-
-# Familien-Subtyp + Generations-Version aus dem Modellnamen (für „echtes Upgrade?").
-_FAM_PATS = (("qwen", r"qwen(\d+(?:\.\d+)?)"), ("gemma", r"gemma[-_ ]?(\d+(?:\.\d+)?)"),
-             ("llama", r"llama[-_ ]?(\d+(?:\.\d+)?)"), ("phi", r"phi[-_ ]?(\d+(?:\.\d+)?)"),
-             ("mistral", r"mistral"), ("hermes", r"hermes[-_ ]?(\d+(?:\.\d+)?)"))
-
-
-def _gen_key(name: str):
-    """(Familie+Subtyp, Generations-Version) oder None. Z.B. 'Qwen3-VL-2B' → ('qwen-vl', 3.0),
-    'Qwen2.5-VL-7B' → ('qwen-vl', 2.5). Nur gleiche Familie ist sinnvoll vergleichbar."""
-    low = (name or "").lower()
-    sub = "-vl" if any(k in low for k in ("-vl", "vl-", "vision", "llava", "pixtral")) else \
-          "-coder" if ("coder" in low or "-code" in low) else ""
-    for fam, pat in _FAM_PATS:
-        m = re.search(pat, low)
-        if m:
-            ver = float(m.group(1)) if (m.groups() and m.group(1)) else 0.0
-            return (fam + sub, ver)
-    return None
-
-
-def _meta(name: str, model_dict: dict | None = None, im: dict | None = None) -> dict:
-    """Metadaten (family, gen, total, active, moe) — bevorzugt den kuratierten Katalog,
-    sonst die Felder eines Discover-/Modell-Dicts, sonst Namens-/Größen-Heuristik."""
-    cm = catalog.meta_for_name(name)
-    if cm:
-        return {"family": cm.get("family"), "gen": cm.get("generation"),
-                "total": float(cm.get("total_params_b") or 0),
-                "active": cm.get("active_params_b"), "moe": bool(cm.get("moe"))}
-    d = model_dict or {}
-    g = _gen_key(name)
-    total = float(d.get("params_b") or 0) or (_params_of(im) if im else 0.0)
-    return {"family": (d.get("family") or (g[0] if g else None)),
-            "gen": (d.get("generation") if d.get("generation") is not None else (g[1] if g else None)),
-            "total": total, "active": d.get("active_b"), "moe": bool(d.get("moe"))}
-
-
-def model_upgrades() -> list[dict]:
-    """Je Rolle ein ECHTES Upgrade — nur wenn die Empfehlung wirklich besser ist:
-    gleiche Familie UND (neuere Generation ODER deutlich größer) UND kein Tempo-Downgrade
-    (MoE-first für die bandbreiten-limitierte Box: dense ersetzt MoE nur bei großem Wissens-
-    Sprung). Metadaten kommen aus dem kuratierten Katalog → keine Namens-Raterei."""
-    disc = discover.safe_discover(_ram_gb())
-    if not disc:
-        return []
-
-    installed = llamaswap.list_models()
-    inst_by_role = {m["role"]: m for m in installed if m.get("role")}
-    cmds = " ".join(str(s.get("cmd", "")).lower()
-                    for s in (llamaswap.read_config().get("models") or {}).values())
-    out = []
-
-    for c in disc.get("categories", []):
-        role = c["role"]
-        im = inst_by_role.get(role)
-        if im is None:
-            continue
-        rec = c.get("recommended")
-        if not rec:
-            continue
-        rec_model = next((x for x in c.get("models", []) if x.get("repo") == rec), None)
-
-        i = _meta(im["name"], im=im)
-        r = _meta(rec, model_dict=rec_model)
-
-        if not i["family"] or not r["family"] or i["family"] != r["family"]:
-            continue                                   # andere/unbekannte Familie → kein Upgrade
-        if r["gen"] is not None and i["gen"] is not None and r["gen"] < i["gen"] - 1e-6:
-            continue                                   # ältere Generation → niemals
-        same_gen = (r["gen"] is None or i["gen"] is None or abs(r["gen"] - i["gen"]) < 1e-6)
-        if same_gen:
-            if r["total"] and i["total"] and r["total"] < i["total"] * 1.05:
-                continue                               # gleiche Gen, nicht größer → kein Upgrade
-            # MoE-first: ein MoE durch dense ersetzen nur bei deutlichem Wissens-Sprung
-            if i["moe"] and not r["moe"] and r["total"] < i["total"] * 1.5:
-                continue
-            # Tempo nicht verschlechtern (aktive Params), außer großer Wissens-Gewinn
-            ia, ra = (i["active"] or i["total"]), (r["active"] or r["total"])
-            if ia and ra > ia * 1.3 and r["total"] < i["total"] * 1.3:
-                continue
-
-        base = rec.split("/")[-1].lower()
-        stem = base.removesuffix("-gguf")
-        if base in cmds or (stem and stem in cmds):
-            continue                                   # schon installiert
-        out.append({"role": role, "title": c["title"], "repo": rec})
-    return out
-
-
 def _last_apt_update() -> float | None:
     for path in ["/var/lib/apt/periodic/update-success-stamp", "/var/cache/apt/pkgcache.bin"]:
         if os.path.exists(path):
@@ -312,11 +236,23 @@ def _last_apt_update() -> float | None:
 
 
 def updates() -> dict:
-    ups = model_upgrades()
-    return {"os": _os_upgradable(), "engine": 1 if _engine_update_available() else 0,
-            "swap": 1 if _swap_update_available() else 0,
-            "models": len(ups), "model_list": ups, "last_check": _last_apt_update(),
-            "components": _components_cached()}
+    """Offene Updates je Baustein. `pruef_fehler` nennt je Baustein, warum nicht geprüft werden
+    konnte (None = geprüft). Die frühere Modell-Upgrade-Empfehlung ist raus (24.09.2026): das
+    Modell-Radar hat die Aufgabe übernommen, und die Oberfläche zeigte sie nicht mehr."""
+    daten = {"os": _os_upgradable(), "engine": 1 if _engine_update_available() else 0,
+             "swap": 1 if _swap_update_available() else 0,
+             "last_check": _last_apt_update(), "components": _components_cached()}
+    daten["pruef_fehler"] = dict(PRUEF_FEHLER)
+    return daten
+
+
+def _nach_update() -> None:
+    """Nach einem abgeschlossenen Update: Zwischenspeicher leeren und den Stand hochzählen."""
+    global update_stand
+    _engine_cache.update(ts=0.0, avail=False)
+    _swap_cache.update(ts=0.0, avail=False)
+    _comp_cache.update(ts=0.0, data=[])
+    update_stand += 1
 
 
 # ── Update-Details (was genau wird aktualisiert) — on-demand beim Öffnen des Fensters ──
@@ -630,30 +566,28 @@ def logs(service: str, lines: int = 200) -> dict:
         return {"ok": r["ok"], "text": r["out"] or r["err"]}
     return {"ok": False, "text": "", "err": "Dienst nicht erlaubt."}
 
-def check_updates_job() -> dict:
-    if err := check_sudo_needs_password():
-        return err
-    
-    def on_done():
-        _engine_cache.update(ts=0.0, avail=False)
-        _comp_cache.update(ts=0.0, data=[])  # Hermes-Status ebenfalls neu berechnen lassen
-
-    cmd = "sudo apt-get update"
-    job_id = jobengine.start_job(["bash", "-c", cmd], "Nach Updates suchen", on_done=on_done)
+def _starten(args: list[str], label: str, on_done=None, zeitlimit_s: int | None = None) -> dict:
+    """Wartungs-Riegel: nur EIN binär-/dienst-veränderndes Job gleichzeitig. Prüfen und Eintragen
+    passieren unter einer Sperre (jobengine.start_job_exklusiv) — vorher lag zwischen Prüfung und
+    Start ein langsamer Aufruf, und zwei Klicks konnten zwei Updates starten."""
+    job_id, laeuft = jobengine.start_job_exklusiv("maintenance", args, label, on_done=on_done,
+                                                  zeitlimit_s=zeitlimit_s)
+    if job_id is None:
+        return {"ok": False, "status": "busy", "running": (laeuft or {}).get("label"),
+                "detail": f"Es läuft schon: {(laeuft or {}).get('label', 'ein Update')}."}
     return {"ok": True, "job_id": job_id}
 
 
-def _maintenance_busy() -> dict | None:
-    """Wartungs-Riegel: nur EIN binär-/dienst-veränderndes Update gleichzeitig. Verhindert
-    Doppelklick UND parallele Updates aus zwei Tabs/Sessions (racende .bak-Sicherung/Restarts)."""
-    if j := jobengine.active_in_group("maintenance"):
-        return {"ok": False, "status": "busy", "running": j.get("label")}
-    return None
+def check_updates_job() -> dict:
+    if err := check_sudo_needs_password():
+        return err
+    # apt-get update gehört in den Wartungs-Riegel: parallel zu einem apt upgrade kollidiert es mit
+    # der dpkg-Sperre. In der Gruppe taucht der Job auch in der Oberfläche auf.
+    return _starten(["bash", "-c", "sudo apt-get update"], "Nach Updates suchen",
+                    on_done=_nach_update, zeitlimit_s=15 * 60)
 
 
 def os_update_job() -> dict:
-    if busy := _maintenance_busy():
-        return busy
     if err := check_sudo_needs_password():
         return err
     # Nach dem apt-Upgrade den Stack funktional prüfen (Job wird rot, wenn etwas kaputt ging).
@@ -662,49 +596,26 @@ def os_update_job() -> dict:
     cmd = ("sudo apt-get update && "
            "sudo bash -c 'DEBIAN_FRONTEND=noninteractive apt-get upgrade -y' "
            f"&& bash {STACK_POSTCHECK}")
-    job_id = jobengine.start_job(["bash", "-c", cmd], "OS-Update (apt)",
-                                 group="maintenance")
-    return {"ok": True, "job_id": job_id}
+    return _starten(["bash", "-c", cmd], "OS-Update (apt)", on_done=_nach_update, zeitlimit_s=90 * 60)
 
 
 def engine_update_job() -> dict | None:
     if not ENGINE_UPDATE_CMD:
         return None
-    if busy := _maintenance_busy():
-        return busy
-    # KEIN sudo-Passwort-Gate: update-engine.sh ist per sudoers NOPASSWD freigegeben
-    # (sudoers-mc2-autonomie) und läuft passwortlos. Das frühere `sudo true`-Gate hat das
-    # Update fälschlich blockiert, wenn (noch) kein Box-Passwort hinterlegt war.
-
-    def on_done():
-        _engine_cache.update(ts=0.0, avail=False)  # Cache leeren → frischer Build-Vergleich
-
     # update-engine.sh sichert den alten Build, aktualisiert, startet llama-swap neu, prüft den
     # Stack (stack-postcheck.sh) und rollt bei Fehler selbst zurück. Exit 0 nur bei verifiziertem
-    # neuen Build → on_done (Cache leeren) läuft nur dann; bei Rollback (Exit 1/2) bleibt das Badge.
-    job_id = jobengine.start_job(["bash", "-c", ENGINE_UPDATE_CMD],
-                                 "Engine-Update (llama.cpp Vulkan)",
-                                 group="maintenance", on_done=on_done)
-    return {"ok": True, "job_id": job_id}
+    # neuen Build. KEIN sudo-Passwort-Gate: das Skript ist per sudoers NOPASSWD freigegeben.
+    return _starten(["bash", "-c", ENGINE_UPDATE_CMD], "Engine-Update (llama.cpp Vulkan)",
+                    on_done=_nach_update, zeitlimit_s=60 * 60)
 
 
 def swap_update_job() -> dict | None:
     if not SWAP_UPDATE_CMD:
         return None
-    if busy := _maintenance_busy():
-        return busy
-    # KEIN sudo-Passwort-Gate: update-swap.sh ist per sudoers NOPASSWD freigegeben (wie die Engine).
-
-    def on_done():
-        _swap_cache.update(ts=0.0, avail=False)  # Cache leeren → frischer Versions-Vergleich
-
     # update-swap.sh sichert die alte Binary, aktualisiert, startet llama-swap neu, prüft den Stack
-    # (stack-postcheck.sh) und rollt bei Fehler selbst zurück. Exit 0 nur bei verifizierter neuer
-    # Version → on_done (Cache leeren) läuft nur dann; bei Rollback (Exit 1/2) bleibt das Badge.
-    job_id = jobengine.start_job(["bash", "-c", SWAP_UPDATE_CMD],
-                                 "Router-Update (llama-swap)",
-                                 group="maintenance", on_done=on_done)
-    return {"ok": True, "job_id": job_id}
+    # und rollt bei Fehler selbst zurück. Exit 0 nur bei verifizierter neuer Version.
+    return _starten(["bash", "-c", SWAP_UPDATE_CMD], "Router-Update (llama-swap)",
+                    on_done=_nach_update, zeitlimit_s=30 * 60)
 
 
 def _hermes_update_cmd() -> str:
@@ -753,16 +664,9 @@ def _hermes_update_cmd() -> str:
 def hermes_update_job() -> dict:
     """Hermes-Agent aktualisieren wie die CLI (`hermes update` = git pull + Deps), danach
     den Gateway neu starten. Davor ein Sicherheits-Backup (unser deploy/backup.sh). Kein sudo
-    (alles im User-Space). Läuft als Hintergrund-Job (kann ~1 Min dauern)."""
-    if busy := _maintenance_busy():
-        return busy
-
-    def on_done():
-        _comp_cache.update(ts=0.0, data=[])  # Update-Status neu berechnen lassen
-
-    job_id = jobengine.start_job(["bash", "-c", _hermes_update_cmd()], "Hermes-Agent-Update",
-                                 group="maintenance", on_done=on_done)
-    return {"ok": True, "job_id": job_id}
+    (alles im User-Space). Läuft als Hintergrund-Job (kann einige Minuten dauern)."""
+    return _starten(["bash", "-c", _hermes_update_cmd()], "Hermes-Agent-Update",
+                    on_done=_nach_update, zeitlimit_s=45 * 60)
 
 
 def update_all_job() -> dict:
@@ -771,8 +675,9 @@ def update_all_job() -> dict:
     Befehl des Einzel-Updates (mit eigenem Backup/Postcheck/Rollback). `&&`-Kette = bei
     Fehler stoppt der Rest (das Log zeigt, wo). OS zuletzt, weil apt am breitesten eingreift;
     es ist das einzige mit sudo — scheitert das, laufen die sudo-freien Teile trotzdem."""
-    if busy := _maintenance_busy():
-        return busy
+    if laeuft := jobengine.active_in_group("maintenance"):
+        return {"ok": False, "status": "busy", "running": laeuft.get("label"),
+                "detail": f"Es läuft schon: {laeuft.get('label', 'ein Update')}."}
     upd = updates()
     parts: list[tuple[str, str]] = []
     if upd.get("engine") and ENGINE_UPDATE_CMD:
@@ -804,18 +709,9 @@ def update_all_job() -> dict:
     if not os_pending:
         cmd += f" && bash {STACK_POSTCHECK}"  # Abschluss-Check, falls apt ihn nicht schon lieferte
 
-    def on_done():
-        _engine_cache.update(ts=0.0, avail=False)
-        _swap_cache.update(ts=0.0, avail=False)
-        _comp_cache.update(ts=0.0, data=[])
-
     labels = " → ".join(label for label, _ in parts)
-    job_id = jobengine.start_job(["bash", "-c", cmd], f"Alle aktualisieren ({labels})",
-                                 group="maintenance", on_done=on_done)
-    return {"ok": True, "job_id": job_id, "parts": [label for label, _ in parts]}
-
-
-def reboot() -> dict:
-    if err := check_sudo_needs_password():
-        return err
-    return _run(["sudo", "reboot"])
+    ergebnis = _starten(["bash", "-c", cmd], f"Alle aktualisieren ({labels})",
+                        on_done=_nach_update, zeitlimit_s=3 * 3600)
+    if ergebnis.get("ok"):
+        ergebnis["parts"] = [label for label, _ in parts]
+    return ergebnis

backend/services/metrics_history.py

@@ -1,128 +0,0 @@
-"""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/radar.py

@@ -1384,16 +1384,19 @@ def _tausche_ein(k: dict) -> dict:
     else:
         ziel = quelle                 # schon verschoben (früherer, abgebrochener Versuch)
     pfade = _lokale_pfade(k, ziel)
-    modell_id = llamaswap.register_model(pfade["gguf"], role=ALIAS[rolle], ctx=int(k.get("ctx") or CTX_ROLLE[rolle]),
-                                         mmproj_path=None, jinja=True, set_alias=False)
-    cfg = llamaswap.read_config()
-    try:   # die getesteten Flags statt der Vorlage aus register_model (sonst liefe ein ungetesteter Draft mit)
-        cfg["models"][modell_id]["cmd"] = LiteralScalarString(betriebs_befehl(rolle, pfade, k) + "\n")
-    except (KeyError, TypeError) as e:
-        raise RuntimeError(f"{modell_id} fehlt nach dem Eintragen in der llama-swap-Config.") from e
-    if pfade.get("mmproj"):
-        _zwilling_eintragen(cfg, rolle, modell_id, pfade, k)
-    llamaswap.write_config(cfg)
+    # Eintragen, Befehl ersetzen und Zwilling anlegen unter EINER Config-Sperre (24.09.2026).
+    with llamaswap.config_sperre():
+        modell_id = llamaswap.register_model(pfade["gguf"], role=ALIAS[rolle],
+                                             ctx=int(k.get("ctx") or CTX_ROLLE[rolle]),
+                                             mmproj_path=None, jinja=True, set_alias=False)
+        cfg = llamaswap.read_config()
+        try:   # die getesteten Flags statt der Vorlage aus register_model (sonst liefe ein ungetesteter Draft mit)
+            cfg["models"][modell_id]["cmd"] = LiteralScalarString(betriebs_befehl(rolle, pfade, k) + "\n")
+        except (KeyError, TypeError) as e:
+            raise RuntimeError(f"{modell_id} fehlt nach dem Eintragen in der llama-swap-Config.") from e
+        if pfade.get("mmproj"):
+            _zwilling_eintragen(cfg, rolle, modell_id, pfade, k)
+        llamaswap.write_config(cfg)
     hinweis = None
     if rolle == "hirn":
         from services.agent import set_agent_brain

backend/services/roles.py

@@ -1,143 +0,0 @@
-"""
-Rollen-Empfehlung: welches INSTALLIERTE Modell passt am besten auf eine Serving-Rolle?
-Capability-getrieben (Vision/Coder/Tools/MoE aus services.caps) + setup-bewusster Fit
-(services.budget). Speist den 'Empfohlen'-Hinweis + Auto-Pick im Rollen-Zuweisungs-Modal.
-
-EINE Quelle der Wahrheit mit der ctx-/Fit-Logik: nutzt budget.setup_aware_ctx_for_model
-und fit.evaluate_fit — dieselbe Mathematik wie Install-Automatik und Auto-ctx-Button.
-"""
-
-import psutil
-
-from services import budget, catalog, llamaswap
-from services.fit import evaluate_fit
-
-
-def _ram_gb() -> float:
-    return psutil.virtual_memory().total / (1024 ** 3)
-
-
-def _capability_suit(role: str, caps: dict, name: str) -> float:
-    """0..1 — Capability-Eignung (HARTE Gates). 0 = grundsätzlich falsch für die Rolle.
-    Größe/Tempo bewertet getrennt _pref(), damit z.B. 'fast' nicht das größte Modell zieht."""
-    role = (role or "").lower()
-    low = (name or "").lower()
-    vision = bool(caps.get("vision"))
-    coder = bool(caps.get("coder"))
-    tools = caps.get("tools") != "no"
-
-    if role == "vision":
-        if not vision:
-            return 0.0                                 # harte Anforderung
-        return 1.0 if ("vl" in low or "llava" in low or "pixtral" in low) else 0.7  # dediziert > omni
-    if role == "coder":
-        return 1.0 if coder else 0.4                   # Coder-Modell Pflicht für Empfehlung
-    if role == "hermes":
-        # Agent-Hirn: Hermes-Familie am robustesten; sonst natives Tool-Calling Pflicht.
-        if "hermes" in low:
-            return 1.0
-        return 0.6 if tools else 0.1
-    if role == "fast":
-        # Alltags-Hirn braucht zuverlässige Tools; Größe/Tempo macht _pref.
-        return 1.0 if tools else 0.6
-    if role == "heavy":
-        return 1.0
-    if role == "scout":
-        return 0.9 if vision else 0.7
-    return 0.5
-
-
-def _pref(role: str, params: float, tps: float) -> float:
-    """0..1 — rollengerechte GRÖSSEN-/TEMPO-Präferenz. 'fast' belohnt Tempo & Kleinheit,
-    'heavy' Größe (Wissen), 'hermes' moderate Größe (muss warm + ko-resident bleiben)."""
-    role = (role or "").lower()
-    if role == "fast":
-        speed = min(tps / 25.0, 1.0)
-        size_ok = 1.0 if params <= 50 else 50.0 / params
-        return speed * size_ok
-    if role == "heavy":
-        return min(params / 120.0, 1.0)
-    if role == "hermes":
-        return 1.0 if params <= 24 else max(0.15, 24.0 / params)   # 7–24B ideal als Hirn
-    if role == "vision":
-        return 1.0 if params <= 12 else 0.7                        # klein/günstig bevorzugt
-    if role == "coder":
-        return 0.5 + 0.5 * min(params / 80.0, 1.0)
-    if role == "scout":
-        return 1.0 if params <= 40 else 0.5
-    return 0.5
-
-
-def _catalog_role_match(role: str, name: str) -> bool:
-    """Ist dieses Modell im kuratierten Katalog (Cookbook) genau für DIESE Rolle gelistet?
-    Dann ist es der prinzipien-konforme Pick → starker Bonus."""
-    meta = catalog.meta_for_name(name)
-    return bool(meta and (meta.get("role") or "").lower() == (role or "").lower())
-
-
-def _reason(role: str, caps: dict, name: str, fit: dict, fits: bool,
-            incomplete: bool, cat_match: bool) -> str:
-    if incomplete:
-        return "Download unvollständig"
-    if role == "vision" and not caps.get("vision"):
-        return "keine Vision-Fähigkeit"
-    if role == "coder" and not caps.get("coder"):
-        return "kein Coder-Modell"
-    if role == "hermes" and "hermes" not in (name or "").lower() and caps.get("tools") == "no":
-        return "kein natives Tool-Calling"
-    if not fits:
-        return "passt nicht ins Budget (OOM)"
-    bits = []
-    if cat_match:
-        bits.append("Katalog-Pick ✓")
-    if role == "vision":
-        bits.append("Vision ✓")
-    if role == "coder" and caps.get("coder"):
-        bits.append("Coder ✓")
-    if role == "hermes":
-        bits.append("Hermes" if "hermes" in (name or "").lower()
-                    else ("Tools ✓" if caps.get("tools") != "no" else "ohne Tools"))
-    if caps.get("moe"):
-        bits.append("MoE")
-    bits.append(f"{fit['text']}, ~{fit['tps']:.0f} t/s")
-    return " · ".join(bits)
-
-
-def recommend_for_role(role: str) -> dict:
-    """Rankt alle installierten Modelle für eine Rolle. Empfohlen = bester geeigneter,
-    passender Eintrag. Liefert pro Modell Fit/Eignung/Begründung fürs UI."""
-    role = (role or "").strip().lower()
-    ram = _ram_gb()
-    out = []
-    for m in llamaswap.list_models():
-        caps = m.get("capabilities") or {}
-        params = budget.params_of_model(m)
-        quant = m.get("quant") or "Q4_K_M"
-        ctx = budget.setup_aware_ctx_for_model(m)["ctx"]
-        fit = evaluate_fit(params, quant, ctx, ram, name=m["name"])
-        incomplete = bool(m.get("incomplete"))
-        fits = (fit["level"] != "too_tight") and not incomplete
-        tps = fit["tps"] or 0
-        suit = _capability_suit(role, caps, m["name"])
-        cat_match = _catalog_role_match(role, m["name"])
-        suitable = suit >= 0.5 and fits
-
-        fit_term = {"perfect": 1.0, "marginal": 0.3}.get(fit["level"], -2.0)
-        # Eignung dominiert (×2), rollengerechte Größe/Tempo (_pref), Katalog-Anker, dann Fit.
-        score = (2.0 * suit) + _pref(role, params, tps) + (0.6 if cat_match else 0.0) + fit_term
-        if not fits:
-            score -= 5.0
-
-        out.append({
-            "name": m["name"], "current_role": m.get("role"),
-            "params_b": round(params, 1), "quant": quant,
-            "fit": fit, "suitable": suitable, "incomplete": incomplete,
-            "score": round(score, 3),
-            "reason": _reason(role, caps, m["name"], fit, fits, incomplete, cat_match),
-        })
-
-    out.sort(key=lambda x: -x["score"])
-    rec = next((o["name"] for o in out if o["suitable"]), None)
-    for o in out:
-        o["recommended"] = (o["name"] == rec)
-    return {"role": role, "recommended": rec, "models": out}

backend/services/router_logic.py

@@ -19,8 +19,6 @@ from services.routing_policy import load_policy
 # (routing_policy.py) und kommen pro Request via load_policy() (hot-reload). Die Env-Vars
 # sind dort die Defaults. Die Regex-Keyword-Listen unten bleiben bewusst im Code.
 
-# Virtuelle Lanes, die im Gateway als „Modelle" sichtbar sind.
-LANES = ["coding", "chat"]
 LANE_ALIASES = {"auto": "chat"}  # Rückwärtskompatibel: model:auto == chat
 
 _HEAVY_KW = re.compile(
@@ -36,18 +34,6 @@ _CODING_HEAVY_KW = re.compile(
     r"entwirf\s+(eine\s+)?architektur|plane?\s+(die\s+)?architektur)\b",
     re.IGNORECASE,
 )
-# Code-Indikatoren — verhindert, dass echte Code-Anfragen als „trivial" auf fast abrutschen.
-# Bewusst breit (inkl. natürlichsprachiger Coding-Begriffe DE+EN): in der coding-Lane soll im Zweifel
-# `coder` gewinnen; nur echte Nicht-Code-Kürze ("hallo", "wie spät") rutscht auf fast.
-_CODE_HINT = re.compile(
-    r"```|\bdef \b|\bclass \b|\bimport \b|\bfunction\b|=>|;\s*$|"
-    r"\.(py|ts|tsx|js|jsx|go|rs|java|cpp|c|rb|php|sql)\b|/src/|traceback|stack\s*trace|"
-    r"\b(funktion|function|bug|fix|fehler|error|exception|implementier\w*|schreib\w*|"
-    r"code\w*|coden|test\w*|klasse|method\w*|methode|refactor\w*|kompil\w*|compile|"
-    r"build|deploy|debug|script|skript|api|endpoint|query|regex|json|yaml|"
-    r"npm|pip|git|docker|terminal|shell|command)\b",
-    re.IGNORECASE | re.MULTILINE,
-)
 
 
 # Bild-Weiche (Faden 11): Aliase, die selbst Bilder koennen — die werden NIE umgeroutet.
@@ -150,6 +136,3 @@ def choose_for_lane(lane: str, body: dict) -> tuple[str, str]:
     return _route_chat(text, n)  # chat + alles Unbekannte
 
 
-def choose_model(body: dict) -> tuple[str, str]:
-    """Rückwärtskompatibel: altes `model:auto` == chat-Lane."""
-    return choose_for_lane("chat", body)

backend/services/routing_policy.py

@@ -115,21 +115,3 @@ def load_policy() -> dict:
         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/voice_metrics.py

@@ -1,173 +0,0 @@
-"""
-Per-Stage-Latenz-Metriken + Per-Turn-Trace für die Voice/Lucy-Pipeline.
-
-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
-**Gedächtnis-Abruf** dagegen läuft seit der Ablösung des Sidecars (07.08.2026) Hermes-intern — es
-gibt keinen Rückruf an MC2 mehr, also auch keine Messung; er steckt jetzt in der Hirn-Zeit. Ebenso die
-**Tool-Runden**: im Hermes-LLM-Loop ohne Callback an MC2 → unsichtbar, im „Generierung"-Bucket.
-
-STT läuft als eigener HTTP-Request VOR dem Turn, ohne Turn-ID. Auf einem EIN-Nutzer-Gerät genügt eine
-schlanke Best-Effort-Korrelation: die zuletzt gemessene STT-Dauer wird global „geparkt" und vom
-nächsten Chat-Turn eingesammelt (mit Frist-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", "chat_first_content", "tts")
-
-# Best-effort-Korrelation (Ein-Nutzer-Gerät): zuletzt gemessene STT-Dauer als
-# (ms, perf_counter-Zeitstempel). Der nächste Chat-Turn sammelt sie ein und leert sie.
-_PARKED: dict[str, tuple[float, float] | None] = {"stt": None}
-
-
-def record_stage(stage: str, ms: float) -> None:
-    """Eine gemessene Stage-Dauer (ms) verbuchen. No-op bei negativen Werten."""
-    if ms is None or ms < 0:
-        return
-    with _LOCK:
-        dq = _STAGES.get(stage)
-        if dq is None:
-            dq = _STAGES[stage] = deque(maxlen=_MAX)
-        dq.append(float(ms))
-
-
-def park(kind: str, ms: float) -> None:
-    """Eine Messung, die NICHT im Chat-Request selbst passiert (STT läuft davor), 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
-
-
-class Timer:
-    """Context-Manager: misst die verstrichene Zeit und verbucht sie auf `stage`.
-    Funktioniert um `await`-Aufrufe herum (enter → await → exit)."""
-
-    def __init__(self, stage: str) -> None:
-        self.stage = stage
-        self._t0 = 0.0
-
-    def __enter__(self) -> "Timer":
-        self._t0 = time.perf_counter()
-        return self
-
-    def __exit__(self, *exc) -> None:
-        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."""
-
-    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 + Gedächtnis + 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 + Gedächtnis + 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
-        # 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,
-            "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}
-    s = sorted(vals)
-    n = len(s)
-    return {
-        "count": n,
-        "avg_ms": round(sum(s) / n, 1),
-        "p50_ms": round(s[n // 2], 1),
-        "p95_ms": round(s[min(n - 1, int(n * 0.95))], 1),
-        "last_ms": round(vals[-1], 1),
-    }
-
-
-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/waechter.py

@@ -480,8 +480,15 @@ def takt() -> None:
             continue    # während eines Updates sind Neustarts normal
         try:
             befunde += pruefung()
-        except Exception:
-            log.debug("waechter: %s fehlgeschlagen", pruefung.__name__, exc_info=True)
+        except Exception as exc:
+            # Bis 24.09.2026 stand das nur im Debug-Log: Die Prüfung war dann still aus, und das
+            # Cockpit blieb grün (z. B. wenn Hermes das Format seiner Job-Liste ändert).
+            log.warning("waechter: %s fehlgeschlagen", pruefung.__name__, exc_info=True)
+            befunde.append(Befund(
+                id=f"pruefung:{pruefung.__name__}", stufe="gelb",
+                titel="Eine Prüfung des Wächters lief nicht",
+                text=f"{pruefung.__name__}: {exc.__class__.__name__}: {exc}"[:240],
+                quelle="mc2-steward"))
 
     with _lock:
         hinweise: dict = _stand["hinweise"]