refactor

backend/guide_board.py

@@ -22,10 +22,9 @@ import re
 import database as db
 import readability
 from blocks import _sink_json
-from config import (FORMAT_PURPOSE, READABILITY_ACTIVE,
-                    TEMPLATES_DIR, MAX_CONCURRENT_AGENTS_PER_TOPIC)
+from config import (FIX_LAENGE_BAND, READABILITY_ACTIVE, TEMPLATES_DIR,
+                    MAX_CONCURRENT_AGENTS_PER_TOPIC, ZIELE_MAX)
 from guide_qa import block_budget
-from fsutil import atomic_write_json
 from jsonio import read_json_file as _json_file
 from pipeline import (CANCELLED, FAILED, OK, GenContext, _extra, _log, _prompt,
                       _timeout, is_guide_cancelled, run_single_slot)
@@ -57,7 +56,7 @@ def _ziele_schema(data):
             return None
         zid = str(z.get("id", "")).strip()
         text = str(z.get("text", "")).strip()
-        if not zid or not text or zid in seen or len(out) >= 12:
+        if not zid or not text or zid in seen or len(out) >= ZIELE_MAX:
             continue
         seen.add(zid)
         out.append({"id": zid, "text": text, "sub": str(z.get("sub", "")).strip()})
@@ -140,10 +139,35 @@ class _Env:
         return self.content_path.parent / f"{self.content_path.stem}.{name}"
 
 
+def _memo(env, attr: str) -> dict:
+    """Lazy per-Karte-Cache auf dem env-Objekt (funktioniert auch für Test-Mocks). Lernziele,
+    Beispiel-Rows und Facts-Grounding sind während EINES Laufs immutabel, wurden aber je Karte
+    2–3× neu geholt (writer, pruefer, re-pruefer). Karten haben disjunkte block_norm-Keys und
+    laufen ihre Stages seriell → kein Race."""
+    d = env.__dict__.get(attr)
+    if d is None:
+        d = env.__dict__[attr] = {}
+    return d
+
+
+async def _ziele(env: _Env, block_norm: str) -> list[dict]:
+    cache = _memo(env, "_ziele_cache")
+    if block_norm not in cache:
+        cache[block_norm] = await db.list_lernziele(env.topic, block_norm)
+    return cache[block_norm]
+
+
+def _ziele_text(ziele: list[dict]) -> str:
+    return "\n".join(f"- ({z['ziel_id']}) {z['text']}" for z in ziele) or "(keine definiert)"
+
+
 def _card_facts(env: _Env, block_title: str) -> str:
-    from guide import _facts_grounding  # lazy: guide imports this module
-    grounding = _facts_grounding({block_title: env.subs_by_title.get(block_title, [])})
-    return grounding or env.fallback_facts
+    cache = _memo(env, "_facts_cache")
+    if block_title not in cache:
+        from guide import _facts_grounding  # lazy: guide imports this module
+        grounding = _facts_grounding({block_title: env.subs_by_title.get(block_title, [])})
+        cache[block_title] = grounding or env.fallback_facts
+    return cache[block_title]
 
 
 async def _card_examples(env: _Env, block_norm: str, subs: list[dict],
@@ -151,7 +175,10 @@ async def _card_examples(env: _Env, block_norm: str, subs: list[dict],
     """Verified worked examples of the block as writer input, matched to `subs` via
     sub_norm (a split half gets only its own). Rows whose sub does not match (generation
     mismatch) go to the full writer / split part 1 so they never vanish silently."""
-    rows = await db.get_sub_artefakte(env.topic, type="example", block_norm=block_norm)
+    cache = _memo(env, "_example_rows")
+    if block_norm not in cache:
+        cache[block_norm] = await db.get_sub_artefakte(env.topic, type="example", block_norm=block_norm)
+    rows = cache[block_norm]
     if not rows:
         return ""
     wanted = {_norm_title(s["title"]) for s in subs}
@@ -326,8 +353,7 @@ async def _write_split(env: _Env, card: dict, ziele_text: str):
 
 async def _stage_writer(env: _Env, card: dict) -> bool:
     norm = card["block_norm"]
-    ziele = await db.list_lernziele(env.topic, norm)
-    ziele_text = "\n".join(f"- ({z['ziel_id']}) {z['text']}" for z in ziele) or "(keine definiert)"
+    ziele_text = _ziele_text(await _ziele(env, norm))
     # oversized first drafts: two halves, merged into one canonical section
     if card["writer_rounds"] == 0 and len(env.subs_by_title.get(card["block"], [])) > WRITER_SPLIT_SUBS:
         text = await _write_split(env, card, ziele_text)
@@ -385,9 +411,10 @@ def _det_hinweise(env: _Env, card: dict, sec: dict) -> list[str]:
     budget = block_budget(subs_all)
     aus = re.split(r"<!--\s*ausführlich\s*-->", sec["md"], maxsplit=1)
     zeichen = len(aus[1] if len(aus) == 2 else sec["md"])
-    if not (0.5 * budget <= zeichen <= 1.2 * budget):
+    lo, hi = FIX_LAENGE_BAND
+    if not (lo * budget <= zeichen <= hi * budget):
         out.append(
-            f"Länge {zeichen} Zeichen (Budget {budget}, erlaubt {round(0.5 * budget)}–{round(1.2 * budget)}): "
+            f"Länge {zeichen} Zeichen (Budget {budget}, erlaubt {round(lo * budget)}–{round(hi * budget)}): "
             f"schreibe den ausführlich-Teil auf etwa {budget} Zeichen GESAMT um — Sockel-Prosa und "
             f"Wiederholungen streichen, alle Sub-Marker und Beispiele behalten")
     return out
@@ -424,8 +451,8 @@ async def _pruefer_call(env: _Env, card: dict, sec: dict, tag: str, det: list[st
     Section-Text in drei seriellen Calls). Text-Antwort + Engine-Sink (Datei-schreibende
     Judges lieferten invalides JSON). → Verdikt | None (FAILED/CANCELLED)."""
     norm = card["block_norm"]
-    ziele = await db.list_lernziele(env.topic, norm)
-    ziele_text = "\n".join(f"- ({z['ziel_id']}) {z['text']}" for z in ziele) or "(keine definiert)"
+    ziele = await _ziele(env, norm)
+    ziele_text = _ziele_text(ziele)
     ids = {z["ziel_id"] for z in ziele}
     facts = _card_facts(env, card["block"])
     ex = await _card_examples(env, norm, env.subs_by_title.get(card["block"], []))
@@ -441,7 +468,7 @@ async def _pruefer_call(env: _Env, card: dict, sec: dict, tag: str, det: list[st
                        hinweise=hinweise, extra=_extra(env.instructions)),
         role="judge", capabilities="none",
         payload=lambda result: _sink_json(result, path, lambda d: _pruefer_schema(d, ids)),
-        timeout=_timeout("fakten_gate", 1))
+        timeout=_timeout("pruefer", 1))
     if status != OK or verdict is None:
         return None
     for zid, ok in verdict["ziele"].items():
@@ -520,12 +547,19 @@ async def _stage_fix(env: _Env, card: dict) -> bool:
             card["md"] = fixed
             angewandt = True
     rest = ""
+    if not angewandt:
+        # Fix ohne Ergebnis: Befunde nicht stumm löschen — sie bleiben im gate_info sichtbar
+        rest = "Fix ohne Ergebnis — offene Befunde:\n" + auftraege
+        _log(env.topic, f"Fix {card['block']}: nicht angewandt — Befunde bleiben sichtbar")
     if kritisch and angewandt:
         sec2 = _first_section(card["md"])
         verdict = await _pruefer_call(env, card, sec2, "re", [])
         if verdict is None and is_guide_cancelled(env.guide_id):
             return False
-        if verdict:
+        if verdict is None:
+            rest = "Re-Prüfer ohne Ergebnis — Fix ungeprüft übernommen"
+            _log(env.topic, f"Re-Prüfer {card['block']}: kein Ergebnis — Fix ungeprüft übernommen")
+        else:
             zeilen, _k = _auftraege(verdict, [], _n_rel(env, card))
             if zeilen:
                 rest = "Rest-Befunde nach Fix:\n" + "\n".join(zeilen)
@@ -568,6 +602,22 @@ async def _run_card_inner(env: _Env, card: dict) -> None:
 
 
 # ── Orchestration ──────────────────────────────────────────────────────────────────
+async def _progress_reporter(guide_id: str, topic: str, format_name: str, takt: float = 2.0) -> None:
+    """Live-Fortschritt fürs Frontend; ein DB-Fehler darf den Reporter nie beenden
+    (der Fortschritt fror sonst still ein), unveränderter Stand wird nicht geschrieben."""
+    zuletzt = None
+    while True:
+        try:
+            counts = await db.guide_stage_counts(topic, format_name)
+            stand = (counts.get("done", 0), sum(counts.values()))
+            if stand != zuletzt:
+                zuletzt = stand
+                await db.update_guide(guide_id, progress=f"Board: {stand[0]}/{stand[1]} Karten fertig")
+        except Exception:
+            log.exception("[%s] guide progress reporter", topic)
+        await asyncio.sleep(takt)
+
+
 async def _chapter_map(topic: str, entries: dict[int, str]) -> dict[str, tuple[str, int]]:
     """block_norm → (chapter title, global order) from the outline artefact."""
     from guide import _outline_from_db, _fallback_outline, _with_remainder
@@ -602,25 +652,20 @@ async def run_guide_board(guide_id: str, topic: str, format_name: str, entries:
                     else _prompt("Guide-Facts-Thema"))
         env = _Env(ctx, guide_id, topic, format_name, instructions, content_path,
                    subs_raw, await _chapter_map(topic, entries), fallback, spec)
-        for num, line in entries.items():
-            title = _title(line)
-            await db.upsert_guide_card(topic, format_name, _norm_title(title), title)
+        await db.upsert_guide_cards_many(
+            topic, format_name,
+            [(_norm_title(_title(line)), _title(line)) for line in entries.values()])
         cards = await db.list_guide_cards(topic, format_name)
         open_cards = [c for c in cards if c["stage"] != "done"]
         if open_cards:
             sem = asyncio.Semaphore(CARD_CONCURRENCY)
-
-            async def _progress():
-                while True:
-                    counts = await db.guide_stage_counts(topic, format_name)
-                    done = counts.get("done", 0)
-                    total = sum(counts.values())
-                    await db.update_guide(guide_id, progress=f"Board: {done}/{total} Karten fertig")
-                    await asyncio.sleep(2.0)
-
-            reporter = asyncio.create_task(_progress())
+            reporter = asyncio.create_task(_progress_reporter(guide_id, topic, format_name))
             try:
-                await asyncio.gather(*[_run_card(env, c, sem) for c in open_cards])
+                ergebnisse = await asyncio.gather(*[_run_card(env, c, sem) for c in open_cards],
+                                                  return_exceptions=True)
+                for c, r in zip(open_cards, ergebnisse):
+                    if isinstance(r, BaseException):
+                        log.error("[%s] guide card task %s: %r", topic, c["block"], r)
             finally:
                 reporter.cancel()
         if is_guide_cancelled(guide_id):
@@ -701,9 +746,7 @@ async def board_snapshot(topic: str, format_name: str, limit: int = 20) -> dict:
         columns.append({"key": stage, "label": STAGE_LABELS[stage],
                         "total": len(in_stage), "cards": views})
     import qa as qa_mod  # lazy wie in board_inventory
-    tdir = qa_mod.QA_DIR / topic
-    greports = sorted(tdir.glob("guide-*.json"), key=lambda p: p.stat().st_mtime) if tdir.is_dir() else []
-    note_guide = (_json_file(greports[-1]) or {}).get("note_guide") if greports else None
+    note_guide = (qa_mod.latest_report(topic, guide=True) or {}).get("note_guide")
     return {"columns": columns, "qa_guide": note_guide}
 
 
@@ -713,8 +756,7 @@ async def repair_karten(topic: str, format_name: str) -> list[str]:
     generate_guide resumt die offenen Karten und misst am Ende neu. Pendant zum
     Blocks-Repair („Score unter 10 muss einen Fix-Pfad haben"). → betroffene Blocktitel."""
     import qa as qa_mod
-    tdir = qa_mod.QA_DIR / topic
-    reports = sorted(tdir.glob("guide-*.json"), key=lambda p: p.stat().st_mtime) if tdir.is_dir() else []
+    reports = qa_mod.report_paths(topic, guide=True)
     rep = _json_file(reports[-1]) if reports else None
     if not rep:
         return []
@@ -762,8 +804,7 @@ async def reset_from_stage(topic: str, format_name: str, ab_stage: int) -> int:
     target = GUIDE_STAGES[ab_stage]
     stages = list(GUIDE_STAGES[ab_stage:]) + ["done"]
     if ab_stage == 0:
-        for c in await db.list_guide_cards(topic, format_name):
-            await db.delete_lernziele(topic, c["block_norm"])
+        await db.delete_lernziele_all(topic)
     moved = await db.reset_guide_cards_from_stage(topic, format_name, stages, target,
                                                   clear_md=ab_stage <= 2)
     return moved