Fix: Modell-Manager Rollen-Taxonomie vereinheitlicht (5 Rollen) + echter Vocab-Check

- Rollen ueberall = fast/heavy/coder/vision/scout (eine Quelle der Wahrheit):
  sources.py CATEGORIES (agent/reasoning raus, fast/heavy rein), llamaswap.ROLE_IDS,
  maintenance ROLE_MAP entfernt (Discover-Rollen == Serving-Rollen), Discover.tsx
  ROLE_METADATA, ModelBadges.ROLES, ActiveModelsCard (stale reasoning-Farbe raus).
  Behebt: Discover zeigte "Reasoning"/"agent"; aus Discover installierte Modelle
  landeten in keinem Cockpit-Slot.
- gguf_meta: Vocab-Check jetzt ECHT - sha256 ueber die vollstaendige Token-Liste statt
  nur Metadaten. Familienunabhaengig (Qwen/Llama/Mistral/...). Verifiziert: Coder + Qwen3-0.6B
  byte-identisch (kompatibel), Qwen3.6 abweichend (inkompatibel), 0.11s/Scan.
- RolesCard SPEC-Badge -> spec_active (Konsistenz mit Cockpit).

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

backend/services/gguf_meta.py

@@ -11,6 +11,7 @@ Fälle zu unterscheiden (Qwen2.5 vs Qwen3 vs Qwen3.6 etc.). Die llama.cpp-Prüfu
 beim Laden bleibt der letzte Schiedsrichter.
 """
 
+import hashlib
 import struct
 from functools import lru_cache
 
@@ -79,16 +80,26 @@ def _read_fingerprint(path: str) -> dict | None:
             r.u32()                 # version
             r.u64()                 # tensor_count
             kv_count = r.u64()
-            fp: dict = {"model": None, "pre": None, "arch": None, "n_vocab": None}
+            fp: dict = {"model": None, "pre": None, "arch": None, "n_vocab": None,
+                        "tokens_sha": None}
             for _ in range(kv_count):
                 key = r.gstr()
                 vtype = r.u32()
                 if key == "tokenizer.ggml.tokens" and vtype == _T_ARRAY:
                     etype = r.u32()
-                    fp["n_vocab"] = r.u64()
-                    # Wir haben alles (model/pre kommen vor tokens) → abbrechen.
+                    count = r.u64()
+                    fp["n_vocab"] = count
                     if etype != _T_STRING:
                         return None
+                    # ECHTE Vocab-Identität: sha256 über die tatsächliche Token-Liste
+                    # (familienunabhängig — funktioniert für Qwen, Llama, Mistral, …).
+                    h = hashlib.sha256()
+                    h.update(count.to_bytes(8, "little"))
+                    for _ in range(count):
+                        n = r.u64()
+                        h.update(r.read(n))
+                    fp["tokens_sha"] = h.hexdigest()
+                    # model/pre kommen vor tokens → wir haben alles. Abbrechen.
                     break
                 if key in _WANT_STRINGS and vtype == _T_STRING:
                     val = r.gstr()
@@ -112,12 +123,12 @@ def _cached(path: str, mtime: float, size: int) -> tuple | None:
     fp = _read_fingerprint(path)
     if fp is None:
         return None
-    return (fp.get("model"), fp.get("pre"), fp.get("n_vocab"), fp.get("arch"))
+    return (fp.get("model"), fp.get("pre"), fp.get("n_vocab"), fp.get("arch"), fp.get("tokens_sha"))
 
 
 def fingerprint(path: str) -> dict | None:
     """Tokenizer-Fingerprint eines GGUF (gecacht nach Pfad+mtime+size).
-    Returns dict(model, pre, n_vocab, arch) oder None wenn nicht lesbar."""
+    Returns dict(model, pre, n_vocab, arch, tokens_sha) oder None wenn nicht lesbar."""
     import os
     try:
         st = os.stat(path)
@@ -126,16 +137,18 @@ def fingerprint(path: str) -> dict | None:
     t = _cached(path, st.st_mtime, st.st_size)
     if t is None:
         return None
-    return {"model": t[0], "pre": t[1], "n_vocab": t[2], "arch": t[3]}
+    return {"model": t[0], "pre": t[1], "n_vocab": t[2], "arch": t[3], "tokens_sha": t[4]}
 
 
 def vocab_key(path: str) -> tuple | None:
-    """Vergleichsschlüssel für Vocab-Kompatibilität: (model, pre, n_vocab).
-    Genau diese Identität verlangt llama.cpp für Speculative Decoding."""
+    """ECHTER Vergleichsschlüssel für Vocab-Kompatibilität: (model, pre, n_vocab, sha256
+    der vollständigen Token-Liste). Vergleicht den TATSÄCHLICHEN Vokabular-Inhalt, nicht
+    nur Metadaten — familienunabhängig (Qwen, Llama, Mistral, …). Genau diese Identität
+    verlangt llama.cpp für Speculative Decoding."""
     fp = fingerprint(path)
-    if not fp or fp["n_vocab"] is None:
+    if not fp or fp["n_vocab"] is None or not fp.get("tokens_sha"):
         return None
-    return (fp["model"], fp["pre"], fp["n_vocab"])
+    return (fp["model"], fp["pre"], fp["n_vocab"], fp["tokens_sha"])
 
 
 def compatible(target_path: str, draft_path: str) -> bool | None:

backend/services/llamaswap.py

@@ -20,8 +20,9 @@ from config import (
 
 log = logging.getLogger(__name__)
 
-# Kanonische Rollen (vereinheitlicht ggü. v1: kein manager/reviewer mehr).
-ROLE_IDS = {"vision", "coder", "agent", "scout"}
+# Kanonische Serving-Rollen — EINE Quelle der Wahrheit (identisch zu sources.ROLE_IDS,
+# maintenance, frontend ModelBadges.ROLES). Kein agent/reasoning mehr.
+ROLE_IDS = {"fast", "heavy", "coder", "vision", "scout"}
 
 _CTX_RE = re.compile(r"-(?:c|-ctx-size)\s+(\d+)")
 _PATH_RE = re.compile(r"-(?:m|-model)\s+([^\s]+)")

backend/services/maintenance.py

@@ -168,19 +168,11 @@ def model_upgrades() -> list[dict]:
     cmds = " ".join(str(s.get("cmd", "")).lower()
                     for s in (llamaswap.read_config().get("models") or {}).values())
     out = []
-    
-    ROLE_MAP = {
-        "agent": "fast",
-        "scout": "fast",
-        "coder": "coder",
-        "vision": "vision"
-    }
 
+    # Discover-Rollen == Serving-Rollen (fast/heavy/coder/vision/scout) → kein Mapping mehr.
     for c in disc.get("categories", []):
-        disc_role = c["role"]
-        mapped_role = ROLE_MAP.get(disc_role, disc_role)
-        
-        if mapped_role not in active_roles:
+        role = c["role"]
+        if role not in active_roles:        # nur Rollen, die bereits ein Modell haben
             continue
 
         rec = c.get("recommended")
@@ -190,7 +182,7 @@ def model_upgrades() -> list[dict]:
         stem = base[:-5] if base.endswith("-gguf") else base
         if base in cmds or (stem and stem in cmds):
             continue
-        out.append({"role": mapped_role, "title": c["title"], "repo": rec})
+        out.append({"role": role, "title": c["title"], "repo": rec})
     return out
 
 

backend/services/sources.py

@@ -1,24 +1,31 @@
 """
 Vertrauenswürdige Quellen + Kategorien für die automatische Modell-Entdeckung.
-Portiert aus Mission Control v1 (sources.py). Rollen sind die EINE Quelle der
-Wahrheit (vereinheitlicht): vision · coder · agent · scout.
+Rollen = die EINE Quelle der Wahrheit, identisch zu den llama-swap-Serving-Rollen
+und der UI: fast · heavy · coder · vision · scout.
 """
 
 # HF-Orgs, die zuverlässig aktuelle, hochwertige GGUF-Quants veröffentlichen.
 TRUSTED_AUTHORS = ["unsloth", "bartowski", "ggml-org", "lmstudio-community"]
 
+# Kanonische Rollen — eine Quelle der Wahrheit (deckt sich mit llamaswap.ROLE_IDS,
+# maintenance.ROLE_MAP, frontend ModelBadges.ROLES + Discover.ROLE_METADATA).
+ROLE_IDS = ["fast", "heavy", "coder", "vision", "scout"]
+
 # Kategorien (Reihenfolge = Anzeige + Zuordnungs-Priorität). Ein Modell wird der
 # ERSTEN Kategorie zugeordnet, deren Stichwort im Repo-Namen vorkommt; sonst „scout".
-# Die `role` ist zugleich der Alias-Vorschlag und gehört zu ROLE_IDS.
+# Die `role` ist zugleich der Alias-Vorschlag und EINE der 5 kanonischen Rollen.
 CATEGORIES = [
     {"role": "vision", "title": "Bilder verstehen", "icon": "eye",
      "kw": ["-vl-", "-vl", "vision", "llava", "multimodal", "-mm-", "pixtral"]},
     {"role": "coder", "title": "Coden & Programmieren", "icon": "code",
      "kw": ["coder", "-code-", "code-", "codestral", "starcoder"]},
-    {"role": "agent", "title": "Agenten & Tool-Use", "icon": "layers",
-     "kw": ["hermes", "-tool", "command-r", "watt", "-fc-", "function"]},
-    {"role": "scout", "title": "Allrounder & Chat", "icon": "compass",
-     "kw": []},  # Fallback: instruct/chat-Modelle
+    {"role": "heavy", "title": "Schweres Reasoning", "icon": "brain",
+     "kw": ["reasoning", "-think", "thinking", "gpt-oss", "deepseek-r", "-r1", "qwq",
+            "-70b", "-72b", "-120b", "-123b", "-235b", "-405b", "-a10b", "-a22b"]},
+    {"role": "fast", "title": "Schnelles Alltags-Hirn", "icon": "zap",
+     "kw": ["-a3b", "-a1", "-a2", "-30b", "-32b", "-14b", "-8b", "-7b", "-4b", "-moe"]},
+    {"role": "scout", "title": "Multimodal-Allrounder", "icon": "compass",
+     "kw": []},  # Fallback: instruct/chat-Modelle, die in keine Spezialrolle fallen
 ]
 
 # Repo-Namensteile, die bei der Entdeckung übersprungen werden (Roh-/Spezialformate).