"""Bausteine-Pipeline: Recherche-Konsens + Klärungs-Loop — reines Inventar, unsortiert.

5x Recherche (min. 3, Grace) → Mapping (Konsens/Rest) → Klärungs-Loop (max.
KONSENS_MAX_RUNDEN Runden): 3 Auswahl-Agenten (min. 2, Grace) entscheiden
über den strittigen Rest, ein Mapping-Agent sortiert in aufnehmen/verwerfen/
weiter strittig. Leerer Rest beendet den Loop; die letzte Runde muss alles
entscheiden. Races nutzen ein Grace-Fenster statt „erste N gewinnen": Nach dem
ersten gültigen Ergebnis dürfen die übrigen Agenten KONSENS_GRACE Sekunden
fertig werden. Der Konsens wird im Code akkumuliert — kein Agent re-emittiert
die Gesamtliste.
"""

import asyncio
import json
import logging
import math
import re
import shutil
import subprocess
import time
from pathlib import Path

import database as db
import embedding
from agents import kill_process, cancel_scope, clear_scope, run_agent
from config import KONSENS_GRACE, RECHERCHE_GRACE, KONSENS_MAX_RUNDEN, DEFAULT_PROVIDER, CRAWL_KEEP_PATTERNS, CRAWL_NOISE_PATTERNS, CRAWL_MIN_CHARS, QUELLE_RELEVANZ_CHUNK, QUELLE_RELEVANZ_SNIPPET, EMBEDDING_AKTIV, EMBEDDING_SUB_DUP
from fsutil import atomic_write_text, atomic_write_json
from jsonio import read_json_file as _json_datei
from paths import arbeit_dir, bausteine_path, frage_muster_path, project_dir, subbausteine_path, quelle_path, quelle_crawl_dir, safe_ordner
from crawl import crawl
from pipeline import (
    CANCELLED, FAILED, OK, GenContext, _extra, _gather_fortschritt, _janein_schema, _log, _prompt, _race,
    _relevanz_schema, _runde_schema, _semaphore, _str_liste, _stufen_schema, _timeout, run_single_slot,
)
from textkit import (
    _eindeutige_titel, _lade_bausteine, _norm_titel, _parse_auswahl, _parse_subbausteine, _titel,
    _titel_aufloesen, _titel_index,
)

# Subbausteine (Websuche je Baustein) chunken: 1 Agent je ~10 Bausteine, gedeckelt.
SUBBAUSTEIN_CHUNK = 10
SUBBAUSTEIN_MAX = 40
# Einstufen ist billig (kurzes Urteil, keine Websuche) → größere Pakete, weniger Dateien/Agenten.
STUFE_CHUNK = 100

# Recherche: feste Datei-Batches statt Such-Loop → jede Crawl-Seite genau einmal zugeteilt.
RECHERCHE_BATCH = 20        # Crawl-Seiten je Batch
RECHERCHE_READERS = 2       # Reader-Agenten je Batch (Konsens ≥2 innerhalb des Batches)
RECHERCHE_THEMA_AGENTEN = 5  # Web-Modus (Quelle „thema", kein Crawl-Ordner)
RECHERCHE_KAPPE = 1800      # Sicherheits-Deckel je Batch-Agent
# uni/projekt: Skript-Text in Abschnitte ~dieser Größe chunken (gegen Lost-in-the-Middle bei
# großen Dokumenten). ~12k Zeichen ≈ 3k Token → sicher unter der Recall-Abfall-Schwelle.
RECHERCHE_ABSCHNITT_ZEICHEN = 12000
# Sichtung (Content/Noise) ist jetzt ein deterministischer Regel-Filter (config.CRAWL_*).
SUBBAUSTEIN_KAPPE = 900     # Subbaustein-Finde-Loop je Chunk (15 min)
KONSOLIDIERUNG_CHUNK = 600  # bis hierher EIN globaler Judge (dedupt alles); darüber chunked + Merge-Pass — nur Fallback-Pfad
DEDUP_MAX_RUNDEN = 3        # finaler Dedup-Pass: max. Iterationen (die kleinere Liste blockt je Runde neu)
DEDUP_MIN_DELTA = 3         # Abbruch, wenn eine Runde weniger als dieses % der Liste entfernt (konvergiert)
# Frage-Muster-Chunks per LPT nach Sub-Last balancieren (Makespan), statt nach Baustein-Anzahl.
FRAGE_CHUNK_SUBS = 50       # Ziel-Summe relevanter Subs je Chunk
FAKTEN_CHUNK_SUBS = 25      # Fakten-Extraktion: kleinere Chunks (Fakten sind umfangreicher als Muster)
FAKTEN_CHECK_PANEL = 3      # Judges je Chunk im Fakten-Check (Mehrheit beanstandet)
KONSOLIDIERUNG_PANEL = 3    # Mapping-Judges je Chunk (Panel → Reconcile statt Einzel-Judge)
SUBBAUSTEIN_PANEL = 3       # Source-Judges in der Subbaustein-Klärung (Mehrheit statt Einzel-Judge)

log = logging.getLogger("creator.bausteine")

_bausteine_progress: dict[str, str] = {}
_bausteine_errors: dict[str, str] = {}
_bausteine_cancelled: set[str] = set()
_bausteine_step: dict[str, int] = {}

BAUSTEINE_STEPS = (
    "Recherche", "Konsolidierung", "Klärung",
    "Subbausteine finden", "Subbausteine wählen", "Subbausteine klären",
    "Fakten finden", "Fakten prüfen", "Fakten fix",
    "Stufen finden", "Stufen wählen", "Stufen klären",
    "Relevanz finden", "Relevanz wählen", "Relevanz klären",
    "Gliederung",
    "Fragen finden", "Fragen wählen", "Fragen klären", "Fragen prüfen",
    "Karteikarten", "Beispiele",
)
ARTEFAKT_TYPEN = ("karteikarte", "beispiel")


def lade_quelle(topic: str) -> dict:
    """Persistierte Quellen-Wahl lesen. Fallback (Alt-Themen ohne quelle.json):
    existiert projects/<topic> → projekt, sonst thema."""
    q = _json_datei(quelle_path(topic))
    if isinstance(q, dict) and q.get("type") in ("thema", "projekt", "uni", "link"):
        return q
    if project_dir(topic).is_dir():
        return {"type": "projekt", "ort": f"projects/{topic}", "spec": ""}
    return {"type": "thema", "ort": "", "spec": ""}


def quelle_ordner(topic: str) -> Path | None:
    """Ordner-Quelle (projekt/uni → Pfad, link → Crawl-Ordner) — sonst None (thema)."""
    q = lade_quelle(topic)
    if q["type"] == "link":
        return quelle_crawl_dir(topic)
    if q["type"] in ("projekt", "uni"):
        return safe_ordner(q.get("ort", ""))
    return None


def _crawl_fertig(topic: str) -> bool:
    return (quelle_crawl_dir(topic) / ".done").exists()  # Marker erst bei sauberem Abschluss


# Lernpfad-Stufen (anfaenger/fortgeschritten/experte); alte Schwierigkeits-Werte abwärtskompatibel.
_STUFEN = ("anfaenger", "fortgeschritten", "experte", "einfach", "mittel", "schwer")


async def subbausteine_titel(topic: str, baustein: str) -> list[str]:
    """Subbaustein-Titel eines Bausteins — DB-first (Konsens), Fallback Sidecar-Datei."""
    rows = [s["sub_titel"] for s in await db.list_subbausteine(topic, _norm_titel(baustein))
            if s["status"] == "konsens" and s["sub_titel"]]
    if rows:
        return rows
    sc = _json_datei(subbausteine_path(topic))
    if not isinstance(sc, dict):
        return []
    return [
        t for s in (sc.get(baustein) or [])
        if isinstance(s, dict) and (t := str(s.get("titel", "")).strip())
    ]


async def lade_frage_muster(topic: str, baustein: str) -> list[dict]:
    """Vordefinierte Frage-Muster eines Bausteins — DB-first, Fallback Sidecar (leer = Live)."""
    rows = await db.list_frage_muster(topic, _norm_titel(baustein))
    if rows:
        return [{"subbaustein": r["sub_titel"], "frage": r["frage"]} for r in rows if r["frage"]]
    fm = _json_datei(frage_muster_path(topic))
    if not isinstance(fm, dict):
        return []
    return [
        {"subbaustein": str(e.get("subbaustein", "")).strip(), "frage": frage}
        for e in (fm.get(baustein) or [])
        if isinstance(e, dict) and (frage := str(e.get("frage", "")).strip())
    ]


async def subbausteine_frei(topic: str, baustein: str, max_ebene: int) -> list[str]:
    """Subbaustein-Titel bis zur freigeschalteten Ebene (≤ max_ebene). Fallback ohne
    Ebenen-Wissen (Altbestand/Sidecar): alle Subbaustein-Titel."""
    rows = await db.subs_mit_ebene(topic, baustein)
    if not rows:
        return await subbausteine_titel(topic, baustein)
    return [s["titel"] for s in rows if s["ebene"] <= max_ebene and s["titel"]]


async def lade_frage_muster_frei(topic: str, baustein: str, max_ebene: int) -> list[dict]:
    """Frage-Muster, gefiltert auf Subbausteine bis zur freigeschalteten Ebene. Ohne
    Ebenen-Wissen (Altbestand/Sidecar) ungefiltert."""
    rows = await db.subs_mit_ebene(topic, baustein)
    if not rows:
        return await lade_frage_muster(topic, baustein)
    frei = {s["norm"] for s in rows if s["ebene"] <= max_ebene}
    return [m for m in await lade_frage_muster(topic, baustein) if _norm_titel(m["subbaustein"]) in frei]


async def lade_uebersicht(topic: str) -> list[dict]:
    """Strukturierte Baustein-Liste für die Übersicht — DB-first (Konsens + Subs/Stufen/Relevanz),
    Fallback bausteine.md + Sidecar (Alt-Themen)."""
    bs = await db.list_bausteine(topic, status="konsens")
    if bs:
        out = []
        for num, b in enumerate(bs, 1):
            subs = [s for s in await db.list_subbausteine(topic, b["titel_norm"]) if s["status"] == "konsens"]
            out.append({
                "num": num, "titel": b["titel"], "beschreibung": b["beschreibung"],
                "subbausteine": [
                    {"titel": s["sub_titel"],
                     "stufe": s["stufe"] if s["stufe"] in _STUFEN else "fortgeschritten",
                     "relevanz": s["relevanz"] if s["relevanz"] in ("relevant", "rand") else None}
                    for s in subs if s["sub_titel"]
                ],
            })
        return out
    entries = _lade_bausteine(_read(bausteine_path(topic)))
    sidecar = _json_datei(subbausteine_path(topic))
    sidecar = sidecar if isinstance(sidecar, dict) else {}
    out = []
    for num, entry in entries.items():
        titel = _titel(entry)
        teile = entry.split(" — ", 1)
        beschreibung = teile[1].strip() if len(teile) == 2 else ""
        subbausteine = [
            {
                "titel": t,
                "stufe": s.get("stufe") if s.get("stufe") in _STUFEN else "fortgeschritten",
                "relevanz": s.get("relevanz") if s.get("relevanz") in ("relevant", "rand") else None,
            }
            for s in (sidecar.get(titel) or [])
            if isinstance(s, dict) and (t := str(s.get("titel", "")).strip())
        ]
        out.append({"num": num, "titel": titel, "beschreibung": beschreibung, "subbausteine": subbausteine})
    return out


def _bausteine_steps(topic: str) -> tuple:
    """Schritte je Quelle: link bekommt vorne „Quelle laden", projekt zusätzlich „Ergänzung".

    Subbausteine + Stufen sind je drei Phasen (Finden, Wählen, Klären). Pro Phase
    laufen alle Pakete parallel; der Schritt bleibt, bis das letzte Paket fertig ist.
    """
    q = lade_quelle(topic)
    base = ("Recherche", "Konsolidierung", "Klärung", "Dedup")
    rest = (
        "Subbausteine finden", "Subbausteine wählen", "Subbausteine klären",
        "Fakten finden", "Fakten prüfen", "Fakten fix",
        "Stufen finden", "Stufen wählen", "Stufen klären",
        "Relevanz finden", "Relevanz wählen", "Relevanz klären",
        "Gliederung",
        "Fragen finden", "Fragen wählen", "Fragen klären", "Fragen prüfen",
        "Karteikarten", "Beispiele",
    )
    mitte = base + (("Ergänzung",) if q["type"] == "projekt" else ()) + rest
    return (("Quelle aufbereiten",) if q["type"] == "link" else ()) + mitte


def _step_idx(topic: str, name: str) -> int:
    return _bausteine_steps(topic).index(name)


def _melde_p(set_p, topic: str, schritt: str):
    """Async-Melde-Callback für _gather_fortschritt: setzt „<Schritt> d/t…" + Schritt-Index."""
    idx = _step_idx(topic, schritt)
    async def melde(d, t):
        set_p(f"{schritt} {d}/{t}…", step=idx)
    return melde


# Grobe Anzeige-Phasen: bündeln die Feinschritte (intern bleibt alles feingranular).
# Sonderschritte (Quelle laden, Ergänzung) gehören zur Phase „Inventar".
PHASEN = (
    ("Quelle", ("Quelle aufbereiten",)),
    ("Inventar", ("Recherche", "Konsolidierung", "Klärung", "Dedup", "Ergänzung")),
    ("Subbausteine", ("Subbausteine finden", "Subbausteine wählen", "Subbausteine klären")),
    ("Fakten", ("Fakten finden", "Fakten prüfen", "Fakten fix")),
    ("Stufen", ("Stufen finden", "Stufen wählen", "Stufen klären")),
    ("Relevanz", ("Relevanz finden", "Relevanz wählen", "Relevanz klären")),
    ("Gliederung", ("Gliederung",)),
    ("Fragen", ("Fragen finden", "Fragen wählen", "Fragen klären", "Fragen prüfen")),
    ("Artefakte", ("Karteikarten", "Beispiele")),
)


def _phasen(topic: str) -> list[tuple[str, int]]:
    """[(grob_label, Anzahl vorhandener Feinschritte)] für die aktuelle Quelle."""
    feine = _bausteine_steps(topic)
    return [(label, n) for label, members in PHASEN if (n := sum(f in members for f in feine))]


def _phasen_status(topic: str, current: int | None) -> list[dict]:
    """Grobe Phasen-Zustände aus dem feinen Fortschritt `current` (None = alles pending,
    len(feine) = alles done). → [{label, state}] mit state done/active/pending."""
    out, start = [], 0
    for label, n in _phasen(topic):
        end = start + n
        if current is None or current < start:
            state = "pending"
        elif current >= end:
            state = "done"
        else:
            state = "active"
        out.append({"label": label, "state": state})
        start = end
    return out


def _bausteine_files(topic: str) -> dict:
    arbeit = arbeit_dir(topic)
    runden = range(1, KONSENS_MAX_RUNDEN + 1)
    return {
        "final": bausteine_path(topic),
        "arbeit": arbeit,
        "recherche": [arbeit / f"recherche-{i}.md" for i in (1, 2, 3, 4, 5)],
        "recherche_mapping": arbeit / "recherche-mapping.json",
        "auswahl": {n: [arbeit / f"auswahl-r{n}-{i}.json" for i in (1, 2, 3)] for n in runden},
        "mapping": {n: arbeit / f"auswahl-mapping-r{n}.json" for n in runden},
        "ergaenzung": arbeit / "ergaenzung.json",
        "sub_roh": arbeit / "subbausteine-roh.json",
        "fakten": arbeit / "subbausteine-fakten.json",
        "sidecar": subbausteine_path(topic),
        "frage_muster": frage_muster_path(topic),
        "gliederung": arbeit / "gliederung.json",
        "gliederung_slots": [arbeit / f"gliederung-{i}.json" for i in (1, 2, 3)],
        "artefakte": arbeit / "artefakte.json",
    }


def _alle_slot_dateien(files: dict) -> list[Path]:
    arbeit = files["arbeit"]
    # Subbaustein-/Stufen-Slots sind pro Chunk dynamisch — per Glob einsammeln.
    dyn = (list(arbeit.glob("subbaustein-*")) + list(arbeit.glob("fakten-*")) + list(arbeit.glob("stufe-*")) + list(arbeit.glob("relevanz-*"))
           + list(arbeit.glob("frage-muster-*")) + list(arbeit.glob("gliederung-*")) + list(arbeit.glob("artefakt-*"))
           + list(arbeit.glob("recherche-*")) + list(arbeit.glob("konsolidierung-*"))
           + list(arbeit.glob("klaerung*")) + list(arbeit.glob("dedup-*"))) if arbeit.is_dir() else []
    return [
        *files["recherche"], files["recherche_mapping"],
        *(p for slots in files["auswahl"].values() for p in slots),
        *files["mapping"].values(), files["ergaenzung"],
        files["sub_roh"], files["sidecar"], files["frage_muster"],
        files["fakten"], files["gliederung"], files["artefakte"], *dyn,
    ]


def cancel_bausteine(topic: str) -> bool:
    if topic not in _bausteine_progress:
        return False
    _bausteine_cancelled.add(topic)
    cancel_scope(f"bausteine-{topic}-")  # wartende Agenten bailen vorm Spawn
    kill_process(f"bausteine-{topic}-")  # laufende Subprozesse killen
    return True


def _resume_step(topic: str) -> int:
    """Erster noch offener Schritt anhand der persistierten Artefakte.
    Inventar (Recherche→Konsolidierung→Klärung) gilt als fertig, sobald bausteine.md vorliegt."""
    files = _bausteine_files(topic)
    q = lade_quelle(topic)
    if q["type"] == "link" and not _crawl_fertig(topic):
        return _step_idx(topic, "Quelle aufbereiten")
    if not files["final"].exists():  # Inventar (DB-Loop) noch offen
        return _step_idx(topic, "Recherche")
    if q["type"] == "projekt" and not files["ergaenzung"].exists():
        return _step_idx(topic, "Ergänzung")
    sidecar = _json_datei(files["sidecar"])
    if _sidecar_schema(sidecar) is not None:
        # Stufen fertig; nur noch Relevanz offen?
        if not _relevanz_komplett(sidecar):
            return _step_idx(topic, "Relevanz finden")
        # Relevanz fertig; Gliederung (Bausteine-Artefakt für den Guide) offen?
        if not _gliederung_komplett(files):
            return _step_idx(topic, "Gliederung")
        # Gliederung fertig; Frage-Muster offen?
        if not _frage_muster_komplett(topic):
            return _step_idx(topic, "Fragen finden")
        # Fragen fertig; Lern-Artefakte (Karteikarten/Beispiele) offen?
        if not _artefakte_komplett(files):
            return _step_idx(topic, "Karteikarten")
        return len(_bausteine_steps(topic))
    if _sub_roh_schema(_json_datei(files["sub_roh"])) is None:
        return _step_idx(topic, "Subbausteine finden")
    # Subbausteine fertig; Fakten noch offen? (Fakten kommen vor den Stufen.)
    if not _fakten_komplett(files):
        return _step_idx(topic, "Fakten finden")
    return _step_idx(topic, "Stufen finden")


def bausteine_status(topic: str) -> dict:
    # Intern feingranular (Resume/Progress); für die Anzeige zu 5 groben Phasen gebündelt.
    feine = _bausteine_steps(topic)
    ready = bausteine_path(topic).exists()
    generating = topic in _bausteine_progress
    partial = False
    if generating:
        current = _bausteine_step.get(topic)
    elif ready:
        current = len(feine)  # alles fertig → alle Phasen done
    else:
        current = _resume_step(topic)
        partial = current > 0
    return {
        "ready": ready,
        "generating": generating,
        "progress": _bausteine_progress.get(topic),
        "error": _bausteine_errors.get(topic),
        "partial": partial,
        "steps": _phasen_status(topic, current),
    }


def active_bausteine() -> list[dict]:
    return [{"topic": t, "progress": p} for t, p in _bausteine_progress.items()]


def reset_bausteine(topic: str) -> None:
    """„Entfernen": löscht den GESAMTEN Bausteine-Bereich — Crawl, Sichtung, Inventar … Fragen.
    BEHÄLT nur die Themen-Config `quelle.json` (Typ/Link/Spec). Re-Generieren crawlt neu.
    (Crawl/Sichtung gehören zu den Bausteinen; nur die Config ist „Thema".)"""
    files = _bausteine_files(topic)
    files["final"].unlink(missing_ok=True)
    files["sidecar"].unlink(missing_ok=True)
    files["frage_muster"].unlink(missing_ok=True)
    shutil.rmtree(quelle_crawl_dir(topic), ignore_errors=True)  # Crawl gehört zu Bausteinen
    shutil.rmtree(files["arbeit"], ignore_errors=True)
    _bausteine_errors.pop(topic, None)
    # quelle.json bleibt bewusst stehen — das ist die Themen-Config.


def _phase_idx(label: str) -> int:
    """Index der groben Phase in der kanonischen Reihenfolge (Quelle=0 … Fragen=5)."""
    order = [l for l, _ in PHASEN]
    return order.index(label) if label in order else 1


def _reset_ab_phase(topic: str, label: str) -> None:
    """Datei-Artefakte AB der groben Phase `label` löschen (Quelle/Inventar … Fragen), frühere
    behalten. Kumulativ. quelle.json + Crawl (.done) bleiben immer (re-crawl nur bei Voll-Reset)."""
    files = _bausteine_files(topic)
    arbeit = files["arbeit"]
    idx = _phase_idx(label)

    def glob_del(pat: str) -> None:
        if arbeit.is_dir():
            for p in arbeit.glob(pat):
                p.unlink(missing_ok=True)

    # Phasen-Index: Quelle=0 · Inventar=1 · Subbausteine=2 · Fakten=3 · Stufen=4 · Relevanz=5 · Gliederung=6 · Fragen=7 · Artefakte=8
    if idx <= 8:  # Artefakte (Karteikarten/Beispiele)
        files["artefakte"].unlink(missing_ok=True)
        glob_del("artefakt-*")
    if idx <= 7:  # Fragen
        files["frage_muster"].unlink(missing_ok=True)
        glob_del("frage-muster-*")
    if idx <= 6:  # Gliederung
        files["gliederung"].unlink(missing_ok=True)
        glob_del("gliederung-*")
    if idx <= 5:  # Relevanz
        glob_del("relevanz-*")
        if idx <= 4:  # Stufen + Relevanz teilen die Sidecar → ab Stufen ganz neu
            files["sidecar"].unlink(missing_ok=True)
            glob_del("stufe-*")
        else:  # ab Relevanz: Stufen behalten, nur Relevanz-Felder strippen
            sc = _json_datei(files["sidecar"])
            if isinstance(sc, dict):
                for subs in sc.values():
                    for s in (subs if isinstance(subs, list) else []):
                        if isinstance(s, dict):
                            s.pop("relevanz", None)
                atomic_write_json(files["sidecar"], sc, indent=1)
    if idx <= 3:  # Fakten (vor den Stufen) — Fakten-Map + Arbeitsdateien weg
        files["fakten"].unlink(missing_ok=True)
        glob_del("fakten-*")
    if idx <= 2:  # Subbausteine
        files["sub_roh"].unlink(missing_ok=True)
        glob_del("subbaustein-*")
    if idx <= 1:  # Inventar (und Quelle) = Inventar-Dateien + bausteine.md weg
        for p_alt in _alle_slot_dateien(files):
            p_alt.unlink(missing_ok=True)
        files["final"].unlink(missing_ok=True)


def _ergaenzung_schema(data):
    """{"bausteine": [{"titel", "beschreibung"}]} → Liste (leer erlaubt) · sonst None."""
    if not isinstance(data, dict) or not isinstance(data.get("bausteine"), list):
        return None
    out = []
    for b in data["bausteine"]:
        if not isinstance(b, dict) or not isinstance(b.get("titel"), str) or not isinstance(b.get("beschreibung"), str):
            return None
        titel, beschreibung = b["titel"].strip(), b["beschreibung"].strip()
        if not titel:
            return None
        out.append((titel, beschreibung))
    return out


def _pdfs_konvertieren(project: Path) -> None:
    """PDFs im Projekt in .txt wandeln (pdftotext) — Agenten lesen Text statt Seiten-Bildern.

    Wird vor jeder Projekt-Generierung aufgerufen; konvertiert nur, wenn die
    .txt fehlt oder älter als das PDF ist. Das Original bleibt unangetastet.
    Fehlt pdftotext und das Projekt enthält PDFs → harter Fehler statt
    unzuverlässigem Direkt-Lese-Modus (MiniMax-Bilderlimit, Vision-Kosten).
    """
    pdfs = list(project.rglob("*.pdf"))
    if not pdfs:
        return
    if shutil.which("pdftotext") is None:
        raise RuntimeError("pdftotext fehlt (poppler-utils installieren) — PDFs im Projekt können nicht gelesen werden")
    for pdf in pdfs:
        txt = pdf.with_suffix(".txt")
        if txt.exists() and txt.stat().st_mtime >= pdf.stat().st_mtime:
            continue
        try:
            subprocess.run(["pdftotext", "-layout", str(pdf), str(txt)], check=True, timeout=120)
            _log(project.name, f"PDF konvertiert: {pdf.name} → {txt.name}")
        except Exception as e:
            raise RuntimeError(f"PDF-Konvertierung fehlgeschlagen ({pdf.name}): {e}") from e


_QUELLE_TEMPLATE = {"projekt": "Bausteine-Quelle-Projekt", "uni": "Bausteine-Quelle-Uni", "link": "Bausteine-Quelle-Link"}


def _text_abschnitte(text: str, ziel: int = RECHERCHE_ABSCHNITT_ZEICHEN) -> list[str]:
    """Text an Absatz-/Zeilengrenzen in Abschnitte ~`ziel` Zeichen splitten (gegen Lost-in-the-Middle
    bei großen Dokumenten). Kleiner Text bleibt EIN Abschnitt. Inhalt bleibt vollständig — nur
    Trenn-Whitespace fällt weg."""
    text = text.strip()
    if len(text) <= ziel:
        return [text] if text else []
    abschnitte: list[str] = []
    buf = ""

    def flush():
        nonlocal buf
        if buf.strip():
            abschnitte.append(buf.strip())
        buf = ""

    for block in re.split(r"\n\s*\n", text):  # an Absatz-Grenzen
        block = block.strip()
        if not block:
            continue
        if len(block) > ziel:  # einzelner Riesen-Absatz → hart an Zeilen schneiden
            flush()
            for zeile in block.split("\n"):
                if buf and len(buf) + len(zeile) + 1 > ziel:
                    flush()
                buf += zeile + "\n"
            flush()
        elif buf and len(buf) + len(block) + 2 > ziel:
            flush()
            buf = block
        else:
            buf = (buf + "\n\n" + block) if buf else block
    flush()
    return abschnitte


def _build_recherche_prompt(topic: str, out_path: Path, instructions: str, typ: str, ordner: Path | None, fokus: str = "", abschnitt: str = "") -> str:
    if abschnitt:
        # Abschnitt-Modus (uni/projekt): Text direkt im Prompt → kleiner Kontext, kein Datei-Lesen.
        source = abschnitt
    elif typ in _QUELLE_TEMPLATE:
        source = _prompt(_QUELLE_TEMPLATE[typ], project=ordner)
    else:
        source = _prompt("Bausteine-Quelle-Thema", topic=topic)
    return _prompt(
        "Bausteine-Recherche",
        topic=topic, source=source, bausteine_path=out_path, fokus=fokus, extra=_extra(instructions),
    )


def _file_payload(path: Path):
    """Gültig, wenn die Slot-Datei existiert und nummerierte Einträge enthält."""
    if not path.exists():
        return None
    text = path.read_text(encoding="utf-8")
    return text if _parse_auswahl(text) else None


def _mapping_schema(data):
    """{"bausteine": [str, ≥1], "rest": [str]} → (bausteine, rest) · sonst None."""
    if not isinstance(data, dict):
        return None
    bausteine = _str_liste(data.get("bausteine"))
    rest = _str_liste(data.get("rest"))
    if not bausteine or rest is None:
        return None
    return bausteine, rest


def _sub_roh_schema(data):
    """{Baustein-Titel: [Subbaustein, …]} → dict · sonst None (Zwischenstand Block B)."""
    if not isinstance(data, dict) or not data:
        return None
    out: dict[str, list[str]] = {}
    for k, v in data.items():
        subs = _str_liste(v) if isinstance(v, list) else None
        if not isinstance(k, str) or not k.strip() or not subs:
            return None
        out[k] = subs
    return out


def _sidecar_schema(data):
    """{Baustein-Titel: [{titel, stufe}, …]} → dict · sonst None (Sidecar mit Stufen)."""
    if not isinstance(data, dict) or not data:
        return None
    for v in data.values():
        if not isinstance(v, list) or not v:
            return None
        for s in v:
            if not isinstance(s, dict) or not str(s.get("titel", "")).strip() or s.get("stufe") not in _STUFEN:
                return None
    return data


def _relevanz_komplett(data) -> bool:
    """Jeder Subbaustein der Sidecar trägt eine gültige Relevanz (relevant/rand)?"""
    if not isinstance(data, dict) or not data:
        return False
    return all(
        isinstance(s, dict) and s.get("relevanz") in ("relevant", "rand")
        for v in data.values() if isinstance(v, list)
        for s in v
    )




def _frage_muster_chunk_schema(data) -> list[dict] | None:
    """{"muster": [{baustein, subbaustein, frage}, …]} → Liste valider Einträge · sonst None.

    Ein Muster je Subbaustein (kein Typ-Kreuzprodukt — die Schwierigkeit kommt erst bei der
    Prüfung aus dem Lerner-Niveau). Ungültige Einzel-Einträge werden übersprungen."""
    if not isinstance(data, dict) or not isinstance(data.get("muster"), list):
        return None
    out = []
    for e in data["muster"]:
        if not isinstance(e, dict):
            continue
        bau = str(e.get("baustein", "")).strip()
        sub = str(e.get("subbaustein", "")).strip()
        frage = str(e.get("frage", "")).strip()
        if not bau or not sub or not frage:
            continue
        out.append({"baustein": bau, "subbaustein": sub, "frage": frage})
    return out or None


def _frage_muster_komplett(topic: str) -> bool:
    """Frage-Muster-Sidecar existiert (Build gelaufen)? Einzelne leere Bausteine
    fallen zur Prüfungszeit auf Live-Generierung zurück — daher genügt die Datei."""
    return isinstance(_json_datei(frage_muster_path(topic)), dict)


def _read(p: Path) -> str:
    return p.read_text(encoding="utf-8") if p.exists() else ""


def _chunk_nums(items: list, n: int) -> list[list]:
    """Teilt eine flache Liste in n möglichst gleich große Chunks."""
    n = max(1, n)
    size = max(1, math.ceil(len(items) / n))
    return [items[i:i + size] for i in range(0, len(items), size)]


def _n_chunks(count: int, size: int = SUBBAUSTEIN_CHUNK) -> int:
    return min(SUBBAUSTEIN_MAX, max(1, math.ceil(count / size)))


def _lpt_chunks(gewichte: list[int], target: int) -> list[list[int]]:
    """Indizes lastbalanciert auf Chunks verteilen (LPT, Makespan-minimal). Gewicht = Kosten je Index.
    K = ceil(Gesamtgewicht/target); schwerste zuerst in den jeweils leichtesten Bin. → Index-Listen."""
    if not gewichte:
        return []
    K = max(1, math.ceil(sum(gewichte) / max(1, target)))
    bins: list[list[int]] = [[] for _ in range(K)]
    last = [0] * K
    for i in sorted(range(len(gewichte)), key=lambda x: gewichte[x], reverse=True):
        j = min(range(K), key=lambda b: last[b])
        bins[j].append(i)
        last[j] += gewichte[i]
    return [b for b in bins if b]








async def _subbausteine_block(ctx: GenContext, set_p, files: dict, entries: dict, instructions: str) -> dict | None:
    """Block B (DB + Loop): je Paket Subbausteine in Runden finden (3 Finder, bis 0 neue/Kappe),
    in der DB sammeln (≥2 Nennungen = Konsens, 1× verworfen), Judge bereinigt je Paket.
    → {Baustein-Titel: [Subbaustein, …]} (Konsens) oder None. Befüllt DB-Tabelle `subbausteine`."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    arbeit = files["arbeit"]
    ordner = quelle_ordner(topic)
    caps = "files" if ordner else "full"
    # Quelle für die Beleg-Prüfung im Klär-Schritt (verwirft erfundene/unbelegbare Subs).
    _typ = lade_quelle(topic).get("type", "thema")
    source = _prompt(_QUELLE_TEMPLATE[_typ], project=ordner) if _typ in _QUELLE_TEMPLATE else _prompt("Bausteine-Quelle-Thema", topic=topic)
    nums = list(entries)
    chunks = _chunk_nums(nums, _n_chunks(len(nums)))
    n = len(chunks)
    titel_by_num = {num: _titel(entries[num]) for num in nums}
    norm_by_num = {num: _norm_titel(titel_by_num[num]) for num in nums}
    await db.delete_subbausteine(topic)  # Frischstart des Blocks (idempotenter Zähler)

    async def _bekannt_block(chunk):
        bl = []
        for num in chunk:
            subs = [s["sub_titel"] for s in await db.list_subbausteine(topic, norm_by_num[num])]
            if subs:
                bl.append(f"<!-- baustein: {titel_by_num[num]} -->\n" + "\n".join(f"- {s}" for s in subs))
        if not bl:
            return ""
        # Bekanntes NICHT erneut auflisten lassen (sonst bläht Re-Bestätigung den Mention-Count auf,
        # Self-Bias/Echo) — nur Fehlendes ergänzen. Der Zähler bleibt so ein ehrliches Konsens-Signal.
        return ("\n\nBEREITS ERFASST — liste diese NICHT erneut. Finde nur, was FEHLT:\n" + "\n".join(bl))

    # Phase „Subbausteine finden": je Paket Loop bis 0 neue Subs / Zeit-Kappe.
    async def _finde(c, chunk):
        zuteilung = "\n".join(f"- {entries[num]}" for num in chunk)
        chunk_idx = _titel_index({num: titel_by_num[num] for num in chunk})
        start = time.monotonic()
        runde = 0
        while not is_cancelled():
            runde += 1
            bekannt = await _bekannt_block(chunk) if runde > 1 else ""
            paths = [arbeit / f"subbaustein-c{c}-r{runde}-{i}.md" for i in (1, 2, 3)]
            for p in paths:
                p.unlink(missing_ok=True)
            slots = [{
                "key": f"bausteine-{topic}-subbaustein-c{c}-r{runde}-{i}",
                "prompt": _prompt("Subbaustein-Recherche", topic=topic, zuteilung=zuteilung, bekannt=bekannt, out_path=p, extra=_extra(instructions)),
                "role": "quick", "capabilities": caps,
                "payload": (lambda result, p=p: _parse_subbausteine(_read(p)) or None),
            } for i, p in enumerate(paths, 1)]
            texte = await _race(topic, f"Subbausteine Paket {c} R{runde}", slots, 2, _timeout("subbaustein", len(chunk)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
            if is_cancelled():
                return False
            if not texte:
                return runde > 1  # Runde 1 ohne Ergebnis = Fehler; spätere = einfach Ende
            vorhanden = {num: {s["sub_norm"] for s in await db.list_subbausteine(topic, norm_by_num[num])} for num in chunk}
            neu = 0
            for d in texte:
                for marker, subs in d.items():
                    num = _titel_aufloesen(chunk_idx, marker)
                    if num is None:
                        continue
                    gesehen = set()
                    for sub in subs:
                        sn = _norm_titel(sub)
                        if not sn or sn in gesehen:
                            continue
                        gesehen.add(sn)
                        if sn not in vorhanden[num]:
                            neu += 1
                            vorhanden[num].add(sn)
                        await db.upsert_subbaustein(topic, norm_by_num[num], sn, titel_by_num[num], sub)
            if neu == 0:
                break
            if time.monotonic() - start > SUBBAUSTEIN_KAPPE:
                _log(topic, f"Subbausteine Paket {c}: Zeit-Kappe erreicht (Runde {runde})")
                break
        return True

    oks = await _gather_fortschritt([_finde(c, chunk) for c, chunk in enumerate(chunks, 1)], n, _melde_p(set_p, topic, "Subbausteine finden"))
    if is_cancelled():
        return None
    if not all(ok is True for ok in oks):
        _bausteine_errors[topic] = "Subbausteine fehlgeschlagen (Recherche)"
        return None

    # Phase „Subbausteine wählen": ≥2 Nennungen = Konsens, 1× verworfen (Code).
    set_p(f"Subbausteine wählen ({n} Pakete)…", step=_step_idx(topic, "Subbausteine wählen"))
    for num in nums:
        for s in await db.list_subbausteine(topic, norm_by_num[num]):
            await db.set_subbaustein_felder(topic, norm_by_num[num], s["sub_norm"],
                                            status=("konsens" if s["nennungen"] >= 2 else "verworfen"))

    # Phase „Subbausteine klären": Source-Panel (SUBBAUSTEIN_PANEL Judges) prüft Konsens + Unsicher (1×)
    # gegen die Quelle; Code-Mehrheit je Sub. Externes, mehrstimmiges Gate gegen Einzel-Judge-Bias + Echo.
    async def _klaere(c, chunk):
        fp = arbeit / f"subbaustein-final-c{c}.md"
        if _parse_subbausteine(_read(fp)):
            return
        bloecke, hat = [], False
        konsens_by_num: dict[int, list[str]] = {}
        for num in chunk:
            rows = await db.list_subbausteine(topic, norm_by_num[num])
            kon = [s["sub_titel"] for s in rows if s["status"] == "konsens"]
            uns = [s["sub_titel"] for s in rows if s["status"] != "konsens" and s["nennungen"] == 1]
            konsens_by_num[num] = kon
            if not kon and not uns:
                continue
            hat = True
            k_zeilen = "\n".join(f"- {s}" for s in kon) if kon else "- (keiner)"
            u_zeilen = "\n".join(f"- {s}" for s in uns) if uns else "- (keiner)"
            bloecke.append(f"BAUSTEIN: {titel_by_num[num]}\nKonsens (≥2 Finder):\n{k_zeilen}\nUnsicher (1× — streng gegen Quelle prüfen):\n{u_zeilen}")
        if not hat:
            return

        chunk_idx = _titel_index({num: titel_by_num[num] for num in chunk})
        paths = [arbeit / f"subbaustein-final-c{c}-j{j}.md" for j in range(1, SUBBAUSTEIN_PANEL + 1)]
        offen = [(j, p) for j, p in enumerate(paths, 1) if _parse_subbausteine(_read(p)) is None]
        for _, p in offen:
            p.unlink(missing_ok=True)
        if offen:
            slots = [{
                "key": f"bausteine-{topic}-subbaustein-final-c{c}-j{j}",
                "prompt": _prompt("Subbaustein-Mapping", topic=topic, source=source, bausteine="\n\n".join(bloecke), out_path=p, extra=_extra(instructions)),
                "role": "judge", "capabilities": caps,
                "payload": (lambda result, p=p: _parse_subbausteine(_read(p)) or None),
            } for j, p in offen]
            vorhanden = SUBBAUSTEIN_PANEL - len(offen)
            await _race(topic, f"Subbaustein-Klärung {c}", slots, max(1, 2 - vorhanden),
                        _timeout("subbaustein_check", len(chunk)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
        if is_cancelled():
            return
        outs = [d for p in paths if (d := _parse_subbausteine(_read(p)))]
        if not outs:  # Panel komplett gescheitert → Konsens übernehmen (wie bisher der Fallback)
            _log(topic, f"Subbaustein-Klärung Paket {c} fehlgeschlagen — Konsens übernommen")
            text = "\n\n".join(f"<!-- baustein: {titel_by_num[num]} -->\n" + "\n".join(f"- {s}" for s in konsens_by_num[num])
                               for num in chunk if konsens_by_num[num])
            atomic_write_text(fp, text)
            return

        # Code-Mehrheit je Baustein/Sub-Norm: behalten wenn Mehrheit der Judges ihn führt (Tie → behalten).
        bloecke_out = []
        for num in chunk:
            votes: dict[str, int] = {}
            form: dict[str, str] = {}
            for d in outs:
                seen = set()
                for marker, subs in d.items():
                    if _titel_aufloesen(chunk_idx, marker) != num:
                        continue
                    for sub in subs:
                        sn = _norm_titel(sub)
                        if not sn or sn in seen:
                            continue
                        seen.add(sn)
                        form.setdefault(sn, sub)
                        votes[sn] = votes.get(sn, 0) + 1
            kept = [form[sn] for sn in form if votes[sn] * 2 >= len(outs)]
            if kept:
                bloecke_out.append(f"<!-- baustein: {titel_by_num[num]} -->\n" + "\n".join(f"- {s}" for s in kept))
        atomic_write_text(fp, "\n\n".join(bloecke_out))

    await _gather_fortschritt([_klaere(c, chunk) for c, chunk in enumerate(chunks, 1)], n, _melde_p(set_p, topic, "Subbausteine klären"))
    if is_cancelled():
        return None

    # Finale Liste je Baustein: Judge-Ausgabe, sonst Konsens-Fallback. DB reconcilen + roh bauen.
    roh: dict[str, list[str]] = {}
    for c, chunk in enumerate(chunks, 1):
        final = _parse_subbausteine(_read(arbeit / f"subbaustein-final-c{c}.md")) or {}
        chunk_idx = _titel_index({num: titel_by_num[num] for num in chunk})
        final_by_num = {_titel_aufloesen(chunk_idx, m): subs for m, subs in final.items() if _titel_aufloesen(chunk_idx, m) is not None}
        for num in chunk:
            titel = titel_by_num[num]
            konsens = [s["sub_titel"] for s in await db.list_subbausteine(topic, norm_by_num[num]) if s["status"] == "konsens"]
            subs = final_by_num.get(num) or konsens
            if not subs:
                continue
            roh[titel] = subs
            # DB an die finale Liste angleichen: finale = konsens, Rest verworfen, Neues ergänzen.
            final_norms = {_norm_titel(s) for s in subs}
            have = {s["sub_norm"] for s in await db.list_subbausteine(topic, norm_by_num[num])}
            for s in await db.list_subbausteine(topic, norm_by_num[num]):
                await db.set_subbaustein_felder(topic, norm_by_num[num], s["sub_norm"],
                                                status=("konsens" if s["sub_norm"] in final_norms else "verworfen"))
            for s in subs:
                sn = _norm_titel(s)
                if sn and sn not in have:
                    await db.upsert_subbaustein(topic, norm_by_num[num], sn, titel, s)
                    await db.set_subbaustein_felder(topic, norm_by_num[num], sn, status="konsens")
    await _dedup_subbausteine(topic, roh)  # Near-Dup-Filter je Baustein (deterministisch, kein LLM)
    if not roh:
        _bausteine_errors[topic] = "Keine Subbausteine ermittelt"
        return None
    return roh


async def _dedup_subbausteine(topic: str, roh: dict[str, list[str]]) -> None:
    """Deterministischer Near-Duplicate-Filter pro Baustein: Subbausteine mit Cosine ≥
    EMBEDDING_SUB_DUP sind dieselbe Aussage (im engen Baustein-Kontext zuverlässig — kein LLM
    nötig). Behält je Dublett-Gruppe den informativsten (längsten); Rest → DB verworfen + aus `roh`.
    Modell fehlt → still überspringen (wie der übrige Embedding-Fallback)."""
    if not EMBEDDING_AKTIV or not await asyncio.to_thread(embedding.verfuegbar):
        return
    for titel, subs in list(roh.items()):
        if len(subs) < 2:
            continue
        sims = await asyncio.to_thread(embedding.embed_sims, subs)
        if sims is None:
            return
        behalten: list[int] = []
        verworfen: list[int] = []
        for i in sorted(range(len(subs)), key=lambda x: (-len(subs[x]), x)):  # informativster zuerst
            if any(float(sims[i][j]) >= EMBEDDING_SUB_DUP for j in behalten):
                verworfen.append(i)
            else:
                behalten.append(i)
        if not verworfen:
            continue
        bnorm = _norm_titel(titel)
        for i in verworfen:
            await db.set_subbaustein_felder(topic, bnorm, _norm_titel(subs[i]), status="verworfen")
        roh[titel] = [subs[i] for i in sorted(behalten)]  # Original-Reihenfolge der Behaltenen


async def _stufen_block(ctx: GenContext, set_p, files: dict, roh: dict, instructions: str) -> dict | None:
    """Block C: drei Phasen mit Barriere — Finden (einstufen), Wählen (Vote), Klären.
    Lokale IDs 1..n pro Paket, hinterher auf globale gid gemappt.
    → {Baustein-Titel: [{titel, stufe}, …]} oder None."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    arbeit = files["arbeit"]
    # Kernpunkte je Sub als knapper Kontext (fundiertere Einstufung; Klassifikation braucht wenig).
    fakten_map = _json_datei(files["fakten"])
    fakten_map = fakten_map if isinstance(fakten_map, dict) else {}
    items = [(titel, sub) for titel, subs in roh.items() for sub in subs]  # globale id = index+1
    if not items:
        return {titel: [] for titel in roh}
    # Chunks aus GANZEN Bausteinen packen (keinen Baustein splitten) → Rater sieht je Baustein
    # alle Subs und kann relativ einstufen. Item-Indizes je Baustein in roh-Reihenfolge.
    chunks, cur, i = [], [], 0
    for _titel_b, subs in roh.items():
        g = list(range(i, i + len(subs)))
        i += len(subs)
        if cur and len(cur) + len(g) > STUFE_CHUNK:
            chunks.append(cur)
            cur = []
        cur.extend(g)
    if cur:
        chunks.append(cur)
    n = len(chunks)

    def rater_paths(c):
        return [arbeit / f"stufe-c{c}-{i}.json" for i in (1, 2, 3)]

    def lset(item_idxs):
        return set(range(1, len(item_idxs) + 1))

    # Phase „Stufen finden": pro Paket 3 Rater (min. 2), lokale IDs.
    async def _rate(c, item_idxs):
        local_set = lset(item_idxs)
        paths = rater_paths(c)
        vorhanden = sum(1 for p in paths if _stufen_schema(_json_datei(p), local_set))
        if vorhanden >= 2:
            return True
        enum_zeilen, cur_b = [], None
        for k, j in enumerate(item_idxs, 1):
            b, sub = items[j]
            if b != cur_b:
                enum_zeilen.append(f"\nBAUSTEIN: {b}")
                cur_b = b
            enum_zeilen.append(f"{k}. {sub}")
            if (kz := _kern_zeile(fakten_map.get(b, {}).get(_norm_titel(sub)))):
                enum_zeilen.append(f"   {kz}")
        enum = "\n".join(enum_zeilen).strip()
        offen = [(i, p) for i, p in enumerate(paths, 1) if not _stufen_schema(_json_datei(p), local_set)]
        slots = [{
            "key": f"bausteine-{topic}-stufe-c{c}-{i}",
            "prompt": _prompt("Stufen-Recherche", topic=topic, subbausteine=enum, out_path=p, extra=_extra(instructions)),
            "role": "fast", "capabilities": "files",
            "payload": (lambda result, p=p, ids=local_set: _stufen_schema(_json_datei(p), ids)),
        } for i, p in offen]
        neu = await _race(topic, f"Stufen Paket {c}", slots, 2 - vorhanden, _timeout("stufe", len(item_idxs)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
        return not is_cancelled() and neu is not None

    oks = await _gather_fortschritt([_rate(c, idxs) for c, idxs in enumerate(chunks, 1)], len(chunks), _melde_p(set_p, topic, "Stufen finden"))
    if is_cancelled():
        return None
    if not all(ok is True for ok in oks):
        _bausteine_errors[topic] = "Einstufung fehlgeschlagen (Recherche)"
        return None

    # Phase „Stufen wählen": Code-Vote je Paket → (ergebnis, strittig).
    set_p(f"Stufen wählen ({n} Pakete)…", step=_step_idx(topic, "Stufen wählen"))
    vote_by_c = {}
    for c, item_idxs in enumerate(chunks, 1):
        local_set = lset(item_idxs)
        rater = [d for p in rater_paths(c) if (d := _stufen_schema(_json_datei(p), local_set))]
        ergebnis: dict[int, str] = {}
        strittig: dict[int, list[str]] = {}
        for k in range(1, len(item_idxs) + 1):
            stimmen = [d[k] for d in rater if k in d]
            zaehler: dict[str, int] = {}
            for s in stimmen:
                zaehler[s] = zaehler.get(s, 0) + 1
            best = max(zaehler.values(), default=0)
            gewinner = [s for s, v in zaehler.items() if v == best]
            if len(gewinner) == 1 and best >= 2:
                ergebnis[k] = gewinner[0]
            else:
                strittig[k] = stimmen
        vote_by_c[c] = (ergebnis, strittig)

    # Phase „Stufen klären": Judge je Paket mit Strittigem, alle parallel.
    async def _klaere(c, item_idxs):
        ergebnis, strittig = vote_by_c[c]
        if strittig:
            judge_path = arbeit / f"stufe-final-c{c}.json"
            entsch = _stufen_schema(_json_datei(judge_path), set(strittig))
            if entsch is None:
                strittig_block = "\n".join(
                    f"{k}. [{items[item_idxs[k - 1]][0]}] {items[item_idxs[k - 1]][1]} — Stimmen: {', '.join(stimmen) or 'keine'}"
                    for k, stimmen in strittig.items()
                )
                status, entsch = await run_single_slot(
                    ctx, f"Stufen-Klärung {c}",
                    key=f"bausteine-{topic}-stufe-final-c{c}",
                    prompt=_prompt("Stufen-Mapping", topic=topic, strittig=strittig_block, out_path=judge_path, extra=_extra(instructions)),
                    role="judge", capabilities="files",
                    payload=lambda result, p=judge_path, ids=set(strittig): _stufen_schema(_json_datei(p), ids),
                    timeout=_timeout("stufe_check", len(strittig)),
                )
                if status == FAILED:
                    _log(topic, f"Stufen-Klärung Paket {c} fehlgeschlagen — Default 'fortgeschritten'")
                entsch = entsch if isinstance(entsch, dict) else {}
            # Strittige ohne Entscheid → 'fortgeschritten'; Vote-Gewinner bleiben; Judge überschreibt.
            ergebnis = {**{k: "fortgeschritten" for k in strittig}, **ergebnis, **entsch}
        return {item_idxs[k - 1] + 1: stufe for k, stufe in ergebnis.items()}

    parts = await _gather_fortschritt([_klaere(c, idxs) for c, idxs in enumerate(chunks, 1)], len(chunks), _melde_p(set_p, topic, "Stufen klären"))
    if is_cancelled():
        return None
    stufe_by_id: dict[int, str] = {}
    for c, part in enumerate(parts, 1):
        if not isinstance(part, dict):
            # Klärung ist nicht fatal: Vote-Ergebnis + Default 'fortgeschritten' für Strittige.
            if isinstance(part, BaseException):
                _log(topic, f"Stufen-Klärung Paket {c}: {type(part).__name__}: {part}")
            ergebnis, strittig = vote_by_c[c]
            item_idxs = chunks[c - 1]
            merged = {**{k: "fortgeschritten" for k in strittig}, **ergebnis}
            part = {item_idxs[k - 1] + 1: s for k, s in merged.items()}
        stufe_by_id.update(part)

    # Sidecar zusammensetzen — gleiche Reihenfolge wie items → gid stimmt
    sidecar: dict[str, list[dict]] = {}
    gid = 0
    for titel, subs in roh.items():
        lst = []
        for sub in subs:
            gid += 1
            lst.append({"titel": sub, "stufe": stufe_by_id.get(gid, "fortgeschritten")})
        sidecar[titel] = lst
    return sidecar


_FAKTEN_FELDER = ("kernpunkte", "voraussetzungen", "huerden", "belegte_fakten", "beispiel_idee")


def _fakten_schema(data) -> list[dict] | None:
    """{"fakten": [{baustein, subbaustein, …}]} → valide Liste · sonst None.
    Trennt belegte_fakten (mit Quelle) hart von beispiel_idee (generativ)."""
    if not isinstance(data, dict) or not isinstance(data.get("fakten"), list):
        return None
    out = []
    for e in data["fakten"]:
        if not isinstance(e, dict):
            continue
        bau = str(e.get("baustein", "")).strip()
        sub = str(e.get("subbaustein", "")).strip()
        if not bau or not sub:
            continue
        bf = [{"text": t, "quelle": str(f.get("quelle", "")).strip()}
              for f in (e.get("belegte_fakten") or []) if isinstance(f, dict) and (t := str(f.get("text", "")).strip())]
        out.append({
            "baustein": bau, "subbaustein": sub,
            "kernpunkte": [k for x in (e.get("kernpunkte") or []) if (k := str(x).strip())],
            "voraussetzungen": str(e.get("voraussetzungen", "")).strip(),
            "huerden": str(e.get("huerden", "")).strip(),
            "belegte_fakten": bf,
            "beispiel_idee": str(e.get("beispiel_idee", "")).strip(),
        })
    return out or None


def _fakten_check_schema(data) -> list[tuple[str, bool]] | None:
    """Fakten-Check → [(sub_norm, verwerfen)] je Beanstandung · {ok:true}→[] · None bei ungültig.
    verwerfen=True: Sub inhaltlich nicht belegbar (entfernen). verwerfen=False: nur Fakt korrigieren."""
    if not isinstance(data, dict):
        return None
    if data.get("ok") is True:
        return []
    pr = data.get("probleme")
    if not isinstance(pr, list):
        return None
    return [(sn, bool(p.get("verwerfen")))
            for p in pr if isinstance(p, dict) and (sn := _norm_titel(str(p.get("subbaustein", ""))))]


def _kern_zeile(fk) -> str:
    """Knappe Kernpunkt-Zeile für Klassifikation (Stufe/Relevanz) — weniger Kontext genügt dort.
    Leer, wenn keine Fakten/Kernpunkte (Altbestand)."""
    if not isinstance(fk, dict) or not fk.get("kernpunkte"):
        return ""
    return "Kern: " + " · ".join(str(k) for k in fk["kernpunkte"])


def _fakten_zeilen(fk: dict) -> str:
    z = []
    if fk.get("kernpunkte"):
        z.append("Kernpunkte: " + " · ".join(str(k) for k in fk["kernpunkte"]))
    if fk.get("voraussetzungen"):
        z.append("Voraussetzung: " + fk["voraussetzungen"])
    if fk.get("huerden"):
        z.append("Hürde: " + fk["huerden"])
    for bf in fk.get("belegte_fakten", []):
        z.append(f"FAKT: {bf['text']} (Quelle: {bf.get('quelle', '?')})")
    if fk.get("beispiel_idee"):
        z.append("Beispiel: " + fk["beispiel_idee"])
    return "\n".join(z)


def _fakten_komplett(files: dict) -> bool:
    """Fakten-Map existiert (Block durch)? {Baustein: {sub_norm: {...}}}."""
    d = _json_datei(files["fakten"])
    return isinstance(d, dict) and bool(d)


async def _fakten_block(ctx, set_p, files: dict, roh: dict, q: dict, ordner, instructions: str) -> tuple | None:
    """Block: je Sub Quell-Fakten extrahieren (finden) → verifizieren (prüfen) → korrigieren/verwerfen (fix).
    Extract-once-Grounding: das Ergebnis nährt Stufe/Relevanz/Fragen/Guide.
    → (fakten_map, verworfen_map) — fakten_map {Baustein: {sub_norm: fakten}}, verworfen_map
      {Baustein: {sub_norm}} (unbelegbare Subs zum Entfernen) — oder None bei Abbruch/Fehler."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    arbeit = files["arbeit"]
    caps = "files" if ordner else "full"
    typ = q.get("type", "thema")
    source = _prompt(_QUELLE_TEMPLATE[typ], project=ordner) if typ in _QUELLE_TEMPLATE else _prompt("Bausteine-Quelle-Thema", topic=topic)
    bausteine = [(titel, [str(s).strip() for s in subs if str(s).strip()]) for titel, subs in roh.items() if subs]
    if not bausteine:
        return {}, {}
    chunks = _lpt_chunks([len(subs) for _, subs in bausteine], FAKTEN_CHUNK_SUBS)

    def roh_path(ci): return arbeit / f"fakten-c{ci}.json"
    def erg_path(ci): return arbeit / f"fakten-erg-c{ci}.json"
    def chk_path(ci, j): return arbeit / f"fakten-check-c{ci}-j{j}.json"
    def fix_path(ci): return arbeit / f"fakten-fix-c{ci}.json"
    def ctitel(idxs): return [bausteine[i][0] for i in idxs]
    def block_text(idxs):
        return "\n\n".join(
            f"BAUSTEIN: {bausteine[i][0]}\nSUBBAUSTEINE:\n" + "\n".join(f"- {s}" for s in bausteine[i][1])
            for i in idxs)

    # Roh-Fakten eines Chunks → {Baustein: {sub_norm: {sub, …felder}}}, auf Chunk-Titel gematcht.
    def roh_map(ci, path):
        idxs = chunks[ci]
        rel_by = {bausteine[i][0]: bausteine[i][1] for i in idxs}
        ct = ctitel(idxs)
        out: dict[str, dict] = {}
        for e in _fakten_schema(_json_datei(path)) or []:
            bt = _match_sub(e["baustein"], ct)
            if bt not in rel_by:
                continue
            sub = _match_sub(e["subbaustein"], rel_by[bt])
            out.setdefault(bt, {})[_norm_titel(sub)] = {"sub": sub, **{k: e[k] for k in _FAKTEN_FELDER}}
        return out

    # Roh-Fakten + Completeness-Ergänzungen vereinigen (Recall): nur Subs, die in roh existieren.
    def _chunk_fakten(ci):
        roh = roh_map(ci, roh_path(ci))
        erg = roh_map(ci, erg_path(ci)) if erg_path(ci).exists() else {}
        if not erg:
            return roh
        for bt, fm in roh.items():
            ebt = erg.get(bt, {})
            for sn, fk in fm.items():
                ek = ebt.get(sn)
                if not ek:
                    continue
                seen = {str(k).strip().casefold() for k in fk.get("kernpunkte", [])}
                for k in ek.get("kernpunkte", []):
                    if str(k).strip().casefold() not in seen:
                        seen.add(str(k).strip().casefold())
                        fk["kernpunkte"].append(k)
                seent = {bf["text"].strip().casefold() for bf in fk.get("belegte_fakten", [])}
                for bf in ek.get("belegte_fakten", []):
                    if bf["text"].strip().casefold() not in seent:
                        seent.add(bf["text"].strip().casefold())
                        fk["belegte_fakten"].append(bf)
                for f in ("voraussetzungen", "huerden", "beispiel_idee"):
                    if not fk.get(f) and ek.get(f):
                        fk[f] = ek[f]
        return roh

    # Phase „Fakten finden": 1 Generator je Chunk.
    async def _finde(ci, idxs):
        fp = roh_path(ci)
        if _fakten_schema(_json_datei(fp)):
            return True
        subs_total = sum(len(bausteine[i][1]) for i in idxs)
        status, _r = await run_single_slot(
            ctx, f"Fakten {ci}", key=f"bausteine-{topic}-fakten-c{ci}",
            prompt=_prompt("Fakten-Recherche", topic=topic, source=source, bausteine=block_text(idxs), out_path=fp, extra=_extra(instructions)),
            role="guide", capabilities=caps,
            payload=lambda result, p=fp: _fakten_schema(_json_datei(p)),
            timeout=_timeout("inhalt", subs_total))
        return status != FAILED and _fakten_schema(_json_datei(fp)) is not None

    oks = await _gather_fortschritt([_finde(ci, idxs) for ci, idxs in enumerate(chunks)], len(chunks), _melde_p(set_p, topic, "Fakten finden"))
    if is_cancelled():
        return None
    if not any(ok is True for ok in oks):
        _bausteine_errors[topic] = "Fakten-Extraktion fehlgeschlagen"
        return None

    # Phase „Fakten ergänzen" (Recall): ein gezielter Gap-Hunt je Chunk sucht source-belegte Fakten, die
    # der Single-Pass übersah. Best-effort — schlägt nie fehl (keine erg-Datei → Merge nutzt nur roh).
    async def _ergaenze(ci, idxs):
        ep = erg_path(ci)
        if _fakten_schema(_json_datei(ep)):
            return
        per = roh_map(ci, roh_path(ci))
        if not per:
            return
        block = "\n\n".join(
            f"BAUSTEIN: {bt}\nSUBBAUSTEINE (mit bereits erfassten Fakten):\n" + "\n".join(
                f"- {fk['sub']}\n  Erfasst: " + ("; ".join(
                    list(fk.get("kernpunkte", [])) + [bf["text"] for bf in fk.get("belegte_fakten", [])]) or "(nichts)")
                for fk in fm.values())
            for bt, fm in per.items())
        subs_total = sum(len(bausteine[i][1]) for i in idxs)
        await run_single_slot(
            ctx, f"Fakten ergänzen {ci}", key=f"bausteine-{topic}-fakten-erg-c{ci}",
            prompt=_prompt("Fakten-Ergaenzung", topic=topic, source=source, bausteine=block, out_path=ep, extra=_extra(instructions)),
            role="guide", capabilities=caps,
            payload=lambda result, p=ep: _fakten_schema(_json_datei(p)),
            timeout=_timeout("inhalt", subs_total))

    set_p("Fakten ergänzen…", step=_step_idx(topic, "Fakten finden"))
    await _gather_fortschritt([_ergaenze(ci, idxs) for ci, idxs in enumerate(chunks)], len(chunks), _melde_p(set_p, topic, "Fakten finden"))
    if is_cancelled():
        return None

    # Phase „Fakten prüfen": FAKTEN_CHECK_PANEL Judges je Chunk. Zwei Mehrheits-Mengen:
    # beanstandet (Fakt ungenau → korrigieren) und verwerfen (Sub nicht belegbar → entfernen).
    async def _pruefe(ci, idxs):
        per = _chunk_fakten(ci)  # roh + Ergänzungen → Panel verifiziert die Vereinigung
        if not per:
            return ci, set(), set()
        fakten_text = "\n\n".join(f"SUBBAUSTEIN: {fk['sub']}\n{_fakten_zeilen(fk)}" for fm in per.values() for fk in fm.values())
        offen = [j for j in (1, 2, 3)[:FAKTEN_CHECK_PANEL] if _fakten_check_schema(_json_datei(chk_path(ci, j))) is None]
        await asyncio.gather(*[
            run_agent(f"bausteine-{topic}-fakten-check-c{ci}-j{j}",
                _prompt("Fakten-Check", topic=topic, source=source, fakten=fakten_text, out_path=chk_path(ci, j), extra=_extra(instructions)),
                _timeout("inhalt_check", len(per)), provider=provider, role="judge", capabilities=caps)
            for j in offen], return_exceptions=True)
        outs = [s for j in (1, 2, 3)[:FAKTEN_CHECK_PANEL] if (s := _fakten_check_schema(_json_datei(chk_path(ci, j)))) is not None]
        bvotes: dict[str, int] = {}
        vvotes: dict[str, int] = {}
        for s in outs:  # s = [(sub_norm, verwerfen)] eines Judges
            gb, gv = set(), set()
            for sn, verw in s:
                if sn not in gb:
                    gb.add(sn); bvotes[sn] = bvotes.get(sn, 0) + 1
                if verw and sn not in gv:
                    gv.add(sn); vvotes[sn] = vvotes.get(sn, 0) + 1
        schwelle = len(outs) / 2 if outs else 99
        beanstandet = {sn for sn, v in bvotes.items() if v > schwelle}
        # Verwerfen ist irreversibel → strenger als Beanstanden: Mehrheit UND ≥2 zustimmende Judges
        # (verhindert Löschung durch eine Einzelstimme, wenn das Panel degradiert ist).
        verwerfen = {sn for sn, v in vvotes.items() if v > schwelle and v >= 2}
        return ci, beanstandet, verwerfen

    pruef = await _gather_fortschritt([_pruefe(ci, idxs) for ci, idxs in enumerate(chunks)], len(chunks), _melde_p(set_p, topic, "Fakten prüfen"))
    if is_cancelled():
        return None
    beanstandet: dict[int, set] = {}
    verwerfen: dict[int, set] = {}
    for r in pruef:
        if isinstance(r, tuple) and len(r) == 3:
            ci, b, v = r
            beanstandet[ci] = b
            verwerfen[ci] = v

    # Phase „Fakten fix": nur KORRIGIERBARE (beanstandet ohne verwerfen) neu extrahieren.
    korrigieren = {ci: (beanstandet.get(ci, set()) - verwerfen.get(ci, set())) for ci in beanstandet}
    n_problem = sum(len(s) for s in korrigieren.values())
    if n_problem:
        set_p(f"Fakten korrigieren ({n_problem})…", step=_step_idx(topic, "Fakten fix"))
        async def _fix(ci):
            subs_norm = korrigieren.get(ci, set())
            if not subs_norm or _fakten_schema(_json_datei(fix_path(ci))):
                return
            idxs = chunks[ci]
            rel_by = {bausteine[i][0]: bausteine[i][1] for i in idxs}
            # nur die korrigierbaren Subs als Block
            ziel = []
            for bt, subs in rel_by.items():
                betroffen = [s for s in subs if _norm_titel(s) in subs_norm]
                if betroffen:
                    ziel.append(f"BAUSTEIN: {bt}\nSUBBAUSTEINE:\n" + "\n".join(f"- {s}" for s in betroffen))
            if not ziel:
                return
            await run_single_slot(
                ctx, f"Fakten-Fix {ci}", key=f"bausteine-{topic}-fakten-fix-c{ci}",
                prompt=_prompt("Fakten-Recherche", topic=topic, source=source, bausteine="\n\n".join(ziel), out_path=fix_path(ci), extra=_extra(instructions)),
                role="guide", capabilities=caps,
                payload=lambda result, p=fix_path(ci): _fakten_schema(_json_datei(p)),
                timeout=_timeout("inhalt", len(subs_norm)))
        await _gather_fortschritt([_fix(ci) for ci in korrigieren], len(korrigieren), _melde_p(set_p, topic, "Fakten fix"))
        if is_cancelled():
            return None

    # Zusammensetzen: roh + Fix-Overrides für korrigierte. Verworfene Subs raus (+ je Baustein melden).
    ergebnis: dict[str, dict] = {}
    verworfen_map: dict[str, set] = {}
    for ci in range(len(chunks)):
        per = _chunk_fakten(ci)  # roh + Ergänzungen (Recall); Fix überschreibt nur Korrigierte
        fix = roh_map(ci, fix_path(ci)) if fix_path(ci).exists() else {}
        verw = verwerfen.get(ci, set())
        for bt, fm in per.items():
            for sn, fk in fm.items():
                if sn in verw:
                    verworfen_map.setdefault(bt, set()).add(sn)
                    continue
                gewinner = fix.get(bt, {}).get(sn, fk) if sn in korrigieren.get(ci, set()) else fk
                ergebnis.setdefault(bt, {})[sn] = {k: gewinner[k] for k in _FAKTEN_FELDER}
    if verworfen_map:
        _log(topic, f"Fakten-Check verwirft {sum(len(s) for s in verworfen_map.values())} unbelegbare Subbausteine")
    return ergebnis, verworfen_map


async def _relevanz_block(ctx: GenContext, set_p, files: dict, sidecar: dict, instructions: str) -> dict | None:
    """Block D: drei Phasen mit Barriere — Finden (relevant/rand), Wählen (Vote), Klären.
    Items aus der Sidecar; lokale IDs 1..n pro Paket → globale gid.
    → {gid: relevanz} oder None bei Abbruch/Recherche-Fehler. Default bei Lücke/Streit: 'relevant'."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    arbeit = files["arbeit"]
    items = [(titel, sub["titel"], sub.get("fakten")) for titel, subs in sidecar.items() for sub in subs]  # globale id = index+1
    if not items:
        return {}
    chunks = _chunk_nums(list(range(len(items))), _n_chunks(len(items), STUFE_CHUNK))
    n = len(chunks)

    def rater_paths(c):
        return [arbeit / f"relevanz-c{c}-{i}.json" for i in (1, 2, 3)]

    def lset(item_idxs):
        return set(range(1, len(item_idxs) + 1))

    # Phase „Relevanz finden": pro Paket 3 Rater (min. 2), lokale IDs.
    async def _rate(c, item_idxs):
        local_set = lset(item_idxs)
        paths = rater_paths(c)
        vorhanden = sum(1 for p in paths if _relevanz_schema(_json_datei(p), local_set))
        if vorhanden >= 2:
            return True
        enum_zeilen = []
        for k, j in enumerate(item_idxs, 1):
            enum_zeilen.append(f"{k}. [{items[j][0]}] {items[j][1]}")
            if (kz := _kern_zeile(items[j][2])):
                enum_zeilen.append(f"   {kz}")
        enum = "\n".join(enum_zeilen)
        offen = [(i, p) for i, p in enumerate(paths, 1) if not _relevanz_schema(_json_datei(p), local_set)]
        slots = [{
            "key": f"bausteine-{topic}-relevanz-c{c}-{i}",
            "prompt": _prompt("Relevanz-Recherche", topic=topic, subbausteine=enum, out_path=p, extra=_extra(instructions)),
            "role": "fast", "capabilities": "files",
            "payload": (lambda result, p=p, ids=local_set: _relevanz_schema(_json_datei(p), ids)),
        } for i, p in offen]
        neu = await _race(topic, f"Relevanz Paket {c}", slots, 2 - vorhanden, _timeout("relevanz", len(item_idxs)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
        return not is_cancelled() and neu is not None

    oks = await _gather_fortschritt([_rate(c, idxs) for c, idxs in enumerate(chunks, 1)], len(chunks), _melde_p(set_p, topic, "Relevanz finden"))
    if is_cancelled():
        return None
    if not all(ok is True for ok in oks):
        _bausteine_errors[topic] = "Relevanz fehlgeschlagen (Recherche)"
        return None

    # Phase „Relevanz wählen": Code-Vote je Paket → (ergebnis, strittig).
    set_p(f"Relevanz wählen ({n} Pakete)…", step=_step_idx(topic, "Relevanz wählen"))
    vote_by_c = {}
    for c, item_idxs in enumerate(chunks, 1):
        local_set = lset(item_idxs)
        rater = [d for p in rater_paths(c) if (d := _relevanz_schema(_json_datei(p), local_set))]
        ergebnis: dict[int, str] = {}
        strittig: dict[int, list[str]] = {}
        for k in range(1, len(item_idxs) + 1):
            stimmen = [d[k] for d in rater if k in d]
            zaehler: dict[str, int] = {}
            for s in stimmen:
                zaehler[s] = zaehler.get(s, 0) + 1
            best = max(zaehler.values(), default=0)
            gewinner = [s for s, v in zaehler.items() if v == best]
            if len(gewinner) == 1 and best >= 2:
                ergebnis[k] = gewinner[0]
            else:
                strittig[k] = stimmen
        vote_by_c[c] = (ergebnis, strittig)

    # Phase „Relevanz klären": Judge je Paket mit Strittigem, alle parallel.
    async def _klaere(c, item_idxs):
        ergebnis, strittig = vote_by_c[c]
        if strittig:
            judge_path = arbeit / f"relevanz-final-c{c}.json"
            entsch = _relevanz_schema(_json_datei(judge_path), set(strittig))
            if entsch is None:
                strittig_block = "\n".join(
                    f"{k}. [{items[item_idxs[k - 1]][0]}] {items[item_idxs[k - 1]][1]} — Stimmen: {', '.join(stimmen) or 'keine'}"
                    for k, stimmen in strittig.items()
                )
                status, entsch = await run_single_slot(
                    ctx, f"Relevanz-Klärung {c}",
                    key=f"bausteine-{topic}-relevanz-final-c{c}",
                    prompt=_prompt("Relevanz-Mapping", topic=topic, strittig=strittig_block, out_path=judge_path, extra=_extra(instructions)),
                    role="judge", capabilities="files",
                    payload=lambda result, p=judge_path, ids=set(strittig): _relevanz_schema(_json_datei(p), ids),
                    timeout=_timeout("relevanz_check", len(strittig)),
                )
                if status == FAILED:
                    _log(topic, f"Relevanz-Klärung Paket {c} fehlgeschlagen — Default 'relevant'")
                entsch = entsch if isinstance(entsch, dict) else {}
            # Strittige ohne Entscheid → 'relevant' (nie versehentlich ausschließen).
            ergebnis = {**{k: "relevant" for k in strittig}, **ergebnis, **entsch}
        return {item_idxs[k - 1] + 1: rel for k, rel in ergebnis.items()}

    parts = await _gather_fortschritt([_klaere(c, idxs) for c, idxs in enumerate(chunks, 1)], len(chunks), _melde_p(set_p, topic, "Relevanz klären"))
    if is_cancelled():
        return None
    relevanz_by_id: dict[int, str] = {}
    for c, part in enumerate(parts, 1):
        if not isinstance(part, dict):
            # Klärung ist nicht fatal: Vote-Ergebnis + Default 'relevant' für Strittige.
            if isinstance(part, BaseException):
                _log(topic, f"Relevanz-Klärung Paket {c}: {type(part).__name__}: {part}")
            ergebnis, strittig = vote_by_c[c]
            item_idxs = chunks[c - 1]
            merged = {**{k: "relevant" for k in strittig}, **ergebnis}
            part = {item_idxs[k - 1] + 1: s for k, s in merged.items()}
        relevanz_by_id.update(part)
    return relevanz_by_id


def _norm_frage(t: str) -> str:
    return " ".join(str(t or "").lower().split())


def _match_sub(agent_sub: str, rel: list[str]) -> str:
    """Subbaustein-Titel des Agenten auf den passenden relevanten Titel mappen — exakt,
    dann normalisiert, dann Teilstring (der Agent lässt z. B. das Präfix „Frage: " weg).
    Kein Treffer → Agent-Titel behalten. So geht KEIN Muster durch Titel-Abweichung verloren."""
    if agent_sub in rel:
        return agent_sub
    an = _norm_titel(agent_sub)
    for r in rel:
        rn = _norm_titel(r)
        if an and rn and (an == rn or an in rn or rn in an):
            return r
    return agent_sub


async def _frage_muster_block(ctx: GenContext, set_p, files: dict, sidecar: dict, instructions: str) -> dict | None:
    """Block E (10er-Chunks): Finden (1 Generator je ~10 Bausteine, parallel), Wählen (Code:
    je Baustein gruppieren + Dedup), Klären (1 Kritiker je Chunk), Prüfen (Nachrunde).
    Zuordnung je Eintrag über das `baustein`-Feld (Chunk-Datei trägt mehrere Bausteine).
    → {Baustein-Titel: [{subbaustein, frage}, …]} oder None bei Abbruch."""
    topic, is_cancelled = ctx.topic, ctx.is_cancelled
    arbeit = files["arbeit"]
    # ALLE Subbausteine (auch rand) bekommen ein Muster — Rand ist in der FGuide-Ebene prüfbar.
    # fakten_by: voller Fakten-Kontext je Sub (Generierung profitiert davon — bessere Fragen).
    bausteine = []
    fakten_by: dict[tuple, dict] = {}
    for titel, subs in sidecar.items():
        alle = []
        for s in subs:
            if isinstance(s, dict) and (st := str(s.get("titel", "")).strip()):
                alle.append(st)
                if isinstance(s.get("fakten"), dict):
                    fakten_by[(titel, _norm_titel(st))] = s["fakten"]
        if alle:
            bausteine.append((titel, alle))
    if not bausteine:
        return {}
    chunks = _lpt_chunks([len(rel) for _, rel in bausteine], FRAGE_CHUNK_SUBS)  # lastbalanciert nach Sub-Zahl

    def roh_path(ci):
        return arbeit / f"frage-muster-c{ci}.json"

    def final_path(ci):
        return arbeit / f"frage-muster-final-c{ci}.json"

    def _chunk_titel(idxs):
        return [bausteine[i][0] for i in idxs]

    # Phase „Fragen finden": je Chunk 1 Generator, alle parallel.
    async def _finde(ci, idxs):
        fp = roh_path(ci)
        if _frage_muster_chunk_schema(_json_datei(fp)):
            return  # Resume
        def _sub_zeile(bi, s):
            zeile = f"- {s}"
            fk = fakten_by.get((bausteine[bi][0], _norm_titel(s)))
            if fk and (ft := _fakten_zeilen(fk)):
                zeile += "\n" + "\n".join("    " + l for l in ft.split("\n"))
            return zeile
        block = "\n\n".join(
            f"BAUSTEIN: {bausteine[i][0]}\nSUBBAUSTEINE:\n" + "\n".join(_sub_zeile(i, s) for s in bausteine[i][1])
            for i in idxs
        )
        subs_total = sum(len(bausteine[i][1]) for i in idxs)
        status, _ = await run_single_slot(
            ctx, f"Frage-Muster {ci}",
            key=f"bausteine-{topic}-frage-muster-c{ci}",
            prompt=_prompt("Frage-Muster-Recherche", topic=topic, bausteine=block,
                           out_path=fp, extra=_extra(instructions)),
            role="fast", capabilities="files",
            payload=lambda result, p=fp: _frage_muster_chunk_schema(_json_datei(p)),
            timeout=_timeout("frage_muster", subs_total),
        )
        if status == FAILED:
            _log(topic, f"Frage-Muster Chunk {ci} fehlgeschlagen — Bausteine im Fallback (Nachrunde/Live)")

    async def finde_alle(ci_list):
        ci_list = list(ci_list)
        await _gather_fortschritt([_finde(ci, chunks[ci]) for ci in ci_list], len(ci_list), _melde_p(set_p, topic, "Fragen finden"))

    await finde_alle(range(len(chunks)))
    if is_cancelled():
        return None

    # Phase „Fragen wählen": Code — Chunk-Dateien je Baustein gruppieren, Dubletten raus,
    # Baustein-/Subbaustein-Titel locker auf die Vorgaben mappen (nichts wegen Abweichung verwerfen).
    def _waehle_chunk(ci):
        idxs = chunks[ci]
        ctitel = _chunk_titel(idxs)
        rel_by = {bausteine[i][0]: bausteine[i][1] for i in idxs}
        out, gesehen = {}, {}
        for e in _frage_muster_chunk_schema(_json_datei(roh_path(ci))) or []:
            titel = _match_sub(e["baustein"], ctitel)
            if titel not in rel_by:
                continue  # nicht zuordenbar → verwerfen
            sub = _match_sub(e["subbaustein"], rel_by[titel])
            seen = gesehen.setdefault(titel, set())
            if sub in seen:
                continue  # genau ein Muster je Subbaustein
            seen.add(sub)
            out.setdefault(titel, []).append({"subbaustein": sub, "frage": e["frage"]})
        return out

    def _waehle_all(ci_list):
        roh = {}
        for ci in ci_list:
            for titel, eintraege in _waehle_chunk(ci).items():
                roh.setdefault(titel, []).extend(eintraege)
        return roh

    set_p("Fragen wählen…", step=_step_idx(topic, "Fragen wählen"))
    roh_by_titel = _waehle_all(range(len(chunks)))

    # Phase „Fragen klären": je Chunk 1 Kritiker bereinigt die Tabellen (nach Baustein gruppiert).
    async def _klaere(ci, idxs):
        fp = final_path(ci)
        if _frage_muster_chunk_schema(_json_datei(fp)):
            return  # Resume
        bloecke = []
        for i in idxs:
            t = bausteine[i][0]
            eintraege = roh_by_titel.get(t) or []
            if not eintraege:
                continue
            zeilen = "\n".join(f"- ({e['subbaustein']}) {e['frage']}" for e in eintraege)
            bloecke.append(f"BAUSTEIN: {t}\n{zeilen}")
        if not bloecke:
            return  # nichts zu klären in diesem Chunk
        subs_total = sum(len(bausteine[i][1]) for i in idxs)
        status, _ = await run_single_slot(
            ctx, f"Frage-Muster-Klärung {ci}",
            key=f"bausteine-{topic}-frage-muster-final-c{ci}",
            prompt=_prompt("Frage-Muster-Kritik", topic=topic, tabelle="\n\n".join(bloecke), out_path=fp, extra=_extra(instructions)),
            role="judge", capabilities="files",
            payload=lambda result, p=fp: _frage_muster_chunk_schema(_json_datei(p)),
            timeout=_timeout("frage_muster_check", subs_total),
        )
        if status == FAILED:
            _log(topic, f"Frage-Muster-Klärung Chunk {ci} fehlgeschlagen — Roh-Muster übernommen")

    async def klaere_alle(ci_list):
        ci_list = list(ci_list)
        await _gather_fortschritt([_klaere(ci, chunks[ci]) for ci in ci_list], len(ci_list), _melde_p(set_p, topic, "Fragen klären"))

    await klaere_alle(range(len(chunks)))
    if is_cancelled():
        return None

    # Geklärte Chunk-Tabelle je Baustein, Fallback auf Roh-Muster. Titel locker mappen.
    def _final_by_titel(ci_list):
        out = {}
        for ci in ci_list:
            idxs = chunks[ci]
            ctitel = _chunk_titel(idxs)
            rel_by = {bausteine[i][0]: bausteine[i][1] for i in idxs}
            for e in _frage_muster_chunk_schema(_json_datei(final_path(ci))) or []:
                titel = _match_sub(e["baustein"], ctitel)
                if titel not in rel_by:
                    continue
                out.setdefault(titel, []).append(
                    {"subbaustein": _match_sub(e["subbaustein"], rel_by[titel]), "frage": e["frage"]})
        return out

    final_by_titel = _final_by_titel(range(len(chunks)))
    ergebnis = {t: (final_by_titel.get(t) or roh_by_titel.get(t) or []) for t, _ in bausteine}

    # Phase „Fragen prüfen": Chunks mit ≥1 leeren Baustein eine Runde nachholen.
    set_p("Fragen prüfen…", step=_step_idx(topic, "Fragen prüfen"))
    leer_titel = {t for t, _ in bausteine if not ergebnis.get(t)}
    if leer_titel:
        nach = [ci for ci, idxs in enumerate(chunks) if any(bausteine[i][0] in leer_titel for i in idxs)]
        _log(topic, f"Frage-Muster: {len(leer_titel)} Baustein(e) ohne Muster — Nachrunde über {len(nach)} Chunk(s)")
        for ci in nach:
            roh_path(ci).unlink(missing_ok=True)
            final_path(ci).unlink(missing_ok=True)
        await finde_alle(nach)
        if is_cancelled():
            return None
        for titel, eintraege in _waehle_all(nach).items():
            roh_by_titel[titel] = eintraege
        await klaere_alle(nach)
        if is_cancelled():
            return None
        for titel, eintraege in _final_by_titel(nach).items():
            final_by_titel[titel] = eintraege
        for t, _ in bausteine:
            if not ergebnis.get(t):
                ergebnis[t] = final_by_titel.get(t) or roh_by_titel.get(t) or []
        rest = [t for t, _ in bausteine if not ergebnis.get(t)]
        if rest:
            _log(topic, f"Frage-Muster: {len(rest)} Baustein(e) bleiben leer (Fallback Live): {rest[:5]}")
    return ergebnis


# ── Inventar in der DB: Recherche-Loop · Konsolidierung · Klärung ────────────



def _crawl_index(ordner) -> dict[str, str]:
    """Alias (Dateiname ODER QUELLE:-URL, klein) → kanonischer Seiten-Key (Dateiname)."""
    idx: dict[str, str] = {}
    if not ordner or not Path(ordner).is_dir():
        return idx
    for p in sorted(Path(ordner).glob("*.txt")):
        key = p.name
        idx[key.lower()] = key
        try:
            erste = p.read_text(encoding="utf-8").splitlines()[0]
        except (OSError, IndexError):
            erste = ""
        if erste.startswith("QUELLE:"):
            url = erste[len("QUELLE:"):].strip()
            if url:
                idx[url.lower()] = key
                idx[url.rstrip("/").lower()] = key
    return idx






async def _set_inventar(topic: str, eintrag: str, status: str) -> None:
    """Einen Inventar-Eintrag ('Titel — Beschreibung') mit Status in die DB schreiben."""
    titel = _titel(eintrag)
    norm = _norm_titel(titel)
    if not norm:
        return
    teile = [t.strip() for t in eintrag.split(" — ")]
    besch = teile[1] if len(teile) >= 2 else ""
    await db.upsert_baustein(topic, norm, titel, besch)
    await db.set_baustein_status(topic, norm, status)


def _sichte_regeln(ordner, pages: list[str]) -> tuple[list[str], list[str]]:
    """Deterministischer Content/Noise-Filter (config.CRAWL_*). Substring-Match (klein) gegen
    URL + Dateiname. Reihenfolge: keep > noise > min_chars > behalten. → (content, noise)."""
    ordner = Path(ordner)
    content, noise = [], []
    for fn in pages:
        zeilen = _read(ordner / fn).splitlines()
        url = zeilen[0][len("QUELLE:"):].strip() if zeilen and zeilen[0].startswith("QUELLE:") else ""
        body = "\n".join(zeilen[1:]).strip()
        hay = f"{url}\n{fn}".lower()
        if any(p in hay for p in CRAWL_KEEP_PATTERNS):
            content.append(fn)
        elif any(p in hay for p in CRAWL_NOISE_PATTERNS):
            noise.append(fn)
        elif len(body) < CRAWL_MIN_CHARS:
            noise.append(fn)
        else:
            content.append(fn)  # Default: behalten — alles mit Inhalt bleibt
    return content, noise


def _seite_snippet(ordner, fn: str) -> tuple[str, str]:
    """(url, snippet) einer Crawl-Seite für das Relevanz-Gate. url aus der QUELLE:-Zeile;
    snippet = Body-Auszug (Navigations-Boilerplate steht vorn — der Prompt ignoriert es).
    URL ist das Primärsignal (sprechender Slug), der Snippet stützt nur."""
    zeilen = _read(Path(ordner) / fn).splitlines()
    url = zeilen[0][len("QUELLE:"):].strip() if zeilen and zeilen[0].startswith("QUELLE:") else ""
    body = "\n".join(zeilen[1:]).strip()
    snippet = " ".join(body.split())[:QUELLE_RELEVANZ_SNIPPET]
    return (url or fn), snippet


async def _relevanz_sichtung(ctx: GenContext, set_p, files: dict, ordner, content: list[str], spec: str, instructions: str) -> tuple[list[str], list[str]]:
    """LLM-Themen-Gate nach dem Regel-Filter: jede Content-Seite ja/nein gegen die Spec.
    Off-topic (anderes Fachgebiet) → raus. Muster wie `_relevanz_block`: kleine Pakete, 3 Rater
    (`fast`), 2-von-3-Konsens. KONSERVATIV: nur bei klarer „nein"-Mehrheit droppen; Streit/Lücke/
    Race-Fehler → behalten. SAFETY: würde das Gate ≥80 % (oder alles) droppen, bleibt alles
    (Spec-Mismatch/Bug soll die Quelle nicht leeren). → (behalten, raus) als Dateinamen."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    arbeit = files["arbeit"]
    pages = sorted(content)
    if not pages:
        return content, []
    items = [_seite_snippet(ordner, fn) for fn in pages]  # Index deckt sich mit `pages`
    chunks = _chunk_nums(list(range(len(pages))), _n_chunks(len(pages), QUELLE_RELEVANZ_CHUNK))
    n = len(chunks)

    def rater_paths(c):
        return [arbeit / f"quelle-relevanz-c{c}-{i}.json" for i in (1, 2, 3)]

    def lset(idxs):
        return set(range(1, len(idxs) + 1))

    async def _rate(c, idxs):
        local_set = lset(idxs)
        paths = rater_paths(c)
        vorhanden = sum(1 for p in paths if _janein_schema(_json_datei(p), local_set))
        if vorhanden >= 2:
            return True
        enum_zeilen = []
        for k, j in enumerate(idxs, 1):
            url, snip = items[j]
            enum_zeilen.append(f"{k}. {url}")
            if snip:
                enum_zeilen.append(f"   {snip}")
        enum = "\n".join(enum_zeilen)
        offen = [(i, p) for i, p in enumerate(paths, 1) if not _janein_schema(_json_datei(p), local_set)]
        slots = [{
            "key": f"bausteine-{topic}-quelle-relevanz-c{c}-{i}",
            "prompt": _prompt("Quelle-Relevanz", topic=topic, spec=spec, seiten=enum, out_path=p, extra=_extra(instructions)),
            "role": "fast", "capabilities": "files",
            "payload": (lambda result, p=p, ids=local_set: _janein_schema(_json_datei(p), ids)),
        } for i, p in offen]
        neu = await _race(topic, f"Relevanz-Sichtung Paket {c}", slots, 2 - vorhanden, _timeout("relevanz", len(idxs)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
        return not is_cancelled() and neu is not None

    _qidx = _step_idx(topic, "Quelle aufbereiten")  # Gate läuft im Quelle-Schritt (kein eigener Step)
    set_p(f"Prüfe Relevanz zur Spec ({n} Pakete)…", step=_qidx)
    async def _melde_sichtung(d, t):
        set_p(f"Prüfe Relevanz zur Spec {d}/{t}…", step=_qidx)
    await _gather_fortschritt([_rate(c, idxs) for c, idxs in enumerate(chunks, 1)], n, _melde_sichtung)
    if is_cancelled():
        return content, []  # Abbruch → nichts droppen (Caller bricht ab)

    # Vote je Seite: nur eine klare „nein"-Mehrheit (≥2 und mehr als „ja") wirft raus.
    raus: list[str] = []
    for c, idxs in enumerate(chunks, 1):
        local_set = lset(idxs)
        rater = [d for p in rater_paths(c) if (d := _janein_schema(_json_datei(p), local_set))]
        for k in range(1, len(idxs) + 1):
            stimmen = [d[k] for d in rater if k in d]
            nein, ja = stimmen.count("nein"), stimmen.count("ja")
            if nein >= 2 and nein > ja:
                raus.append(pages[idxs[k - 1]])

    if raus and len(raus) >= max(1, int(len(pages) * 0.8)):
        _log(topic, f"Relevanz-Sichtung: würde {len(raus)}/{len(pages)} droppen — verworfen (Spec-Mismatch?), alles behalten")
        return content, []
    raus_set = set(raus)
    behalten = [fn for fn in pages if fn not in raus_set]
    return behalten, raus


async def _quelle_aufbereiten(ctx: GenContext, set_p, files: dict, q: dict, ordner, instructions: str) -> bool:
    """Schritt „Quelle aufbereiten": Crawl (link) + PDF-Konvert + Content/Noise-Sichtung.
    Persistiert die Sichtung in der Coverage-Tabelle (inhalt). → True (ok) / False (Abbruch/Fehler).
    thema: nichts. projekt/uni: nur PDFs (kuratierter Ordner, keine Sichtung)."""
    topic, is_cancelled = ctx.topic, ctx.is_cancelled
    if not ordner:
        return True  # thema → keine Quelle aufzubereiten
    if q["type"] != "link":
        await asyncio.to_thread(_pdfs_konvertieren, ordner)  # projekt/uni: nur PDFs, keine Sichtung
        return True
    if await db.get_step_status(topic, "Quelle aufbereiten") == "fertig":
        return True
    if not _crawl_fertig(topic):
        set_p("Quelle laden (Crawl)…", step=_step_idx(topic, "Quelle aufbereiten"))
        n = await asyncio.to_thread(crawl, q["ort"], ordner, cancelled=is_cancelled)
        if is_cancelled():
            return False
        if not n:
            _bausteine_errors[topic] = "Crawl ergab keine Inhalte — Link/Domain prüfen"
            return False
    await asyncio.to_thread(_pdfs_konvertieren, ordner)
    pages = sorted(set(_crawl_index(ordner).values()))
    if pages:
        set_p("Sichte Seiten…", step=_step_idx(topic, "Quelle aufbereiten"))
        await db.delete_coverage(topic)
        content, noise = _sichte_regeln(ordner, pages)  # deterministischer Regel-Filter
        if q.get("spec") and content:  # Themen-Gate: trennt das Fachgebiet (Regeln können das nicht)
            content, raus = await _relevanz_sichtung(ctx, set_p, files, ordner, content, q["spec"], instructions)
            if is_cancelled():
                return False
            if raus:
                noise = sorted(set(noise) | set(raus))
                _log(topic, f"LLM-Relevanz: {len(raus)} Seiten off-topic → Noise")
        await db.mark_inhalt(topic, sorted(content), sorted(noise))
        _log(topic, f"Sichtung: {len(content)} Content / {len(noise)} Noise von {len(pages)} (Regeln + LLM-Gate)")
    await db.set_step_status(topic, "Quelle aufbereiten", "fertig")
    return True


async def _recherche_batch(ctx: GenContext, set_p, files: dict, q: dict, ordner, instructions: str) -> bool:
    """Befüllt DB-Tabelle `bausteine` mit Kandidaten (+ Nennungszähler). FESTE Datei-Batches:
    jede Crawl-Seite wird genau einem Batch zugeteilt und von RECHERCHE_READERS Agenten gelesen
    (Konsens ≥2 im Batch). Alle zugeteilten Seiten werden als gelesen markiert → 100 % Abdeckung.
    Ohne Crawl-Ordner (Quelle „thema") → freie Web-Recherche, eine Runde. → True/False."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    if await db.get_step_status(topic, "Recherche") == "fertig":
        return True
    arbeit = files["arbeit"]
    await db.delete_bausteine(topic)  # Coverage/inhalt gehört der Sichtung — NICHT löschen
    await db.set_step_status(topic, "Recherche", "laufend")

    async def _ingest(reader_id: str, text: str) -> None:
        gesehen = set()
        for eintrag in _parse_auswahl(text).values():
            titel = _titel(eintrag)
            norm = _norm_titel(titel)
            if not norm or norm in gesehen:
                continue
            gesehen.add(norm)  # ein Reader = eine Stimme je Konzept
            teile = [t.strip() for t in eintrag.split(" — ")]
            besch = teile[1] if len(teile) >= 2 else ""
            quelle = [teile[2]] if len(teile) >= 3 and teile[2] else []
            await db.upsert_baustein(topic, norm, titel, besch, quelle, reader=reader_id)

    pages = await db.list_content(topic)  # von der Sichtung als Content markierte Seiten
    if not pages and ordner:
        pages = sorted(set(_crawl_index(ordner).values()))  # Fallback (projekt/uni: keine Sichtung)

    if not pages:
        # Quelle „thema" (oder kein Crawl): freie Web-Recherche, eine Runde.
        set_p("Recherche läuft…", step=_step_idx(topic, "Recherche"))
        caps = "files" if ordner else "full"
        paths = [arbeit / f"recherche-{i}.md" for i in range(1, RECHERCHE_THEMA_AGENTEN + 1)]
        for p in paths:
            p.unlink(missing_ok=True)
        slots = [{
            "key": f"bausteine-{topic}-recherche-{i}",
            "prompt": _build_recherche_prompt(topic, p, instructions, q["type"], ordner),
            "role": "quick", "capabilities": caps,
            "payload": (lambda result, p=p, rid=f"t{i}": ((rid, t) if (t := _file_payload(p)) else None)),
        } for i, p in enumerate(paths, 1)]
        texte = await _race(topic, "Recherche", slots, 3, _timeout("recherche"), provider,
                            cancelled=is_cancelled, grace=RECHERCHE_GRACE)
        if is_cancelled():
            return False
        if not texte:
            _bausteine_errors[topic] = "Recherche fehlgeschlagen (Minimum nicht erreicht)"
            return False
        for rid, text in texte:
            await _ingest(rid, text)
        await db.set_step_status(topic, "Recherche", "fertig")
        return True

    # uni/projekt: kuratierte, oft GROSSE Dateien (Skript). Statt alle am Stück zu lesen
    # (Lost-in-the-Middle), in Abschnitte chunken und JEDEN gründlich von 2 Readern lesen —
    # Text direkt im Prompt (kleiner Kontext), Nennungen akkumulieren zu Konsens.
    if q["type"] in ("uni", "projekt"):
        eintraege: list[tuple[str, str]] = []  # (dateiname, abschnitt-text)
        for fn in sorted(pages):
            for absch in _text_abschnitte(_read(ordner / fn)):
                eintraege.append((fn, absch))
        if not eintraege:
            _bausteine_errors[topic] = "Recherche: Quelle leer"
            return False
        set_p(f"Recherche ({len(eintraege)} Abschnitte)…", step=_step_idx(topic, "Recherche"))

        async def _lese_abschnitt(ei: int, fn: str, absch: str) -> None:
            block = (f"ARBEITE AUSSCHLIESSLICH MIT DIESEM TEXTABSCHNITT (Quelle: {fn}). Lies ihn "
                     f"VOLLSTÄNDIG, überspringe nichts. Notiere `{fn}` als Quelle jedes Bausteins. "
                     f"Suche NICHT im Web — nur dieser Abschnitt zählt.\n\n-----\n{absch}\n-----")
            paths = [arbeit / f"recherche-a{ei}-{i}.md" for i in range(1, RECHERCHE_READERS + 1)]
            # Reader-Datei-Wiederverwendung: liegen alle Reader-Outputs valide vor (Resume /
            # Re-Run ohne Recherche-Änderung), re-ingestieren statt erneut Agenten zu spawnen.
            vorhanden = [(f"a{ei}-{i}", t) for i, p in enumerate(paths, 1) if (t := _file_payload(p))]
            if len(vorhanden) == len(paths):
                for rid, text in vorhanden:
                    await _ingest(rid, text)
                return
            for p in paths:
                p.unlink(missing_ok=True)
            if is_cancelled():
                return
            slots = [{
                "key": f"bausteine-{topic}-recherche-a{ei}-{i}",
                "prompt": _build_recherche_prompt(topic, p, instructions, q["type"], ordner, abschnitt=block),
                "role": "quick", "capabilities": "files",
                "payload": (lambda result, p=p, rid=f"a{ei}-{i}": ((rid, t) if (t := _file_payload(p)) else None)),
            } for i, p in enumerate(paths, 1)]
            # Quorum 2: beide Reader pro Abschnitt sollen durch (mehr Augen = mehr Konzepte +
            # echter Konsens); nach Timeout fällt _race auf das Vorhandene zurück.
            texte = await _race(topic, f"Recherche Abschnitt {ei}", slots, 2, _timeout("recherche", 1),
                                provider, cancelled=is_cancelled, grace=RECHERCHE_GRACE)
            for rid, text in (texte or []):
                await _ingest(rid, text)

        await _gather_fortschritt([_lese_abschnitt(ei, fn, a) for ei, (fn, a) in enumerate(eintraege, 1)],
                                  len(eintraege), _melde_p(set_p, topic, "Recherche"))
        if is_cancelled():
            return False
        await db.mark_quellen_gelesen(topic, sorted(pages))
        gesamt = len(await db.list_bausteine(topic))
        _log(topic, f"Recherche (uni/projekt): {gesamt} Kandidaten aus {len(eintraege)} Abschnitten ({len(pages)} Dateien)")
        if not gesamt:
            _bausteine_errors[topic] = "Recherche fehlgeschlagen (keine Bausteine)"
            return False
        await db.set_step_status(topic, "Recherche", "fertig")
        return True

    # Crawl/Link: viele kleine Content-Seiten (Sichtung im Schritt „Quelle aufbereiten").
    # Feste Batches, je Batch RECHERCHE_READERS Reader, die GENAU diese Dateien lesen.
    batches = _chunk_nums(sorted(pages), max(1, math.ceil(len(pages) / RECHERCHE_BATCH)))

    async def _lese_batch(bi: int, batch: list[str]) -> bool:
        liste = "\n".join(f"- {p}" for p in batch)
        fokus = ("WICHTIG — feste Zuteilung: Bearbeite AUSSCHLIESSLICH diese Dateien und lies JEDE "
                 f"vollständig. Ignoriere alle anderen Dateien im Ordner:\n{liste}")
        paths = [arbeit / f"recherche-b{bi}-{i}.md" for i in range(1, RECHERCHE_READERS + 1)]
        for p in paths:
            p.unlink(missing_ok=True)
        if not is_cancelled():
            slots = [{
                "key": f"bausteine-{topic}-recherche-b{bi}-{i}",
                "prompt": _build_recherche_prompt(topic, p, instructions, q["type"], ordner, fokus=fokus),
                "role": "quick", "capabilities": "files",
                "payload": (lambda result, p=p, rid=f"b{bi}-{i}": ((rid, t) if (t := _file_payload(p)) else None)),
            } for i, p in enumerate(paths, 1)]
            texte = await _race(topic, f"Recherche Batch {bi}", slots, 1, _timeout("recherche", len(batch)),
                                provider, cancelled=is_cancelled, grace=RECHERCHE_GRACE)
            for rid, text in (texte or []):
                await _ingest(rid, text)
        await db.mark_quellen_gelesen(topic, batch)  # alle zugeteilten Seiten abhaken (auch ohne Treffer)
        return not is_cancelled()

    await _gather_fortschritt([_lese_batch(bi, b) for bi, b in enumerate(batches, 1)],
                              len(batches), _melde_p(set_p, topic, "Recherche"))
    if is_cancelled():
        return False
    gesamt = len(await db.list_bausteine(topic))
    deckung = len(await db.list_coverage(topic))
    _log(topic, f"Recherche: {gesamt} Kandidaten, Abdeckung {deckung}/{len(pages)} Seiten ({len(batches)} Batches)")
    if not gesamt:
        _bausteine_errors[topic] = "Recherche fehlgeschlagen (keine Bausteine)"
        return False
    await db.set_step_status(topic, "Recherche", "fertig")
    return True


def _grp_schema(data, ids: set[int]):
    """{"gruppen": [[1,3],[2], …]} → Partition von `ids` als Liste von Index-Gruppen.
    Tolerant: ignoriert Fremd-/Doppel-Nummern; vergessene Kandidaten werden eigenständig
    (Singleton-Gruppe) ergänzt. None nur bei strukturell kaputtem JSON."""
    if not isinstance(data, dict) or not isinstance(data.get("gruppen"), list):
        return None
    gruppen, gesehen = [], set()
    for g in data["gruppen"]:
        if not isinstance(g, list):
            return None
        grp = []
        for x in g:
            try:
                num = int(x)
            except (ValueError, TypeError):
                continue
            if num in ids and num not in gesehen:
                gesehen.add(num)
                grp.append(num)
        if grp:
            gruppen.append(grp)
    gruppen += [[r] for r in sorted(ids - gesehen)]  # vergessene Kandidaten bleiben eigenständig
    return gruppen or None


_ASPEKT_MARKER = ("∈ np", "∈np", " in np", "np-schwer", "np-vollständig", "verifizierer",
                  "zertifikat", "ndtm", "nicht-determ", "lower bound", "untere schranke",
                  "bzgl", "als sprache")


def _aspekt_marker(titel: str) -> int:
    """Anzahl Eigenschafts-Marker im Titel (∈NP, NP-schwer, Verifizierer, Lower Bound …).
    0 = generisches Hauptkonzept (das Problem selbst); >0 = eine Eigenschaft davon."""
    t = titel.casefold()
    return sum(1 for m in _ASPEKT_MARKER if m in t)


def _canonical(kandidaten: list[dict], idxs: list[int], gesehen_norm: set[str]) -> dict:
    """Repräsentant eines Clusters = das Hauptkonzept (wenigste Eigenschafts-Marker — das Problem
    selbst, nicht „… ∈ NP"); Tie → häufigster norm-Titel → meiste Reader. Titel global eindeutig
    (Suffix ' (2)'), damit er als Schlüssel taugt."""
    by_norm: dict[str, list[int]] = {}
    for k in idxs:
        by_norm.setdefault(_norm_titel(kandidaten[k]["titel"]), []).append(k)

    def gewicht(nb: str):
        ms = by_norm[nb]
        reader = set().union(*[set(kandidaten[m]["reader"]) for m in ms]) if ms else set()
        return (-_aspekt_marker(nb), len(ms), len(reader))  # aspekt-arm zuerst = Hauptkonzept

    best = max(by_norm, key=gewicht)
    k = max(by_norm[best], key=lambda m: len(kandidaten[m]["beschreibung"]))
    titel = kandidaten[k]["titel"]
    n = 2
    while _norm_titel(titel) in gesehen_norm:
        titel = f"{kandidaten[k]['titel']} ({n})"
        n += 1
    gesehen_norm.add(_norm_titel(titel))
    return {"titel": titel, "beschreibung": kandidaten[k]["beschreibung"]}


async def _block_gruppieren(ctx: GenContext, set_p, arbeit: Path, kandidaten: list[dict],
                            blocks: list[list[int]], praefix: str = "konsolidierung",
                            schritt: str = "Konsolidierung") -> list[list[int]]:
    """Je Ähnlichkeits-Block gruppiert ein Judge die Titel in die echten Bausteine (merge
    Paraphrasen, split Über-Merges). Singletons direkt. Fehler/Timeout → konservativ jeder
    Kandidat einzeln (vermeidet fälschliches Über-Mergen). → finale Gruppen (globale Indizes).
    `praefix`/`schritt` trennen Konsolidierung und Dedup (Artefakte, Race-Key, Fortschritt)."""
    topic, is_cancelled = ctx.topic, ctx.is_cancelled
    multi = [(bi, b) for bi, b in enumerate(blocks) if len(b) > 1]
    ergebnis: list[list[int]] = [list(b) for b in blocks if len(b) == 1]  # Singletons direkt

    def _zeile(k: int, g: int) -> str:
        b = kandidaten[g]
        return f"{k}. {b['titel']}" + (f" — {b['beschreibung']}" if b["beschreibung"] else "")

    async def _grp(bi: int, block: list[int]) -> None:
        ids = set(range(1, len(block) + 1))
        p = arbeit / f"{praefix}-block-c{bi}.json"
        part = _grp_schema(_json_datei(p), ids)
        if part is None:  # Resume: gültige Datei nicht neu rechnen
            p.unlink(missing_ok=True)
            if is_cancelled():
                return
            zeilen = [_zeile(k, block[k - 1]) for k in range(1, len(block) + 1)]
            status, part = await run_single_slot(
                ctx, f"Block-Gruppieren {bi}",
                key=f"bausteine-{topic}-{praefix}-block-c{bi}",
                prompt=_prompt("Bausteine-Block-Gruppieren", topic=topic, eintraege="\n".join(zeilen), out_path=p),
                role="judge", capabilities="files",
                payload=(lambda result, p=p, ids=ids: _grp_schema(_json_datei(p), ids)),
                timeout=_timeout("recherche_mapping", len(block)),
            )
            part = part if status == OK else None
        if part is None:  # Judge gescheitert → einzeln (kein Über-Merge)
            ergebnis.extend([idx] for idx in block)
        else:  # lokale Nummern → globale Kandidaten-Indizes
            ergebnis.extend([block[k - 1] for k in g] for g in part)

    await _gather_fortschritt([_grp(bi, b) for bi, b in multi],
                              len(multi), _melde_p(set_p, topic, schritt))
    return ergebnis


async def _konsolidiere_embedding(ctx: GenContext, set_p, files: dict, kandidaten: list[dict]) -> bool:
    """Zweistufig: Embeddings → grobe Capped-Blocks (High-Recall) → je Multi-Block ein Judge,
    der die Titel in die echten Bausteine gruppiert → Reader-Union (≥2 = Konsens)."""
    topic, is_cancelled = ctx.topic, ctx.is_cancelled
    arbeit = files["arbeit"]
    texts = [f"{b['titel']} — {b['beschreibung']}" if b["beschreibung"] else b["titel"] for b in kandidaten]
    sims = await asyncio.to_thread(embedding.embed_sims, texts)
    if sims is None:  # Modell doch nicht verfügbar → Fallback
        return await _konsolidiere_llm(ctx, set_p, files, kandidaten)
    # Stufe 1: grobe Ähnlichkeits-Blocks (gedeckelt, kein Giant-Component).
    blocks = await asyncio.to_thread(embedding.capped_blocks, sims, None, None)
    # Stufe 2: ein Judge gruppiert JEDEN Multi-Block in die echten Bausteine.
    gruppen = await _block_gruppieren(ctx, set_p, arbeit, kandidaten, blocks)
    if is_cancelled():
        return False

    def _min_cos(idxs):  # interne Kohärenz zur Kontrolle (Ketten hätten ~0,3)
        if len(idxs) < 2:
            return 1.0
        return round(min(float(sims[i][j]) for n, i in enumerate(idxs) for j in idxs[n + 1:]), 3)

    # Konsens = ≥2 distinkte Reader pro Cluster. Legacy-DBs ohne Reader-Tracking (Recherche lief
    # vor der Migration, kein Re-Ingest) haben leere Reader-Sets → Rückfall auf Titel-Heuristik
    # (sonst landete ALLES im Rest).
    hat_reader = any(b["reader"] for b in kandidaten)
    konsens, rest, debug, gesehen_norm = [], [], [], set()
    for idxs in gruppen:
        reader = set().union(*[set(kandidaten[k]["reader"]) for k in idxs]) if idxs else set()
        if hat_reader:
            score = len(reader)
        else:  # ohne Reader-Daten: max(Nennungen, Anzahl distinkter Titel-Varianten im Cluster)
            score = max(max(kandidaten[k]["nennungen"] for k in idxs),
                        len({kandidaten[k]["titel_norm"] for k in idxs}))
        rep = _canonical(kandidaten, idxs, gesehen_norm)
        eintrag = f"{rep['titel']} — {rep['beschreibung']}" if rep["beschreibung"] else rep["titel"]
        (konsens if score >= 2 else rest).append(eintrag)
        debug.append({"titel": rep["titel"], "reader": sorted(reader), "score": score,
                      "konsens": score >= 2, "min_cos": _min_cos(idxs),
                      "mitglieder": [kandidaten[k]["titel"] for k in idxs]})
    atomic_write_json(arbeit / "konsolidierung-cluster.json", debug, indent=1)
    multi_blocks = sum(1 for b in blocks if len(b) > 1)
    _log(topic, f"Konsolidierung (Embedding): {len(blocks)} Blocks ({multi_blocks} per LLM gruppiert) "
                f"→ {len(gruppen)} Cluster aus {len(kandidaten)} Kandidaten "
                f"→ {len(konsens)} Konsens / {len(rest)} Rest")

    await db.delete_bausteine(topic)
    for t in konsens:
        await _set_inventar(topic, t, "konsens")
    for t in rest:
        await _set_inventar(topic, t, "rest")
    await db.set_step_status(topic, "Konsolidierung", "fertig")
    return True


async def _konsolidiere(ctx: GenContext, set_p, files: dict) -> bool:
    """Mergt Roh-Kandidaten zu Konsens (≥2 Reader)/Rest. Deterministisch per Embedding-Clustering;
    fehlt das Modell → Rückfall auf das LLM-Panel (`_konsolidiere_llm`). Status in DB."""
    topic = ctx.topic
    if await db.get_step_status(topic, "Konsolidierung") == "fertig":
        return True
    set_p("Konsolidiere Recherche…", step=_step_idx(topic, "Konsolidierung"))
    kandidaten = await db.list_bausteine(topic)
    if not kandidaten:
        _bausteine_errors[topic] = "Konsolidierung: keine Kandidaten"
        return False
    if EMBEDDING_AKTIV and await asyncio.to_thread(embedding.verfuegbar):
        return await _konsolidiere_embedding(ctx, set_p, files, kandidaten)
    return await _konsolidiere_llm(ctx, set_p, files, kandidaten)


async def _konsolidiere_llm(ctx: GenContext, set_p, files: dict, kandidaten: list[dict]) -> bool:
    """Fallback (nur ohne Embedding-Modell): Panel (KONSOLIDIERUNG_PANEL Judges) mergt Kandidaten
    semantisch; ein Reconcile-Judge führt die Panel-Ausgaben zur finalen Konsens (≥2)/Rest (1×)-Liste
    zusammen. Panel statt Einzel-Judge: ein einzelner Judge ist bias-anfällig und instabil."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    arbeit = files["arbeit"]
    chunks = _chunk_nums(kandidaten, max(1, math.ceil(len(kandidaten) / KONSOLIDIERUNG_CHUNK)))

    async def _map_panel(c: int, eintraege: str, anzahl: int):
        """3 Mapping-Judges über `eintraege` → Reconcile-Judge → (konsens, rest). None bei Abbruch/Fehler."""
        paths = [arbeit / f"konsolidierung-c{c}-j{j}.json" for j in range(1, KONSOLIDIERUNG_PANEL + 1)]
        offen = [(j, p) for j, p in enumerate(paths, 1) if _mapping_schema(_json_datei(p)) is None]
        for _, p in offen:
            p.unlink(missing_ok=True)
        if offen:
            slots = [{
                "key": f"bausteine-{topic}-konsolidierung-c{c}-j{j}",
                "prompt": _prompt("Bausteine-Recherche-Mapping", topic=topic, n=RECHERCHE_READERS, eintraege=eintraege, out_path=p),
                "role": "judge", "capabilities": "files",
                "payload": (lambda result, p=p: _mapping_schema(_json_datei(p))),
            } for j, p in offen]
            vorhanden = KONSOLIDIERUNG_PANEL - len(offen)
            await _race(topic, f"Konsolidierung {c}", slots, max(1, 2 - vorhanden),
                        _timeout("recherche_mapping", anzahl), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
        if is_cancelled():
            return None
        outs = [m for p in paths if (m := _mapping_schema(_json_datei(p)))]
        if not outs:
            return None
        # Union der Panel-Titel; je Titel zählen, wie viele Judges ihn als Konsens führen.
        kvotes: dict[str, int] = {}
        form: dict[str, str] = {}      # norm → Anzeigetitel (erstes Vorkommen)
        order: list[str] = []
        for kk, rr in outs:
            for t in kk + rr:
                nt = _norm_titel(_titel(t))
                if not nt:
                    continue
                if nt not in form:
                    form[nt] = t
                    order.append(nt)
                    kvotes.setdefault(nt, 0)
            for t in kk:
                nt = _norm_titel(_titel(t))
                if nt:
                    kvotes[nt] = kvotes.get(nt, 0) + 1
        # Reconcile: ein Merge-Judge über die Union, annotiert mit Judge-Stimmen ("k× genannt").
        rp = arbeit / f"konsolidierung-c{c}-reconcile.json"
        recon = _mapping_schema(_json_datei(rp))
        if recon is None:
            rp.unlink(missing_ok=True)
            eintraege_r = "\n".join(f"{i}. {form[nt]} ({max(1, kvotes[nt])}× genannt)" for i, nt in enumerate(order, 1))
            status, recon = await run_single_slot(
                ctx, f"Konsolidierung Reconcile {c}",
                key=f"bausteine-{topic}-konsolidierung-c{c}-reconcile",
                prompt=_prompt("Bausteine-Recherche-Mapping", topic=topic, n=KONSOLIDIERUNG_PANEL, eintraege=eintraege_r, out_path=rp),
                role="judge", capabilities="files",
                payload=lambda result, p=rp: _mapping_schema(_json_datei(p)),
                timeout=_timeout("recherche_mapping", len(order)),
            )
            if status == CANCELLED:
                return None
            recon = recon if status != FAILED else None
        if recon:
            return recon
        # Fallback (Reconcile gescheitert): Code-Mehrheit — Konsens, wenn Mehrheit der Judges Konsens sagt.
        konsens = [form[nt] for nt in order if kvotes[nt] * 2 >= len(outs) and kvotes[nt] > 0]
        kset = {_norm_titel(_titel(t)) for t in konsens}
        return konsens, [form[nt] for nt in order if nt not in kset]

    konsens, rest = [], []
    for c, chunk in enumerate(chunks, 1):
        eintraege = "\n".join(
            f"{i}. {b['titel']} — {b['beschreibung']} ({b['nennungen']}× genannt)" for i, b in enumerate(chunk, 1)
        )
        res = await _map_panel(c, eintraege, len(chunk))
        if res is None:
            if is_cancelled():
                return False
            _bausteine_errors[topic] = "Recherche-Mapping fehlgeschlagen"
            return False
        k, r = res
        konsens += k
        rest += r
    # Bei mehreren Chunks: ein globaler Merge-Pass über die vereinten Konsens-Einträge,
    # damit Dubletten über Chunk-Grenzen (DAL×4, PHPUnit×5 …) verschmelzen.
    if len(chunks) > 1 and konsens:
        fp = arbeit / "konsolidierung-merge.json"
        fp.unlink(missing_ok=True)
        eintraege = "\n".join(f"{i}. {t} (2× genannt)" for i, t in enumerate(konsens, 1))
        status, mapping = await run_single_slot(
            ctx, "Konsolidierung Merge",
            key=f"bausteine-{topic}-konsolidierung-merge",
            prompt=_prompt("Bausteine-Recherche-Mapping", topic=topic, n=RECHERCHE_READERS, eintraege=eintraege, out_path=fp),
            role="judge", capabilities="files",
            payload=lambda result, p=fp: _mapping_schema(_json_datei(p)),
            timeout=_timeout("recherche_mapping", len(konsens)),
        )
        if status == CANCELLED:
            return False
        if status != FAILED and mapping:
            konsens, r2 = mapping
            rest += r2  # vom Merge zurückgestufte Einträge in den Rest
    # Judge-Ausgabe ist maßgeblich → Inventar in der DB neu setzen.
    await db.delete_bausteine(topic)
    for t in konsens:
        await _set_inventar(topic, t, "konsens")
    for t in rest:
        await _set_inventar(topic, t, "rest")
    await db.set_step_status(topic, "Konsolidierung", "fertig")
    return True


async def _klaere_inventar(ctx: GenContext, set_p, files: dict) -> bool:
    """Panel (KONSOLIDIERUNG_PANEL Judges) entscheidet über den Rest (1×-Genannte): Mehrheit `aufnehmen`
    → Konsens, sonst verworfen. Panel statt Einzel-Judge — der Rest-Schnitt ist der schärfste Eingriff;
    ein einzelner Judge ist hier zu instabil. Konservativer Tie → behalten (nie ein Konzept verlieren)."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    if await db.get_step_status(topic, "Klärung") == "fertig":
        return True
    set_p("Klärung läuft…", step=_step_idx(topic, "Klärung"))
    rest_rows = await db.list_bausteine(topic, status="rest")
    if rest_rows:
        arbeit = files["arbeit"]
        paths = [arbeit / f"klaerung-j{j}.json" for j in range(1, KONSOLIDIERUNG_PANEL + 1)]
        offen = [(j, p) for j, p in enumerate(paths, 1) if _runde_schema(_json_datei(p), final=True) is None]
        for _, p in offen:
            p.unlink(missing_ok=True)
        if offen:
            slots = [{
                "key": f"bausteine-{topic}-klaerung-j{j}",
                "prompt": _prompt(
                    "Bausteine-Klaerung", topic=topic,
                    rest="\n".join(f"- {b['titel']}" for b in rest_rows),
                    final="\n- Entscheide JEDEN Eintrag. `rest` MUSS leer sein.",
                    out_path=p,
                ),
                "role": "judge", "capabilities": "files",
                "payload": (lambda result, p=p: _runde_schema(_json_datei(p), final=True)),
            } for j, p in offen]
            vorhanden = KONSOLIDIERUNG_PANEL - len(offen)
            await _race(topic, "Klärung", slots, max(1, 2 - vorhanden),
                        _timeout("auswahl_mapping", len(rest_rows)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
        if is_cancelled():
            return False
        outs = [r for p in paths if (r := _runde_schema(_json_datei(p), final=True))]
        if not outs:
            _bausteine_errors[topic] = "Klärung fehlgeschlagen"
            return False
        # Mehrheit je Rest-Eintrag (per Norm-Titel). Tie → behalten (votes*2 >= n).
        votes: dict[str, int] = {}
        for aufnehmen, _ in outs:
            for nt in {_norm_titel(_titel(t)) for t in aufnehmen}:
                votes[nt] = votes.get(nt, 0) + 1
        for b in rest_rows:
            auf = votes.get(b["titel_norm"], 0) * 2 >= len(outs)
            await db.set_baustein_status(topic, b["titel_norm"], "konsens" if auf else "verworfen")
    await db.set_step_status(topic, "Klärung", "fertig")
    return True


async def _dedup_inventar(ctx: GenContext, set_p, files: dict) -> bool:
    """Finaler iterativer Dedup-Pass über die fertige Konsens-Liste: Embedding-Block + LLM-
    Gruppierung. Fängt Dubletten, die Konsolidierung (Block-Grenzen, Cap) und Klärung (lange
    Liste, Lost-in-the-Middle) übersehen. Pro Gruppe bleibt EIN Repräsentant, der Rest wird
    verworfen. Iteriert, weil die kleinere Liste je Runde neu blockt (Cross-Block-Reste)."""
    topic, is_cancelled = ctx.topic, ctx.is_cancelled
    if await db.get_step_status(topic, "Dedup") == "fertig":
        return True
    if not (EMBEDDING_AKTIV and await asyncio.to_thread(embedding.verfuegbar)):
        await db.set_step_status(topic, "Dedup", "fertig")  # ohne Modell: still überspringen
        return True
    set_p("Dedup…", step=_step_idx(topic, "Dedup"))
    arbeit = files["arbeit"]
    for runde in range(1, DEDUP_MAX_RUNDEN + 1):
        konsens = await db.list_bausteine(topic, status="konsens")
        if len(konsens) < 2:
            break
        texts = [f"{b['titel']} — {b['beschreibung']}" if b["beschreibung"] else b["titel"] for b in konsens]
        sims = await asyncio.to_thread(embedding.embed_sims, texts)
        if sims is None:
            break
        blocks = await asyncio.to_thread(embedding.capped_blocks, sims, None, None)
        gruppen = await _block_gruppieren(ctx, set_p, arbeit, konsens, blocks,
                                          praefix=f"dedup-r{runde}", schritt="Dedup")
        if is_cancelled():
            return False
        weg = 0
        for idxs in gruppen:
            if len(idxs) < 2:
                continue
            # Repräsentant = Hauptkonzept (wenigste Eigenschafts-Marker), dann kürzester Titel; Rest verwerfen.
            rep = min(idxs, key=lambda k: (_aspekt_marker(konsens[k]["titel"]), len(konsens[k]["titel"]), k))
            for k in idxs:
                if k != rep:
                    await db.set_baustein_status(topic, konsens[k]["titel_norm"], "verworfen")
                    weg += 1
        atomic_write_json(arbeit / f"dedup-runde-{runde}.json",
                          {"vorher": len(konsens), "entfernt": weg,
                           "gruppen": [[konsens[k]["titel"] for k in g] for g in gruppen if len(g) > 1]}, indent=1)
        _log(topic, f"Dedup Runde {runde}: {len(konsens)} → {len(konsens) - weg} (−{weg})")
        if weg <= max(1, len(konsens) * DEDUP_MIN_DELTA // 100):  # konvergiert → Schluss
            break
    await db.set_step_status(topic, "Dedup", "fertig")
    return True


# --- Gliederung (Bausteine-Artefakt: Kapitel-Struktur, vom Guide nur gelesen) ---

def _gliederung_komplett(files: dict) -> bool:
    """Gliederung steht (Kapitel-Liste vorhanden)?"""
    d = _json_datei(files["gliederung"])
    return isinstance(d, dict) and isinstance(d.get("kapitel"), list) and bool(d.get("kapitel"))


def _gliederung_schema(data, valid: set[int]):
    """{"kapitel":[{titel,nummern}]} → bereinigt (valide Nummern, je genau einmal) ·
    None bei <80 % Abdeckung (Agent/Judge hat zu viel weggelassen)."""
    if not isinstance(data, dict) or not isinstance(data.get("kapitel"), list):
        return None
    out, seen = [], set()
    for ch in data["kapitel"]:
        if not isinstance(ch, dict):
            continue
        titel = str(ch.get("titel", "")).strip() or "Kapitel"
        nums = []
        for n in (ch.get("nummern") or []):
            try:
                n = int(n)
            except (ValueError, TypeError):
                continue
            if n in valid and n not in seen:
                seen.add(n)
                nums.append(n)
        if nums:
            out.append({"titel": titel, "nummern": nums})
    if not out or len(seen) < 0.8 * len(valid):
        return None
    return {"kapitel": out}


def _prereq_schema(data, valid: set[int]) -> dict[int, list[int]]:
    """{"prereqs": {"3": [1, 7]}} → {num: [prereq-nums]} · nur Nummern aus `valid`, ohne Selbstkante.
    Ungültig/leer → {} (Best-effort: dann Original-Reihenfolge)."""
    if not isinstance(data, dict) or not isinstance(data.get("prereqs"), dict):
        return {}
    out: dict[int, list[int]] = {}
    for k, v in data["prereqs"].items():
        try:
            num = int(k)
        except (ValueError, TypeError):
            continue
        if num not in valid or not isinstance(v, list):
            continue
        pres = []
        for p in v:
            try:
                p = int(p)
            except (ValueError, TypeError):
                continue
            if p in valid and p != num and p not in pres:
                pres.append(p)
        if pres:
            out[num] = pres
    return out


def _topo_order(nums: list[int], edges: dict[int, list[int]]) -> list[int]:
    """Kahn-Topo-Sort: Voraussetzungen zuerst. `edges[num]` = Nummern, die VOR num kommen müssen.
    Stabiler Tie-Break (Original-Reihenfolge von `nums`); Zyklen werden gebrochen (nie Deadlock)."""
    pos = {n: i for i, n in enumerate(nums)}
    # Resteingangsgrad nur über gültige Knoten; Selbst-/Fremdkanten ignoriert.
    pre = {n: [p for p in edges.get(n, []) if p in pos and p != n] for n in nums}
    fertig: list[int] = []
    erledigt: set[int] = set()
    rest = list(nums)
    while rest:
        bereit = [n for n in rest if all(p in erledigt for p in pre[n])]
        if not bereit:  # Zyklus → den in Original-Reihenfolge frühesten Rest-Knoten erzwingen
            bereit = [min(rest, key=lambda n: pos[n])]
        nxt = min(bereit, key=lambda n: pos[n])  # stabil: kleinste Original-Position zuerst
        fertig.append(nxt)
        erledigt.add(nxt)
        rest.remove(nxt)
    return fertig


async def _lernreihenfolge(ctx: GenContext, set_p, files: dict, entries: dict, valid: set[int], instructions: str) -> dict:
    """entries (num→titel) in Lernreihenfolge bringen: LLM extrahiert Prereq-Kanten aus den
    extrahierten `voraussetzungen`, Code löst per Topo-Sort. Best-effort → sonst entries unverändert."""
    if len(entries) < 3:
        return entries
    topic = ctx.topic
    fakten_map = _json_datei(files["fakten"])
    fakten_map = fakten_map if isinstance(fakten_map, dict) else {}

    def _hint(titel):
        fm = fakten_map.get(titel) or {}
        vs = [v for fk in fm.values() if isinstance(fk, dict) and (v := str(fk.get("voraussetzungen", "")).strip())]
        return " · ".join(dict.fromkeys(vs))

    pp = files["arbeit"] / "gliederung-prereqs.json"

    def _payload(result, p=pp):
        d = _json_datei(p)
        return d if isinstance(d, dict) and "prereqs" in d else None

    vorhanden = _json_datei(pp)
    if not (isinstance(vorhanden, dict) and "prereqs" in vorhanden):
        zeilen = [f"{n}. {t}" + (f"\n   braucht vorher: {h}" if (h := _hint(t)) else "") for n, t in entries.items()]
        set_p("Gliederung — Lernreihenfolge…", step=_step_idx(topic, "Gliederung"))
        await run_single_slot(
            ctx, "Gliederung-Voraussetzungen", key=f"bausteine-{topic}-gliederung-prereqs",
            prompt=_prompt("Gliederung-Voraussetzungen", topic=topic, bausteine="\n".join(zeilen), out_path=pp, extra=_extra(instructions)),
            role="guide", capabilities="files", payload=_payload, timeout=_timeout("plan", len(entries)))
    edges = _prereq_schema(_json_datei(pp), valid)
    if not edges:
        return entries  # keine/ungültige Kanten → Original-Reihenfolge (kein Regress)
    ordered = _topo_order(list(entries), edges)
    return {n: entries[n] for n in ordered}


async def _gliederung_block(ctx: GenContext, set_p, files: dict, entries: dict, instructions: str) -> dict:
    """Format-agnostische Gliederung über ALLE Bausteine — 3 Vorschläge → Judge merged.
    Bricht nie ab: 0 gültige → ein Kapitel mit allem; fehlende Bausteine landen in „Weitere".
    → {"kapitel":[{titel,nummern}]} (auch in files["gliederung"])."""
    topic, is_cancelled = ctx.topic, ctx.is_cancelled
    valid = set(entries)
    step = _step_idx(topic, "Gliederung")

    # Lernreihenfolge gründen (LLM-Modulo): LLM extrahiert Prereq-Kanten aus den extrahierten
    # `voraussetzungen`, Code löst per Topo-Sort. Best-effort → sonst Original-Reihenfolge.
    entries = await _lernreihenfolge(ctx, set_p, files, entries, valid, instructions)
    liste = "\n".join(f"{n}. {t}" for n, t in entries.items())
    set_p("Gliederung — Vorschläge…", step=step)

    async def _vorschlag(i, path):
        if _gliederung_schema(_json_datei(path), valid):
            return True
        await run_single_slot(
            ctx, f"Gliederung {i}", key=f"bausteine-{topic}-gliederung-{i}",
            prompt=_prompt("Guide-Gliederung", topic=topic, bausteine=liste, out_path=path, extra=_extra(instructions)),
            role="guide", capabilities="files",
            payload=lambda result, p=path: _gliederung_schema(_json_datei(p), valid),
            timeout=_timeout("plan", len(entries)))
        return _gliederung_schema(_json_datei(path), valid) is not None

    slots = files["gliederung_slots"]
    await _gather_fortschritt([_vorschlag(i, p) for i, p in enumerate(slots, 1)], len(slots), _melde_p(set_p, topic, "Gliederung"))
    if is_cancelled():
        return {}
    vorschlaege = [v for p in slots if (v := _gliederung_schema(_json_datei(p), valid))]

    if not vorschlaege:
        plan = {"kapitel": [{"titel": "Inhalte", "nummern": list(entries)}]}
    elif len(vorschlaege) == 1:
        plan = vorschlaege[0]
    else:
        set_p("Gliederung zusammenführen…", step=step)
        bloecke = "\n\n".join(
            f"### Vorschlag {i}\n" + "\n".join(
                f"KAPITEL: {ch['titel']}\n  Nummern: {', '.join(str(n) for n in ch['nummern'])}" for ch in v["kapitel"])
            for i, v in enumerate(vorschlaege, 1))
        await run_single_slot(
            ctx, "Gliederung-Judge", key=f"bausteine-{topic}-gliederung-judge",
            prompt=_prompt("Guide-Gliederung-Judge", topic=topic, format_name="den Guide",
                           zweck="alle Bausteine in einem roten Faden", n=len(vorschlaege),
                           bausteine=liste, gliederungen=bloecke, out_path=files["gliederung"], extra=_extra(instructions)),
            role="judge", capabilities="files",
            payload=lambda result: _gliederung_schema(_json_datei(files["gliederung"]), valid),
            timeout=_timeout("plan_judge", len(entries)))
        plan = _gliederung_schema(_json_datei(files["gliederung"]), valid) or vorschlaege[0]

    # Vollständigkeit: jeder Baustein kommt vor — fehlende in „Weitere" (gegen weglassende Agenten/Judge).
    drin = {n for ch in plan["kapitel"] for n in ch["nummern"]}
    fehlen = [n for n in entries if n not in drin]
    if fehlen:
        plan["kapitel"].append({"titel": "Weitere", "nummern": fehlen})
    atomic_write_json(files["gliederung"], plan, indent=1)
    return plan


# --- Lern-Artefakte (Karteikarten/Beispiele aus den Fakten) ---

def _karten_schema(data):
    """{"karten":[{baustein,subbaustein,frage,antwort}]} → Liste (auch leer) · None bei kaputt."""
    if not isinstance(data, dict) or not isinstance(data.get("karten"), list):
        return None
    out = []
    for e in data["karten"]:
        if isinstance(e, dict) and (f := str(e.get("frage", "")).strip()) and (a := str(e.get("antwort", "")).strip()):
            out.append({"baustein": str(e.get("baustein", "")).strip(), "subbaustein": str(e.get("subbaustein", "")).strip(),
                        "frage": f, "antwort": a})
    return out


def _beispiel_schema(data):
    """{"beispiele":[{baustein,subbaustein,problem,schritte,ergebnis}]} → Liste (auch leer) · None bei kaputt."""
    if not isinstance(data, dict) or not isinstance(data.get("beispiele"), list):
        return None
    out = []
    for e in data["beispiele"]:
        if not isinstance(e, dict):
            continue
        problem = str(e.get("problem", "")).strip()
        schritte = [s for x in (e.get("schritte") or []) if (s := str(x).strip())]
        if problem and schritte:
            out.append({"baustein": str(e.get("baustein", "")).strip(), "subbaustein": str(e.get("subbaustein", "")).strip(),
                        "problem": problem, "schritte": schritte, "ergebnis": str(e.get("ergebnis", "")).strip()})
    return out


def _beispiel_check_schema(data):
    """Worked-Example-Check → {"ok": true} → set() (alles korrekt); {"probleme":[{"index":N}]} →
    {N, …} (1-basierte beanstandete Indizes); None bei kaputt."""
    if not isinstance(data, dict):
        return None
    if data.get("ok") is True:
        return set()
    pr = data.get("probleme")
    if not isinstance(pr, list):
        return None
    out: set[int] = set()
    for p in pr:
        if isinstance(p, dict):
            try:
                out.add(int(p.get("index")))
            except (ValueError, TypeError):
                continue
    return out


_ARTEFAKT_SCHEMA = {"karteikarte": _karten_schema, "beispiel": _beispiel_schema}
_ARTEFAKT_PROMPT = {"karteikarte": "Artefakt-Karteikarte", "beispiel": "Artefakt-Beispiel"}
_ARTEFAKT_SCHRITT = {"karteikarte": "Karteikarten", "beispiel": "Beispiele"}


def _artefakte_komplett(files: dict) -> bool:
    """Artefakt-Map steht (alle Typen erzeugt)? Werte dürfen leer sein (content-aware)."""
    d = _json_datei(files["artefakte"])
    return isinstance(d, dict) and all(t in d for t in ARTEFAKT_TYPEN)


async def _artefakte_block(ctx: GenContext, set_p, files: dict, sidecar: dict, instructions: str) -> dict | None:
    """Lern-Artefakte je Typ aus den gespeicherten Fakten erzeugen — ein Generierungs-Durchlauf
    je Typ über Chunks. Worked Examples werden gegen die Fakten verifiziert (falsche verworfen);
    Karteikarten sind risikoarm und bleiben ungeprüft. → {typ: [eintraege]} (auch in files)."""
    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
    arbeit = files["arbeit"]
    caps = "files"
    # Bausteine mit Subs + Fakten-Zeilen als Input-Block (extract-once aus den Fakten).
    bausteine = []
    for btitel, subs in sidecar.items():
        if not isinstance(subs, list):
            continue
        zeilen = []
        for s in subs:
            if not isinstance(s, dict) or not (st := str(s.get("titel", "")).strip()):
                continue
            fk = s.get("fakten") if isinstance(s.get("fakten"), dict) else {}
            zeile = f"- {st}"
            if fk and (fk_text := _fakten_zeilen(fk)):
                zeile += "\n" + "\n".join("  " + l for l in fk_text.split("\n"))
            zeilen.append(zeile)
        if zeilen:
            bausteine.append((btitel, zeilen))
    if not bausteine:
        leer = {t: [] for t in ARTEFAKT_TYPEN}
        atomic_write_json(files["artefakte"], leer, indent=1)
        return leer

    chunks = _lpt_chunks([len(z) for _, z in bausteine], FAKTEN_CHUNK_SUBS)
    def block_text(idxs):
        return "\n\n".join(f"BAUSTEIN: {bausteine[i][0]}\nSUBBAUSTEINE:\n" + "\n".join(bausteine[i][1]) for i in idxs)

    # Worked Examples gegen die Fakten prüfen (Panel-Mehrheit) — falsche verwerfen. CoT-Schritte sind
    # fehleranfällig; ein falsches Beispiel prägt ein fehlerhaftes Schema ein → kein Beispiel > falsches.
    async def _pruefe_beispiele(ci, idxs, items):
        if is_cancelled() or not items:
            return items
        def cpath(j): return arbeit / f"artefakt-beispiel-check-c{ci}-j{j}.json"
        beispiele_txt = "\n\n".join(
            f"{k}. PROBLEM: {e['problem']}\n   SCHRITTE: " + " | ".join(e.get("schritte", []))
            + (f"\n   ERGEBNIS: {e['ergebnis']}" if e.get("ergebnis") else "")
            for k, e in enumerate(items, 1))
        offen = [j for j in (1, 2, 3)[:FAKTEN_CHECK_PANEL] if _beispiel_check_schema(_json_datei(cpath(j))) is None]
        if offen:
            await asyncio.gather(*[
                run_agent(f"bausteine-{topic}-artefakt-beispiel-check-c{ci}-j{j}",
                    _prompt("Artefakt-Beispiel-Check", topic=topic, fakten=block_text(idxs), beispiele=beispiele_txt, out_path=cpath(j), extra=_extra(instructions)),
                    _timeout("inhalt_check", len(items)), provider=provider, role="judge", capabilities=caps)
                for j in offen], return_exceptions=True)
        outs = [s for j in (1, 2, 3)[:FAKTEN_CHECK_PANEL] if (s := _beispiel_check_schema(_json_datei(cpath(j)))) is not None]
        if not outs:
            return items  # keine Prüfung möglich → behalten (Best-effort)
        votes: dict[int, int] = {}
        for s in outs:
            for idx in s:
                votes[idx] = votes.get(idx, 0) + 1
        schwelle = len(outs) / 2
        raus = {idx for idx, v in votes.items() if v > schwelle}  # Mehrheit (≥2 von 3) beanstandet → raus
        if raus:
            _log(topic, f"Worked-Example-Check Chunk {ci}: {len(raus)}/{len(items)} verworfen")
        return [e for k, e in enumerate(items, 1) if k not in raus]

    ergebnis: dict[str, list] = {}
    for typ in ARTEFAKT_TYPEN:
        schema = _ARTEFAKT_SCHEMA[typ]
        def apath(ci, t=typ): return arbeit / f"artefakt-{t}-c{ci}.json"

        async def _gen(ci, idxs, t=typ, schema=schema):
            p = apath(ci, t)
            if schema(_json_datei(p)) is not None:
                return True
            await run_single_slot(
                ctx, f"{_ARTEFAKT_SCHRITT[t]} {ci}", key=f"bausteine-{topic}-artefakt-{t}-c{ci}",
                prompt=_prompt(_ARTEFAKT_PROMPT[t], topic=topic, bausteine=block_text(idxs), out_path=p, extra=_extra(instructions)),
                role="guide", capabilities="files",
                payload=lambda result, p=p, schema=schema: schema(_json_datei(p)),
                timeout=_timeout("inhalt", sum(len(bausteine[i][1]) for i in idxs)))
            return schema(_json_datei(p)) is not None

        await _gather_fortschritt([_gen(ci, idxs) for ci, idxs in enumerate(chunks)], len(chunks), _melde_p(set_p, topic, _ARTEFAKT_SCHRITT[typ]))
        if is_cancelled():
            return None
        eintraege: list = []
        for ci in range(len(chunks)):
            chunk_items = schema(_json_datei(apath(ci))) or []
            if typ == "beispiel" and chunk_items:
                chunk_items = await _pruefe_beispiele(ci, chunks[ci], chunk_items)
            eintraege += chunk_items
        ergebnis[typ] = eintraege
    atomic_write_json(files["artefakte"], ergebnis, indent=1)
    return ergebnis


async def _mirror_artefakte_db(topic: str, sidecar: dict, artefakte: dict) -> None:
    """Artefakte in die DB spiegeln. Karteikarte/Beispiel je Sub (sub_norm)."""
    await db.delete_sub_artefakte(topic)
    btitel_list = list(sidecar.keys())
    for typ in ARTEFAKT_TYPEN:
        for e in artefakte.get(typ, []):
            bt = _match_sub(e.get("baustein", ""), btitel_list)
            bnorm, sn = _norm_titel(bt), _norm_titel(e.get("subbaustein", ""))
            if not bnorm or not sn:
                continue
            daten = json.dumps({k: v for k, v in e.items() if k not in ("baustein", "subbaustein")}, ensure_ascii=False)
            await db.put_sub_artefakt(topic, bnorm, sn, typ, daten, bt, e.get("subbaustein", ""))


async def _mirror_sidecar_db(topic: str, sidecar: dict) -> None:
    """Sidecar {Baustein-Titel: [{titel, stufe, relevanz}]} in die DB-Tabelle subbausteine spiegeln."""
    for btitel, subs in sidecar.items():
        bnorm = _norm_titel(btitel)
        if not bnorm or not isinstance(subs, list):
            continue
        for s in subs:
            if not isinstance(s, dict):
                continue
            st = str(s.get("titel", "")).strip()
            sn = _norm_titel(st)
            if not sn:
                continue
            fakten = json.dumps(s["fakten"], ensure_ascii=False) if isinstance(s.get("fakten"), dict) else None
            await db.put_subbaustein(topic, bnorm, sn, btitel, st,
                                     stufe=s.get("stufe"), relevanz=s.get("relevanz"),
                                     fakten=fakten, status="konsens")


async def _mirror_frage_muster_db(topic: str, muster: dict) -> None:
    """Frage-Muster {Baustein-Titel: [{subbaustein, frage}]} in die DB-Tabelle frage_muster spiegeln."""
    await db.delete_frage_muster(topic)
    for btitel, eintraege in muster.items():
        bnorm = _norm_titel(btitel)
        if not bnorm or not isinstance(eintraege, list):
            continue
        for e in eintraege:
            if not isinstance(e, dict):
                continue
            sub = str(e.get("subbaustein", "")).strip()
            sn = _norm_titel(sub)
            frage = str(e.get("frage", "")).strip()
            if not (sn and frage):
                continue
            await db.upsert_frage_muster(topic, bnorm, sn, btitel, sub, frage)


async def _reset_db_ab_phase(topic: str, label: str) -> None:
    """DB-Inhalt der Phasen ≥ `label` verwerfen (kanonische Reihenfolge Quelle…Artefakte)."""
    idx = _phase_idx(label)
    if idx <= 8:  # Artefakte (Karteikarten/Beispiele)
        await db.delete_sub_artefakte(topic)
    if idx <= 7:  # Fragen
        await db.delete_frage_muster(topic)
    if idx <= 6:  # Gliederung
        await db.delete_gliederung(topic)
    if idx <= 2:  # Subbausteine (Fakten/Stufen/Relevanz greifen über Sidecar→Mirror)
        await db.delete_subbausteine(topic)
    if idx <= 1:  # Inventar: Inventar + Recherche-Schritte — Sichtung bleibt
        await db.delete_bausteine(topic)
        await db.delete_pipeline_state(topic, ["Recherche", "Konsolidierung", "Klärung", "Dedup"])
    if idx <= 0:  # Quelle: Sichtung neu (Coverage/inhalt + Schritt)
        await db.delete_coverage(topic)
        await db.delete_pipeline_state(topic, ["Quelle aufbereiten"])


async def generate_bausteine(topic: str, instructions: str = "", provider: str = DEFAULT_PROVIDER, ab_phase: int | None = None) -> None:
    if topic in _bausteine_progress:
        return
    _bausteine_progress[topic] = "Wartend…"
    _bausteine_errors.pop(topic, None)

    files = _bausteine_files(topic)
    final_path = files["final"]
    q = lade_quelle(topic)
    ordner = quelle_ordner(topic)  # projekt/uni/link → Ordner, thema → None
    instructions = q.get("spec") or instructions  # persistierte Spezifikation bevorzugen (auch bei Resume)

    def set_p(msg: str, step: int | None = None) -> None:
        _bausteine_progress[topic] = msg
        if step is not None:
            _bausteine_step[topic] = step

    def is_cancelled() -> bool:
        return topic in _bausteine_cancelled

    def abgebrochen() -> None:
        _bausteine_errors[topic] = "Abgebrochen — Fortschritt bleibt erhalten"

    ctx = GenContext(topic=topic, provider=provider, is_cancelled=is_cancelled)

    try:
        async with _semaphore:
            files["arbeit"].mkdir(parents=True, exist_ok=True)
            # Re-Run ab gewählter Phase: Artefakte ab dort löschen; der Frischstart-Block
            # unten wird übersprungen (er würde bei erhaltener Sidecar sonst alles wischen).
            if ab_phase is not None:
                phasen = _phasen(topic)
                label = phasen[ab_phase - 1][0] if 1 <= ab_phase <= len(phasen) else "Inventar"
                _reset_ab_phase(topic, label)
                await _reset_db_ab_phase(topic, label)
            # Schritt „Quelle aufbereiten": Crawl (link) + PDFs + Content/Noise-Sichtung.
            if not await _quelle_aufbereiten(ctx, set_p, files, q, ordner, instructions):
                if is_cancelled():
                    abgebrochen()
                return
            # „Neu erstellen": NUR wenn wirklich alles fertig ist (bausteine.md UND
            # Sidecar) → kompletter Frischstart. Liegt bausteine.md ohne Sidecar vor,
            # ist das ein Teil-Stand (Block B/C offen) → Resume, nicht wischen.
            # Bei explizitem Re-Run (ab_phase) hat _reset_ab_phase das schon erledigt.
            fertig = ab_phase is None and final_path.exists() and _sidecar_schema(_json_datei(files["sidecar"])) is not None
            if fertig:
                for p_alt in _alle_slot_dateien(files):
                    p_alt.unlink(missing_ok=True)
                await db.delete_pipeline_state(topic)
                await db.delete_bausteine(topic)
                await db.delete_subbausteine(topic)
                await db.delete_frage_muster(topic)
                await db.delete_coverage(topic)
                await db.delete_gliederung(topic)
                await db.delete_sub_artefakte(topic)

            # Inventar (DB): Recherche-Loop → Konsolidierung → Klärung.
            if not await _recherche_batch(ctx, set_p, files, q, ordner, instructions):
                if is_cancelled():
                    abgebrochen()
                return
            if not await _konsolidiere(ctx, set_p, files):
                if is_cancelled():
                    abgebrochen()
                return
            if not await _klaere_inventar(ctx, set_p, files):
                if is_cancelled():
                    abgebrochen()
                return
            if not await _dedup_inventar(ctx, set_p, files):
                if is_cancelled():
                    abgebrochen()
                return
            konsens_rows = await db.list_bausteine(topic, status="konsens")
            entries = {
                i: (f"{b['titel']} — {b['beschreibung']}" if b["beschreibung"] else b["titel"])
                for i, b in enumerate(konsens_rows, 1)
            }

            # Nur Projekte: Themenfeld-Ergänzung — Skript/Projekt ist ein Ausschnitt,
            # ein Web-Agent ergänzt kanonisch fehlende Bausteine, markiert mit [Ergänzung].
            if q["type"] == "projekt":
                set_p("Ergänze Themenfeld…", step=_step_idx(topic, "Ergänzung"))
                erg_path = files["ergaenzung"]
                ergaenzungen = _ergaenzung_schema(_json_datei(erg_path))
                if ergaenzungen is None:
                    erg_path.unlink(missing_ok=True)
                    status, ergaenzungen = await run_single_slot(
                        ctx, "Ergänzung",
                        key=f"bausteine-{topic}-ergaenzung-1",
                        prompt=_prompt(
                            "Bausteine-Ergaenzung",
                            topic=topic, bausteine="\n".join(f"- {t}" for t in entries.values()),
                            out_path=erg_path, extra=_extra(instructions),
                        ),
                        role="quick", capabilities="full",
                        payload=lambda result: _ergaenzung_schema(_json_datei(erg_path)),
                        timeout=_timeout("ergaenzung"),
                    )
                    if status == CANCELLED:
                        abgebrochen()
                        return
                    if status == FAILED:
                        _bausteine_errors[topic] = "Ergänzung fehlgeschlagen (kein gültiges Ergebnis)"
                        return
                idx = _titel_index(entries)
                neu = [(t, b) for t, b in ergaenzungen if _titel_aufloesen(idx, t) is None]
                if neu:
                    _log(topic, f"Ergänzung: {len(neu)} Baustein(e) aus dem Themenfeld ergänzt")
                    start = max(entries, default=0) + 1
                    for off, (t, b) in enumerate(neu):
                        entries[start + off] = f"{t} — {b} [Ergänzung]"

            # Titel eindeutig machen und unsortiertes Inventar schreiben
            entries = _eindeutige_titel(entries)
            atomic_write_text(final_path, "\n".join(f"{i}. {t}" for i, t in entries.items()) + "\n")

            # Block B + C: Subbausteine je Baustein + Stufen → Sidecar subbausteine.json.
            # Nicht-destruktiv: bausteine.md steht schon; fehlt die Sidecar, wird beim
            # nächsten Lauf nur dieser Teil neu versucht. Guide fällt ohne Sidecar zurück.
            if _sidecar_schema(_json_datei(files["sidecar"])) is None:
                roh = _sub_roh_schema(_json_datei(files["sub_roh"]))
                if roh is None:
                    roh = await _subbausteine_block(ctx, set_p, files, entries, instructions)
                    if is_cancelled():
                        abgebrochen()
                        return
                    if roh is None:
                        return  # Fehler ist gesetzt
                    atomic_write_json(files["sub_roh"], roh, indent=1)
                # Fakten je Sub (VOR der Stufe): Quell-Fakten extrahieren + verifizieren → fakten.json.
                # Extract-once-Grounding — Stufe/Relevanz/Fragen/Guide nähren sich daraus.
                if not _fakten_komplett(files):
                    res = await _fakten_block(ctx, set_p, files, roh, q, ordner, instructions)
                    if is_cancelled():
                        abgebrochen()
                        return
                    if res is None:
                        return  # Fehler ist gesetzt
                    fakten_map, verworfen = res
                    # Verworfene (unbelegbare) Subs aus roh streichen — ZUERST (Resume-robust), dann
                    # fakten.json. So sehen Stufen/Relevanz/Gliederung/Fragen/Guide sie nicht mehr.
                    if verworfen:
                        for bt, sns in verworfen.items():
                            if bt in roh:
                                roh[bt] = [s for s in roh[bt] if _norm_titel(s) not in sns]
                        roh = {bt: subs for bt, subs in roh.items() if subs}  # leere Bausteine raus (_sub_roh_schema verlangt ≥1)
                        atomic_write_json(files["sub_roh"], roh, indent=1)
                    atomic_write_json(files["fakten"], fakten_map, indent=1)
                sidecar = await _stufen_block(ctx, set_p, files, roh, instructions)
                if is_cancelled():
                    abgebrochen()
                    return
                if sidecar is None:
                    return
                # Fakten in die Sidecar-Subs mergen (DB-Spiegel + Guide-Nutzung).
                fakten_map = _json_datei(files["fakten"])
                if isinstance(fakten_map, dict):
                    for btitel, subs in sidecar.items():
                        fm = fakten_map.get(btitel, {})
                        for sub in subs:
                            if (fk := fm.get(_norm_titel(sub["titel"]))):
                                sub["fakten"] = fk
                atomic_write_json(files["sidecar"], sidecar, indent=1)

            # Block D: Relevanz je Subbaustein (relevant/rand) → in die Sidecar mergen.
            # Eigene Phase nach den Stufen; treibt das ProGuide-Format (alle Bausteine
            # mit ≥1 relevantem Subbaustein) und filtert Rand-Subs aus den Guides.
            sidecar = _json_datei(files["sidecar"])
            if _sidecar_schema(sidecar) is not None and not _relevanz_komplett(sidecar):
                relevanz_by_id = await _relevanz_block(ctx, set_p, files, sidecar, instructions)
                if is_cancelled():
                    abgebrochen()
                    return
                if relevanz_by_id is None:
                    return  # Fehler ist gesetzt
                gid = 0
                for subs in sidecar.values():
                    for sub in subs:
                        gid += 1
                        sub["relevanz"] = relevanz_by_id.get(gid, "relevant")
                atomic_write_json(files["sidecar"], sidecar, indent=1)

            # Block D.5: Gliederung (Bausteine-Artefakt) — Kapitel-Struktur über ALLE Bausteine,
            # vom Guide nur noch gelesen. Format-agnostisch; der Guide filtert je Format.
            if not _gliederung_komplett(files):
                await _gliederung_block(ctx, set_p, files, entries, instructions)
                if is_cancelled():
                    abgebrochen()
                    return

            # Block E: Frage-Muster je relevantem Subbaustein × Typ → eigenes Sidecar.
            # Zur Prüfungszeit zieht jeder Agent ein Muster ohne Zurücklegen und formuliert
            # daraus eine Frage — distinkte Saat verhindert die Doppelfragen der Live-Generierung.
            sidecar = _json_datei(files["sidecar"])
            if _sidecar_schema(sidecar) is not None and _relevanz_komplett(sidecar) and not _frage_muster_komplett(topic):
                muster = await _frage_muster_block(ctx, set_p, files, sidecar, instructions)
                if is_cancelled():
                    abgebrochen()
                    return
                if muster is None:
                    return  # Abbruch
                atomic_write_json(files["frage_muster"], muster, indent=1)

            # Block F: Lern-Artefakte (Karteikarten/Beispiele) aus den Fakten — Bonus,
            # vom Frontend präsentiert. Bricht den Lauf nicht ab (Artefakte sind optional).
            sidecar = _json_datei(files["sidecar"])
            if _sidecar_schema(sidecar) is not None and not _artefakte_komplett(files):
                artefakte = await _artefakte_block(ctx, set_p, files, sidecar, instructions)
                if is_cancelled():
                    abgebrochen()
                    return
                if artefakte is None:
                    return  # Abbruch (Fehler/Cancel)

            # DB-Spiegel (Brücke): finalen Sidecar- + Frage-Muster-Stand in die DB schreiben.
            sidecar = _json_datei(files["sidecar"])
            if _sidecar_schema(sidecar) is not None:
                await _mirror_sidecar_db(topic, sidecar)
            muster = _json_datei(files["frage_muster"])
            if isinstance(muster, dict) and muster:
                await _mirror_frage_muster_db(topic, muster)
            # Gliederung (Titel-basiert, robust gegen Nummern-Drift) → DB.
            plan = _json_datei(files["gliederung"])
            if isinstance(plan, dict) and plan.get("kapitel"):
                kapitel = [
                    {"titel": ch.get("titel", "Kapitel"),
                     "bausteine": [_titel(entries[n]) for n in ch.get("nummern", []) if n in entries]}
                    for ch in plan["kapitel"]
                ]
                await db.set_gliederung(topic, json.dumps({"kapitel": kapitel}, ensure_ascii=False))
            # Artefakte → DB (Karteikarte/Beispiel je Sub, Diagramm je Baustein).
            artefakte = _json_datei(files["artefakte"])
            if isinstance(artefakte, dict) and _sidecar_schema(sidecar) is not None:
                await _mirror_artefakte_db(topic, sidecar, artefakte)
    except Exception as e:
        log.exception("[%s] Bausteine-Generierung fehlgeschlagen", topic)
        _bausteine_errors[topic] = str(e)[:2000]
    finally:
        # Kein Datei-Cleanup: Zwischendateien bleiben für Resume bzw. Nachvollziehbarkeit.
        _bausteine_progress.pop(topic, None)
        _bausteine_step.pop(topic, None)
        _bausteine_cancelled.discard(topic)
        clear_scope(f"bausteine-{topic}-")  # Scope leeren → Neustart blockiert nicht