update

backend/guide_board.py

@@ -22,8 +22,9 @@ import re
 import database as db
 import readability
 from blocks import _sink_json
-from config import (FORMAT_PURPOSE, GUIDE_LAENGE_MAX, GUIDE_LAENGE_MIN, READABILITY_ACTIVE,
+from config import (FORMAT_PURPOSE, READABILITY_ACTIVE,
                     TEMPLATES_DIR, MAX_CONCURRENT_AGENTS_PER_TOPIC)
+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,
@@ -274,12 +275,6 @@ def _merge_split_sections(sec_a: dict, sec_b: dict) -> str:
     return "\n\n".join(lines)
 
 
-def _writer_budget(n_subs: int, sockel: int = 800) -> int:
-    """Length guideline (chars) for the detailed version — unguided sections measured 2–4×
-    too long (23k) or, after the readability fix, far too thin (180 chars/sub)."""
-    return sockel + 400 * max(n_subs, 1)
-
-
 async def _write_split(env: _Env, card: dict, ziele_text: str):
     """First draft in two halves (parallel), merged into one section.
     → merged text | None (failed) | False (cancelled)."""
@@ -316,7 +311,7 @@ async def _write_split(env: _Env, card: dict, ziele_text: str):
                            examples=await _card_examples(env, norm, parts[i],
                                                          include_unmatched=(i == 0)),
                            gaps="\n" + hints[i] + "\n",
-                           budget=_writer_budget(len(parts[i]), sockel=400),
+                           budget=block_budget(parts[i]),
                            spec=env.spec, out_path=path, extra=_extra(env.instructions)),
             role="guide", capabilities="files", payload=_payload,
             timeout=_timeout("writer", 1))
@@ -360,7 +355,7 @@ async def _stage_writer(env: _Env, card: dict) -> bool:
                        facts=_card_facts(env, card["block"]),
                        examples=await _card_examples(env, norm, env.subs_by_title.get(card["block"], [])),
                        gaps="", spec=env.spec,
-                       budget=_writer_budget(len(env.subs_by_title.get(card["block"], []))),
+                       budget=block_budget(env.subs_by_title.get(card["block"], [])),
                        out_path=path, extra=_extra(env.instructions)),
         role="guide", capabilities="files", payload=_payload,
         timeout=_timeout("writer", 1))
@@ -373,22 +368,27 @@ async def _stage_writer(env: _Env, card: dict) -> bool:
     return True
 
 
+def _n_rel(env: _Env, card: dict) -> int:
+    return sum(1 for s in env.subs_by_title.get(card["block"], [])
+               if s.get("relevance") != "peripheral")
+
+
 def _det_hinweise(env: _Env, card: dict, sec: dict) -> list[str]:
     """Deterministische Befunde (extern geerdet, kein LLM): Readability-Modell +
-    Längen-Rahmen — dieselbe Formel wie der QA-Detektor. Gehen direkt in den Fix
+    Längenbudget — dieselbe Formel wie der QA-Detektor (guide_qa.block_budget), nur mit
+    engerem Band, damit der Fix VOR der QA-Grenze greift. Gehen direkt in den Fix
     und als „nicht wiederholen"-Notiz in den Prüfer-Prompt."""
     out: list[str] = []
     subs_all = env.subs_by_title.get(card["block"], [])
-    n_rel = max(sum(1 for s in subs_all if s.get("relevance") != "peripheral"), 1)
+    if not any(s.get("relevance") != "peripheral" for s in subs_all):
+        return out  # kein Inventar als Budget-Basis → kein Längen-Urteil (wie der QA-Detektor)
+    budget = block_budget(subs_all)
     aus = re.split(r"<!--\s*ausführlich\s*-->", sec["md"], maxsplit=1)
-    pro_sub = len(aus[1] if len(aus) == 2 else sec["md"]) / n_rel
-    if not (GUIDE_LAENGE_MIN <= pro_sub <= GUIDE_LAENGE_MAX * 0.9):
-        # Ziel nach der QA-Formel (Zeichen ÷ relevante Subs ≤ MAX), nicht dem Writer-Budget —
-        # die zwei Formeln liefen auseinander und der Fix verfehlte den QA-Rahmen
-        ziel = n_rel * round(GUIDE_LAENGE_MAX * 0.75)
+    zeichen = len(aus[1] if len(aus) == 2 else sec["md"])
+    if not (0.5 * budget <= zeichen <= 1.2 * budget):
         out.append(
-            f"Länge {round(pro_sub)} Zeichen/Sub (Rahmen {GUIDE_LAENGE_MIN}–{round(GUIDE_LAENGE_MAX * 0.9)}): "
-            f"schreibe den ausführlich-Teil auf etwa {ziel} Zeichen GESAMT um — Sockel-Prosa und "
+            f"Länge {zeichen} Zeichen (Budget {budget}, erlaubt {round(0.5 * budget)}–{round(1.2 * 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
 
@@ -400,13 +400,15 @@ async def _det_readability(sec: dict) -> list[str]:
     return [hints[1]] if hints.get(1) else []
 
 
-def _auftraege(verdict: dict, det: list[str]) -> tuple[list[str], bool]:
+def _auftraege(verdict: dict, det: list[str], n_rel: int = 0) -> tuple[list[str], bool]:
     """Prüfer-Verdikt → Fix-Auftragszeilen. kritisch = falsch-Claims oder Lücken
     (nur die rechtfertigen den Re-Prüfer-Pass — Fakten/Coverage sind der Qualitätskern).
-    Claims-Schwelle wie beim alten Gate: 1–2 nur-„unbelegt" lohnen keinen Fix-Pass."""
+    Claims-Schwelle: wenige nur-„unbelegt" lohnen keinen Fix-Pass — bei kleinen Sektionen
+    sinkt sie auf die Sub-Zahl (2 unbelegte Claims in 2 Subs sind viel, nicht wenig)."""
     claims = verdict["claims"]
     falsch = [c for c in claims if c["urteil"] == "falsch"]
-    if claims and not falsch and len(claims) < GATE_FIX_MIN:
+    schwelle = min(GATE_FIX_MIN, n_rel) if n_rel else GATE_FIX_MIN
+    if claims and not falsch and len(claims) < schwelle:
         claims = []
     zeilen = [f"- CLAIM ({c['urteil']}): {c['text']}" + (f" — {c['grund']}" if c['grund'] else "")
               for c in claims]
@@ -465,7 +467,7 @@ async def _stage_pruefer(env: _Env, card: dict) -> bool:
         # gehen trotzdem in den Fix
         _log(env.topic, f"Prüfer {card['block']}: kein Ergebnis — nur deterministische Checks")
         verdict = {"claims": [], "ziele": {}, "luecken": [], "ballast": [], "lese_probleme": []}
-    zeilen, kritisch = _auftraege(verdict, det)
+    zeilen, kritisch = _auftraege(verdict, det, _n_rel(env, card))
     if not zeilen:
         await _set(env, card, md=card["md"], stage="done", status="ok", gate_info="")
         return True
@@ -524,7 +526,7 @@ async def _stage_fix(env: _Env, card: dict) -> bool:
         if verdict is None and is_guide_cancelled(env.guide_id):
             return False
         if verdict:
-            zeilen, _k = _auftraege(verdict, [])
+            zeilen, _k = _auftraege(verdict, [], _n_rel(env, card))
             if zeilen:
                 rest = "Rest-Befunde nach Fix:\n" + "\n".join(zeilen)
                 _log(env.topic, f"Re-Prüfer {card['block']}: {len(zeilen)} Rest-Befund(e) bleiben")