refactor

backend/repair.py

@@ -6,29 +6,22 @@ deterministisch, bestätigte Dubletten mergen (Zweitmeinung), Fremd/Unecht nur n
 Gegen-Judge entfernen (fail-open: Zweifel/Fehler → behalten). Lücken brauchen Recherche,
 Verwaiste den nächsten Board-2-Lauf — beides wird nur ausgewiesen."""
 
-import json
 import logging
 import re
 
 import database as db
 import qa
-from agents import run_agent
 from blocks import _blocks_files, _evidence_pack, source_folder
+from config import EVIDENCE_PER_BLOCK
 from fsutil import atomic_write_json
-from jsonio import parse_json_text, read_json_file as _json_file
-from pipeline import _yesno_schema
-from textkit import _norm_title, _title, clean_title
+from jsonio import read_json_file as _json_file
+from textkit import _norm_title, _title, clean_title, parse_facts
 
 log = logging.getLogger("creator.repair")
 
-JUDGE_TIMEOUT = 600
-from config import EVIDENCE_PER_BLOCK, JUDGE_CHUNK  # noqa: E402 — zentral tunebar
-
 
 async def repair_befunde(topic: str) -> dict:
-    tdir = qa.QA_DIR / topic
-    reports = sorted((p for p in tdir.glob("*.json") if not p.name.startswith("guide-")),
-                     key=lambda p: p.stat().st_mtime) if tdir.is_dir() else []
+    reports = qa.report_paths(topic)
     report = _json_file(reports[-1]) if reports else None
     if not report:
         return {"fehler": "kein QA-Report — erst QA laufen lassen"}
@@ -53,21 +46,8 @@ async def repair_befunde(topic: str) -> dict:
 
 
 async def _judge(template: str, topic: str, key: str, slot: str, items: list[str]) -> dict[int, str]:
-    """No-Tool-Judge-Wellen über alle Items (fail-open: Fehler → leeres Verdikt = behalten)."""
-    verdicts: dict[int, str] = {}
-    for lo in range(0, len(items), JUDGE_CHUNK):
-        chunk = items[lo:lo + JUDGE_CHUNK]
-        listing = "\n\n".join(f"{k}. {it}" for k, it in enumerate(chunk, 1))
-        try:
-            rc, out, _err = await run_agent(
-                f"repair-{topic}-{key}-{lo}", qa._qa_prompt(template, topic=topic, extra="", **{slot: listing}),
-                JUDGE_TIMEOUT, role="judge", capabilities="none", scope=topic, label=f"Repair {key}")
-            v = (_yesno_schema(parse_json_text(out)) or {}) if rc == 0 else {}
-        except Exception:
-            log.exception("[%s] Repair-Judge %s fehlgeschlagen — Befunde bleiben", topic, key)
-            v = {}
-        verdicts.update({lo + k: urteil for k, urteil in v.items()})
-    return verdicts
+    """No-Tool-Judge-Welle (fail-open: Fehler → leeres Verdikt = behalten)."""
+    return await qa.judge_wave(template, topic, key, slot, items, prefix="repair", label="Repair")
 
 
 def _speichere_freispruch(topic: str, kategorie: str, keys: list[str]) -> None:
@@ -165,10 +145,7 @@ _SUB_PAAR = re.compile(r"^\[(.+?)\] (.+)$", re.S)
 def _sub_gewinner(a: dict, b: dict) -> tuple[dict, dict]:
     """Gewinner = mehr key_points im facts-Feld, dann längerer Titel (Muster Konsolidierung)."""
     def score(r):
-        try:
-            kp = len((json.loads(r.get("facts") or "{}")).get("key_points") or [])
-        except ValueError:
-            kp = 0
+        kp = len(parse_facts(r.get("facts")).get("key_points") or [])
         return (kp, len(r.get("sub_title") or ""))
     return (a, b) if score(a) >= score(b) else (b, a)