radar: Kandidaten messen mit der schnellsten Draft-Variante, Bild-Probe und Betrieb wie heute mit Zwilling

Das heutige Modell misst mit seinem Draft (Hirn 106 t/s, ohne 68), Kandidaten liefen ohne -
Ornith fiel am 24.09. deshalb durch, obwohl es dieselbe Architektur hat. Jetzt probiert das Radar
kurz: ohne Draft, eingebauten MTP-Kopf und den Draft des heutigen Modells (gleiche Architektur,
Speicher reicht) und testet mit der schnellsten. Spekulatives Dekodieren aendert die Antworten
nicht, nur das Tempo.

Mit Draft laeuft die Bild-Probe auf einem Zwilling ohne Draft (llama.cpp: Draft und Bild = HTTP
500). Uebernehmen baut wie der Betrieb seit 24.09.: Hauptmodell mit dem gewaehlten Draft ohne
Projektor, dazu ein Bild-Zwilling; der alte Zwilling fliegt raus.

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

backend/tests/test_radar.py

@@ -355,7 +355,10 @@ def _uebernahme_vorbereiten(zustand, monkeypatch, rolle: str, alt: dict) -> tupl
     stand = radar._leer()
     stand["kandidaten"]["o"] = _kandidat("o", rolle=rolle, status="bestanden", ordner=str(ordner))
     radar._speichere(stand)
-    aufrufe, cfg = [], {"models": {}}
+    aufrufe = []
+    cfg = {"models": {"alter-zwilling": {"cmd": "llama-server -m /alt.gguf --mmproj /alt-mm.gguf",
+                                         "aliases": ["vision" if rolle == "hirn" else "coder-bild"]}},
+           "groups": {"bild": {"swap": True, "exclusive": False, "members": ["alter-zwilling"]}}}
 
     def eintragen(pfad, **kw):
         aufrufe.append(("eintragen", pfad, kw["role"], kw["set_alias"]))
@@ -386,7 +389,11 @@ def test_uebernehmen_hirn_nutzt_den_hirn_wechsel_und_nimmt_fast_mit(zustand, mon
     assert [a[0] for a in aufrufe] == ["eintragen", "schreiben", "hirn", "dazu", "steward"]
     assert aufrufe[0][2:] == ("hermes", False) and aufrufe[3] == ("dazu", "o", "fast")
     befehl = str(cfg["models"]["o"]["cmd"])
-    assert "--parallel 2" in befehl and "-ctk q8_0" in befehl and "--mmproj" in befehl
+    assert "--parallel 2" in befehl and "-ctk q8_0" in befehl and "--mmproj" not in befehl
+    # Wie im Betrieb seit 24.09.: Bilder sieht der neue Bild-Zwilling (Projektor, ohne Draft), der alte fliegt raus.
+    zwilling = cfg["models"]["o-Bild"]
+    assert zwilling["aliases"] == ["vision"] and "--mmproj" in str(zwilling["cmd"]) and "--spec" not in str(zwilling["cmd"])
+    assert "alter-zwilling" not in cfg["models"] and cfg["groups"]["bild"]["members"] == ["o-Bild"]
     assert (zustand / "models" / "o-GGUF" / "o-Q4_K_M.gguf").exists() and not (radar.RADAR_DIR / "o").exists()
     k = radar._lade()["kandidaten"]["o"]
     assert k["status"] == "uebernommen" and "vorher Qwen3.6-35B-A3B" in k["begruendung"]
@@ -405,16 +412,98 @@ def test_uebernehmen_coder_nimmt_heavy_mit(zustand, monkeypatch):
 
 
 def test_betriebsbefehl_uebernimmt_die_getesteten_flags():
+    pfade = {"gguf": "/srv/models/F-GGUF/f.gguf", "mmproj": "/srv/models/F-GGUF/mm.gguf", "draft": None}
     k = _kandidat("f", rolle="coder", ctx=65536, draft={"typ": "draft-mtp", "n_max": 2, "datei": None}, flags=["-ub", "512"])
-    befehl = radar.betriebs_befehl("coder", {"gguf": "/srv/models/F-GGUF/f.gguf", "mmproj": "/srv/models/F-GGUF/mm.gguf",
-                                             "draft": None}, k)
+    befehl = radar.betriebs_befehl("coder", pfade, k)
     assert "-c 65536" in befehl and "--parallel 1" in befehl and "-ctk q8_0 -ctv q8_0" in befehl
-    assert "--mmproj /srv/models/F-GGUF/mm.gguf" in befehl and "--load-mode none" in befehl
+    assert "--mmproj" not in befehl and "--load-mode none" in befehl       # Bilder sieht der Zwilling
     assert befehl.endswith("--spec-type draft-mtp --spec-draft-n-max 2 -ub 512")
+    zwilling = radar.zwilling_befehl("coder", pfade, k)
+    assert "--mmproj /srv/models/F-GGUF/mm.gguf" in zwilling and "--spec" not in zwilling and "-c 131072" in zwilling
+    assert zwilling.endswith("-ub 512")
     assert "--parallel 2" in radar.betriebs_befehl("hirn", {"gguf": "x.gguf", "mmproj": None, "draft": None},
                                                     _kandidat("h"))
 
 
+def test_betriebsbefehl_nimmt_den_im_test_gewaehlten_draft():
+    """Gewählt wurde der Draft des heutigen Modells: fester Pfad, nicht der Kandidaten-Ordner."""
+    pfade = {"gguf": "/srv/models/O-GGUF/o.gguf", "mmproj": "/srv/models/O-GGUF/mm.gguf", "draft": None}
+    k = _kandidat("o", draft_betrieb={"typ": "draft-dflash", "ort": "fremd", "pfad": "/srv/models/D/d.gguf",
+                                      "n_max": None})
+    assert radar.betriebs_befehl("hirn", pfade, k).endswith("--spec-type draft-dflash --spec-draft-model /srv/models/D/d.gguf")
+    k["draft_betrieb"] = None                                   # im Test war „ohne Draft“ am schnellsten
+    assert "--spec" not in radar.betriebs_befehl("hirn", pfade, k)
+
+
+def _gguf_datei(pfad, arch: str) -> None:
+    """Winzige GGUF-Datei mit general.architecture (genug für _lokale_architektur)."""
+    wert = arch.encode()
+    schluessel = b"general.architecture"
+    daten = (b"GGUF" + struct.pack("<I", 3) + struct.pack("<Q", 0) + struct.pack("<Q", 1)
+             + struct.pack("<Q", len(schluessel)) + schluessel + struct.pack("<I", 8)
+             + struct.pack("<Q", len(wert)) + wert)
+    pfad.write_bytes(daten)
+
+
+def test_draft_varianten_probieren_den_draft_des_heutigen_modells_bei_gleicher_architektur(tmp_path, monkeypatch):
+    hirn_gguf, draft = tmp_path / "hirn.gguf", tmp_path / "dflash.gguf"
+    _gguf_datei(hirn_gguf, "qwen35moe")
+    draft.write_bytes(b"x" * 1000)
+    heute = {"name": "Hirn", "gguf_path": str(hirn_gguf),
+             "cmd": f"llama-server -m {hirn_gguf} --spec-type draft-dflash --spec-draft-model {draft}"}
+    monkeypatch.setattr(radar, "_heutige_modelle", lambda: {"hirn": heute})
+    pfade = {"gguf": "/x/k.gguf", "mmproj": "/x/mm.gguf", "draft": None}
+
+    gleich = radar._draft_varianten(_kandidat("k", arch="qwen35moe", bedarf_gb=24.2, mtp=True), pfade)
+    assert [v["name"] for v in gleich] == ["ohne Draft", "eingebauter MTP-Kopf", "Draft des heutigen Modells"]
+    assert gleich[2]["flags"] == ["--spec-type", "draft-dflash", "--spec-draft-model", str(draft)]
+    assert gleich[2]["draft"]["ort"] == "fremd"
+
+    fremd = radar._draft_varianten(_kandidat("k", arch="qwen3next", bedarf_gb=24.2), pfade)
+    assert [v["name"] for v in fremd] == ["ohne Draft"]                       # andere Architektur: nicht probieren
+    zu_gross = radar._draft_varianten(_kandidat("k", arch="qwen35moe", bedarf_gb=88.0), pfade)
+    assert [v["name"] for v in zu_gross] == ["ohne Draft"]                    # Draft passt nicht mehr in den Speicher
+    merkliste = radar._draft_varianten(_kandidat("k", arch="qwen35moe", draft={"typ": "draft-simple"}),
+                                       {**pfade, "draft": "/x/d.gguf"})
+    assert [v["name"] for v in merkliste] == ["Draft aus der Merkliste"]
+
+
+def test_waehle_draft_nimmt_die_schnellste_variante_die_startet(ps, monkeypatch):
+    tempi = {"": 67.4, "draft-mtp": 81.0, "draft-dflash": 98.2}
+
+    def mit_server(gguf, arbeit, *, flags=(), **kw):
+        typ = flags[1] if flags else ""
+        if typ == "draft-mtp":
+            raise ps.ServerFehler("vocab mismatch")
+        return {"tiefe": {"tg_tps": tempi[typ], "acc": 0.8 if typ else None}}, None
+
+    monkeypatch.setattr(ps, "mit_server", mit_server)
+    varianten = [{"name": "ohne Draft", "flags": []},
+                 {"name": "eingebauter MTP-Kopf", "flags": ["--spec-type", "draft-mtp"]},
+                 {"name": "Draft des heutigen Modells", "flags": ["--spec-type", "draft-dflash"]}]
+    wahl = ps.waehle_draft("/x/k.gguf", varianten, protokoll=lambda *_: None)
+    assert wahl["name"] == "Draft des heutigen Modells"
+    assert wahl["messungen"]["ohne Draft"] == 67.4 and "geht nicht" in wahl["messungen"]["eingebauter MTP-Kopf"]
+    assert "Gemessen mit Draft des heutigen Modells" in radar._draft_text({**wahl, "draft": {"typ": "draft-dflash"}})
+
+
+def test_mit_draft_laeuft_die_bild_probe_auf_einem_zwilling_ohne_draft(ps, monkeypatch):
+    """Draft und Bild gehen in llama.cpp nicht zusammen (HTTP 500) — der Prüfstand trennt sie wie der Betrieb."""
+    starts = []
+
+    def mit_server(gguf, arbeit, *, mmproj=None, flags=(), **kw):
+        starts.append((mmproj, list(flags)))
+        return ({"bild": None, "tiefe": {}} if len(starts) == 1 else {"direkt": 1.0, "agentisch": True}), \
+            type("S", (), {"befehl": ["llama-server"], "ladezeit": 4})()
+
+    monkeypatch.setattr(ps, "mit_server", mit_server)
+    lauf = ps.pruefe_kandidat("hirn", "/x/k.gguf", mmproj="/x/mm.gguf",
+                              flags=["--spec-type", "draft-dflash", "--spec-draft-model", "/d.gguf", "-ub", "512"])
+    assert starts[0] == (None, ["--spec-type", "draft-dflash", "--spec-draft-model", "/d.gguf", "-ub", "512"])
+    assert starts[1] == ("/x/mm.gguf", ["-ub", "512"])
+    assert lauf["werte"]["bild"] == {"direkt": 1.0, "agentisch": True}
+
+
 # --- Prüfstand: Urteil, Programmieraufgaben, Bild ----------------------------------------------------
 
 @pytest.fixture(scope="module")