MC2 Final (D16 a/b/d): verständliche Updates + ehrliche Speicher-Zahlen

a) Update-Meldungen: generischer Release-Summarizer in Lucys Stimme mit
   strukturiertem Aktions-Verdikt ("Musst du etwas tun? NEIN/JA") für
   Hermes, Engine (llama.cpp) und llama-swap; Fangnetz-Hinweis verheiratet
   Breaking-Change-Sorge mit dem Postcheck.
b) OS ehrlich: zurückgestellte Pakete (Phasen-Rollout / kept back) werden
   ausgewiesen statt scheinbar zu hängen.
d) Ehrliche Speicher-Zahlen: KV-Cache aus echten GGUF-Architektur-Daten
   (Layer × KV-Köpfe × head_dim) + KV-Quant aus dem cmd statt params-blinder
   Schätzung — footprint_gb als eine Zahlensprache (Zentrale, Modell-Manager,
   fits-Check auf warmset+largest). Auto-Rewarm-Nudge nach Config-Reload.

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

backend/services/budget.py

@@ -54,16 +54,46 @@ def params_of_model(model: dict) -> float:
     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 + kalibrierter KV-Anteil (bei seinem
-    aktuellen ctx)."""
+    """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 = estimate_memory_gb(pb, quant, ctx) - pb * bpp
+    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)
 
 
@@ -139,9 +169,37 @@ 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 (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"))
+    """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"]}