refactor

backend/qa.py

@@ -11,7 +11,7 @@ previous report of the same topic.
 """
 
 import asyncio
-import json
+import logging
 import re
 import sys
 from datetime import datetime, timezone
@@ -19,12 +19,14 @@ from pathlib import Path
 
 import database as db
 import embedding
-from config import STORAGE_DIR, SUB_DUP_KANDIDAT_COS
+from config import JUDGE_CHUNK, STORAGE_DIR, SUB_DUP_KANDIDAT_COS
 from fsutil import atomic_write_json
 from jsonio import read_json_file as _json_file
 from paths import arbeit_dir
 from textkit import _norm_title
 
+log = logging.getLogger("creator.qa")
+
 QA_DIR = STORAGE_DIR / "qa"
 JACCARD_FLOOR = 0.5      # title token overlap that makes a pair suspicious
 EMB_FLOOR = 0.82         # casefolded title cosine (own threshold, NOT the pipeline's 0.65)
@@ -281,19 +283,70 @@ def _qa_prompt(name: str, **kwargs) -> str:
     return (TEMPLATES_DIR / "QA" / f"{name}.md").read_text(encoding="utf-8").format(**kwargs)
 
 
-async def _llm_verdicts(template: str, topic: str, key: str, items: list[str]) -> dict[int, str]:
+async def judge_wave(template: str, topic: str, key: str, slot: str, items: list[str],
+                     *, chunk: int = JUDGE_CHUNK, prefix: str = "qa", label: str = "QA") -> dict[int, str]:
+    """Gechunkte Ja/Nein-Judge-Welle über ALLE Items, Chunks parallel (die Semaphoren in
+    agents.py begrenzen); Ergebnis mit globalen 1-basierten Indizes. Fail-open pro Chunk
+    (Items bleiben ohne Urteil), aber nie stumm. Ersetzt die drei strukturgleichen
+    Handkopien in repair/qa/guide_qa."""
     from agents import run_agent
-    from pipeline import _yesno_schema
+    from pipeline import _timeout, _yesno_schema
     from jsonio import parse_json_text
-    listing = "\n\n".join(f"{k}. {it}" for k, it in enumerate(items, 1))
-    slot = {"Dubletten": "pairs", "Luecken": "sections", "Bausteine": "blocks", "Sub": "pairs"}[template.split("-")[1]]
-    rc, out, _err = await run_agent(f"qa-{topic}-{key}", _qa_prompt(template, topic=topic, extra="", **{slot: listing}),
-                                    600, role="judge", capabilities="none", scope=topic, label=f"QA {key}")
-    return (_yesno_schema(parse_json_text(out)) or {}) if rc == 0 else {}
+
+    async def _chunk(lo: int) -> dict[int, str]:
+        teil = items[lo:lo + chunk]
+        listing = "\n\n".join(f"{k}. {it}" for k, it in enumerate(teil, 1))
+        try:
+            rc, out, _err = await run_agent(
+                f"{prefix}-{topic}-{key}-{lo}", _qa_prompt(template, topic=topic, extra="", **{slot: listing}),
+                _timeout("qa_judge"), role="judge", capabilities="none", scope=topic, label=f"{label} {key}")
+        except Exception:
+            log.exception("[%s] %s-Judge %s+%d fehlgeschlagen — Items ohne Urteil", topic, label, key, lo)
+            return {}
+        if rc != 0:
+            log.warning("[%s] %s-Judge %s+%d fehlgeschlagen (rc=%s) — %d Items ohne Urteil",
+                        topic, label, key, lo, rc, len(teil))
+            return {}
+        return _yesno_schema(parse_json_text(out)) or {}
+
+    offsets = range(0, len(items), chunk)
+    results = await asyncio.gather(*[_chunk(lo) for lo in offsets])
+    return {lo + k: urteil for lo, v in zip(offsets, results) for k, urteil in v.items()}
 
 
 # ── Report ──────────────────────────────────────────────────────────────────────────
 
+def report_paths(topic: str, guide: bool = False) -> list[Path]:
+    """QA-Reports eines Topics, mtime-aufsteigend (Run-ID- und Timestamp-Namen sortieren
+    lexikographisch nicht). guide=True → die separate guide-*-Serie (guide_qa.py).
+    freispruch.json teilt den Ordner, ist aber kein Report — immer außen vor."""
+    tdir = QA_DIR / topic
+    if not tdir.is_dir():
+        return []
+    return sorted((p for p in tdir.glob("*.json")
+                   if p.name.startswith("guide-") == guide and p.name != "freispruch.json"),
+                  key=lambda p: p.stat().st_mtime)
+
+
+_latest_cache: dict[tuple[str, bool], tuple[float, dict]] = {}
+
+
+def latest_report(topic: str, guide: bool = False) -> dict | None:
+    """Jüngster Report als geparstes dict, mtime-gecacht — die Board-Snapshots lesen das
+    im 1,2-s-Frontend-Takt, ein JSON-Read je Poll war unnötiges Datei-I/O. glob+stat
+    bleiben (billig), der Read passiert nur bei geänderter mtime."""
+    reports = report_paths(topic, guide)
+    if not reports:
+        return None
+    p = reports[-1]
+    mtime = p.stat().st_mtime
+    key = (topic, guide)
+    cached = _latest_cache.get(key)
+    if cached is None or cached[0] != mtime:
+        _latest_cache[key] = (mtime, _json_file(p) or {})
+    return _latest_cache[key][1]
+
+
 def freispruch_pfad(topic: str) -> Path:
     return QA_DIR / topic / "freispruch.json"
 
@@ -341,41 +394,37 @@ async def qa_report(topic: str, llm: bool = False) -> dict | None:
     fr = [t for t in fr if _norm_title(t) not in frei_fremd]
 
     if llm and d:
-        v = await _llm_verdicts("QA-Dubletten", topic, "dubletten",
-                                [f"A: {p['a']}\nB: {p['b']}" for p in d[:LLM_SAMPLE]])
+        v = await judge_wave("QA-Dubletten", topic, "dubletten", "pairs",
+                             [f"A: {p['a']}\nB: {p['b']}" for p in d[:LLM_SAMPLE]])
         for k, p in enumerate(d[:LLM_SAMPLE], 1):
             p["llm"] = v.get(k, "?")
     if llm and lk:
-        v = await _llm_verdicts("QA-Luecken", topic, "luecken",
-                                [f"[{x['datei']} #{x['abschnitt']}] {x['vorschau']}" for x in lk[:LLM_SAMPLE]])
+        v = await judge_wave("QA-Luecken", topic, "luecken", "sections",
+                             [f"[{x['datei']} #{x['abschnitt']}] {x['vorschau']}" for x in lk[:LLM_SAMPLE]])
         for k, x in enumerate(lk[:LLM_SAMPLE], 1):
             x["llm"] = v.get(k, "?")
     if llm and sd:  # full coverage in chunks — a sampled quota would mislead the note
-        for lo in range(0, len(sd), 40):
-            chunk = sd[lo:lo + 40]
-            v = await _llm_verdicts("QA-Sub-Dubletten", topic, f"sub-dubletten-{lo}",
-                                    [f"A: {p['a']}\nB: {p['b']}" for p in chunk])
-            for k, p in enumerate(chunk, 1):
-                p["llm"] = v.get(k, "?")
+        v = await judge_wave("QA-Sub-Dubletten", topic, "sub-dubletten", "pairs",
+                             [f"A: {p['a']}\nB: {p['b']}" for p in sd])
+        for k, p in enumerate(sd, 1):
+            p["llm"] = v.get(k, "?")
         frei_sub = set(frei.get("sub_dubletten") or [])
         for p in sd:
             if p.get("llm") == "ja" and _paar_key(p["a"], p["b"]) in frei_sub:
                 p["freispruch"] = True  # 2:1-Urteil „behalten" — sichtbar, aber notenfrei
     unecht: list[str] | None = None
     if llm and blocks:
-        verdacht = []
-        for lo in range(0, len(blocks), 80):  # ein Call je 80 Titel
-            chunk = blocks[lo:lo + 80]
-            v = await _llm_verdicts("QA-Bausteine", topic, f"bausteine-{lo}",
-                                    [f"{b['title']} — {b['description'] or '(ohne Beschreibung)'}" for b in chunk])
-            verdacht += [b for k, b in enumerate(chunk, 1) if v.get(k) == "nein"]
+        v = await judge_wave("QA-Bausteine", topic, "bausteine", "blocks",
+                             [f"{b['title']} — {b['description'] or '(ohne Beschreibung)'}" for b in blocks],
+                             chunk=80)
+        verdacht = [b for k, b in enumerate(blocks, 1) if v.get(k) == "nein"]
         # Bestätiger-Pass nur über die Geflaggten: der Einzel-Judge flaggte pro Lauf ANDERE
         # Blöcke (gemessen aak: Note pendelte 9.3↔10.0 bei identischem Bestand) — nur
         # doppelt-„nein" zählt; Repair hat als dritte Sicherung die eigene Zweitmeinung
         unecht = []
         if verdacht:
-            v2 = await _llm_verdicts("QA-Bausteine", topic, "bausteine-b2",
-                                     [f"{b['title']} — {b['description'] or '(ohne Beschreibung)'}" for b in verdacht])
+            v2 = await judge_wave("QA-Bausteine", topic, "bausteine-b2", "blocks",
+                                  [f"{b['title']} — {b['description'] or '(ohne Beschreibung)'}" for b in verdacht])
             unecht = [b["title"] for k, b in enumerate(verdacht, 1) if v2.get(k) == "nein"]
         frei_unecht = set(frei.get("unecht") or [])
         unecht = [t for t in unecht if _norm_title(t) not in frei_unecht]
@@ -432,10 +481,7 @@ def _diff(prev: dict | None, cur: dict) -> dict:
 def _write_report(report: dict) -> Path:
     tdir = QA_DIR / report["topic"]
     tdir.mkdir(parents=True, exist_ok=True)
-    # by mtime: run-id names (…-1311-5e5c) and timestamp names don't sort lexicographically.
-    # guide-* reports share the directory but are a SEPARATE series (guide_qa.py).
-    older = sorted((p for p in tdir.glob("*.json") if not p.name.startswith("guide-")),
-                   key=lambda p: p.stat().st_mtime)
+    older = report_paths(report["topic"])
     prev = _json_file(older[-1]) if older else None
     report["diff_zum_vorlauf"] = _diff(prev, report)
     name = report["run_id"] or datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")