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/gguf_meta.py

@@ -49,6 +49,14 @@ class _Reader:
         n = self.u64()
         return self.read(n).decode("utf-8", "replace")
 
+    def scalar(self, vtype: int):
+        """Liest einen Skalar-Wert (für die Architektur-Metadaten). None bei Nicht-Skalar."""
+        fmt = _SCALAR_FMT.get(vtype)
+        if not fmt:
+            self.skip_value(vtype)
+            return None
+        return struct.unpack(fmt, self.read(_SCALAR_SIZE[vtype]))[0]
+
     def skip_value(self, vtype: int) -> None:
         """Liest einen Wert und verwirft ihn (um den Datei-Pointer korrekt
         weiterzuschieben). Arrays werden elementweise konsumiert."""
@@ -159,3 +167,100 @@ def compatible(target_path: str, draft_path: str) -> bool | None:
     if a is None or b is None:
         return None
     return a == b
+
+
+# ── Architektur-Metadaten für EHRLICHE KV-Cache-Größen ──────────────────────────────
+# Der KV-Cache hängt an (Layer × KV-Heads × Head-Dim), NICHT an den Gesamt-Parametern.
+# Bei MoE (z.B. Qwen3.6-35B-A3B) ist das entscheidend: die alte params-basierte Schätzung
+# überschätzte grob (aktive vs. gesamte Params + GQA), reale KV liest man direkt hier.
+# Schlüssel sind arch-präfixiert ('qwen3moe.block_count', 'llama.attention.head_count_kv' …),
+# gegen echte GGUFs verifiziert. Wir sammeln die gewünschten Skalar-Schlüssel per Suffix.
+_ARCH_WANT = (
+    ".block_count", ".attention.head_count_kv", ".attention.head_count",
+    ".attention.key_length", ".attention.value_length", ".embedding_length",
+    ".context_length",
+)
+
+
+def _read_arch_meta(path: str) -> dict | None:
+    try:
+        with open(path, "rb") as fh:
+            r = _Reader(fh)
+            if r.read(4) != b"GGUF":
+                return None
+            r.u32()                 # version
+            r.u64()                 # tensor_count
+            kv_count = r.u64()
+            raw: dict = {}
+            arch = None
+            for _ in range(kv_count):
+                key = r.gstr()
+                vtype = r.u32()
+                if key == "general.architecture" and vtype == _T_STRING:
+                    arch = r.gstr()
+                    continue
+                if key == "tokenizer.ggml.tokens":
+                    break            # Arch-Metadaten stehen davor → fertig, Rest überspringen
+                suf = next((s for s in _ARCH_WANT if key.endswith(s)), None)
+                if suf is not None and vtype in _SCALAR_SIZE:
+                    raw[suf] = r.scalar(vtype)
+                else:
+                    r.skip_value(vtype)
+            n_layers = raw.get(".block_count")
+            n_head = raw.get(".attention.head_count")
+            n_head_kv = raw.get(".attention.head_count_kv") or n_head   # GQA fehlt → MHA
+            n_embd = raw.get(".embedding_length")
+            hd_k = raw.get(".attention.key_length") \
+                or (int(n_embd / n_head) if (n_embd and n_head) else None)
+            hd_v = raw.get(".attention.value_length") or hd_k
+            if not (n_layers and n_head_kv and hd_k and hd_v):
+                return None          # unvollständig → Aufrufer nutzt Heuristik-Fallback
+            return {"arch": arch, "n_layers": int(n_layers), "n_head_kv": int(n_head_kv),
+                    "head_dim_k": int(hd_k), "head_dim_v": int(hd_v),
+                    "n_ctx_train": int(raw[".context_length"]) if raw.get(".context_length") else None}
+    except (OSError, EOFError, ValueError, struct.error):
+        return None
+
+
+@lru_cache(maxsize=128)
+def _arch_cached(path: str, mtime: float, size: int) -> dict | None:
+    return _read_arch_meta(path)
+
+
+def arch_meta(path: str) -> dict | None:
+    """Architektur-Metadaten eines GGUF (gecacht nach Pfad+mtime+size):
+    {arch, n_layers, n_head_kv, head_dim_k, head_dim_v, n_ctx_train}. None wenn nicht lesbar
+    oder unvollständig."""
+    import os
+    try:
+        st = os.stat(path)
+    except OSError:
+        return None
+    return _arch_cached(path, st.st_mtime, st.st_size)
+
+
+# Bytes pro KV-Cache-Element je cache-type (inkl. Block-Overhead der k-Quants).
+_KV_BPE = {
+    "f32": 4.0, "f16": 2.0, "bf16": 2.0,
+    "q8_0": 1.0625, "q5_1": 0.75, "q5_0": 0.6875,
+    "q4_1": 0.625, "q4_0": 0.5625, "iq4_nl": 0.5625,
+}
+_GIB = 1024 ** 3
+
+
+def _bpe(cache_type: str | None) -> float:
+    return _KV_BPE.get((cache_type or "f16").lower(), 2.0)
+
+
+def kv_cache_gb(meta: dict, ctx: int, ck: str | None = None, cv: str | None = None) -> float:
+    """Echte KV-Cache-Größe (GiB) für ctx Tokens, K/V ggf. quantisiert. Formel wie llama.cpp:
+    je Layer & Token hält der Cache n_head_kv × head_dim Elemente für K und für V."""
+    per_tok = meta["n_layers"] * meta["n_head_kv"] * ctx
+    k = per_tok * meta["head_dim_k"] * _bpe(ck)
+    v = per_tok * meta["head_dim_v"] * _bpe(cv)
+    return (k + v) / _GIB
+
+
+def kv_gb_per_token(meta: dict, ck: str | None = None, cv: str | None = None) -> float:
+    """KV-GiB pro Kontext-Token — für den analytischen ctx-Solver (linear in ctx)."""
+    return kv_cache_gb(meta, 1, ck, cv)