Aktualisierung der AM-RL-Module und Retrieval-Logik

src/__init__.py

@@ -0,0 +1,15 @@
+"""Backend package.
+
+The modules in here import each other flat (`from retriever import ...`) rather
+than relative, which is what the test suite and `--app-dir src` already assume.
+Adding this directory to `sys.path` on package import makes the documented and
+deployed entrypoint `uvicorn src.app:app` resolve those same names, so the app
+starts identically whether it is imported as `src.app` or as `app`.
+"""
+
+import sys
+from pathlib import Path
+
+_SRC_DIR = str(Path(__file__).resolve().parent)
+if _SRC_DIR not in sys.path:
+    sys.path.insert(0, _SRC_DIR)

src/amrl_austauschbarkeit.py

@@ -0,0 +1,492 @@
+"""Austauschbarkeit von Darreichungsformen nachschlagen (AM-RL Anlage VII Teil A).
+
+Teil A beantwortet eine andere Frage als Teil B, und beide werden in der Offizin
+mit demselben Satz gestellt.  „Darf ich austauschen?" kann heißen:
+
+* dasselbe Präparat eines anderen Herstellers → das regelt der
+  Substitutionsausschluss, siehe `amrl_substitution`;
+* **eine andere Darreichungsform** → das regelt Teil A, und darum geht es hier.
+
+Der Zuschnitt der Daten trägt die Rechtsfolge: Jede Tabellenzeile ist eine
+**Gruppe**, deren Formen untereinander austauschbar sind — über Gruppengrenzen
+hinweg nicht.  Ambroxol steht deshalb zweimal in der Anlage, feste Formen in der
+einen Gruppe, flüssige in der anderen.  Wer beide zusammenwirft, erklärt
+Brausetabletten für gegen Sirup austauschbar.  Cetirizin steht sogar dreimal,
+zweimal davon mit einer einzigen Form: genau das ist die Aussage, dass diese
+Form mit den anderen *nicht* getauscht werden darf.
+
+Wie in `amrl_substitution` gilt: kein Retaxationsurteil, kein Raten. Zurück
+kommt der Listenstatus mit Fundstelle und Stand; was daraus für Abgabe und
+Abrechnung folgt, bleibt Sache des RAG-Teils.
+
+Die Zustände:
+
+    austauschbar             beide Formen stehen in derselben Gruppe
+    nicht_austauschbar       beide Formen stehen beim Wirkstoff, aber in
+                             verschiedenen Gruppen — die aussagekräftigste
+                             Auskunft, und ohne vollständige Liste nicht zu haben
+    form_nicht_gelistet      der Wirkstoff ist gelistet, die erfragte Form nicht
+    wirkstoff_nicht_gelistet Teil A trifft für den Wirkstoff keine Aussage
+    uebersicht               nur eine Form genannt: die Gruppe wird aufgezählt
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+# Dieselbe Anlage, dieselbe Aufgabe: einen Wirkstoffnamen erkennen, der nicht auf
+# der jeweiligen Liste steht. Die kuratierte Endungsliste wird geteilt, statt sie
+# zweimal zu pflegen und auseinanderlaufen zu lassen.
+from amrl_substitution import wirkstoff_kandidat
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+VERALTET_AB_TAGEN = 180
+
+# Fragen nach der Darreichungsform, zusätzlich zu den Austauschsignalen aus
+# `amrl_substitution`. Rein regelbasiert wie das Routing: eine Substring-Prüfung
+# entscheidet das exakt.
+FORM_SIGNALE: tuple[str, ...] = (
+    "darreichungsform",
+    "aut idem",
+    "aut-idem",
+    "statt",
+    "anstelle",
+    "umstellen",
+    "umstellung",
+)
+
+
+@dataclass(frozen=True)
+class Gruppe:
+    nr: int
+    tabelle: int
+    wirkstoffe: Tuple[str, ...]
+    applikation: Optional[str]
+    qualifier: Optional[str]
+    formen: Tuple[str, ...]
+    bedingungen: Tuple[Tuple[str, str], ...]  # (Form, Bedingung)
+
+    def label(self) -> str:
+        teile = [" / ".join(self.wirkstoffe)]
+        if self.applikation:
+            teile.append(f"[{self.applikation}]")
+        if self.qualifier:
+            teile.append(f"({self.qualifier})")
+        return " ".join(teile)
+
+
+@dataclass
+class Befund:
+    status: str
+    wirkstoff: Optional[str] = None
+    form_a: Optional[str] = None
+    form_b: Optional[str] = None
+    gruppen: List[Gruppe] = field(default_factory=list)
+    treffer_gruppe: Optional[Gruppe] = None
+    stand: str = ""
+    stand_iso: str = ""
+    veraltet: bool = False
+    alter_tage: Optional[int] = None
+    fundstelle: str = ""
+    url: str = ""
+    grund: str = ""
+
+    @property
+    def ist_belastbar(self) -> bool:
+        return self.status in {
+            "austauschbar",
+            "nicht_austauschbar",
+            "form_nicht_gelistet",
+            "wirkstoff_nicht_gelistet",
+            "uebersicht",
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "wirkstoff": self.wirkstoff,
+            "form_a": self.form_a,
+            "form_b": self.form_b,
+            "gruppen": [
+                {
+                    "nr": g.nr,
+                    "tabelle": g.tabelle,
+                    "wirkstoffe": list(g.wirkstoffe),
+                    "applikation": g.applikation,
+                    "qualifier": g.qualifier,
+                    "formen": list(g.formen),
+                }
+                for g in self.gruppen
+            ],
+            "stand": self.stand,
+            "veraltet": self.veraltet,
+            "alter_tage": self.alter_tage,
+            "fundstelle": self.fundstelle,
+            "url": self.url,
+            "grund": self.grund,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Daten
+# ---------------------------------------------------------------------------
+
+def load_liste(path: Path) -> Dict[str, Any]:
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
+        logger.warning("Austauschbarkeitsliste nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+_MONATE = {
+    "januar": 1, "februar": 2, "märz": 3, "maerz": 3, "april": 4, "mai": 5,
+    "juni": 6, "juli": 7, "august": 8, "september": 9, "oktober": 10,
+    "november": 11, "dezember": 12,
+}
+
+
+def _stand_iso(stand: str) -> str:
+    text = " ".join(str(stand or "").split())
+    treffer = re.match(r"^(\d{1,2})\.\s*([A-Za-zÄÖÜäöü]+)\s*(\d{4})$", text)
+    if treffer:
+        monat = _MONATE.get(treffer.group(2).lower())
+        if monat:
+            return f"{int(treffer.group(3)):04d}-{monat:02d}-{int(treffer.group(1)):02d}"
+    return text if re.match(r"^\d{4}-\d{2}-\d{2}$", text) else ""
+
+
+def _gruppen(daten: Dict[str, Any]) -> List[Gruppe]:
+    out: List[Gruppe] = []
+    for roh in daten.get("gruppen") or []:
+        formen = tuple(str(e.get("form") or "") for e in roh.get("darreichungsformen") or [])
+        bedingungen = tuple(
+            (str(e.get("form") or ""), str(e["bedingung"]))
+            for e in roh.get("darreichungsformen") or []
+            if e.get("bedingung")
+        )
+        out.append(
+            Gruppe(
+                nr=int(roh.get("nr") or 0),
+                tabelle=int(roh.get("tabelle") or 1),
+                wirkstoffe=tuple(str(w) for w in roh.get("wirkstoffe") or []),
+                applikation=(str(roh["applikation"]) if roh.get("applikation") else None),
+                qualifier=(str(roh["qualifier"]) if roh.get("qualifier") else None),
+                formen=formen,
+                bedingungen=bedingungen,
+            )
+        )
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Erkennung in der Frage
+# ---------------------------------------------------------------------------
+
+def _norm(text: str) -> str:
+    return " ".join(str(text or "").lower().split())
+
+
+def wirkstoff_index(gruppen: Sequence[Gruppe]) -> List[Tuple[str, str]]:
+    """(Suchbegriff, kanonischer Name), längste zuerst."""
+    paare: List[Tuple[str, str]] = []
+    for gruppe in gruppen:
+        for name in gruppe.wirkstoffe:
+            paare.append((name, name))
+            ohne = re.sub(r"\s*\([^)]*\)\s*", " ", name).strip()
+            if ohne and ohne != name:
+                paare.append((ohne, name))
+    return sorted(set(paare), key=lambda p: -len(p[0]))
+
+
+def erkannter_wirkstoff(question: str, gruppen: Sequence[Gruppe]) -> Optional[str]:
+    haystack = _norm(question)
+    for begriff, kanonisch in wirkstoff_index(gruppen):
+        if re.search(rf"(?<![\wäöüß]){re.escape(begriff.lower())}(?![\wäöüß])", haystack):
+            return kanonisch
+    return None
+
+
+def genannte_formen(question: str, gruppen: Sequence[Gruppe]) -> List[str]:
+    """Darreichungsformen aus der Frage, in der Reihenfolge ihres Auftretens.
+
+    Das Vokabular kommt aus der Anlage selbst — ein Standard Term, den Teil A
+    nirgends führt, kann auch keine Gruppenzugehörigkeit begründen.
+    """
+    haystack = _norm(question)
+    alle = {f for gruppe in gruppen for f in gruppe.formen if f}
+    treffer: List[Tuple[int, str]] = []
+    belegt: List[Tuple[int, int]] = []
+
+    for form in sorted(alle, key=len, reverse=True):
+        for match in re.finditer(re.escape(_norm(form)), haystack):
+            span = (match.start(), match.end())
+            if any(s <= span[0] and span[1] <= e for s, e in belegt):
+                continue
+            belegt.append(span)
+            treffer.append((span[0], form))
+
+    return [form for _, form in sorted(treffer)]
+
+
+def fragt_nach_darreichungsform(question: str) -> bool:
+    haystack = _norm(question)
+    return any(signal in haystack for signal in FORM_SIGNALE)
+
+
+# ---------------------------------------------------------------------------
+# Prüfung
+# ---------------------------------------------------------------------------
+
+def pruefe(
+    question: str = "",
+    *,
+    path: Path,
+    wirkstoff: Optional[str] = None,
+    formen: Optional[Sequence[str]] = None,
+    heute: Optional[date] = None,
+) -> Befund:
+    daten = load_liste(path)
+    gruppen_alle = _gruppen(daten)
+    if not gruppen_alle:
+        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")
+
+    quelle = daten.get("quelle") or {}
+    stand = str(quelle.get("stand") or "")
+    fundstelle = f"{quelle.get('dokument', 'AM-RL Anlage VII')} Teil A"
+    url = str(quelle.get("url") or "")
+
+    if not stand:
+        return Befund(status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url)
+
+    stand_iso = _stand_iso(stand)
+    alter_tage: Optional[int] = None
+    veraltet = False
+    if stand_iso:
+        try:
+            alter_tage = max(0, ((heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()).days)
+            veraltet = alter_tage > VERALTET_AB_TAGEN
+        except ValueError:
+            alter_tage = None
+
+    def _fertig(befund: Befund) -> Befund:
+        befund.stand = stand
+        befund.stand_iso = stand_iso
+        befund.alter_tage = alter_tage
+        befund.veraltet = veraltet
+        befund.fundstelle = fundstelle
+        befund.url = url
+        return befund
+
+    name = wirkstoff or erkannter_wirkstoff(question, gruppen_alle)
+    gefragte = list(formen) if formen else genannte_formen(question, gruppen_alle)
+
+    if not name:
+        # Der Wirkstoff steht nicht in Teil A. Das ist selbst eine Auskunft —
+        # aber nur, wenn überhaupt ein Wirkstoff genannt wurde. Ohne einen
+        # wäre „Teil A sagt dazu nichts" eine Aussage über eine Frage, die
+        # keinen Wirkstoff nennt; Teil A ordnet Formen immer wirkstoffbezogen zu.
+        kandidat = wirkstoff_kandidat(question)
+        if not kandidat:
+            return _fertig(Befund(status="nicht_pruefbar", grund="kein_wirkstoff_erkannt"))
+        return _fertig(
+            Befund(
+                status="wirkstoff_nicht_gelistet",
+                wirkstoff=kandidat,
+                grund="wirkstoff_nicht_in_teil_a",
+            )
+        )
+
+    passend = [g for g in gruppen_alle if name in g.wirkstoffe]
+    if not passend:
+        return _fertig(
+            Befund(status="wirkstoff_nicht_gelistet", wirkstoff=name, grund="wirkstoff_nicht_in_teil_a")
+        )
+
+    if len(gefragte) < 2:
+        if len(gefragte) == 1:
+            mit_form = [g for g in passend if gefragte[0] in g.formen]
+            if not mit_form:
+                return _fertig(
+                    Befund(
+                        status="form_nicht_gelistet",
+                        wirkstoff=name,
+                        form_a=gefragte[0],
+                        gruppen=passend,
+                        grund="form_nicht_in_den_gruppen",
+                    )
+                )
+            return _fertig(
+                Befund(status="uebersicht", wirkstoff=name, form_a=gefragte[0], gruppen=mit_form)
+            )
+        return _fertig(Befund(status="uebersicht", wirkstoff=name, gruppen=passend))
+
+    form_a, form_b = gefragte[0], gefragte[1]
+    gemeinsam = [g for g in passend if form_a in g.formen and form_b in g.formen]
+    if gemeinsam:
+        return _fertig(
+            Befund(
+                status="austauschbar",
+                wirkstoff=name,
+                form_a=form_a,
+                form_b=form_b,
+                gruppen=gemeinsam,
+                treffer_gruppe=gemeinsam[0],
+            )
+        )
+
+    hat_a = [g for g in passend if form_a in g.formen]
+    hat_b = [g for g in passend if form_b in g.formen]
+    if not hat_a or not hat_b:
+        fehlend = form_a if not hat_a else form_b
+        return _fertig(
+            Befund(
+                status="form_nicht_gelistet",
+                wirkstoff=name,
+                form_a=fehlend,
+                form_b=(form_b if not hat_a else form_a),
+                gruppen=passend,
+                grund="form_nicht_in_den_gruppen",
+            )
+        )
+
+    return _fertig(
+        Befund(
+            status="nicht_austauschbar",
+            wirkstoff=name,
+            form_a=form_a,
+            form_b=form_b,
+            gruppen=hat_a + hat_b,
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Darstellung
+# ---------------------------------------------------------------------------
+
+_EINLEITUNG = "Austauschbarkeit der Darreichungsform — deterministische Listenprüfung"
+
+
+def _gruppe_zeile(gruppe: Gruppe) -> str:
+    return f"  · {gruppe.label()}: " + ", ".join(gruppe.formen)
+
+
+def befund_block(befund: Befund) -> str:
+    if not befund.ist_belastbar:
+        return ""
+
+    zeilen: List[str] = [f"{_EINLEITUNG} ({befund.fundstelle}, Stand {befund.stand}):"]
+
+    if befund.status == "wirkstoff_nicht_gelistet":
+        zeilen.append(
+            f"Für {befund.wirkstoff} enthält Teil A keine Gruppe austauschbarer "
+            "Darreichungsformen. Ein Austausch über die Darreichungsform hinweg ist damit "
+            "nicht durch die Hinweise nach § 129 Absatz 1a Satz 1 SGB V gedeckt."
+        )
+    elif befund.status == "austauschbar":
+        gruppe = befund.treffer_gruppe
+        zeilen.append(
+            f"Ja. {befund.form_a} und {befund.form_b} stehen bei {befund.wirkstoff} in "
+            "derselben Gruppe und sind damit austauschbar."
+        )
+        if gruppe:
+            zeilen.append(f"Gruppe: {', '.join(gruppe.formen)}.")
+            if gruppe.qualifier:
+                zeilen.append(f"Die Gruppe gilt nur für: {gruppe.qualifier}.")
+            if gruppe.applikation:
+                zeilen.append(f"Applikation: {gruppe.applikation}.")
+            for form, bedingung in gruppe.bedingungen:
+                zeilen.append(f"Zu ��{form}“: {bedingung}.")
+    elif befund.status == "nicht_austauschbar":
+        zeilen.append(
+            f"Nein. {befund.form_a} und {befund.form_b} stehen bei {befund.wirkstoff} zwar "
+            "beide in Teil A, aber in verschiedenen Gruppen — und nur innerhalb einer "
+            "Gruppe sind Formen austauschbar."
+        )
+        for gruppe in befund.gruppen:
+            zeilen.append(_gruppe_zeile(gruppe))
+    elif befund.status == "form_nicht_gelistet":
+        zeilen.append(
+            f"„{befund.form_a}“ führt Teil A bei {befund.wirkstoff} nicht. Ein Austausch "
+            "gegen diese Form ist durch die Hinweise nach § 129 Absatz 1a Satz 1 SGB V "
+            "nicht gedeckt. Gelistet sind:"
+        )
+        for gruppe in befund.gruppen:
+            zeilen.append(_gruppe_zeile(gruppe))
+    else:  # uebersicht
+        anzahl = len(befund.gruppen)
+        zeilen.append(
+            f"Teil A führt {befund.wirkstoff} in {anzahl} "
+            f"{'Gruppe' if anzahl == 1 else 'Gruppen'} austauschbarer Darreichungsformen. "
+            "Austauschbar ist nur innerhalb einer Gruppe:"
+        )
+        for gruppe in befund.gruppen:
+            zeilen.append(_gruppe_zeile(gruppe))
+
+    # Nur zu den verneinenden Befunden: dort entscheidet die Vorbemerkung
+    # mit, ob eine nicht aufgeführte Bezeichnung doch erfasst ist. Bei einem
+    # klaren „austauschbar" trägt sie nichts bei und verwässert die Auskunft.
+    if befund.status in {"nicht_austauschbar", "form_nicht_gelistet", "wirkstoff_nicht_gelistet"}:
+        zeilen.append(
+            "Nicht aufgeführte Bezeichnungen sind nach der Vorbemerkung mit erfasst, soweit "
+            "sie den definitorischen Voraussetzungen der gelisteten Standard Terms "
+            "entsprechen; das ist gesondert zu prüfen."
+        )
+
+    if befund.veraltet:
+        zeilen.append(
+            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Vor einer "
+            "Entscheidung ist die geltende Fassung abzugleichen."
+        )
+    if befund.url:
+        zeilen.append(f"Quelle: {befund.url}")
+
+    return "\n".join(zeilen)
+
+
+def verdikt(befund: Befund) -> str:
+    """Die Antwort in einem Satz — nur wenn die Frage entschieden werden konnte."""
+    if befund.status == "austauschbar":
+        return (
+            f"Ja. {befund.form_a} und {befund.form_b} sind bei {befund.wirkstoff} nach Teil A "
+            f"der AM-RL-Anlage VII austauschbar (Listenprüfung oben, Stand {befund.stand})."
+        )
+    if befund.status == "nicht_austauschbar":
+        return (
+            f"Nein. {befund.form_a} und {befund.form_b} stehen bei {befund.wirkstoff} in "
+            f"verschiedenen Gruppen der AM-RL-Anlage VII Teil A und sind deshalb nicht "
+            f"austauschbar (Listenprüfung oben, Stand {befund.stand})."
+        )
+    if befund.status == "form_nicht_gelistet":
+        return (
+            f"„{befund.form_a}“ ist bei {befund.wirkstoff} in Teil A der AM-RL-Anlage VII "
+            f"nicht als austauschbare Darreichungsform geführt (Listenprüfung oben, "
+            f"Stand {befund.stand})."
+        )
+    if befund.status == "wirkstoff_nicht_gelistet":
+        return (
+            f"Für {befund.wirkstoff} trifft Teil A der AM-RL-Anlage VII keine Aussage zur "
+            f"Austauschbarkeit von Darreichungsformen (Listenprüfung oben, Stand {befund.stand})."
+        )
+    # Die Übersicht beantwortet keine Ja/Nein-Frage und ersetzt deshalb keine
+    # Kurzantwort — der Block darüber zeigt die Gruppen.
+    return ""

src/amrl_biosimilars.py

@@ -0,0 +1,588 @@
+"""Biosimilar-Zuordnung nachschlagen (AM-RL Anlage VIIa).
+
+Diese Anlage ist die einzige der erschlossenen Listen, die die **Apotheke
+unmittelbar adressiert**.  § 40c AM-RL verpflichtet sie zur Ersetzung eines
+verordneten biotechnologisch hergestellten Fertigarzneimittels, § 40b zur
+Ersetzung des zu verarbeitenden Fertigarzneimittels in parenteralen
+Zubereitungen.  Wogegen ersetzt werden darf, sagt § 40c Absatz 3: gegen ein
+Biosimilar zum verordneten Referenzarzneimittel oder gegen ein Biosimilar, das
+mit Bezug auf *dasselbe* Referenzarzneimittel zugelassen ist.  Welche
+Arzneimittel in diesem Verhältnis zueinander stehen, führt Anlage VIIa auf.
+
+Warum das ein Lookup ist und kein Retrieval: Die Zuordnung hängt an der
+Tabellenzeile.  Denosumab steht mit zwei Referenzarzneimitteln in der Anlage,
+Prolia und Xgeva, mit vollständig verschiedenen Biosimilar-Listen; Wyost gehört
+zu Xgeva.  Trastuzumab, Tocilizumab, Ustekinumab, Rituximab und Natalizumab
+trennen intravenös und subkutan ebenso.  Ein Vektor-Retrieval liefert die
+ähnlichsten Textstellen und kann diese Grenze nicht halten — es würde Prolia und
+Wyost nebeneinander zeigen, weil beide unter „Denosumab" stehen.
+
+**Der entscheidende Unterschied zu Anlage VII Teil B**: Dort trägt die
+Negativauskunft — „steht nicht auf der Liste, also nicht ausgeschlossen".  Hier
+nicht.  Die Anlage sagt über sich selbst, sie habe „keinen abschließenden
+Charakter", und aus einem Nichtvorkommen folgt deshalb nichts.  Dieses Modul
+gibt darum **nur positive Befunde** zurück: was die Liste zeigt, und zwischen
+welchen Arzneimitteln sie eine Zuordnung *ausschließt*, weil sie beide führt und
+verschiedenen Referenzarzneimitteln zuordnet.  Ein „nicht gelistet" gibt es hier
+bewusst nicht.
+
+Ebenso wenig trägt die Anlage die Ersetzungsentscheidung allein.  Sie sagt
+ausdrücklich nichts darüber, ob die Anwendungsgebiete übereinstimmen
+(§ 40b Absatz 1 Satz 2, § 40c Absatz 1 Satz 4), und § 40c Absatz 1 Satz 2 und 3
+verlangen zusätzlich identische Wirkstärke und Packungsgröße sowie — bei gleicher
+gemeldeter Darreichungsform — ein übereinstimmendes Behältnis nach
+Fachinformation.  Der Befund benennt diese Bedingungen, statt sie zu
+unterstellen.
+
+Die Zustände:
+
+    austausch_gelistet     beide Arzneimittel stehen in derselben Zeile
+    andere_referenz        beide stehen beim selben Wirkstoff, aber in
+                           verschiedenen Zeilen — die aussagekräftigste
+                           Auskunft, und ohne die vollständige Liste nicht zu
+                           haben (Prolia gegen Wyost)
+    anderer_wirkstoff      beide gelistet, aber zu verschiedenen Wirkstoffen
+    keine_biosimilars      das genannte Arzneimittel ist gelistet, seine Zeile
+                           führt aber kein Biosimilar
+    uebersicht             ein Arzneimittel genannt: die Zeile wird aufgezählt
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+# Dieselbe Aufgabe, dieselbe Schreibweise des Standes: die Datumsauswertung wird
+# geteilt statt ein drittes Mal geschrieben und auseinanderlaufen gelassen.
+from amrl_substitution import VERALTET_AB_TAGEN, _stand_iso, fragt_nach_austausch
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+# Signale zusätzlich zu denen aus `amrl_substitution`: die Frage nach einer
+# Umstellung auf ein Biosimilar wird selten mit „austauschen" gestellt.
+BIOSIMILAR_SIGNALE: tuple[str, ...] = (
+    "biosimilar",
+    "biologikum",
+    "biologika",
+    "biologisch",
+    "referenzarzneimittel",
+    "originalarzneimittel",
+    "originalpräparat",
+    "umstell",
+)
+
+
+@dataclass(frozen=True)
+class Arzneimittel:
+    name: str
+    zusatz: Optional[str] = None
+    fussnote: Optional[str] = None
+
+    def beschriftung(self) -> str:
+        return f"{self.name} ({self.zusatz})" if self.zusatz else self.name
+
+
+@dataclass(frozen=True)
+class Gruppe:
+    """Eine Tabellenzeile: ein Referenzarzneimittel mit seinen Biosimilars."""
+
+    nr: int
+    wirkstoff: str
+    applikation: Optional[str]
+    referenzen: Tuple[Arzneimittel, ...]
+    biosimilars: Tuple[Arzneimittel, ...]
+    seite: Optional[int]
+
+    def label(self) -> str:
+        namen = " / ".join(a.beschriftung() for a in self.referenzen) or "(kein Referenzarzneimittel)"
+        return f"{namen} [{self.applikation}]" if self.applikation else namen
+
+    def enthaelt(self, name: str) -> bool:
+        return any(a.name == name for a in self.referenzen + self.biosimilars)
+
+    def rolle(self, name: str) -> str:
+        if any(a.name == name for a in self.referenzen):
+            return "referenz"
+        return "biosimilar" if any(a.name == name for a in self.biosimilars) else ""
+
+
+@dataclass
+class Befund:
+    status: str
+    produkt_a: Optional[str] = None
+    produkt_b: Optional[str] = None
+    wirkstoff: Optional[str] = None
+    # referenz_biosimilar | biosimilars_untereinander | referenzen_untereinander
+    bezug: str = ""
+    gruppen: List[Gruppe] = field(default_factory=list)
+    treffer_gruppe: Optional[Gruppe] = None
+    fussnoten: Dict[str, str] = field(default_factory=dict)
+    stand: str = ""
+    stand_iso: str = ""
+    veraltet: bool = False
+    alter_tage: Optional[int] = None
+    fundstelle: str = ""
+    url: str = ""
+    grund: str = ""
+
+    @property
+    def ist_belastbar(self) -> bool:
+        return self.status in {
+            "austausch_gelistet",
+            "andere_referenz",
+            "anderer_wirkstoff",
+            "keine_biosimilars",
+            "uebersicht",
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "produkt_a": self.produkt_a,
+            "produkt_b": self.produkt_b,
+            "wirkstoff": self.wirkstoff,
+            "bezug": self.bezug,
+            "gruppen": [
+                {
+                    "nr": g.nr,
+                    "wirkstoff": g.wirkstoff,
+                    "applikation": g.applikation,
+                    "referenzarzneimittel": [a.name for a in g.referenzen],
+                    "biosimilars": [a.name for a in g.biosimilars],
+                }
+                for g in self.gruppen
+            ],
+            "stand": self.stand,
+            "veraltet": self.veraltet,
+            "alter_tage": self.alter_tage,
+            "fundstelle": self.fundstelle,
+            "url": self.url,
+            "grund": self.grund,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Daten
+# ---------------------------------------------------------------------------
+
+def load_liste(path: Path) -> Dict[str, Any]:
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
+        logger.warning("Biosimilar-Liste nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+def _arzneimittel(rohe: Sequence[Dict[str, Any]]) -> Tuple[Arzneimittel, ...]:
+    return tuple(
+        Arzneimittel(
+            name=str(eintrag.get("name") or ""),
+            zusatz=(str(eintrag["zusatz"]) if eintrag.get("zusatz") else None),
+            fussnote=(str(eintrag["fussnote"]) if eintrag.get("fussnote") else None),
+        )
+        for eintrag in rohe or []
+        if eintrag.get("name")
+    )
+
+
+def _gruppen(daten: Dict[str, Any]) -> List[Gruppe]:
+    out: List[Gruppe] = []
+    for wirkstoff in daten.get("wirkstoffe") or []:
+        for roh in wirkstoff.get("gruppen") or []:
+            out.append(
+                Gruppe(
+                    nr=int(roh.get("nr") or 0),
+                    wirkstoff=str(wirkstoff.get("wirkstoff") or ""),
+                    applikation=(str(roh["applikation"]) if roh.get("applikation") else None),
+                    referenzen=_arzneimittel(roh.get("referenzarzneimittel") or []),
+                    biosimilars=_arzneimittel(roh.get("biosimilars") or []),
+                    seite=roh.get("seite"),
+                )
+            )
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Erkennung in der Frage
+# ---------------------------------------------------------------------------
+
+def _norm(text: str) -> str:
+    return " ".join(str(text or "").lower().split())
+
+
+def produkt_index(gruppen: Sequence[Gruppe]) -> List[str]:
+    """Alle Handelsnamen der Anlage, längste zuerst.
+
+    Die Reihenfolge trägt: „Insulin aspart Sanofi" und „Tocilizumab Stada"
+    enthalten den Wirkstoffnamen, und der kürzere Treffer würde den längeren
+    verdecken.
+    """
+    namen = {a.name for g in gruppen for a in g.referenzen + g.biosimilars if a.name}
+    return sorted(namen, key=len, reverse=True)
+
+
+def erkannte_produkte(question: str, gruppen: Sequence[Gruppe]) -> List[str]:
+    """Genannte Handelsnamen in der Reihenfolge ihres Auftretens, ohne Dubletten."""
+    haystack = _norm(question)
+    treffer: List[Tuple[int, str]] = []
+    belegt: List[Tuple[int, int]] = []
+
+    for name in produkt_index(gruppen):
+        for match in re.finditer(rf"(?<![\wäöüß]){re.escape(_norm(name))}(?![\wäöüß])", haystack):
+            span = (match.start(), match.end())
+            if any(s <= span[0] and span[1] <= e for s, e in belegt):
+                continue
+            belegt.append(span)
+            treffer.append((span[0], name))
+
+    out: List[str] = []
+    for _, name in sorted(treffer):
+        if name not in out:
+            out.append(name)
+    return out
+
+
+def erkannter_wirkstoff(question: str, gruppen: Sequence[Gruppe]) -> Optional[str]:
+    haystack = _norm(question)
+    namen = sorted({g.wirkstoff for g in gruppen if g.wirkstoff}, key=len, reverse=True)
+    for name in namen:
+        if re.search(rf"(?<![\wäöüß]){re.escape(_norm(name))}(?![\wäöüß])", haystack):
+            return name
+    return None
+
+
+def fragt_nach_biosimilar(question: str) -> bool:
+    haystack = _norm(question)
+    return fragt_nach_austausch(question) or any(s in haystack for s in BIOSIMILAR_SIGNALE)
+
+
+# ---------------------------------------------------------------------------
+# Prüfung
+# ---------------------------------------------------------------------------
+
+def pruefe(
+    question: str = "",
+    *,
+    path: Path,
+    produkte: Optional[Sequence[str]] = None,
+    heute: Optional[date] = None,
+) -> Befund:
+    daten = load_liste(path)
+    gruppen_alle = _gruppen(daten)
+    if not gruppen_alle:
+        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")
+
+    quelle = daten.get("quelle") or {}
+    stand = str(quelle.get("stand") or "")
+    fundstelle = str(quelle.get("dokument") or "AM-RL Anlage VIIa")
+    url = str(quelle.get("url") or "")
+
+    if not stand:
+        return Befund(status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url)
+
+    stand_iso = _stand_iso(stand)
+    alter_tage: Optional[int] = None
+    veraltet = False
+    if stand_iso:
+        try:
+            alter_tage = max(0, ((heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()).days)
+            veraltet = alter_tage > VERALTET_AB_TAGEN
+        except ValueError:
+            alter_tage = None
+
+    def _fertig(befund: Befund) -> Befund:
+        befund.stand = stand
+        befund.stand_iso = stand_iso
+        befund.alter_tage = alter_tage
+        befund.veraltet = veraltet
+        befund.fundstelle = fundstelle
+        befund.url = url
+        befund.fussnoten = dict(daten.get("fussnoten") or {})
+        return befund
+
+    genannt = list(produkte) if produkte is not None else erkannte_produkte(question, gruppen_alle)
+
+    # Ein einzelner Handelsname ist noch keine Austauschfrage. „Wie rechne ich
+    # Humira ab?" nennt ein gelistetes Arzneimittel, will aber keine
+    # Biosimilar-Liste vorangestellt bekommen. Zwei genannte Arzneimittel sind
+    # dagegen selbst die Frage, gleich wie sie formuliert ist.
+    if len(genannt) < 2 and not fragt_nach_biosimilar(question):
+        return _fertig(Befund(status="nicht_pruefbar", grund="keine_austauschfrage"))
+
+    if not genannt:
+        wirkstoff = erkannter_wirkstoff(question, gruppen_alle)
+        if not wirkstoff:
+            # Kein Nichtvorkommen melden: die Anlage ist nach ihrer eigenen
+            # Vorbemerkung nicht abschließend, aus einer Lücke folgt nichts.
+            return _fertig(Befund(status="nicht_pruefbar", grund="kein_gelistetes_arzneimittel"))
+        passend = [g for g in gruppen_alle if g.wirkstoff == wirkstoff]
+        if not any(g.biosimilars for g in passend):
+            # Insulin human steht mit sechs Originalarzneimitteln und ohne ein
+            # einziges Biosimilar in der Anlage. Das als „Übersicht" auszugeben
+            # zählte sechs leere Zeilen auf, statt die Auskunft zu geben.
+            return _fertig(
+                Befund(status="keine_biosimilars", wirkstoff=wirkstoff, gruppen=passend)
+            )
+        return _fertig(Befund(status="uebersicht", wirkstoff=wirkstoff, gruppen=passend))
+
+    if len(genannt) == 1:
+        name = genannt[0]
+        passend = [g for g in gruppen_alle if g.enthaelt(name)]
+        mit_biosimilar = [g for g in passend if g.biosimilars]
+        if not mit_biosimilar:
+            return _fertig(
+                Befund(
+                    status="keine_biosimilars",
+                    produkt_a=name,
+                    wirkstoff=passend[0].wirkstoff,
+                    gruppen=passend,
+                    treffer_gruppe=passend[0],
+                )
+            )
+        return _fertig(
+            Befund(
+                status="uebersicht",
+                produkt_a=name,
+                wirkstoff=passend[0].wirkstoff,
+                gruppen=passend,
+                treffer_gruppe=mit_biosimilar[0],
+            )
+        )
+
+    name_a, name_b = genannt[0], genannt[1]
+    gruppen_a = [g for g in gruppen_alle if g.enthaelt(name_a)]
+    gruppen_b = [g for g in gruppen_alle if g.enthaelt(name_b)]
+    gemeinsam = [g for g in gruppen_a if g in gruppen_b]
+
+    if gemeinsam:
+        gruppe = gemeinsam[0]
+        rollen = {gruppe.rolle(name_a), gruppe.rolle(name_b)}
+        if rollen == {"referenz"}:
+            bezug = "referenzen_untereinander"
+        elif rollen == {"biosimilar"}:
+            bezug = "biosimilars_untereinander"
+        else:
+            bezug = "referenz_biosimilar"
+        return _fertig(
+            Befund(
+                status="austausch_gelistet",
+                produkt_a=name_a,
+                produkt_b=name_b,
+                wirkstoff=gruppe.wirkstoff,
+                bezug=bezug,
+                gruppen=gemeinsam,
+                treffer_gruppe=gruppe,
+            )
+        )
+
+    wirkstoffe = {g.wirkstoff for g in gruppen_a} | {g.wirkstoff for g in gruppen_b}
+    status = "andere_referenz" if len(wirkstoffe) == 1 else "anderer_wirkstoff"
+    return _fertig(
+        Befund(
+            status=status,
+            produkt_a=name_a,
+            produkt_b=name_b,
+            wirkstoff=next(iter(wirkstoffe)) if len(wirkstoffe) == 1 else None,
+            gruppen=gruppen_a[:1] + gruppen_b[:1],
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Darstellung
+# ---------------------------------------------------------------------------
+
+_EINLEITUNG = "Biosimilar-Zuordnung — deterministische Listenprüfung"
+
+# Was aus der Anlage gerade nicht folgt. Beide Sätze stehen in ihrer
+# Vorbemerkung; ohne sie liest sich ein „steht in derselben Zeile" als
+# Ersetzungsfreigabe, die die Anlage nicht erteilt.
+_VORBEHALT = (
+    "Die Anlage ordnet nur zu. Ob die Anwendungsgebiete übereinstimmen, ist ihr "
+    "ausdrücklich nicht zu entnehmen (§ 40b Absatz 1 Satz 2, § 40c Absatz 1 Satz 4); "
+    "nach § 40c Absatz 1 Satz 2 und 3 müssen außerdem Wirkstärke und Packungsgröße "
+    "identisch sein und bei gleicher gemeldeter Darreichungsform das in der "
+    "Fachinformation angegebene Behältnis übereinstimmen. Das ist am Fall zu prüfen."
+)
+_NICHT_ABSCHLIESSEND = (
+    "Die Übersicht hat nach ihrer Vorbemerkung keinen abschließenden Charakter; "
+    "aus einem Nichtvorkommen folgt deshalb nichts."
+)
+
+
+def _gruppe_zeile(gruppe: Gruppe) -> str:
+    biosimilars = ", ".join(a.beschriftung() for a in gruppe.biosimilars) or "kein Biosimilar gelistet"
+    return f"  · {gruppe.label()}: {biosimilars}"
+
+
+def _fussnoten_zeilen(befund: Befund) -> List[str]:
+    """Fußnoten der beteiligten Arzneimittel — sie tragen den Zulassungsweg.
+
+    Mixtard, Protaphane und Liprolog sind nicht nach Artikel 10 Absatz 4
+    zugelassen, sondern nach Artikel 10c unter Verwendung fremder Unterlagen.
+    Wer das für ein Biosimilar hält, verwechselt zwei Zulassungswege.
+    """
+    zeilen: List[str] = []
+    gesehen: set = set()
+    for gruppe in befund.gruppen:
+        for mittel in gruppe.referenzen + gruppe.biosimilars:
+            if not mittel.fussnote or mittel.fussnote in gesehen:
+                continue
+            text = befund.fussnoten.get(mittel.fussnote)
+            if text and text != "(nicht besetzt)":
+                gesehen.add(mittel.fussnote)
+                zeilen.append(f"Zu {mittel.name}: {text}.")
+    return zeilen
+
+
+def befund_block(befund: Befund) -> str:
+    if not befund.ist_belastbar:
+        return ""
+
+    zeilen: List[str] = [f"{_EINLEITUNG} ({befund.fundstelle}, Stand {befund.stand}):"]
+
+    if befund.status == "austausch_gelistet":
+        gruppe = befund.treffer_gruppe
+        if befund.bezug == "referenz_biosimilar":
+            zeilen.append(
+                f"{befund.produkt_a} und {befund.produkt_b} stehen bei {befund.wirkstoff} in "
+                "derselben Zeile der Anlage VIIa — als Referenzarzneimittel und als dazu "
+                "zugelassenes Biosimilar. Damit ist die Konstellation des § 40c Absatz 3 "
+                "erster Spiegelstrich (bei parenteralen Zubereitungen § 40b Absatz 3) erfüllt."
+            )
+        elif befund.bezug == "biosimilars_untereinander":
+            zeilen.append(
+                f"{befund.produkt_a} und {befund.produkt_b} sind bei {befund.wirkstoff} beide "
+                "als Biosimilar zu demselben Referenzarzneimittel gelistet. Das ist die "
+                "Konstellation des § 40c Absatz 3 zweiter Spiegelstrich."
+            )
+        else:
+            zeilen.append(
+                f"{befund.produkt_a} und {befund.produkt_b} stehen bei {befund.wirkstoff} in "
+                "derselben Zeile, beide als Original-/Referenzarzneimittel. § 40c Absatz 3 "
+                "benennt für die Ersetzung das Verhältnis von Referenzarzneimittel und "
+                "Biosimilar; für zwei Referenzarzneimittel untereinander trifft die Anlage "
+                "diese Aussage nicht."
+            )
+        if gruppe:
+            zeilen.append(_gruppe_zeile(gruppe))
+        zeilen += _fussnoten_zeilen(befund)
+        zeilen.append(_VORBEHALT)
+
+    elif befund.status == "andere_referenz":
+        zeilen.append(
+            f"{befund.produkt_a} und {befund.produkt_b} stehen bei {befund.wirkstoff} zwar beide "
+            "in der Anlage VIIa, aber in verschiedenen Zeilen — sie sind verschiedenen "
+            "Referenzarzneimitteln zugeordnet. § 40c Absatz 3 lässt die Ersetzung nur "
+            "zwischen einem Referenzarzneimittel und seinen Biosimilars sowie zwischen "
+            "Biosimilars desselben Referenzarzneimittels zu."
+        )
+        for gruppe in befund.gruppen:
+            zeilen.append(_gruppe_zeile(gruppe))
+
+    elif befund.status == "anderer_wirkstoff":
+        zeilen.append(
+            f"{befund.produkt_a} und {befund.produkt_b} sind in der Anlage VIIa "
+            "verschiedenen Wirkstoffen zugeordnet:"
+        )
+        for gruppe in befund.gruppen:
+            zeilen.append(f"  · {gruppe.wirkstoff}: {gruppe.label()}")
+
+    elif befund.status == "keine_biosimilars":
+        if befund.produkt_a:
+            zeilen.append(
+                f"{befund.produkt_a} führt die Anlage VIIa bei {befund.wirkstoff}, in seiner "
+                "Zeile steht aber kein Biosimilar. Eine Ersetzung nach § 40c Absatz 3 kommt "
+                "danach nicht in Betracht."
+            )
+        else:
+            zeilen.append(
+                f"Die Anlage VIIa führt {befund.wirkstoff}, aber zu keinem der dort genannten "
+                "Arzneimittel ein Biosimilar. Eine Ersetzung nach § 40c Absatz 3 kommt danach "
+                "nicht in Betracht."
+            )
+        for gruppe in befund.gruppen:
+            zeilen.append(_gruppe_zeile(gruppe))
+        zeilen.append(_NICHT_ABSCHLIESSEND)
+
+    else:  # uebersicht
+        anzahl = len(befund.gruppen)
+        zeilen_wort = "Zeile" if anzahl == 1 else "Zeilen"
+        if befund.produkt_a:
+            zeilen.append(
+                f"Die Anlage VIIa führt {befund.produkt_a} bei {befund.wirkstoff} in {anzahl} "
+                f"{zeilen_wort}. Zugeordnet ist immer nur innerhalb einer Zeile:"
+            )
+        else:
+            zeilen.append(
+                f"Die Anlage VIIa führt {befund.wirkstoff} in {anzahl} {zeilen_wort}. "
+                "Zugeordnet ist immer nur innerhalb einer Zeile:"
+            )
+        for gruppe in befund.gruppen:
+            zeilen.append(_gruppe_zeile(gruppe))
+        zeilen += _fussnoten_zeilen(befund)
+        zeilen.append(_VORBEHALT)
+
+    if befund.veraltet:
+        zeilen.append(
+            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Vor einer "
+            "Entscheidung ist die geltende Fassung abzugleichen."
+        )
+    if befund.url:
+        zeilen.append(f"Quelle: {befund.url}")
+
+    return "\n".join(zeilen)
+
+
+def verdikt(befund: Befund) -> str:
+    """Die Antwort in einem Satz — nur wenn die Frage entschieden werden konnte."""
+    if befund.status == "austausch_gelistet":
+        if befund.bezug == "referenzen_untereinander":
+            return (
+                f"{befund.produkt_a} und {befund.produkt_b} stehen in der AM-RL-Anlage VIIa in "
+                f"derselben Zeile, beide als Referenzarzneimittel; ein Biosimilar-Verhältnis im "
+                f"Sinne des § 40c Absatz 3 stellt die Anlage zwischen ihnen nicht fest "
+                f"(Listenprüfung oben, Stand {befund.stand})."
+            )
+        return (
+            f"{befund.produkt_a} und {befund.produkt_b} sind in der AM-RL-Anlage VIIa "
+            f"einander zugeordnet; die Ersetzung nach § 40c Absatz 3 kommt damit in Betracht, "
+            f"sofern Anwendungsgebiet, Wirkstärke, Packungsgröße und Behältnis übereinstimmen "
+            f"(Listenprüfung oben, Stand {befund.stand})."
+        )
+    if befund.status == "andere_referenz":
+        return (
+            f"Nein. {befund.produkt_a} und {befund.produkt_b} sind in der AM-RL-Anlage VIIa "
+            f"verschiedenen Referenzarzneimitteln zugeordnet; § 40c Absatz 3 deckt die "
+            f"Ersetzung zwischen ihnen nicht (Listenprüfung oben, Stand {befund.stand})."
+        )
+    if befund.status == "anderer_wirkstoff":
+        return (
+            f"Nein. {befund.produkt_a} und {befund.produkt_b} sind in der AM-RL-Anlage VIIa "
+            f"verschiedenen Wirkstoffen zugeordnet (Listenprüfung oben, Stand {befund.stand})."
+        )
+    if befund.status == "keine_biosimilars":
+        return (
+            f"Zu {befund.produkt_a or befund.wirkstoff} führt die AM-RL-Anlage VIIa kein "
+            f"Biosimilar; eine Ersetzung nach § 40c Absatz 3 kommt danach nicht in Betracht "
+            f"(Listenprüfung oben, Stand {befund.stand})."
+        )
+    # Die Übersicht beantwortet keine Ja/Nein-Frage und ersetzt deshalb keine
+    # Kurzantwort — der Block darüber zeigt die Zeilen.
+    return ""

src/amrl_lifestyle.py

@@ -0,0 +1,646 @@
+"""Lifestyle-Arzneimittel nachschlagen (AM-RL Anlage II).
+
+Arzneimittel, bei deren Anwendung eine Erhöhung der Lebensqualität im
+Vordergrund steht, sind nach § 34 Absatz 1 Satz 7 SGB V von der Versorgung
+ausgeschlossen.  Welche das sind, führt Anlage II in acht Indikationsgebieten
+auf — Abmagerungsmittel, sexuelle Dysfunktion, Nikotinabhängigkeit, Steigerung
+des sexuellen Verlangens, Haarwuchs, Aussehen und der Schlaf-Wach-Rhythmus.  In
+der Offizin sind das die Klassiker des grünen Rezepts: Viagra, Xenical,
+Propecia, Champix — und seit 2023 die GLP-1-Analoga.
+
+**Dieser Ausschluss ist härter als der der Anlage III, und das ist die
+wichtigste Auskunft dieses Moduls.**  § 16 Absatz 5 AM-RL öffnet den medizinisch
+begründeten Einzelfall ausdrücklich nur für die nach den Absätzen 1 und 2
+eingeschränkten und ausgeschlossenen Arzneimittel — also für die
+Verordnungsausschlüsse *dieser Richtlinie* nach § 92 Absatz 1 Satz 1 Halbsatz 3
+SGB V.  Anlage II ruht auf § 34 Absatz 1 Satz 7 SGB V und § 14 AM-RL, nicht auf
+§ 16.  Der Weg über den Einzelfall führt an ihr vorbei; in der Systematik der
+Anlage III ist das die Lage der Marker [1] und [2].  Ein Befund, der ihn hier
+anböte, wäre in der Sache falsch.
+
+**Der Ausschluss hängt am ATC-Code und an der Anwendung, nicht am
+Wirkstoffnamen.**  Das ist die zweite Auskunft, ohne die die erste falsch wird:
+
+    A 08 AX 02 Liraglutid                  -> ausgeschlossen (Saxenda)
+    A 10 BJ 02 (gilt nur bei der Anwendung -> nur dann (Victoza, Diabetes)
+               zur Gewichtsreduktion)
+
+Derselbe Wirkstoff, zwei Codes, zwei Rechtsfolgen.  Bei Semaglutid trägt die
+Maßgabe beide Codes — Wegovy ist ausgeschlossen, Ozempic in der Diabetestherapie
+nicht.  Bei Bupropion trennt sie Zyban von der Anwendung als Antidepressivum,
+bei Betamethasonacetat das Anwendungsgebiet Alopecia areata von jedem anderen.
+Der Befund meldet deshalb nie den bloßen Wirkstoff, sondern immer den Code mit
+seiner Maßgabe, und subsumiert nicht: ob die Anwendung im Fall vorliegt, ist
+eine ärztliche Feststellung und keine Listenauskunft.
+
+**Die Negativauskunft trägt hier nicht.**  § 14 Absatz 2 AM-RL schließt
+Lifestyle-Arzneimittel *insbesondere* aus, Absatz 3 nennt Anlage II eine
+Übersicht; das Wort abschließend, auf dem die Negativauskunft der Anlage I ruht
+(§ 12 Absatz 10 AM-RL), steht hier nirgends.  Fußnote 2 der Anlage sagt es sogar
+ausdrücklich in die andere Richtung: Arzneimittel mit *abweichenden* ATC-Codes
+desselben Wirkprinzips (4. Ebene) sind bei entsprechender Verwendung ebenfalls
+ausgeschlossen.  Aus einem Nichtvorkommen folgt deshalb keine
+Verordnungsfähigkeit — dieselbe Zurückhaltung wie bei Anlage III und VIIa.
+
+**Ein Weg führt an der Liste vorbei, und nur einer.**  Fußnote 1 hängt an der
+Überschrift zur Nikotinabhängigkeit: Versicherte mit festgestellter schwerer
+Tabakabhängigkeit haben nach § 34 Absatz 2 SGB V, § 14a AM-RL Anspruch auf eine
+einmalige Versorgung mit Arzneimitteln zur Tabakentwöhnung im Rahmen
+evidenzbasierter Programme.  Die dafür verordnungsfähigen Arzneimittel stehen in
+Anlage IIa, und die ist inzwischen ebenfalls nachschlagbar
+(`amrl_tabakentwoehnung`).  Dieses Modul löst den Wirkstoff auf — „Champix" steht
+in *seiner* Fertigarzneimittelspalte, nicht in Anlage IIa — und der Aufrufer
+reicht ihn dorthin weiter, sobald der Treffer die Nikotinabhängigkeit betrifft.
+
+Die Zustände:
+
+    ausgeschlossen             Wirkstoff steht in Anlage II, ohne Maßgabe
+    ausgeschlossen_nach_anwendung
+                               er steht dort, aber der Ausschluss ist an eine
+                               Anwendung gebunden oder von einer ausgenommen
+    nicht_gelistet             Anlage II führt ihn nicht — was für sich noch
+                               keine Verordnungsfähigkeit bedeutet
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+# Geteilt statt ein sechstes Mal geschrieben: dieselbe Standangabe, dieselbe
+# Frist, dieselbe Endungsheuristik für einen Wirkstoffnamen.
+from amrl_substitution import VERALTET_AB_TAGEN, _stand_iso, wirkstoff_kandidat
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+# Die Frage muss von der Verordnungsfähigkeit handeln. Regelbasiert wie in den
+# übrigen Listenmodulen: eine Substring-Prüfung entscheidet das exakt.
+#
+# Die Wörter Lifestyle und Lebensqualität stehen mit dabei, weil sie hier die
+# Sache selbst benennen — die Anlage heißt so.
+VERORDNUNGS_SIGNALE: Tuple[str, ...] = (
+    "verordnungsfähig",
+    "verordnungsfaehig",
+    "verordnungsausschl",
+    "erstattungsfähig",
+    "erstattungsfaehig",
+    "erstattung",
+    "ausgeschlossen",
+    "zu lasten der",
+    "kassenrezept",
+    "auf kasse",
+    "grüne rezept",
+    "grünes rezept",
+    "privatrezept",
+    "selbstzahler",
+    "darf ich verordnen",
+    "verordnet werden",
+    "lifestyle",
+    "lebensqualität",
+    "lebensqualitaet",
+)
+
+# Die Anlage beim Namen genannt. Der Ausdruck darf dabei weder Anlage III noch
+# Anlage IIa einfangen: die eine regelt Verordnungseinschränkungen, die andere
+# gerade den *Anspruch* auf Arzneimittel zur Tabakentwöhnung.
+RE_ANLAGE_II = re.compile(r"\banlage\s+ii\b(?![ia])")
+
+# Ein ATC-Code in der Frage, mit oder ohne Leerzeichen: A10BJ06, A 10 BJ 06.
+RE_ATC_FRAGE = re.compile(r"\b([A-Za-z])\s*(\d{2})\s*([A-Za-z]{2})\s*(\d{2})\b")
+
+
+@dataclass(frozen=True)
+class Code:
+    atc: str
+    massgaben: Tuple[Dict[str, str], ...]
+
+    @property
+    def unbedingt(self) -> bool:
+        return not self.massgaben
+
+
+@dataclass(frozen=True)
+class Eintrag:
+    lfd: int
+    indikationsgebiet: str
+    wirkstoff: str
+    zelle: str
+    codes: Tuple[Code, ...]
+    fertigarzneimittel: Tuple[str, ...]
+    generikaklauseln: Tuple[str, ...]
+    fussnote: Optional[str]
+    begriffe: Tuple[str, ...]
+    varianten: Tuple[str, ...]
+    seite: Optional[int]
+
+    @property
+    def massgaben(self) -> Tuple[Dict[str, str], ...]:
+        return tuple(m for c in self.codes for m in c.massgaben)
+
+    @property
+    def nach_anwendung(self) -> bool:
+        return bool(self.massgaben)
+
+    @property
+    def codes_verschieden_geregelt(self) -> bool:
+        """Tragen die Codes dieses Eintrags *verschiedene* Rechtsfolgen?
+
+        Bei Liraglutid ist genau das die Auskunft: unter A08AX02 gilt der
+        Ausschluss unbedingt, unter A10BJ02 nur bei der Anwendung zur
+        Gewichtsreduktion.
+        """
+        return (
+            len(self.codes) > 1
+            and any(c.unbedingt for c in self.codes)
+            and any(not c.unbedingt for c in self.codes)
+        )
+
+
+@dataclass
+class Befund:
+    status: str
+    gefragter_stoff: Optional[str] = None
+    treffer: List[Eintrag] = field(default_factory=list)
+    # Womit der Treffer gefunden wurde: wirkstoff | produkt | atc | gebiet.
+    ueber: str = ""
+    stand: str = ""
+    stand_iso: str = ""
+    veraltet: bool = False
+    alter_tage: Optional[int] = None
+    fundstelle: str = ""
+    url: str = ""
+    grund: str = ""
+    fussnoten: Dict[str, str] = field(default_factory=dict)
+
+    @property
+    def ist_belastbar(self) -> bool:
+        return self.status in {
+            "ausgeschlossen",
+            "ausgeschlossen_nach_anwendung",
+            "nicht_gelistet",
+        }
+
+    @property
+    def tabakentwoehnung(self) -> bool:
+        """Betrifft der Treffer das Gebiet mit dem einen Ausnahmeweg?"""
+        return any(
+            e.fussnote == "1" or e.indikationsgebiet == "Nikotinabhängigkeit"
+            for e in self.treffer
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "gefragter_stoff": self.gefragter_stoff,
+            "gefunden_ueber": self.ueber,
+            "treffer": [
+                {
+                    "wirkstoff": e.wirkstoff,
+                    "indikationsgebiet": e.indikationsgebiet,
+                    "atc": [c.atc for c in e.codes],
+                    "nach_anwendung": e.nach_anwendung,
+                    "seite": e.seite,
+                }
+                for e in self.treffer
+            ],
+            "stand": self.stand,
+            "veraltet": self.veraltet,
+            "alter_tage": self.alter_tage,
+            "fundstelle": self.fundstelle,
+            "url": self.url,
+            "grund": self.grund,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Daten
+# ---------------------------------------------------------------------------
+
+def load_liste(path: Path) -> Dict[str, Any]:
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
+        logger.warning("Anlage-II-Liste nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+def _eintraege(daten: Dict[str, Any]) -> List[Eintrag]:
+    out: List[Eintrag] = []
+    for roh in daten.get("eintraege") or []:
+        out.append(
+            Eintrag(
+                lfd=int(roh.get("lfd") or 0),
+                indikationsgebiet=str(roh.get("indikationsgebiet") or ""),
+                wirkstoff=str(roh.get("wirkstoff") or ""),
+                zelle=str(roh.get("zelle") or ""),
+                codes=tuple(
+                    Code(
+                        atc=str(c.get("atc") or ""),
+                        massgaben=tuple(c.get("massgaben") or []),
+                    )
+                    for c in roh.get("codes") or []
+                ),
+                fertigarzneimittel=tuple(str(f) for f in roh.get("fertigarzneimittel") or []),
+                generikaklauseln=tuple(str(k) for k in roh.get("generikaklauseln") or []),
+                fussnote=roh.get("fussnote"),
+                begriffe=tuple(str(b) for b in roh.get("begriffe") or []),
+                varianten=tuple(str(v) for v in roh.get("varianten") or []),
+                seite=roh.get("seite"),
+            )
+        )
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Erkennung in der Frage
+# ---------------------------------------------------------------------------
+
+def _norm(text: str) -> str:
+    return " ".join(str(text or "").lower().split())
+
+
+def _atc_norm(text: str) -> str:
+    return re.sub(r"\s+", "", str(text or "")).upper()
+
+
+def _wortgrenze(begriff: str, haystack: str) -> bool:
+    muster = rf"(?<![\wäöüß]){re.escape(_norm(begriff))}(?![\wäöüß])"
+    return re.search(muster, haystack) is not None
+
+
+def begriffsindex(eintraege: Sequence[Eintrag]) -> List[Tuple[str, str, Eintrag]]:
+    """(Suchbegriff, Art, Eintrag), längste zuerst.
+
+    Die Reihenfolge trägt: der Eintrag „Turnera diffusa Kombinationen“ darf
+    nicht vom kürzeren „Turnera diffusa“ verdeckt werden und „Nicotinell“ nicht
+    von „Nicotin“.
+    """
+    paare: List[Tuple[str, str, Eintrag]] = []
+    for eintrag in eintraege:
+        for begriff in (*eintrag.begriffe, *eintrag.varianten):
+            if begriff:
+                paare.append((begriff, "wirkstoff", eintrag))
+        # Die Fertigarzneimittel stehen in der Anlage selbst — sie zu erkennen
+        # ist Listenauskunft und keine pharmakologische Zuordnung. Die
+        # Generikaklauseln dagegen bezeichnen eine offene Klasse und taugen
+        # nicht als Suchbegriff.
+        for produkt in eintrag.fertigarzneimittel:
+            paare.append((produkt, "produkt", eintrag))
+    return sorted(paare, key=lambda p: -len(p[0]))
+
+
+def erkannte_eintraege(
+    question: str, eintraege: Sequence[Eintrag]
+) -> Tuple[Optional[str], str, List[Eintrag]]:
+    """(erkannter Begriff, Art, Einträge dazu) — mehrere, wenn er mehrfach steht.
+
+    Turnera diffusa steht unter der sexuellen Dysfunktion *und* unter der
+    Steigerung des sexuellen Verlangens, mit verschiedenen Fertigarzneimitteln.
+    Nur eines davon zu zeigen unterschlüge die halbe Regelung.
+    """
+    haystack = _norm(question)
+
+    # Der ATC-Code zuerst: er ist das, worauf die Anlage zeigt, und eindeutiger
+    # als jeder Name.
+    codes = {_atc_norm("".join(t)) for t in RE_ATC_FRAGE.findall(question or "")}
+    if codes:
+        treffer = [e for e in eintraege if any(_atc_norm(c.atc) in codes for c in e.codes)]
+        if treffer:
+            gefragt = next(
+                c.atc for e in treffer for c in e.codes if _atc_norm(c.atc) in codes
+            )
+            return gefragt, "atc", treffer
+
+    for begriff, art, _ in begriffsindex(eintraege):
+        if not _wortgrenze(begriff, haystack):
+            continue
+        if art == "produkt":
+            passend = [
+                e
+                for e in eintraege
+                if any(_norm(p) == _norm(begriff) for p in e.fertigarzneimittel)
+            ]
+        else:
+            passend = [
+                e
+                for e in eintraege
+                if any(_norm(b) == _norm(begriff) for b in (*e.begriffe, *e.varianten))
+            ]
+        return begriff, art, passend
+    return None, "", []
+
+
+def erkanntes_gebiet(
+    question: str, daten: Dict[str, Any], eintraege: Sequence[Eintrag]
+) -> Tuple[Optional[str], List[Eintrag]]:
+    """Ein Indikationsgebiet in der Frage, etwa die Raucherentwöhnung.
+
+    Die zweite Zugangsart neben dem Stoff. Sie ist gröber und steht deshalb
+    hinter ihm: wer nach Sildenafil fragt, will den Eintrag und nicht alle
+    vierzehn Zeilen der sexuellen Dysfunktion.
+    """
+    haystack = _norm(question)
+    kandidaten: List[Tuple[str, str]] = []
+    for gebiet in daten.get("indikationsgebiete") or []:
+        name = str(gebiet.get("name") or "")
+        for begriff in (name, *(gebiet.get("varianten") or [])):
+            if begriff:
+                kandidaten.append((str(begriff), name))
+    for begriff, name in sorted(kandidaten, key=lambda p: -len(p[0])):
+        if _wortgrenze(begriff, haystack):
+            return name, [e for e in eintraege if e.indikationsgebiet == name]
+    return None, []
+
+
+def fragt_nach_verordnungsfaehigkeit(question: str) -> bool:
+    haystack = _norm(question)
+    if RE_ANLAGE_II.search(haystack):
+        return True
+    return any(signal in haystack for signal in VERORDNUNGS_SIGNALE)
+
+
+# ---------------------------------------------------------------------------
+# Prüfung
+# ---------------------------------------------------------------------------
+
+def pruefe(
+    question: str = "",
+    *,
+    path: Path,
+    stoff: Optional[str] = None,
+    heute: Optional[date] = None,
+) -> Befund:
+    daten = load_liste(path)
+    alle = _eintraege(daten)
+    if not alle:
+        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")
+
+    quelle = daten.get("quelle") or {}
+    stand = str(quelle.get("stand") or "")
+    fundstelle = str(quelle.get("dokument") or "AM-RL Anlage II")
+    url = str(quelle.get("url") or "")
+    noten = {str(k): str(v) for k, v in (daten.get("fussnoten") or {}).items()}
+
+    if not stand:
+        return Befund(
+            status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url
+        )
+
+    stand_iso = _stand_iso(stand)
+    alter_tage: Optional[int] = None
+    veraltet = False
+    if stand_iso:
+        try:
+            alter_tage = max(
+                0,
+                ((heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()).days,
+            )
+            veraltet = alter_tage > VERALTET_AB_TAGEN
+        except ValueError:
+            alter_tage = None
+
+    def _fertig(befund: Befund) -> Befund:
+        befund.stand = stand
+        befund.stand_iso = stand_iso
+        befund.alter_tage = alter_tage
+        befund.veraltet = veraltet
+        befund.fundstelle = fundstelle
+        befund.url = url
+        befund.fussnoten = noten
+        return befund
+
+    # Ohne Bezug zur Verordnungsfähigkeit gar nichts: eine Dosierungsfrage nennt
+    # einen gelisteten Stoff, will aber keine Auskunft darüber, ob er zu Lasten
+    # der GKV verordnet werden darf.
+    if not fragt_nach_verordnungsfaehigkeit(question) and stoff is None:
+        return _fertig(Befund(status="nicht_pruefbar", grund="keine_verordnungsfrage"))
+
+    if stoff:
+        begriff, art = stoff, "wirkstoff"
+        treffer = [
+            e
+            for e in alle
+            if any(_norm(b) == _norm(stoff) for b in (*e.begriffe, *e.varianten))
+        ]
+    else:
+        begriff, art, treffer = erkannte_eintraege(question, alle)
+        if not treffer:
+            begriff, treffer = erkanntes_gebiet(question, daten, alle)
+            art = "gebiet" if treffer else ""
+
+    if treffer:
+        # Die Maßgabe eines einzigen Codes genügt, damit die Auskunft an der
+        # Anwendung hängt — und wo ein Code sie trägt und ein anderer nicht, ist
+        # gerade der Unterschied die Auskunft.
+        #
+        # Beim Indikationsgebiet gilt das *nicht*: dort stehen mehrere Zeilen
+        # nebeneinander, und die Maßgabe einer einzelnen von ihnen sagt nichts
+        # über das Gebiet. Ausgeschlossen ist es als solches (§ 34 Absatz 1
+        # Satz 8 SGB V zählt die Gebiete selbst auf); dass einzelne Zeilen enger
+        # geregelt sind, steht bei ihnen und wird im Block benannt.
+        status = (
+            "ausgeschlossen"
+            if art == "gebiet" or all(not e.nach_anwendung for e in treffer)
+            else "ausgeschlossen_nach_anwendung"
+        )
+        return _fertig(
+            Befund(status=status, gefragter_stoff=begriff, ueber=art, treffer=treffer)
+        )
+
+    # Keine Negativauskunft ins Blaue: ein Nichtvorkommen ist nur dann eine
+    # Aussage, wenn überhaupt ein Stoff genannt wurde.
+    kandidat = begriff or wirkstoff_kandidat(question)
+    if not kandidat:
+        return _fertig(Befund(status="nicht_pruefbar", grund="kein_stoff_erkannt"))
+
+    return _fertig(
+        Befund(status="nicht_gelistet", gefragter_stoff=kandidat, grund="nicht_in_anlage_ii")
+    )
+
+
+# ---------------------------------------------------------------------------
+# Darstellung
+# ---------------------------------------------------------------------------
+
+_EINLEITUNG = "Lifestyle-Arzneimittel — deterministische Listenprüfung"
+
+# Der Weg des medizinisch begründeten Einzelfalls, den Anlage III bei ihren
+# Markern 3 bis 6 offenhält, steht hier nicht offen: § 16 Absatz 5 AM-RL nennt
+# ausdrücklich nur die nach § 16 Absatz 1 und 2 ausgeschlossenen Arzneimittel.
+_KEIN_EINZELFALL = (
+    "Der Ausschluss beruht auf dem Gesetz selbst (§ 34 Absatz 1 Satz 7 SGB V, § 14 AM-RL). "
+    "Der Weg über den medizinisch begründeten Einzelfall steht nach § 16 Absatz 5 AM-RL nur "
+    "bei Ausschlüssen und Einschränkungen durch die Richtlinie nach § 16 Absatz 1 und 2 offen "
+    "und greift hier nicht."
+)
+_ANWENDUNGSVORBEHALT = (
+    "Maßgeblich ist der Wortlaut des Eintrags samt seiner Maßgabe: Der Ausschluss hängt an "
+    "der Anwendung und nicht am Wirkstoff allein. Ob die geregelte Anwendung im Fall vorliegt, "
+    "ist eine ärztliche Feststellung und keine Listenauskunft."
+)
+_CODEVORBEHALT = (
+    "Die ATC-Codes zu {wirkstoff} sind verschieden geregelt — unter dem einen gilt der "
+    "Ausschluss unbedingt, unter dem anderen nur für die genannte Anwendung. Welcher Code "
+    "einschlägig ist, entscheidet die Anwendung im konkreten Fall."
+)
+_GEBIET_MASSGABEN = (
+    "Einzelne Einträge dieses Gebietes sind enger geregelt als das Gebiet selbst; die "
+    "Maßgabe steht oben bei ihrem Wirkstoff und ist dort zu lesen."
+)
+_PRODUKTVORBEHALT = (
+    "Die Anlage führt die Fertigarzneimittel namentlich auf; maßgeblich ist aber der Wirkstoff "
+    "in der Bezeichnung der ATC-Klassifikation. Ein Fertigarzneimittel kann seinen Wirkstoff "
+    "wechseln, und die Klauseln über generische Fertigarzneimittel sind offen."
+)
+_GEBIETSVORBEHALT = (
+    "Gezeigt ist das ganze Indikationsgebiet. Ob ein konkretes Arzneimittel darunterfällt, "
+    "entscheidet sein Wirkstoff mit seinem ATC-Code."
+)
+# Fußnote 2 der Anlage. Sie ist zugleich der Beleg dafür, dass die Liste nicht
+# abschließend ist, und deshalb die Grenze jeder Negativauskunft.
+_FUSSNOTE_ATC = "Zu diesem Wirkstoff gilt zusätzlich die Fußnote 2 der Anlage: {text}"
+_TABAKENTWOEHNUNG = (
+    "Ausnahme nach Fußnote 1 der Anlage: {text} Anlage IIa ist deterministisch geprüft "
+    "(amrl_tabakentwoehnung); ihr Befund steht als eigener Block."
+)
+# Worauf die Negativauskunft *nicht* trägt.
+_GRENZE_DER_NEGATIVAUSKUNFT = (
+    "Daraus folgt allein, dass dieser Ausschlussgrund nicht greift — keine "
+    "Verordnungsfähigkeit. § 14 Absatz 2 AM-RL schließt Arzneimittel zur Erhöhung der "
+    "Lebensqualität nur insbesondere aus, und § 14 Absatz 3 nennt Anlage II eine Übersicht; "
+    "abschließend nennt sie sich nirgends. Nach ihrer Fußnote 2 sind Arzneimittel mit "
+    "abweichenden ATC-Codes desselben Wirkprinzips (4. Ebene) bei entsprechender Verwendung "
+    "ebenfalls ausgeschlossen. Zu prüfen bleiben außerdem Anlage III "
+    "(Verordnungseinschränkungen) und, bei nicht verschreibungspflichtigen Arzneimitteln, "
+    "§ 34 Absatz 1 Satz 1 SGB V mit Anlage I."
+)
+
+
+def _code_zeile(code: Code) -> str:
+    if not code.massgaben:
+        return f"    {code.atc}"
+    zusatz = "; ".join(m.get("text", "") for m in code.massgaben)
+    return f"    {code.atc} ({zusatz})"
+
+
+def _eintrag_block(eintrag: Eintrag) -> str:
+    zeilen = [f"  {eintrag.wirkstoff} — Indikationsgebiet: {eintrag.indikationsgebiet}"]
+    for code in eintrag.codes:
+        zeilen.append(_code_zeile(code))
+    if not eintrag.codes:
+        # Neun Zeilen der Anlage führen keinen ATC-Code, sondern allein den
+        # Wirkstoff (Turnera diffusa, Dexamethason; Alfatradiol).
+        zeilen.append("    ohne ATC-Code in der Anlage geführt")
+    produkte = [*eintrag.fertigarzneimittel, *eintrag.generikaklauseln]
+    if produkte:
+        zeilen.append(f"    Fertigarzneimittel: {', '.join(produkte)}")
+    return "\n".join(zeilen)
+
+
+def befund_block(befund: Befund) -> str:
+    if not befund.ist_belastbar:
+        return ""
+
+    zeilen: List[str] = [f"{_EINLEITUNG} ({befund.fundstelle}, Stand {befund.stand}):"]
+
+    if befund.status in {"ausgeschlossen", "ausgeschlossen_nach_anwendung"}:
+        anzahl = len(befund.treffer)
+        wo = "in einem Eintrag" if anzahl == 1 else f"in {anzahl} Einträgen"
+        gebiete = sorted({e.indikationsgebiet for e in befund.treffer})
+        if befund.ueber == "gebiet":
+            zeilen.append(
+                f"Das Indikationsgebiet {befund.gefragter_stoff} führt Anlage II mit {anzahl} "
+                "Einträgen; die dort geführten Arzneimittel sind nach § 34 Absatz 1 Satz 7 "
+                "SGB V von der Versorgung zu Lasten der GKV ausgeschlossen."
+            )
+        else:
+            zeilen.append(
+                f"{befund.gefragter_stoff} ist in Anlage II {wo} geführt und damit nach § 34 "
+                f"Absatz 1 Satz 7 SGB V von der Versorgung zu Lasten der GKV ausgeschlossen "
+                f"({'; '.join(gebiete)})."
+            )
+        for eintrag in befund.treffer:
+            zeilen.append(_eintrag_block(eintrag))
+
+        if befund.status == "ausgeschlossen_nach_anwendung":
+            zeilen.append(_ANWENDUNGSVORBEHALT)
+        elif befund.ueber == "gebiet" and any(e.nach_anwendung for e in befund.treffer):
+            zeilen.append(_GEBIET_MASSGABEN)
+        for eintrag in befund.treffer:
+            if eintrag.codes_verschieden_geregelt:
+                zeilen.append(_CODEVORBEHALT.format(wirkstoff=eintrag.wirkstoff))
+        zeilen.append(_KEIN_EINZELFALL)
+        if befund.tabakentwoehnung and befund.fussnoten.get("1"):
+            zeilen.append(_TABAKENTWOEHNUNG.format(text=befund.fussnoten["1"]))
+        if any(e.fussnote == "2" for e in befund.treffer) and befund.fussnoten.get("2"):
+            zeilen.append(_FUSSNOTE_ATC.format(text=befund.fussnoten["2"]))
+        if befund.ueber == "produkt":
+            zeilen.append(_PRODUKTVORBEHALT)
+        if befund.ueber == "gebiet":
+            zeilen.append(_GEBIETSVORBEHALT)
+    else:  # nicht_gelistet
+        zeilen.append(
+            f"Anlage II führt {befund.gefragter_stoff} nicht. {_GRENZE_DER_NEGATIVAUSKUNFT}"
+        )
+
+    if befund.veraltet:
+        zeilen.append(
+            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Vor einer "
+            "Entscheidung ist die geltende Fassung abzugleichen."
+        )
+    if befund.url:
+        zeilen.append(f"Quelle: {befund.url}")
+
+    return "\n".join(zeilen)
+
+
+def verdikt(befund: Befund) -> str:
+    """Die Antwort in einem Satz — nur wenn die Frage entschieden werden konnte.
+
+    Für den Zustand „nicht gelistet“ bleibt der Satz bewusst leer: die Auskunft
+    trägt hier nicht so weit wie bei Anlage I und taugt nicht als Kurzantwort.
+    Der Block oben nennt sie trotzdem, weil sie einen Ausschlussgrund ausräumt.
+    """
+    if befund.status not in {"ausgeschlossen", "ausgeschlossen_nach_anwendung"}:
+        return ""
+
+    if befund.ueber == "gebiet":
+        satz = (
+            f"Arzneimittel des Indikationsgebietes {befund.gefragter_stoff} stehen in Anlage II "
+            "der AM-RL und sind nach § 34 Absatz 1 Satz 7 SGB V von der Verordnung zu Lasten "
+            "der GKV ausgeschlossen (Lifestyle-Arzneimittel)"
+        )
+    else:
+        satz = (
+            f"{befund.gefragter_stoff} ist nach Anlage II der AM-RL von der Verordnung zu "
+            "Lasten der GKV ausgeschlossen (Lifestyle-Arzneimittel, § 34 Absatz 1 Satz 7 SGB V)"
+        )
+
+    if befund.status == "ausgeschlossen_nach_anwendung":
+        massgaben: List[str] = []
+        for eintrag in befund.treffer:
+            for massgabe in eintrag.massgaben:
+                text = massgabe.get("text", "")
+                if text and text not in massgaben:
+                    massgaben.append(text)
+        satz += f" — allerdings nur nach Maßgabe des Eintrags: {'; '.join(massgaben)}"
+    else:
+        satz += " — der medizinisch begründete Einzelfall trägt hier nicht"
+
+    return f"{satz} (Listenprüfung oben, Stand {befund.stand})."

src/amrl_otc.py

@@ -0,0 +1,415 @@
+"""OTC auf Kassenrezept nachschlagen (AM-RL Anlage I).
+
+Nicht verschreibungspflichtige Arzneimittel sind nach § 34 Absatz 1 Satz 1 SGB V
+von der Versorgung ausgeschlossen.  Ausnahmsweise verordnungsfähig sind sie,
+wenn sie bei der Behandlung schwerwiegender Erkrankungen als Therapiestandard
+gelten — und welche das sind, führt Anlage I auf.  In der Offizin ist das ein
+häufiger Retaxgrund: OTC auf Kassenrezept ist die Ausnahme.
+
+**Hier trägt die Negativauskunft — anders als bei Anlage VIIa.** § 12 Absatz 10
+der Richtlinie sagt es ausdrücklich: die Absätze 1 bis 9 regeln *abschließend*,
+unter welchen Voraussetzungen nicht verschreibungspflichtige Arzneimittel zu
+Lasten der GKV verordnungsfähig sind.  Ein „steht nicht in Anlage I" ist deshalb
+eine Auskunft und nicht bloß ein fehlender Treffer.  Genau deshalb ist es auch
+ein Lookup: ein Vektor-Retrieval liefert immer die k ähnlichsten Chunks und kann
+Abwesenheit prinzipiell nicht belegen.
+
+**Der Eintrag ist Stoff *und* Indikation, und beide gehören zusammen.**
+Lactulose ist nicht verordnungsfähig, sondern „nur zur Senkung der enteralen
+Ammoniakresorption bei Leberversagen im Zusammenhang mit der hepatischen
+Enzephalopathie".  Der Befund zitiert die Bedingung deshalb vollständig und
+subsumiert nicht — ob sie im Fall vorliegt, ist eine ärztliche Feststellung und
+keine Listenauskunft.  Dieselbe Zurückhaltung wie bei Everolimus in Teil B.
+
+**Vier Wege führen an der Liste vorbei**, und ein Befund, der sie verschweigt,
+ist falsch.  Alle vier stehen in § 12 der Richtlinie, nicht in der Anlage:
+
+    Absatz 12   Der Ausschluss gilt überhaupt nicht für Kinder bis zum
+                vollendeten 12. Lebensjahr und Jugendliche mit
+                Entwicklungsstörungen bis zum vollendeten 18. Lebensjahr.
+    Absatz 7    Begleitmedikation, wenn die Fachinformation des
+                Hauptarzneimittels sie voraussetzt.
+    Absatz 8    Behandlung schwerwiegender unerwünschter Arzneimittelwirkungen
+                eines verordnungsfähigen Arzneimittels.
+    Absatz 6    Anthroposophie und Homöopathie für die in Anlage I gelisteten
+                Indikationsgebiete.
+
+Die Zustände:
+
+    gelistet               Stoff steht in Anlage I — mit seiner Bedingung
+    gruppe_gelistet        die Anlage führt eine Stoffgruppe, kein Einzelpräparat
+                           (Abführmittel, Antihistaminika); ob das konkrete
+                           Präparat dazugehört, ist am Fall zu prüfen
+    nicht_gelistet         die Auskunft, die ein Retrieval nicht geben kann
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+# Geteilt statt ein viertes Mal geschrieben: dieselbe Standangabe, dieselbe
+# Frist, dieselbe Endungsheuristik für einen Wirkstoffnamen.
+from amrl_substitution import VERALTET_AB_TAGEN, _stand_iso, wirkstoff_kandidat
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+# Die Frage muss von der Verordnungsfähigkeit handeln. Regelbasiert wie in den
+# übrigen Listenmodulen: eine Substring-Prüfung entscheidet das exakt.
+OTC_SIGNALE: tuple[str, ...] = (
+    "otc",
+    "kassenrezept",
+    "zu lasten der",
+    "verordnungsfähig",
+    "verordnungsfaehig",
+    "verordnungsausschluss",
+    "erstattungsfähig",
+    "erstattungsfaehig",
+    "erstattung",
+    "rezeptpflichtig",
+    "verschreibungspflichtig",
+    "apothekenpflichtig",
+    "grüne rezept",
+    "grünes rezept",
+    "privatrezept",
+    "selbstzahler",
+    "auf kasse",
+)
+
+# Die Anlage beim Namen genannt. Als Substring wäre „anlage i" auch in
+# „Anlage III" enthalten — und die regelt Verordnungseinschränkungen, nicht die
+# OTC-Ausnahmen.
+RE_ANLAGE_I = re.compile(r"\banlage\s+i\b(?!i)")
+
+# Einträge, die eine Stoffgruppe führen und kein Einzelpräparat. Die Zuordnung
+# eines konkreten Präparats zur Gruppe ist eine pharmakologische Feststellung,
+# die die Anlage nicht trifft — der Befund sagt das, statt sie zu treffen.
+GRUPPENEINTRAEGE: frozenset[str] = frozenset(
+    {"1", "4", "5", "6", "7", "8", "9", "21", "22", "27", "37", "43", "46"}
+)
+
+
+@dataclass(frozen=True)
+class Eintrag:
+    nr: str
+    stoffangabe: str
+    text: str
+    spiegelstriche: Tuple[str, ...]
+    begriffe: Tuple[str, ...]
+    varianten: Tuple[str, ...]
+    seite: Optional[int]
+
+    @property
+    def ist_gruppe(self) -> bool:
+        return self.nr in GRUPPENEINTRAEGE
+
+    def volltext(self) -> str:
+        if not self.spiegelstriche:
+            return self.text
+        return self.text + "\n" + "\n".join(f"    - {s}" for s in self.spiegelstriche)
+
+
+@dataclass
+class Befund:
+    status: str
+    gefragter_stoff: Optional[str] = None
+    treffer: List[Eintrag] = field(default_factory=list)
+    stand: str = ""
+    stand_iso: str = ""
+    veraltet: bool = False
+    alter_tage: Optional[int] = None
+    fundstelle: str = ""
+    url: str = ""
+    grund: str = ""
+
+    @property
+    def ist_belastbar(self) -> bool:
+        return self.status in {"gelistet", "gruppe_gelistet", "nicht_gelistet"}
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "gefragter_stoff": self.gefragter_stoff,
+            "treffer": [
+                {"nr": e.nr, "stoffangabe": e.stoffangabe, "seite": e.seite} for e in self.treffer
+            ],
+            "stand": self.stand,
+            "veraltet": self.veraltet,
+            "alter_tage": self.alter_tage,
+            "fundstelle": self.fundstelle,
+            "url": self.url,
+            "grund": self.grund,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Daten
+# ---------------------------------------------------------------------------
+
+def load_liste(path: Path) -> Dict[str, Any]:
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
+        logger.warning("OTC-Liste nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+def _eintraege(daten: Dict[str, Any]) -> List[Eintrag]:
+    out: List[Eintrag] = []
+    for roh in daten.get("eintraege") or []:
+        if roh.get("unbesetzt"):
+            continue
+        out.append(
+            Eintrag(
+                nr=str(roh.get("nr") or ""),
+                stoffangabe=str(roh.get("stoffangabe") or ""),
+                text=str(roh.get("text") or ""),
+                spiegelstriche=tuple(str(s) for s in roh.get("spiegelstriche") or []),
+                begriffe=tuple(str(b) for b in roh.get("begriffe") or []),
+                varianten=tuple(str(v) for v in roh.get("varianten") or []),
+                seite=roh.get("seite"),
+            )
+        )
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Erkennung in der Frage
+# ---------------------------------------------------------------------------
+
+def _norm(text: str) -> str:
+    return " ".join(str(text or "").lower().split())
+
+
+def begriffsindex(eintraege: Sequence[Eintrag]) -> List[Tuple[str, Eintrag]]:
+    """(Suchbegriff, Eintrag), längste zuerst.
+
+    Die Reihenfolge trägt: „Wasserlösliche Vitamine" darf nicht vom kürzeren
+    „Vitamin" verdeckt werden, und „Eisen-(II)-Verbindungen" nicht von „Eisen".
+    """
+    paare = [(b, e) for e in eintraege for b in (*e.begriffe, *e.varianten) if b]
+    return sorted(paare, key=lambda p: -len(p[0]))
+
+
+def erkannte_eintraege(question: str, eintraege: Sequence[Eintrag]) -> Tuple[Optional[str], List[Eintrag]]:
+    """(erkannter Begriff, Einträge dazu) — mehrere, wenn der Stoff mehrfach steht.
+
+    Calciumverbindungen stehen in Nummer 11 und 12 mit verschiedenen
+    Bedingungen, Magnesiumverbindungen in 28 und 29, Folsäure in 19 und 44. Nur
+    einen davon zu zeigen unterschlüge eine Verordnungsmöglichkeit.
+    """
+    haystack = _norm(question)
+    for begriff, _ in begriffsindex(eintraege):
+        if re.search(rf"(?<![\wäöüß]){re.escape(_norm(begriff))}(?![\wäöüß])", haystack):
+            passend = [
+                e
+                for e in eintraege
+                if any(_norm(b) == _norm(begriff) for b in (*e.begriffe, *e.varianten))
+            ]
+            return begriff, passend
+    return None, []
+
+
+def fragt_nach_verordnungsfaehigkeit(question: str) -> bool:
+    haystack = _norm(question)
+    if RE_ANLAGE_I.search(haystack):
+        return True
+    return any(signal in haystack for signal in OTC_SIGNALE)
+
+
+# ---------------------------------------------------------------------------
+# Prüfung
+# ---------------------------------------------------------------------------
+
+def pruefe(
+    question: str = "",
+    *,
+    path: Path,
+    stoff: Optional[str] = None,
+    heute: Optional[date] = None,
+) -> Befund:
+    daten = load_liste(path)
+    alle = _eintraege(daten)
+    if not alle:
+        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")
+
+    quelle = daten.get("quelle") or {}
+    stand = str(quelle.get("stand") or "")
+    fundstelle = str(quelle.get("dokument") or "AM-RL Anlage I")
+    url = str(quelle.get("url") or "")
+
+    if not stand:
+        return Befund(status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url)
+
+    stand_iso = _stand_iso(stand)
+    alter_tage: Optional[int] = None
+    veraltet = False
+    if stand_iso:
+        try:
+            alter_tage = max(0, ((heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()).days)
+            veraltet = alter_tage > VERALTET_AB_TAGEN
+        except ValueError:
+            alter_tage = None
+
+    def _fertig(befund: Befund) -> Befund:
+        befund.stand = stand
+        befund.stand_iso = stand_iso
+        befund.alter_tage = alter_tage
+        befund.veraltet = veraltet
+        befund.fundstelle = fundstelle
+        befund.url = url
+        return befund
+
+    # Ohne Bezug zur Verordnungsfähigkeit gar nichts: „Wie dosiere ich Iodid?"
+    # nennt einen gelisteten Stoff, will aber keine OTC-Auskunft.
+    if not fragt_nach_verordnungsfaehigkeit(question) and stoff is None:
+        return _fertig(Befund(status="nicht_pruefbar", grund="keine_verordnungsfrage"))
+
+    if stoff:
+        begriff, treffer = stoff, [
+            e for e in alle if any(_norm(b) == _norm(stoff) for b in (*e.begriffe, *e.varianten))
+        ]
+    else:
+        begriff, treffer = erkannte_eintraege(question, alle)
+
+    if treffer:
+        gruppe = all(e.ist_gruppe for e in treffer)
+        return _fertig(
+            Befund(
+                status="gruppe_gelistet" if gruppe else "gelistet",
+                gefragter_stoff=begriff,
+                treffer=treffer,
+            )
+        )
+
+    # Keine Negativauskunft ins Blaue: „nicht in Anlage I" ist nur dann eine
+    # Aussage, wenn überhaupt ein Stoff genannt wurde. Sonst wäre es eine
+    # Aussage über eine Frage, die keinen nennt.
+    kandidat = begriff or wirkstoff_kandidat(question)
+    if not kandidat:
+        return _fertig(Befund(status="nicht_pruefbar", grund="kein_stoff_erkannt"))
+
+    return _fertig(
+        Befund(status="nicht_gelistet", gefragter_stoff=kandidat, grund="nicht_in_anlage_i")
+    )
+
+
+# ---------------------------------------------------------------------------
+# Darstellung
+# ---------------------------------------------------------------------------
+
+_EINLEITUNG = "OTC-Verordnungsfähigkeit — deterministische Listenprüfung"
+
+# Die vier Wege an der Liste vorbei. Sie stehen in § 12 der Richtlinie und nicht
+# in der Anlage; ein Befund, der nur die Liste wiedergibt, ist ohne sie falsch.
+_AUSSERHALB = (
+    "Unabhängig von dieser Liste bleibt verordnungsfähig, was § 12 der Richtlinie "
+    "gesondert regelt: für versicherte Kinder bis zum vollendeten 12. Lebensjahr und "
+    "Jugendliche mit Entwicklungsstörungen bis zum vollendeten 18. Lebensjahr gilt der "
+    "Ausschluss überhaupt nicht (Absatz 12); dazu kommen Begleitmedikation, die die "
+    "Fachinformation des Hauptarzneimittels voraussetzt (Absatz 7), die Behandlung "
+    "schwerwiegender unerwünschter Arzneimittelwirkungen (Absatz 8) und Arzneimittel der "
+    "Anthroposophie und Homöopathie für die hier gelisteten Indikationsgebiete (Absatz 6)."
+)
+_GRUPPENVORBEHALT = (
+    "Die Anlage führt hier eine Stoffgruppe und kein einzelnes Präparat. Ob das konkrete "
+    "Arzneimittel darunter fällt, ist am Fall zu prüfen — die Liste sagt es nicht."
+)
+
+
+def _eintrag_block(eintrag: Eintrag) -> str:
+    zeilen = [f"  Nummer {eintrag.nr}: {eintrag.text}"]
+    for strich in eintrag.spiegelstriche:
+        zeilen.append(f"    – {strich}")
+    return "\n".join(zeilen)
+
+
+def befund_block(befund: Befund) -> str:
+    if not befund.ist_belastbar:
+        return ""
+
+    zeilen: List[str] = [f"{_EINLEITUNG} ({befund.fundstelle}, Stand {befund.stand}):"]
+
+    if befund.status in {"gelistet", "gruppe_gelistet"}:
+        anzahl = len(befund.treffer)
+        wo = (
+            "in einem Eintrag, nur unter der dort genannten Indikation"
+            if anzahl == 1
+            else f"in {anzahl} Einträgen, jeweils nur unter der dort genannten Indikation"
+        )
+        zeilen.append(
+            f"{befund.gefragter_stoff} steht in Anlage I — {wo}. Die Verordnung zu Lasten der "
+            "GKV ist an diese Bedingung gebunden; ob sie im Fall vorliegt, ist eine ärztliche "
+            "Feststellung."
+        )
+        for eintrag in befund.treffer:
+            zeilen.append(_eintrag_block(eintrag))
+        if befund.status == "gruppe_gelistet":
+            zeilen.append(_GRUPPENVORBEHALT)
+    else:  # nicht_gelistet
+        zeilen.append(
+            f"Anlage I führt {befund.gefragter_stoff} nicht. Nicht verschreibungspflichtige "
+            "Arzneimittel sind nach § 34 Absatz 1 Satz 1 SGB V von der Versorgung "
+            "ausgeschlossen, und § 12 Absatz 10 der Richtlinie regelt abschließend, wann "
+            "ausnahmsweise verordnet werden darf. Ist das Arzneimittel nicht "
+            "verschreibungspflichtig, kommt eine Verordnung zu Lasten der GKV danach nicht "
+            "in Betracht."
+        )
+
+    zeilen.append(_AUSSERHALB)
+
+    if befund.veraltet:
+        zeilen.append(
+            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Vor einer "
+            "Entscheidung ist die geltende Fassung abzugleichen."
+        )
+    if befund.url:
+        zeilen.append(f"Quelle: {befund.url}")
+
+    return "\n".join(zeilen)
+
+
+def verdikt(befund: Befund) -> str:
+    """Die Antwort in einem Satz — nur wenn die Frage entschieden werden konnte."""
+    if befund.status == "gelistet":
+        nummern = ", ".join(e.nr for e in befund.treffer)
+        return (
+            f"{befund.gefragter_stoff} ist in Anlage I der AM-RL geführt (Nummer {nummern}) und "
+            f"damit zu Lasten der GKV verordnungsfähig, aber nur unter der dort genannten "
+            f"Indikation (Listenprüfung oben, Stand {befund.stand})."
+        )
+    if befund.status == "gruppe_gelistet":
+        nummern = ", ".join(e.nr for e in befund.treffer)
+        return (
+            f"Anlage I der AM-RL führt {befund.gefragter_stoff} als Stoffgruppe (Nummer "
+            f"{nummern}) und nur unter der dort genannten Indikation; ob das konkrete Präparat "
+            f"darunter fällt, ist am Fall zu prüfen (Listenprüfung oben, Stand {befund.stand})."
+        )
+    if befund.status == "nicht_gelistet":
+        # Der Vorbehalt der Verschreibungspflicht ist kein Hedging, sondern der
+        # Anwendungsbereich: Anlage I entscheidet nur über nicht
+        # verschreibungspflichtige Arzneimittel. Ibuprofen gibt es als beides,
+        # und ein pauschales „nicht verordnungsfähig" wäre für die 600 mg falsch.
+        return (
+            f"{befund.gefragter_stoff} steht nicht in Anlage I der AM-RL. Soweit das "
+            f"Arzneimittel nicht verschreibungspflichtig ist, kommt eine Verordnung zu Lasten "
+            f"der GKV damit nicht in Betracht — vorbehaltlich der Sonderfälle des § 12 AM-RL, "
+            f"insbesondere bei Kindern bis 12 Jahren (Listenprüfung oben, Stand {befund.stand})."
+        )
+    return ""

src/amrl_substitution.py

@@ -0,0 +1,672 @@
+"""Substitutionsausschluss nachschlagen statt danach suchen.
+
+Teil B der AM-RL-Anlage VII listet die Wirkstoffe, deren Ersetzung durch ein
+wirkstoffgleiches Arzneimittel nach § 129 Absatz 1a Satz 2 SGB V ausgeschlossen
+ist.  Diese Liste wird hier **nachgeschlagen**, nicht durchsucht, und der Grund
+ist keine Bequemlichkeit:
+
+* Die für die Apotheke entscheidende Auskunft ist häufig die *negative* — „steht
+  nicht drauf, also darf ausgetauscht werden".  Ein Vektor-Retrieval kann
+  Abwesenheit nicht belegen: es liefert immer die k ähnlichsten Treffer, und
+  „nicht gefunden" heißt dort nie „nicht enthalten".
+* Bei Wirkstoffnamen ist semantische Nähe aktiv gefährlich.  Ciclosporin und
+  Ciclopirox stehen sich im Embedding nah und haben nichts miteinander zu tun.
+
+Zwei Dinge, die dieses Modul bewusst **nicht** tut:
+
+* **Es urteilt nicht über Retaxationsrisiko.**  Zurück kommt der Listenstatus mit
+  Fundstelle — eine Normtatsache.  Welche Abgabe- und Abrechnungsfolge daraus
+  erwächst, steht im Rahmenvertrag und bleibt Sache des RAG-Teils.  Die
+  Verordnungsverantwortung des Arztes und die Prüfpflicht der Apotheke sind nicht
+  dasselbe, und ein Werkzeug, das beides vermischt, wäre fachlich falsch.
+* **Es rät nicht.**  Ein Eintrag wird nur gemeldet, wenn der Wirkstoff wörtlich
+  oder über ein kuratiertes Synonym getroffen wurde.  Fuzzy-Matching auf
+  Wirkstoffnamen ist genau der Fehler, den das Retrieval schon macht.
+
+Vier Fälle sind strikt getrennt, weil sie unterschiedliche Rechtsfolgen haben —
+ein „steht auf der Liste, also verboten" wäre bei den beiden mittleren falsch:
+
+    ausschluss                      Austausch ausgeschlossen.
+    ausschluss_bedingt              Nur unter der genannten Bedingung, z. B.
+                                    Everolimus nur bis 1 mg Wirkstoffgehalt.
+    ausschluss_zwischen_varianten   Nur zwischen den genannten Varianten, z. B.
+                                    Buprenorphin-Pflaster unterschiedlicher
+                                    Applikationshöchstdauer.  Innerhalb derselben
+                                    Variante bleibt der Austausch zulässig.
+    nicht_gelistet                  Kein gelisteter Wirkstoff in der Frage.
+
+Der `stand` ist Pflichtangabe jedes Befundes, nicht Fußnote: eine veraltete
+Liste, die selbstsicher antwortet, ist schlimmer als keine.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence
+
+from answer_schema import SHORT_ANSWER_HEADING, split_sections
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+# Ab hier gilt der Snapshot als überholt und der Befund sagt das.  Der G-BA
+# beschließt Ergänzungen unregelmäßig, in der Praxis wenige Male im Jahr; ein
+# halbes Jahr ohne Abgleich ist die Grenze, ab der eine Auskunft ohne Warnung
+# nicht mehr vertretbar ist.
+VERALTET_AB_TAGEN = 180
+
+# Die Frage muss überhaupt vom Austausch handeln.  Regelbasiert wie
+# `corpus_router`: eine Substring-Prüfung entscheidet das exakt, ein
+# Modellaufruf brächte Latenz und Nichtdeterminismus an eine Stelle, an der
+# Verlässlichkeit der ganze Zweck ist.
+AUSTAUSCH_SIGNALE: tuple[str, ...] = (
+    "aut idem",
+    "aut-idem",
+    # "tausch" statt "austausch": es trägt auch "ausgetauscht" (aus-ge-TAUSCH-t),
+    # das die längere Form verfehlt hätte.
+    "tausch",
+    "ersetzen",
+    "ersetzt",
+    "ersetzung",
+    "substitut",
+    "wirkstoffgleich",
+    "importarzneimittel",
+    "rabattvertrag",
+    "rabattarzneimittel",
+)
+
+# Darreichungsformen, die in einer Frage vorkommen können.  Gebraucht, um zu
+# erkennen, dass nach einer *anderen* Form gefragt wurde als die Liste führt:
+# Ciclosporin steht dort mit „Lösung zum Einnehmen" und „Weichkapseln" — eine
+# Infusionslösung ist davon nicht erfasst, und ein pauschales „ausgeschlossen"
+# wäre an dieser Stelle schlicht falsch.
+DARREICHUNGSFORMEN: tuple[str, ...] = (
+    "lösung zum einnehmen", "transdermale pflaster", "hartkapseln, retardiert",
+    "retardtabletten", "filmtabletten", "brausetabletten", "schmelztabletten",
+    "weichkapseln", "hartkapseln", "infusionslösung", "injektionslösung",
+    "augentropfen", "augensalbe", "zäpfchen", "suppositorien", "granulat",
+    "tabletten", "kapseln", "pflaster", "dragees", "tropfen", "salbe", "creme",
+    "gel", "saft", "sirup", "pulver", "spray", "inhalat", "ampullen",
+)
+
+# Endungen, an denen ein Wirkstoffname erkennbar ist.  Nur dafür da, eine
+# Negativauskunft konkret zu machen („für ‚Simvastatin' ist nichts gelistet")
+# statt bloß allgemein.  Eine Lücke in dieser Liste kostet nur die konkrete
+# Nennung, nie die Richtigkeit: ohne Kandidaten wird allgemeiner formuliert.
+INN_ENDUNGEN: tuple[str, ...] = (
+    "cillin", "mycin", "floxacin", "prazol", "sartan", "pril", "olol", "statin",
+    "dipin", "tidin", "azepam", "barbital", "phyllin", "codon", "morphin",
+    "fentanil", "tinib", "zumab", "ximab", "umab", "cyclin", "conazol",
+    "gliptin", "glitazon", "formin", "parin", "coumon", "xaban", "gatran",
+    "setron", "triptan", "profen", "oxicam", "olimus", "sporin", "limus",
+    "thyroxin", "valproat", "phenidat", "toin", "midon", "oxin", "pam", "zepin",
+)
+
+# Großgeschriebene Wörter, die in solchen Fragen laufend vorkommen und keine
+# Wirkstoffe sind.
+KEINE_WIRKSTOFFE: frozenset[str] = frozenset(
+    {
+        "apotheke", "arzneimittel", "fertigarzneimittel", "rabattvertrag",
+        "rabattverträge", "substitutionsausschluss", "substitutionsausschlussliste",
+        "darreichungsform", "darreichungsformen", "wirkstoff", "krankenkasse",
+        "retaxation", "verordnung", "versicherte", "anlage", "richtlinie",
+        "rahmenvertrag", "tabletten", "retardtabletten", "hartkapseln",
+        "weichkapseln", "pflaster", "kapseln", "lösung", "import",
+        "importarzneimittel", "generikum", "generika", "packung",
+    }
+)
+
+
+@dataclass(frozen=True)
+class Treffer:
+    """Ein Listeneintrag, wie er für die Antwort gebraucht wird."""
+
+    wirkstoff: str
+    darreichungsform: str
+    regel: str
+    bedingung: Optional[str]
+    hinweis: Optional[str]
+    seite: Optional[int]
+
+    @property
+    def status(self) -> str:
+        if self.regel == "ausschluss_zwischen_varianten":
+            return "ausschluss_zwischen_varianten"
+        return "ausschluss_bedingt" if self.bedingung else "ausschluss"
+
+
+@dataclass
+class Befund:
+    """Ergebnis einer Prüfung. `status` ist der Gesamtstatus über alle Treffer."""
+
+    status: str
+    gefragter_wirkstoff: Optional[str] = None
+    treffer: List[Treffer] = field(default_factory=list)
+    gefragte_darreichungsform: Optional[str] = None
+    # passend | unspezifischer | abweichend | nicht_genannt — siehe `_form_bezug`
+    form_bezug: str = "nicht_genannt"
+    stand: str = ""
+    stand_iso: str = ""
+    veraltet: bool = False
+    alter_tage: Optional[int] = None
+    fundstelle: str = ""
+    url: str = ""
+    grund: str = ""
+
+    @property
+    def ist_belastbar(self) -> bool:
+        """True, wenn der Befund eine Auskunft trägt (positiv oder negativ)."""
+        return self.status in {
+            "ausschluss",
+            "ausschluss_bedingt",
+            "ausschluss_zwischen_varianten",
+            "nicht_gelistet",
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "gefragter_wirkstoff": self.gefragter_wirkstoff,
+            "treffer": [
+                {
+                    "wirkstoff": t.wirkstoff,
+                    "darreichungsform": t.darreichungsform,
+                    "regel": t.regel,
+                    "bedingung": t.bedingung,
+                    "seite": t.seite,
+                }
+                for t in self.treffer
+            ],
+            "gefragte_darreichungsform": self.gefragte_darreichungsform,
+            "form_bezug": self.form_bezug,
+            "stand": self.stand,
+            "veraltet": self.veraltet,
+            "alter_tage": self.alter_tage,
+            "fundstelle": self.fundstelle,
+            "url": self.url,
+            "grund": self.grund,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Datenzugriff
+# ---------------------------------------------------------------------------
+
+def load_liste(path: Path) -> Dict[str, Any]:
+    """Snapshot lesen und cachen.  Eine fehlende Datei ist kein Absturz."""
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
+        logger.warning("Substitutionsausschlussliste nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+_MONATE = {
+    "januar": 1, "februar": 2, "märz": 3, "maerz": 3, "april": 4, "mai": 5,
+    "juni": 6, "juli": 7, "august": 8, "september": 9, "oktober": 10,
+    "november": 11, "dezember": 12,
+}
+
+
+def _stand_iso(stand: str) -> str:
+    """'15. Mai 2026' -> '2026-05-15'.  Leer, wenn nicht deutbar."""
+    text = " ".join(str(stand or "").split())
+    match = re.match(r"^(\d{1,2})\.\s*([A-Za-zÄÖÜäöü]+)\s*(\d{4})$", text)
+    if match:
+        monat = _MONATE.get(match.group(2).lower())
+        if monat:
+            return f"{int(match.group(3)):04d}-{monat:02d}-{int(match.group(1)):02d}"
+    match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", text)
+    return text if match else ""
+
+
+# ---------------------------------------------------------------------------
+# Erkennung in der Frage
+# ---------------------------------------------------------------------------
+
+def fragt_nach_austausch(question: str) -> bool:
+    haystack = " ".join(str(question or "").lower().split())
+    return any(signal in haystack for signal in AUSTAUSCH_SIGNALE)
+
+
+def _namen_index(daten: Dict[str, Any]) -> List[tuple[str, str]]:
+    """(suchbegriff, kanonischer Wirkstoff), längste Begriffe zuerst.
+
+    Die Sortierung entscheidet über die Richtigkeit: „Levothyroxin-Natrium +
+    Kaliumiodid (fixe Kombination)" muss vor „Levothyroxin-Natrium" geprüft
+    werden, sonst gewinnt der kürzere Name und die fixe Kombination fällt weg.
+    """
+    paare: List[tuple[str, str]] = []
+    for eintrag in daten.get("eintraege") or []:
+        name = str(eintrag.get("wirkstoff") or "").strip()
+        if not name:
+            continue
+        paare.append((name, name))
+        for synonym in eintrag.get("synonyme") or []:
+            if str(synonym).strip():
+                paare.append((str(synonym).strip(), name))
+    # Klammerzusätze sind in einer Frage nie wörtlich enthalten; der Name ohne
+    # sie bleibt trotzdem suchbar.
+    for name, kanonisch in list(paare):
+        ohne = re.sub(r"\s*\([^)]*\)\s*", " ", name).strip()
+        if ohne and ohne != name:
+            paare.append((ohne, kanonisch))
+    return sorted(set(paare), key=lambda p: -len(p[0]))
+
+
+def erkannte_wirkstoffe(question: str, daten: Dict[str, Any]) -> List[str]:
+    """Gelistete Wirkstoffe, die die Frage nennt — kanonisch, ohne Dubletten."""
+    haystack = " ".join(str(question or "").lower().split())
+    gefunden: List[str] = []
+    verbraucht: List[tuple[int, int]] = []
+
+    for begriff, kanonisch in _namen_index(daten):
+        for match in re.finditer(rf"(?<![\wäöüß]){re.escape(begriff.lower())}(?![\wäöüß])", haystack):
+            span = (match.start(), match.end())
+            # Ein längerer Name hat diese Stelle schon belegt: „Levothyroxin-
+            # Natrium" darf nicht zusätzlich als „Levothyroxin" zählen.
+            if any(s <= span[0] and span[1] <= e for s, e in verbraucht):
+                continue
+            verbraucht.append(span)
+            if kanonisch not in gefunden:
+                gefunden.append(kanonisch)
+    return gefunden
+
+
+def wirkstoff_kandidat(question: str) -> Optional[str]:
+    """Ein wirkstoffartiges Wort aus der Frage, nur zur Formulierung.
+
+    Dient allein dazu, eine Negativauskunft konkret zu benennen.  Findet die
+    Heuristik nichts, wird allgemeiner formuliert — nie falscher.
+    """
+    for wort in re.findall(r"\b([A-ZÄÖÜ][\wäöüß\-]{5,})\b", str(question or "")):
+        if wort.lower() in KEINE_WIRKSTOFFE:
+            continue
+        if wort.lower().endswith(INN_ENDUNGEN):
+            return wort
+    return None
+
+
+def genannte_darreichungsform(question: str) -> Optional[str]:
+    """Die spezifischste Darreichungsform, die die Frage nennt."""
+    haystack = " ".join(str(question or "").lower().split())
+    for form in sorted(DARREICHUNGSFORMEN, key=len, reverse=True):
+        if form in haystack:
+            return form
+    return None
+
+
+def _form_bezug(genannt: Optional[str], gelistet: Sequence[str]) -> str:
+    """Verhältnis der erfragten zur gelisteten Darreichungsform.
+
+    Drei Fälle mit verschiedener Rechtsfolge, und die Mitte ist die wichtige:
+
+    * ``passend``        — identisch, der Eintrag greift.
+    * ``unspezifischer`` — die Frage nennt „Tabletten", die Liste
+      „Retardtabletten".  Nicht dasselbe: eine unretardierte Tablette desselben
+      Wirkstoffs ist nicht vom Ausschluss erfasst.  Wird offengelegt statt
+      entschieden.
+    * ``abweichend``     — kein Bezug, z. B. Infusionslösung gegen „Lösung zum
+      Einnehmen".  Der Eintrag trägt die Frage dann nicht.
+    """
+    if not genannt:
+        return "nicht_genannt"
+
+    gefragt = " ".join(genannt.lower().split())
+    formen = [" ".join(str(f or "").lower().split()) for f in gelistet]
+
+    if any(gefragt == f for f in formen):
+        return "passend"
+    if any(gefragt in f or f in gefragt for f in formen):
+        return "unspezifischer"
+    return "abweichend"
+
+
+# ---------------------------------------------------------------------------
+# Prüfung
+# ---------------------------------------------------------------------------
+
+def pruefe(
+    question: str = "",
+    *,
+    path: Path,
+    wirkstoff: Optional[str] = None,
+    darreichungsform: Optional[str] = None,
+    kandidat: Optional[str] = None,
+    heute: Optional[date] = None,
+) -> Befund:
+    """Teil B für die Frage (oder den übergebenen Wirkstoff) nachschlagen.
+
+    `kandidat` ist ein Wirkstoffname, den ein anderer Nachschlag bereits sicher
+    erkannt hat — Teil A der Anlage führt rund 170 Wirkstoffe, Teil B zwanzig.
+    Ohne diese Übergabe könnte für „Ambroxol" keine Negativauskunft ergehen,
+    obwohl feststeht, dass es ein Wirkstoff ist: die Endungsheuristik in
+    `wirkstoff_kandidat` erkennt ihn nicht, und der Befund fiele auf
+    „nicht prüfbar" zurück, statt „steht nicht auf der Ausschlussliste" zu sagen.
+    """
+    daten = load_liste(path)
+    if not daten or not (daten.get("eintraege") or []):
+        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")
+
+    quelle = daten.get("quelle") or {}
+    stand = str(quelle.get("stand") or "")
+    stand_iso = _stand_iso(stand)
+    fundstelle = f"{quelle.get('dokument', 'AM-RL Anlage VII')} Teil B"
+    url = str(quelle.get("url") or "")
+
+    if not stand:
+        return Befund(status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url)
+
+    alter_tage: Optional[int] = None
+    veraltet = False
+    if stand_iso:
+        try:
+            gemessen = (heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()
+            alter_tage = max(0, gemessen.days)
+            veraltet = alter_tage > VERALTET_AB_TAGEN
+        except ValueError:
+            alter_tage = None
+
+    def _fertig(befund: Befund) -> Befund:
+        befund.stand = stand
+        befund.stand_iso = stand_iso
+        befund.alter_tage = alter_tage
+        befund.veraltet = veraltet
+        befund.fundstelle = fundstelle
+        befund.url = url
+        return befund
+
+    if wirkstoff:
+        namen = erkannte_wirkstoffe(wirkstoff, daten)
+        gefragt = wirkstoff.strip()
+    else:
+        if not fragt_nach_austausch(question):
+            return _fertig(Befund(status="nicht_einschlaegig", grund="frage_ohne_austauschbezug"))
+        namen = erkannte_wirkstoffe(question, daten)
+        gefragt = namen[0] if namen else (wirkstoff_kandidat(question) or (kandidat or "").strip())
+
+    if not namen:
+        if not gefragt:
+            # Ohne erkennbaren Wirkstoff gibt es nichts nachzuschlagen. Eine
+            # Auskunft „nichts gelistet" wäre hier eine Aussage über eine Frage,
+            # die gar keinen Wirkstoff nennt. Der Reichweiten-Hinweis zu den
+            # AM-RL-Anlagen greift in diesem Fall und sagt das Richtige.
+            return _fertig(Befund(status="nicht_pruefbar", grund="kein_wirkstoff_erkannt"))
+        return _fertig(
+            Befund(
+                status="nicht_gelistet",
+                gefragter_wirkstoff=gefragt,
+                grund="wirkstoff_nicht_in_teil_b",
+            )
+        )
+
+    treffer = [
+        Treffer(
+            wirkstoff=str(e.get("wirkstoff") or ""),
+            darreichungsform=str(e.get("darreichungsform") or ""),
+            regel=str(e.get("regel") or "ausschluss"),
+            bedingung=(str(e["bedingung"]) if e.get("bedingung") else None),
+            hinweis=(str(e["hinweis"]) if e.get("hinweis") else None),
+            seite=e.get("seite"),
+        )
+        for e in daten["eintraege"]
+        if str(e.get("wirkstoff") or "") in namen
+    ]
+
+    gefragte_form = darreichungsform or genannte_darreichungsform(question)
+    bezug = _form_bezug(gefragte_form, [t.darreichungsform for t in treffer])
+
+    if bezug == "passend":
+        gefragt_norm = " ".join(str(gefragte_form).lower().split())
+        treffer = [t for t in treffer if " ".join(t.darreichungsform.lower().split()) == gefragt_norm] or treffer
+
+    rangfolge = ("ausschluss", "ausschluss_bedingt", "ausschluss_zwischen_varianten")
+    status = min((t.status for t in treffer), key=rangfolge.index)
+
+    return _fertig(
+        Befund(
+            status=status,
+            gefragter_wirkstoff=namen[0],
+            treffer=treffer,
+            gefragte_darreichungsform=gefragte_form,
+            form_bezug=bezug,
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Darstellung
+# ---------------------------------------------------------------------------
+
+_EINLEITUNG = "Substitutionsausschluss — deterministische Listenprüfung"
+
+
+def _gross(text: Optional[str]) -> str:
+    """Erstes Zeichen groß. Das Formularvokabular ist kleingeschrieben, die
+    Ausgabe geht an einen Nutzer."""
+    value = str(text or "").strip()
+    return value[:1].upper() + value[1:] if value else ""
+
+
+def befund_block(befund: Befund) -> str:
+    """Der Befund als Textblock, der der Antwort vorangestellt wird.
+
+    Bewusst von Code formuliert und nicht vom Modell: der Wert dieser Prüfung
+    liegt in ihrer Verlässlichkeit, und ein Umweg über die Sprachgenerierung
+    gäbe genau die wieder her, die sie beseitigt.
+    """
+    if not befund.ist_belastbar:
+        return ""
+
+    stand = f"Stand {befund.stand}"
+    kopf = f"{_EINLEITUNG} ({befund.fundstelle}, {stand}):"
+    zeilen: List[str] = [kopf]
+
+    if befund.status == "nicht_gelistet":
+        if befund.gefragter_wirkstoff:
+            zeilen.append(
+                f"„{befund.gefragter_wirkstoff}“ ist in Teil B nicht gelistet. Ein "
+                "Substitutionsausschluss nach § 129 Absatz 1a Satz 2 SGB V besteht dafür nicht."
+            )
+        else:
+            zeilen.append(
+                "Die Frage nennt keinen der in Teil B gelisteten Wirkstoffe. Für die "
+                "genannten Arzneimittel besteht danach kein Substitutionsausschluss nach "
+                "§ 129 Absatz 1a Satz 2 SGB V."
+            )
+        zeilen.append(
+            "Die Liste ist wirkstoffbezogen: bei einem Handelsnamen ist der Wirkstoff (INN) "
+            "zu prüfen, bevor auf diese Auskunft abgestellt wird."
+        )
+    else:
+        formen = "; ".join(dict.fromkeys(t.darreichungsform for t in befund.treffer if t.darreichungsform))
+        zeilen.append(f"{befund.gefragter_wirkstoff} ist in Teil B gelistet — {formen}.")
+
+        # Die Einschränkung steht VOR der Rechtsfolge. Andersherum behauptet der
+        # Block erst einen Ausschluss und nimmt ihn im nächsten Satz zurück.
+        if befund.form_bezug == "abweichend":
+            zeilen.append(
+                f"Die Frage nennt „{_gross(befund.gefragte_darreichungsform)}“; diese Form "
+                "führt die Liste für diesen Wirkstoff nicht. Die folgende Rechtsfolge gilt "
+                "deshalb nur für die oben genannten Formen. Die Vorbemerkung zu Teil B "
+                "erfasst allerdings auch nicht aufgeführte Bezeichnungen, soweit sie den "
+                "definitorischen Voraussetzungen der gelisteten Standard Terms entsprechen; "
+                "das ist gesondert zu prüfen."
+            )
+
+        if befund.status == "ausschluss":
+            zeilen.append(
+                "Die Ersetzung durch ein wirkstoffgleiches Arzneimittel ist damit nach "
+                "§ 129 Absatz 1a Satz 2 SGB V ausgeschlossen."
+            )
+        elif befund.status == "ausschluss_bedingt":
+            bedingungen = "; ".join(dict.fromkeys(t.bedingung or "" for t in befund.treffer if t.bedingung))
+            zeilen.append(
+                "Der Ausschluss gilt nur unter der Einschränkung der Liste: "
+                f"{bedingungen}. Ob sie im konkreten Fall erfüllt ist, ist am Präparat zu prüfen."
+            )
+        else:
+            bedingungen = "; ".join(dict.fromkeys(t.bedingung or "" for t in befund.treffer if t.bedingung))
+            zeilen.append(
+                "Der Ausschluss ist hier nicht absolut: ausgeschlossen ist nur der Austausch "
+                f"zwischen unterschiedlichen Varianten — {bedingungen} Innerhalb derselben "
+                "Variante bleibt die Ersetzung zulässig."
+            )
+
+        hinweise = [t.hinweis for t in befund.treffer if t.hinweis]
+        if hinweise:
+            zeilen.append(f"Zum Wirkstoff: {hinweise[0]}.")
+
+        if befund.form_bezug == "unspezifischer":
+            zeilen.append(
+                f"Die Liste benennt die Form genauer als die Frage („{_gross(befund.gefragte_darreichungsform)}“ "
+                f"gegenüber „{formen}“). Ob das verordnete Präparat unter den gelisteten "
+                "Eintrag fällt, ist am Präparat zu prüfen."
+            )
+
+    if befund.veraltet:
+        zeilen.append(
+            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Der G-BA "
+            "ergänzt Teil B durch Beschluss; vor einer Entscheidung ist die geltende Fassung "
+            "abzugleichen."
+        )
+    if befund.url:
+        zeilen.append(f"Quelle: {befund.url}")
+
+    return "\n".join(zeilen)
+
+
+def verdikt(befund: Befund) -> str:
+    """Die Antwort auf die Frage in einem Satz, aus den Daten formuliert."""
+    if not befund.ist_belastbar:
+        return ""
+
+    if befund.status == "nicht_gelistet":
+        wer = f"„{befund.gefragter_wirkstoff}“" if befund.gefragter_wirkstoff else "Der erfragte Wirkstoff"
+        return (
+            f"{wer} steht nicht in Teil B der AM-RL-Anlage VII; ein Substitutionsausschluss "
+            f"nach § 129 Absatz 1a Satz 2 SGB V besteht dafür nicht (Listenprüfung oben, "
+            f"Stand {befund.stand})."
+        )
+
+    formen = "; ".join(dict.fromkeys(t.darreichungsform for t in befund.treffer if t.darreichungsform))
+    bedingungen = "; ".join(dict.fromkeys(t.bedingung or "" for t in befund.treffer if t.bedingung))
+
+    if befund.status == "ausschluss_zwischen_varianten":
+        kern = (
+            f"Nur eingeschränkt: {befund.gefragter_wirkstoff} ({formen}) ist in Teil B der "
+            f"AM-RL-Anlage VII gelistet, ausgeschlossen ist aber allein der Austausch "
+            f"zwischen unterschiedlichen Varianten — {bedingungen} Innerhalb derselben "
+            f"Variante bleibt die Ersetzung zulässig"
+        )
+    elif befund.status == "ausschluss_bedingt":
+        kern = (
+            f"Nur bedingt: {befund.gefragter_wirkstoff} ({formen}) ist in Teil B der "
+            f"AM-RL-Anlage VII gelistet, der Ausschluss greift jedoch nur {bedingungen}"
+        )
+    else:
+        kern = (
+            f"Nein. {befund.gefragter_wirkstoff} ({formen}) ist in Teil B der AM-RL-Anlage VII "
+            f"gelistet; die Ersetzung durch ein wirkstoffgleiches Arzneimittel ist nach "
+            f"§ 129 Absatz 1a Satz 2 SGB V ausgeschlossen"
+        )
+
+    if befund.form_bezug == "abweichend":
+        kern += (
+            f". Das gilt für die gelisteten Formen — die erfragte Form "
+            f"„{_gross(befund.gefragte_darreichungsform)}“ führt die Liste nicht"
+        )
+
+    return f"{kern} (Listenprüfung oben, Stand {befund.stand})."
+
+
+def antwort_mit_befunden(answer: str, *, bloecke: Sequence[str], verdikt: str = "") -> str:
+    """Listenbefunde voranstellen und die Kurzantwort daran angleichen.
+
+    Der gemeinsame Mechanismus für beide Teile der Anlage VII.  Warum die
+    Kurzantwort ersetzt wird und nicht nur ein Block davorgesetzt: das Modell
+    beantwortet dieselbe Frage darunter aus § 129 SGB V noch einmal und kommt
+    zur allgemeinen Regel, weil ihm die Liste fehlt, die die Ausnahme trägt.
+    Gemessen an der ersten Livefrage stand „ist ausgeschlossen" direkt über „ist
+    möglich".  Beide Sätze stimmen in ihrem Bezugsrahmen, aber nichts im Text
+    markiert den Wechsel — dieselbe Lage, die
+    `corpus_amendments.reconcile_negative_answer` für spätere
+    Änderungsvereinbarungen auflöst, und sie wird hier genauso aufgelöst.
+    """
+    vorhanden = [b for b in bloecke if b and b.strip()]
+    if not vorhanden:
+        return answer
+
+    text = (answer or "").strip()
+
+    # Das Verhältnis der beiden Teile explizit machen. Die Kurzantwort unten
+    # wird angeglichen, die übrigen Abschnitte bleiben Modelltext — und der
+    # hedgt regelmäßig ("die Quellen liefern keine direkte Antwort", gemessen
+    # bei der Ambroxol-Frage), weil ihm die Liste fehlt. Ohne diesen Satz liest
+    # sich die Einordnung als Widerruf des Befundes drei Absätze darüber.
+    if text and verdikt:
+        vorhanden = list(vorhanden)
+        vorhanden[-1] += (
+            "\n\nDie Listenprüfung entscheidet die Zugehörigkeit abschließend. Die "
+            "nachfolgenden Abschnitte geben die allgemeine Regelung wieder und stehen "
+            "unter diesem Befund."
+        )
+
+    if text and verdikt:
+        blocks = split_sections(text)
+        if any(heading == SHORT_ANSWER_HEADING for heading, _ in blocks):
+            teile: List[str] = []
+            for heading, body_lines in blocks:
+                body = "\n".join(body_lines).strip()
+                if heading is None:
+                    if body:
+                        teile.append(body)
+                elif heading == SHORT_ANSWER_HEADING:
+                    teile.append(f"{heading}:\n{verdikt}")
+                else:
+                    teile.append(f"{heading}:\n{body}" if body else f"{heading}:")
+            text = "\n\n".join(t for t in teile if t.strip())
+
+    kopf = "\n\n".join(vorhanden)
+    return f"{kopf}\n\n{text}" if text else kopf
+
+
+def in_antwort_einsetzen(answer: str, befund: Befund) -> str:
+    """Befund voranstellen und die Kurzantwort des Modells daran angleichen.
+
+    Beides gehört zusammen.  Der Block allein reicht nicht: das Modell
+    beantwortet dieselbe Frage darunter aus Rahmenvertrag und Gesetz noch einmal
+    und kommt dabei zur allgemeinen Regel („Ersetzung ist vorzunehmen, wenn …"),
+    weil ihm die Liste fehlt, die die Ausnahme trägt.  Gemessen an der ersten
+    Livefrage stand dann „ist ausgeschlossen" direkt über „ist möglich".
+
+    Beide Sätze sind in ihrem Bezugsrahmen richtig, aber nichts im Text markiert
+    den Wechsel — dieselbe Lage, die `corpus_amendments.reconcile_negative_answer`
+    für spätere Änderungsvereinbarungen auflöst, und sie wird hier genauso
+    aufgelöst: die deterministische Prüfung setzt die Kurzantwort, die übrigen
+    Abschnitte des Modells bleiben als Einordnung stehen.
+    """
+    return antwort_mit_befunden(answer, bloecke=[befund_block(befund)], verdikt=verdikt(befund))
+
+
+# Rückwärtskompatibler Name für Aufrufer, die nur den Block voranstellen wollen.
+def voranstellen(answer: str, block: str) -> str:
+    if not block:
+        return answer
+    text = (answer or "").strip()
+    return f"{block}\n\n{text}" if text else block

src/amrl_tabakentwoehnung.py

@@ -0,0 +1,529 @@
+"""Arzneimittel zur Tabakentwöhnung nachschlagen (AM-RL Anlage IIa).
+
+Anlage IIa ist die Gegenanlage zu Anlage II, und nur als Paar ergeben beide
+einen Sinn.  Anlage II schließt Arzneimittel zur Raucherentwöhnung nach § 34
+Absatz 1 Satz 7 SGB V von der Versorgung aus; Anlage IIa nimmt einen Fall davon
+wieder aus.  Versicherte mit festgestellter schwerer Tabakabhängigkeit haben
+nach § 34 Absatz 2 SGB V Anspruch auf eine **einmalige** Versorgung mit
+Arzneimitteln zur Tabakentwöhnung im Rahmen evidenzbasierter Programme, und
+welche Arzneimittel das sind, steht hier.  Fußnote 1 der Anlage II verweist auf
+genau dieses Blatt; bis dahin konnte `amrl_lifestyle` den Weg nur benennen, nicht
+einlösen.
+
+**Die Negativauskunft trägt hier — anders als bei Anlage II.**  Das ist die
+wichtigste Auskunft dieses Moduls.  Anlage II nennt sich selbst eine „Übersicht",
+und § 14 Absatz 2 AM-RL schließt „insbesondere" aus; aus einem Nichtvorkommen
+folgt dort nichts.  Anlage IIa ist das Gegenteil: § 14a Absatz 3 Satz 1 AM-RL
+sagt „Die ausnahmsweise zur Tabakentwöhnung verordnungsfähigen Arzneimittel sind
+in Anlage IIa aufgeführt", und die Vorbemerkung des Blattes wiederholt es für die
+Tabelle.  Eine Ausnahme reicht so weit, wie sie geschrieben ist.  Bupropion
+(Zyban) und Cytisin stehen in Anlage II unter der Nikotinabhängigkeit, in Anlage
+IIa aber **nicht** — für sie greift die Ausnahme nicht, und das ist eine
+belastbare Auskunft und keine Wissenslücke.  Dieselbe Lage wie bei Anlage I
+(§ 12 Absatz 10 AM-RL), nicht die von Anlage II, III und VIIa.
+
+**Die Kombinationsregel ist die praktisch entscheidende Auskunft**, und ein
+Befund, der nur die beiden Wirkstoffe nennt, lässt die Hälfte der Anlage weg:
+
+    Nicotin      Kombination mit Vareniclin ausgeschlossen; untereinander nur,
+                 wenn ein transdermales Pflaster dabei ist
+    Vareniclin   Kombination mit Nicotin ausgeschlossen
+
+Die dritte Spalte wird deshalb wörtlich mitgeführt und wörtlich gezeigt.
+
+**Das Modul entscheidet den Fall nicht.**  Die Anlage führt zwei Wirkstoffe; ob
+verordnet werden darf, hängt an zwei Feststellungen, die keine Listenauskunft
+sind: einer bestehenden schweren Tabakabhängigkeit nach den Kriterien des § 14a
+Absatz 3 AM-RL (ICD-10-GM F17.2, Fagerströmtest) und der Anwendung im Rahmen
+eines evidenzbasierten Programms, dessen Anforderungen § 14a Absatz 4 und Teil B
+der Anlage regeln.  Dazu kommt die Schranke des Gesetzes selbst: die Versorgung
+ist einmalig, erneut frühestens drei Jahre nach Abschluss der Behandlung (§ 34
+Absatz 2 Satz 2 SGB V).  Der Befund benennt alle drei und subsumiert keine davon.
+
+**Keine Fertigarzneimittel in diesem Modul.**  Anlage IIa nennt keine — sie sagt
+„alle marktverfügbaren Arzneimittel, sämtliche Wirkstärken".  Champix und
+Nicorette stehen in Anlage II, und `amrl_lifestyle` löst sie dort auf; der
+Aufrufer reicht den erkannten Wirkstoff über `stoff` herein, statt dass hier eine
+zweite Produktliste entstünde.  Das ist dieselbe Übergabe, mit der
+`amrl_substitution` den Kandidaten aus Teil A übernimmt.
+
+Die Zustände:
+
+    gelistet         Wirkstoff steht in Anlage IIa — ausnahmsweise
+                     verordnungsfähig, unter den Voraussetzungen oben
+    nicht_gelistet   Anlage IIa führt ihn nicht; die Ausnahme des § 34 Absatz 2
+                     SGB V erfasst ihn nicht, es bleibt bei dem Ausschluss
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+# Geteilt statt ein siebtes Mal geschrieben: dieselbe Standangabe, dieselbe
+# Frist, dieselbe Endungsheuristik für einen Wirkstoffnamen.
+from amrl_substitution import VERALTET_AB_TAGEN, _stand_iso, wirkstoff_kandidat
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+# Die Frage muss von der Verordnungsfähigkeit handeln — dieselbe Schranke wie in
+# den übrigen Listenmodulen. Ohne sie beantwortete eine Frage nach der Dosierung
+# eines Nicotinpflasters eine Frage nach der Erstattung.
+VERORDNUNGS_SIGNALE: Tuple[str, ...] = (
+    "verordnungsfähig",
+    "verordnungsfaehig",
+    "verordnungsausschl",
+    "erstattungsfähig",
+    "erstattungsfaehig",
+    "erstattung",
+    "ausgeschlossen",
+    "anspruch",
+    "zu lasten der",
+    "kassenrezept",
+    "auf kasse",
+    "grüne rezept",
+    "grünes rezept",
+    "privatrezept",
+    "selbstzahler",
+    "darf ich verordnen",
+    "verordnet werden",
+    "übernimmt die kasse",
+    "uebernimmt die kasse",
+)
+
+# Das Indikationsgebiet, das dieses Blatt regelt. Zweiter Zugang neben dem
+# Wirkstoff: „Welche Arzneimittel sind zur Tabakentwöhnung verordnungsfähig?"
+# nennt keinen Stoff und ist trotzdem genau die Frage der Anlage.
+GEBIET_SIGNALE: Tuple[str, ...] = (
+    "tabakentwöhnung",
+    "tabakentwoehnung",
+    "raucherentwöhnung",
+    "raucherentwoehnung",
+    "tabakabhängigkeit",
+    "tabakabhaengigkeit",
+    "nikotinabhängigkeit",
+    "nikotinabhaengigkeit",
+    "rauchstopp",
+    "rauchentwöhnung",
+    "rauchentwoehnung",
+)
+
+# Die Anlage beim Namen genannt. Der Ausdruck darf dabei weder Anlage II noch
+# Anlage III einfangen — das Gegenstück zu `amrl_lifestyle.RE_ANLAGE_II`.
+RE_ANLAGE_IIA = re.compile(r"\banlage\s+iia\b")
+
+
+@dataclass(frozen=True)
+class Eintrag:
+    lfd: int
+    wirkstoff: str
+    fertigarzneimittel: str
+    kombination: str
+    begriffe: Tuple[str, ...]
+    varianten: Tuple[str, ...]
+    seite: Optional[int]
+
+
+@dataclass
+class Befund:
+    status: str
+    gefragter_stoff: Optional[str] = None
+    treffer: List[Eintrag] = field(default_factory=list)
+    # Womit der Treffer gefunden wurde: wirkstoff | gebiet | uebergabe.
+    ueber: str = ""
+    stand: str = ""
+    stand_iso: str = ""
+    veraltet: bool = False
+    alter_tage: Optional[int] = None
+    fundstelle: str = ""
+    url: str = ""
+    grund: str = ""
+    programm: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def ist_belastbar(self) -> bool:
+        return self.status in {"gelistet", "nicht_gelistet"}
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "gefragter_stoff": self.gefragter_stoff,
+            "gefunden_ueber": self.ueber,
+            "treffer": [
+                {
+                    "wirkstoff": e.wirkstoff,
+                    "fertigarzneimittel": e.fertigarzneimittel,
+                    "kombination": e.kombination,
+                    "seite": e.seite,
+                }
+                for e in self.treffer
+            ],
+            "stand": self.stand,
+            "veraltet": self.veraltet,
+            "alter_tage": self.alter_tage,
+            "fundstelle": self.fundstelle,
+            "url": self.url,
+            "grund": self.grund,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Daten
+# ---------------------------------------------------------------------------
+
+def load_liste(path: Path) -> Dict[str, Any]:
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
+        logger.warning("Anlage-IIa-Liste nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+def _eintraege(daten: Dict[str, Any]) -> List[Eintrag]:
+    return [
+        Eintrag(
+            lfd=int(roh.get("lfd") or 0),
+            wirkstoff=str(roh.get("wirkstoff") or ""),
+            fertigarzneimittel=str(roh.get("fertigarzneimittel") or ""),
+            kombination=str(roh.get("kombination") or ""),
+            begriffe=tuple(str(b) for b in roh.get("begriffe") or []),
+            varianten=tuple(str(v) for v in roh.get("varianten") or []),
+            seite=roh.get("seite"),
+        )
+        for roh in daten.get("eintraege") or []
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Erkennung in der Frage
+# ---------------------------------------------------------------------------
+
+def _norm(text: str) -> str:
+    return " ".join(str(text or "").lower().split())
+
+
+def _wortgrenze(begriff: str, haystack: str) -> bool:
+    muster = rf"(?<![\wäöüß]){re.escape(_norm(begriff))}(?![\wäöüß])"
+    return re.search(muster, haystack) is not None
+
+
+def erkannter_stoff(
+    question: str, eintraege: Sequence[Eintrag]
+) -> Tuple[Optional[str], List[Eintrag]]:
+    """(erkannter Begriff, Einträge dazu) — über Wirkstoff oder Schreibvariante."""
+    haystack = _norm(question)
+    paare = sorted(
+        (
+            (begriff, eintrag)
+            for eintrag in eintraege
+            for begriff in (*eintrag.begriffe, *eintrag.varianten)
+            if begriff
+        ),
+        key=lambda p: -len(p[0]),
+    )
+    for begriff, eintrag in paare:
+        if _wortgrenze(begriff, haystack):
+            return begriff, [eintrag]
+    return None, []
+
+
+def fragt_nach_verordnungsfaehigkeit(question: str) -> bool:
+    haystack = _norm(question)
+    if RE_ANLAGE_IIA.search(haystack):
+        return True
+    return any(signal in haystack for signal in VERORDNUNGS_SIGNALE)
+
+
+def fragt_nach_tabakentwoehnung(question: str) -> bool:
+    haystack = _norm(question)
+    if RE_ANLAGE_IIA.search(haystack):
+        return True
+    return any(signal in haystack for signal in GEBIET_SIGNALE)
+
+
+# ---------------------------------------------------------------------------
+# Prüfung
+# ---------------------------------------------------------------------------
+
+def pruefe(
+    question: str = "",
+    *,
+    path: Path,
+    stoff: Optional[str] = None,
+    heute: Optional[date] = None,
+) -> Befund:
+    """Ist dieses Arzneimittel von der Ausnahme des § 34 Absatz 2 SGB V erfasst?
+
+    `stoff` ist die Übergabe aus `amrl_lifestyle`: dort wird „Champix" über die
+    Fertigarzneimittelspalte der Anlage II zu „Vareniclin" aufgelöst, und dieses
+    Modul bekommt den Wirkstoff, statt eine zweite Produktliste zu führen. Der
+    Aufrufer reicht ihn nur herein, wenn der Treffer die Nikotinabhängigkeit
+    betrifft — sonst beantwortete eine Frage nach Sildenafil eine Frage nach der
+    Tabakentwöhnung.
+    """
+    daten = load_liste(path)
+    alle = _eintraege(daten)
+    if not alle:
+        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")
+
+    quelle = daten.get("quelle") or {}
+    stand = str(quelle.get("stand") or "")
+    fundstelle = str(quelle.get("dokument") or "AM-RL Anlage IIa")
+    url = str(quelle.get("url") or "")
+    programm = daten.get("programm") or {}
+
+    if not stand:
+        return Befund(
+            status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url
+        )
+
+    stand_iso = _stand_iso(stand)
+    alter_tage: Optional[int] = None
+    veraltet = False
+    if stand_iso:
+        try:
+            alter_tage = max(
+                0,
+                ((heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()).days,
+            )
+            veraltet = alter_tage > VERALTET_AB_TAGEN
+        except ValueError:
+            alter_tage = None
+
+    def _fertig(befund: Befund) -> Befund:
+        befund.stand = stand
+        befund.stand_iso = stand_iso
+        befund.alter_tage = alter_tage
+        befund.veraltet = veraltet
+        befund.fundstelle = fundstelle
+        befund.url = url
+        befund.programm = programm
+        return befund
+
+    if not fragt_nach_verordnungsfaehigkeit(question) and stoff is None:
+        return _fertig(Befund(status="nicht_pruefbar", grund="keine_verordnungsfrage"))
+
+    # Der übergebene Wirkstoff zuerst: er ist bereits an Anlage II aufgelöst und
+    # trägt weiter als jede Erkennung am Fragetext.
+    if stoff:
+        treffer = [
+            e
+            for e in alle
+            if any(_norm(b) == _norm(stoff) for b in (*e.begriffe, *e.varianten))
+        ]
+        if treffer:
+            return _fertig(
+                Befund(status="gelistet", gefragter_stoff=stoff, ueber="uebergabe", treffer=treffer)
+            )
+        return _fertig(
+            Befund(
+                status="nicht_gelistet",
+                gefragter_stoff=stoff,
+                ueber="uebergabe",
+                grund="nicht_in_anlage_iia",
+            )
+        )
+
+    begriff, treffer = erkannter_stoff(question, alle)
+    if treffer:
+        return _fertig(
+            Befund(status="gelistet", gefragter_stoff=begriff, ueber="wirkstoff", treffer=treffer)
+        )
+
+    # Ohne Wirkstoff bleibt die Frage nach dem Gebiet — sie wird mit der ganzen
+    # Tabelle beantwortet, denn die ist zwei Zeilen lang.
+    if not fragt_nach_tabakentwoehnung(question):
+        return _fertig(Befund(status="nicht_pruefbar", grund="keine_tabakfrage"))
+
+    # Ein anderer Stoff, ausdrücklich zur Tabakentwöhnung: hier trägt die
+    # Negativauskunft, weil Anlage IIa die Ausnahme abschließend aufzählt.
+    #
+    # Dieser Weg ist der Rückfall, nicht der Hauptweg. Für Cytisin und Bupropion
+    # — die beiden Stoffe, bei denen die Frage praktisch entsteht — greift er
+    # nicht, weil `INN_ENDUNGEN` ihre Endungen nicht führt; beide stehen aber in
+    # Anlage II, und `amrl_lifestyle` reicht sie über `stoff` herein. Die Lücke
+    # kostet damit dasselbe wie überall, wo diese Heuristik benutzt wird: die
+    # namentliche Nennung, nicht die Richtigkeit. Statt sie zu schließen — „isin"
+    # und „ion" wären als Endungen viel zu weit und schlügen in fünf anderen
+    # Modulen durch — bleibt es bei der Gebietsauskunft, die die zwei Wirkstoffe
+    # der Anlage vollständig zeigt.
+    kandidat = wirkstoff_kandidat(question)
+    if kandidat:
+        return _fertig(
+            Befund(
+                status="nicht_gelistet",
+                gefragter_stoff=kandidat,
+                ueber="wirkstoff",
+                grund="nicht_in_anlage_iia",
+            )
+        )
+
+    return _fertig(
+        Befund(
+            status="gelistet",
+            gefragter_stoff=str((daten.get("teile") or {}).get("A") or "Tabakentwöhnung"),
+            ueber="gebiet",
+            treffer=alle,
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Darstellung
+# ---------------------------------------------------------------------------
+
+_EINLEITUNG = "Arzneimittel zur Tabakentwöhnung — deterministische Listenprüfung"
+
+# Die Ausnahme steht nie für sich. Ohne diesen Satz liest sich der Block wie ein
+# Widerspruch zu dem Block der Anlage II zwei Absätze darüber.
+_AUSNAHME = (
+    "Arzneimittel zur Raucherentwöhnung sind nach § 34 Absatz 1 Satz 7 SGB V von der "
+    "Versorgung ausgeschlossen (Anlage II). Anlage IIa ist die einzige Ausnahme davon: "
+    "Versicherte mit festgestellter schwerer Tabakabhängigkeit haben nach § 34 Absatz 2 "
+    "SGB V, § 14a AM-RL Anspruch auf eine einmalige Versorgung im Rahmen evidenzbasierter "
+    "Programme zur Tabakentwöhnung."
+)
+_VORAUSSETZUNGEN = (
+    "Die Verordnung setzt zweierlei voraus, das keine Listenauskunft ist: eine "
+    "festgestellte bestehende schwere Tabakabhängigkeit nach den Kriterien des § 14a "
+    "Absatz 3 AM-RL (ICD-10-GM F17.2 in Verbindung mit dem Fagerströmtest oder einer "
+    "Risikokonstellation) und die Anwendung im Rahmen eines evidenzbasierten Programms."
+)
+_EINMALIG = (
+    "Der Anspruch ist einmalig; eine erneute Versorgung ist frühestens drei Jahre nach "
+    "Abschluss der Behandlung möglich (§ 34 Absatz 2 Satz 2 SGB V)."
+)
+_KOMBINATION = (
+    "Die Anlage regelt auch die Kombination der Arzneimittel; die Spalte ist Teil des "
+    "Eintrags und oben wörtlich wiedergegeben."
+)
+_PROGRAMM = (
+    "Die Anforderungen an das Programm stehen über § 14a hinaus in Teil B der Anlage: {teile}. "
+    "Ob ein konkretes Programm sie erfüllt, entscheidet diese Prüfung nicht."
+)
+# Worauf die Negativauskunft trägt — und warum sie hier weiter trägt als bei
+# Anlage II.
+_GRENZE_DER_NEGATIVAUSKUNFT = (
+    "Damit greift die Ausnahme des § 34 Absatz 2 SGB V für diesen Wirkstoff nicht: nach "
+    "§ 14a Absatz 3 Satz 1 AM-RL sind die ausnahmsweise zur Tabakentwöhnung "
+    "verordnungsfähigen Arzneimittel in Anlage IIa aufgeführt, und eine Ausnahme reicht "
+    "nur so weit, wie sie geschrieben ist. Es bleibt bei dem Ausschluss nach § 34 Absatz 1 "
+    "Satz 7 SGB V, soweit der Wirkstoff in Anlage II geführt ist."
+)
+_GEBIETSVORBEHALT = (
+    "Gezeigt ist die ganze Tabelle der Anlage. Ob ein konkretes Arzneimittel darunterfällt, "
+    "entscheidet sein Wirkstoff."
+)
+
+
+def _eintrag_block(eintrag: Eintrag) -> str:
+    zeilen = [f"  {eintrag.wirkstoff}"]
+    if eintrag.fertigarzneimittel:
+        zeilen.append(f"    Fertigarzneimittel (apothekenpflichtig): {eintrag.fertigarzneimittel}")
+    if eintrag.kombination:
+        zeilen.append(f"    Kombination: {eintrag.kombination}")
+    return "\n".join(zeilen)
+
+
+def _programmteile(befund: Befund) -> str:
+    abschnitte = (befund.programm or {}).get("abschnitte") or []
+    return "; ".join(
+        f"Buchstabe {a.get('buchstabe')} — {a.get('titel')}" for a in abschnitte if a.get("titel")
+    )
+
+
+def befund_block(befund: Befund) -> str:
+    if not befund.ist_belastbar:
+        return ""
+
+    zeilen: List[str] = [f"{_EINLEITUNG} ({befund.fundstelle}, Stand {befund.stand}):"]
+
+    if befund.status == "gelistet":
+        if befund.ueber == "gebiet":
+            zeilen.append(
+                f"Anlage IIa führt {len(befund.treffer)} Wirkstoffe, die ausnahmsweise zur "
+                "Tabakentwöhnung verordnungsfähig sind."
+            )
+        else:
+            zeilen.append(
+                f"{befund.gefragter_stoff} ist in Anlage IIa geführt und damit nach § 34 "
+                "Absatz 2 SGB V ausnahmsweise zu Lasten der GKV verordnungsfähig."
+            )
+        for eintrag in befund.treffer:
+            zeilen.append(_eintrag_block(eintrag))
+        zeilen.append(_AUSNAHME)
+        zeilen.append(_VORAUSSETZUNGEN)
+        zeilen.append(_EINMALIG)
+        if any(e.kombination for e in befund.treffer):
+            zeilen.append(_KOMBINATION)
+        teile = _programmteile(befund)
+        if teile:
+            zeilen.append(_PROGRAMM.format(teile=teile))
+        if befund.ueber == "gebiet":
+            zeilen.append(_GEBIETSVORBEHALT)
+    else:  # nicht_gelistet
+        zeilen.append(f"Anlage IIa führt {befund.gefragter_stoff} nicht.")
+        zeilen.append(_GRENZE_DER_NEGATIVAUSKUNFT)
+
+    if befund.veraltet:
+        zeilen.append(
+            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Vor einer "
+            "Entscheidung ist die geltende Fassung abzugleichen."
+        )
+    if befund.url:
+        zeilen.append(f"Quelle: {befund.url}")
+
+    return "\n".join(zeilen)
+
+
+def verdikt(befund: Befund) -> str:
+    """Die Antwort in einem Satz.
+
+    Der Satz trägt beide Hälften — Ausschluss und Ausnahme —, weil keine von
+    beiden allein die Frage beantwortet. „Vareniclin ist verordnungsfähig" wäre
+    zu großzügig, „Vareniclin ist ausgeschlossen" zu streng, und beide stünden im
+    Widerspruch zu dem Block der Anlage II darüber. Aus demselben Grund steht
+    dieses Modul in `_listenverdikt` vor `amrl_lifestyle`: es sagt, was jenes
+    sagt, und die Ausnahme dazu.
+    """
+    if not befund.ist_belastbar:
+        return ""
+
+    if befund.status == "nicht_gelistet":
+        return (
+            f"{befund.gefragter_stoff} ist in Anlage IIa der AM-RL nicht aufgeführt; die "
+            "Ausnahme für die Tabakentwöhnung nach § 34 Absatz 2 SGB V erfasst den Wirkstoff "
+            f"nicht (Listenprüfung oben, Stand {befund.stand})."
+        )
+
+    if befund.ueber == "gebiet":
+        stoffe = ", ".join(e.wirkstoff for e in befund.treffer)
+        return (
+            "Arzneimittel zur Raucherentwöhnung sind nach § 34 Absatz 1 Satz 7 SGB V "
+            f"ausgeschlossen; ausnahmsweise verordnungsfähig sind nach Anlage IIa {stoffe} — "
+            "bei festgestellter schwerer Tabakabhängigkeit, einmalig und im Rahmen eines "
+            f"evidenzbasierten Programms (Listenprüfung oben, Stand {befund.stand})."
+        )
+
+    return (
+        f"{befund.gefragter_stoff} ist nach § 34 Absatz 1 Satz 7 SGB V grundsätzlich "
+        "ausgeschlossen, steht aber in Anlage IIa der AM-RL und ist deshalb ausnahmsweise "
+        "verordnungsfähig — bei festgestellter schwerer Tabakabhängigkeit, einmalig und im "
+        f"Rahmen eines evidenzbasierten Programms (Listenprüfung oben, Stand {befund.stand})."
+    )

src/amrl_verordnungsausschluss.py

@@ -0,0 +1,471 @@
+"""Verordnungseinschränkungen und -ausschlüsse nachschlagen (AM-RL Anlage III).
+
+Anlage III führt zusammen, was in der Arzneimittelversorgung ausgeschlossen oder
+nur eingeschränkt verordnungsfähig ist — 53 Nummern von „Acida" bis
+„Dipyridamol in Kombination mit Acetylsalicylsäure".  Sie ist das Gegenstück zu
+Anlage I: dort die Ausnahmen *zugunsten* der Verordnungsfähigkeit, hier die
+Einschränkungen zu ihren Lasten.
+
+**Anders als bei Anlage I trägt die Negativauskunft hier nicht.**  Anlage I ruht
+auf § 12 Absatz 10 AM-RL („regeln abschließend"); ein solcher Satz steht in
+dieser Anlage nirgends — das Wort „abschließend" kommt im ganzen Dokument nicht
+vor.  Sie ist ihrem Titel nach eine *Übersicht*, die Ausschlüsse aus mehreren
+Quellen zusammenstellt.  Aus „steht nicht in Anlage III" folgt deshalb keine
+Verordnungsfähigkeit, sondern nur, dass dieser eine Weg nicht greift.  Der
+Befund sagt das, statt es zu unterschlagen — dieselbe Zurückhaltung wie bei
+Anlage VIIa.
+
+**Die Rechtsfolge steckt in der Ziffer hinter dem Hinweis.**  Jeder Hinweis der
+rechten Spalte endet auf einen Marker [1] bis [6], der auf eine der sechs
+Rechtsgrundlagen der Vorbemerkung zeigt.  Der Unterschied ist keine Formalie:
+
+    [1] Gesetzlicher Ausschluss (§ 34 Absatz 1 Satz 6 SGB V, Bagatellen)
+    [2] Negativliste (Rechtsverordnung nach § 34 Absatz 3 SGB V)
+    [3] Ausschluss nach dieser Richtlinie
+    [4] Einschränkung nach dieser Richtlinie
+    [5] Hinweis Kinder bis 12 / Jugendliche bis 18, Gefährdungspotential
+    [6] Hinweis auf unwirtschaftliche Verordnung bei denselben Gruppen
+
+Nach § 31 Absatz 1 Satz 4 SGB V, § 16 Absatz 5 AM-RL darf die Ärztin ein
+eingeschränktes oder ausgeschlossenes Arzneimittel im medizinisch begründeten
+Einzelfall mit Begründung dennoch verordnen — aber die Vorbemerkung bindet das
+ausdrücklich an die Nummern 3 bis 6.  Bei [1] und [2] gibt es diesen Weg nicht.
+Ein Befund, der beide gleich behandelte, wäre in der einen Richtung zu streng
+und in der anderen zu großzügig.  Deshalb steht der Einzelfall nur dort, wo
+*alle* Marker einer Zeile ihn offenlassen.
+
+**Der Eintrag ist Bezeichnung *und* Ausnahme, und beide gehören zusammen.**
+Nummer 38 schließt Otologika aus — aber Ciprofloxacin bei chronisch eitriger
+Otitis media ist ausgenommen.  Ein Befund, der nur die Bezeichnung meldet, sagt
+das Gegenteil dessen, was in der Anlage steht.  Deshalb wird der Eintrag
+vollständig zitiert und nicht subsumiert: ob die Ausnahme im Fall vorliegt, ist
+eine ärztliche Feststellung und keine Listenauskunft.
+
+**Die Anlage bezeichnet Gruppen, keine Präparate.**  „Antacida in fixer
+Kombination mit anderen Wirkstoffen" ist eine Produktklasse; ob ein konkretes
+Arzneimittel darunterfällt, sagt die Liste nicht.  Und wo eine Zeile eine
+*Kombination* erfasst, trägt sie über den Einzelstoff nichts: Nummer 53 schließt
+Dipyridamol in Kombination mit Acetylsalicylsäure aus, über Acetylsalicylsäure
+allein steht dort nichts.
+
+Die Zustände:
+
+    ausgeschlossen      die Anlage schließt die Bezeichnung aus
+    eingeschraenkt      sie schränkt sie ein, oft mit Ausnahmen
+    nicht_gelistet      Anlage III führt sie nicht — was für sich noch keine
+                        Verordnungsfähigkeit bedeutet
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+# Geteilt statt ein fünftes Mal geschrieben: dieselbe Standangabe, dieselbe
+# Frist, dieselbe Endungsheuristik für einen Wirkstoffnamen.
+from amrl_substitution import VERALTET_AB_TAGEN, _stand_iso, wirkstoff_kandidat
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+# Die Frage muss von der Verordnungsfähigkeit handeln. Regelbasiert wie in den
+# übrigen Listenmodulen: eine Substring-Prüfung entscheidet das exakt.
+VERORDNUNGS_SIGNALE: Tuple[str, ...] = (
+    "verordnungsfähig",
+    "verordnungsfaehig",
+    # Auf den Stamm gekürzt: der Plural bricht sonst am Umlaut
+    # („Verordnungsausschlüsse" enthält kein „verordnungsausschluss").
+    "verordnungsausschl",
+    "verordnungseinschränk",
+    "verordnungseinschraenk",
+    "ausgeschlossen",
+    "eingeschränkt",
+    "eingeschraenkt",
+    "erstattungsfähig",
+    "erstattungsfaehig",
+    "erstattung",
+    "zu lasten der",
+    "kassenrezept",
+    "auf kasse",
+    "darf ich verordnen",
+    "verordnet werden",
+    "unwirtschaftlich",
+    "wirtschaftlichkeitsgebot",
+)
+
+# Die Anlage beim Namen genannt. „anlage iii" ist als Substring nicht in
+# „anlage i" enthalten, wohl aber umgekehrt — die Reihenfolge der Prüfung in
+# `amrl_otc` hängt daran, hier genügt die genaue Form.
+RE_ANLAGE_III = re.compile(r"\banlage\s+iii\b")
+
+# Einträge, die ihre Stoffe selbst benennen — entweder weil die Bezeichnung der
+# Wirkstoff ist (Reboxetin, Febuxostat, Evolocumab) oder weil der Eintrag sie
+# aufzählt („Hierzu zählen: Pioglitazon, Rosiglitazon"). Nur bei den übrigen ist
+# die Zuordnung eines konkreten Präparats zur Gruppe offen und muss im Befund
+# als offen benannt werden; hier wäre derselbe Vorbehalt schlicht falsch.
+#
+# Kuratiert wie `GRUPPENEINTRAEGE` in `amrl_otc`: aus der Bezeichnung ableiten
+# lässt sich das nicht — „Acida" ist eine Gruppe und „Reboxetin" ein Stoff, und
+# beide sind ein einzelnes Wort.
+STOFFGENAUE_EINTRAEGE: frozenset[str] = frozenset(
+    {"10a", "21", "21a", "29a", "33", "33a", "35a", "35b", "35c", "49", "50", "51", "53"}
+)
+
+
+@dataclass(frozen=True)
+class Eintrag:
+    nr: str
+    bezeichnung: str
+    absaetze: Tuple[str, ...]
+    hinweise: Tuple[str, ...]
+    marker: Tuple[str, ...]
+    art: str
+    einzelfall_moeglich: bool
+    kombination: bool
+    begriffe: Tuple[str, ...]
+    varianten: Tuple[str, ...]
+    seite: Optional[int]
+
+    @property
+    def ist_gruppe(self) -> bool:
+        return self.nr not in STOFFGENAUE_EINTRAEGE
+
+    def volltext(self) -> str:
+        return "\n".join(self.absaetze)
+
+
+@dataclass
+class Befund:
+    status: str
+    gefragter_stoff: Optional[str] = None
+    treffer: List[Eintrag] = field(default_factory=list)
+    stand: str = ""
+    stand_iso: str = ""
+    veraltet: bool = False
+    alter_tage: Optional[int] = None
+    fundstelle: str = ""
+    url: str = ""
+    grund: str = ""
+
+    @property
+    def ist_belastbar(self) -> bool:
+        return self.status in {"ausgeschlossen", "eingeschraenkt", "nicht_gelistet"}
+
+    @property
+    def einzelfall_moeglich(self) -> bool:
+        """Nur wenn ihn *jede* getroffene Zeile offenlässt."""
+        return bool(self.treffer) and all(e.einzelfall_moeglich for e in self.treffer)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "gefragter_stoff": self.gefragter_stoff,
+            "treffer": [
+                {"nr": e.nr, "bezeichnung": e.bezeichnung, "art": e.art, "seite": e.seite}
+                for e in self.treffer
+            ],
+            "einzelfall_moeglich": self.einzelfall_moeglich,
+            "stand": self.stand,
+            "veraltet": self.veraltet,
+            "alter_tage": self.alter_tage,
+            "fundstelle": self.fundstelle,
+            "url": self.url,
+            "grund": self.grund,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Daten
+# ---------------------------------------------------------------------------
+
+def load_liste(path: Path) -> Dict[str, Any]:
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
+        logger.warning("Anlage-III-Liste nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+def _eintraege(daten: Dict[str, Any]) -> List[Eintrag]:
+    out: List[Eintrag] = []
+    for roh in daten.get("eintraege") or []:
+        if roh.get("unbesetzt"):
+            continue
+        out.append(
+            Eintrag(
+                nr=str(roh.get("nr") or ""),
+                bezeichnung=str(roh.get("bezeichnung") or ""),
+                absaetze=tuple(str(a) for a in roh.get("absaetze") or []),
+                hinweise=tuple(str(h) for h in roh.get("hinweise") or []),
+                marker=tuple(str(m) for m in roh.get("marker") or []),
+                art=str(roh.get("art") or ""),
+                einzelfall_moeglich=bool(roh.get("einzelfall_moeglich")),
+                kombination=bool(roh.get("kombination")),
+                begriffe=tuple(str(b) for b in roh.get("begriffe") or []),
+                varianten=tuple(str(v) for v in roh.get("varianten") or []),
+                seite=roh.get("seite"),
+            )
+        )
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Erkennung in der Frage
+# ---------------------------------------------------------------------------
+
+def _norm(text: str) -> str:
+    return " ".join(str(text or "").lower().split())
+
+
+def begriffsindex(eintraege: Sequence[Eintrag]) -> List[Tuple[str, Eintrag]]:
+    """(Suchbegriff, Eintrag), längste zuerst.
+
+    Die Reihenfolge trägt: „Insulin glargin" darf nicht vom kürzeren
+    „Insulinanaloga" verdeckt werden und „Antidiarrhoika" nicht von „Antacida".
+    """
+    paare = [(b, e) for e in eintraege for b in (*e.begriffe, *e.varianten) if b]
+    return sorted(paare, key=lambda p: -len(p[0]))
+
+
+def erkannte_eintraege(
+    question: str, eintraege: Sequence[Eintrag]
+) -> Tuple[Optional[str], List[Eintrag]]:
+    """(erkannter Begriff, Einträge dazu) — mehrere, wenn er mehrfach steht.
+
+    Clopidogrel steht in Nummer 21 (Monotherapie) und 21a (in Kombination mit
+    Acetylsalicylsäure) mit verschiedenen Rechtsfolgen, Insulinanaloga in 33 und
+    33a. Nur eine davon zu zeigen unterschlüge die halbe Regelung.
+    """
+    haystack = _norm(question)
+    for begriff, _ in begriffsindex(eintraege):
+        if re.search(rf"(?<![\wäöüß]){re.escape(_norm(begriff))}(?![\wäöüß])", haystack):
+            passend = [
+                e
+                for e in eintraege
+                if any(_norm(b) == _norm(begriff) for b in (*e.begriffe, *e.varianten))
+            ]
+            return begriff, passend
+    return None, []
+
+
+def fragt_nach_verordnungsfaehigkeit(question: str) -> bool:
+    haystack = _norm(question)
+    if RE_ANLAGE_III.search(haystack):
+        return True
+    return any(signal in haystack for signal in VERORDNUNGS_SIGNALE)
+
+
+# ---------------------------------------------------------------------------
+# Prüfung
+# ---------------------------------------------------------------------------
+
+def pruefe(
+    question: str = "",
+    *,
+    path: Path,
+    stoff: Optional[str] = None,
+    heute: Optional[date] = None,
+) -> Befund:
+    daten = load_liste(path)
+    alle = _eintraege(daten)
+    if not alle:
+        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")
+
+    quelle = daten.get("quelle") or {}
+    stand = str(quelle.get("stand") or "")
+    fundstelle = str(quelle.get("dokument") or "AM-RL Anlage III")
+    url = str(quelle.get("url") or "")
+
+    if not stand:
+        return Befund(
+            status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url
+        )
+
+    stand_iso = _stand_iso(stand)
+    alter_tage: Optional[int] = None
+    veraltet = False
+    if stand_iso:
+        try:
+            alter_tage = max(
+                0,
+                ((heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()).days,
+            )
+            veraltet = alter_tage > VERALTET_AB_TAGEN
+        except ValueError:
+            alter_tage = None
+
+    def _fertig(befund: Befund) -> Befund:
+        befund.stand = stand
+        befund.stand_iso = stand_iso
+        befund.alter_tage = alter_tage
+        befund.veraltet = veraltet
+        befund.fundstelle = fundstelle
+        befund.url = url
+        return befund
+
+    # Ohne Bezug zur Verordnungsfähigkeit gar nichts: „Wie dosiere ich
+    # Clopidogrel?" nennt einen gelisteten Stoff, will aber keine Auskunft
+    # darüber, ob er zu Lasten der GKV verordnet werden darf.
+    if not fragt_nach_verordnungsfaehigkeit(question) and stoff is None:
+        return _fertig(Befund(status="nicht_pruefbar", grund="keine_verordnungsfrage"))
+
+    if stoff:
+        begriff, treffer = stoff, [
+            e for e in alle if any(_norm(b) == _norm(stoff) for b in (*e.begriffe, *e.varianten))
+        ]
+    else:
+        begriff, treffer = erkannte_eintraege(question, alle)
+
+    if treffer:
+        # Die schärfere Rechtsfolge bestimmt die Auskunft: wo eine Zeile
+        # ausschließt und eine andere nur einschränkt, ist der Ausschluss das,
+        # was die Abgabe verhindert.
+        status = "ausgeschlossen" if any(e.art == "ausschluss" for e in treffer) else "eingeschraenkt"
+        return _fertig(Befund(status=status, gefragter_stoff=begriff, treffer=treffer))
+
+    # Keine Negativauskunft ins Blaue: „nicht in Anlage III" ist nur dann eine
+    # Aussage, wenn überhaupt ein Stoff genannt wurde.
+    kandidat = begriff or wirkstoff_kandidat(question)
+    if not kandidat:
+        return _fertig(Befund(status="nicht_pruefbar", grund="kein_stoff_erkannt"))
+
+    return _fertig(
+        Befund(status="nicht_gelistet", gefragter_stoff=kandidat, grund="nicht_in_anlage_iii")
+    )
+
+
+# ---------------------------------------------------------------------------
+# Darstellung
+# ---------------------------------------------------------------------------
+
+_EINLEITUNG = "Verordnungsausschluss und -einschränkung — deterministische Listenprüfung"
+
+_EINZELFALL = (
+    "Die Verordnung bleibt im medizinisch begründeten Einzelfall mit Begründung möglich "
+    "(§ 31 Absatz 1 Satz 4 SGB V, § 16 Absatz 5 AM-RL)."
+)
+# Der Weg des Einzelfalls steht nach der Vorbemerkung nur bei den
+# Rechtsgrundlagen 3 bis 6 offen. Wo eine Zeile auch [1] oder [2] trägt, führt
+# er an ihr vorbei — und das ist der Unterschied zwischen „mit Begründung
+# verordnungsfähig" und „gar nicht".
+_KEIN_EINZELFALL = (
+    "Dieser Ausschluss beruht auf dem Gesetz selbst oder auf der Rechtsverordnung nach "
+    "§ 34 Absatz 3 SGB V. Der Weg über den medizinisch begründeten Einzelfall (§ 31 "
+    "Absatz 1 Satz 4 SGB V) steht nach der Vorbemerkung der Anlage nur bei Ausschlüssen "
+    "und Einschränkungen durch die Richtlinie selbst offen und greift hier nicht."
+)
+_GRUPPENVORBEHALT = (
+    "Die Anlage bezeichnet Arzneimittelgruppen und Produktklassen, kein einzelnes "
+    "Präparat. Ob das konkrete Arzneimittel darunterfällt, ist am Fall zu prüfen."
+)
+_KOMBINATIONSVORBEHALT = (
+    "Erfasst ist die genannte Kombination, nicht der Einzelstoff: über dessen Verordnung "
+    "sagt der Eintrag nichts."
+)
+# Worauf die Negativauskunft *nicht* trägt. Anlage III nennt sich selbst eine
+# Übersicht und enthält den Satz nicht, auf dem die Negativauskunft der Anlage I
+# ruht („regeln abschließend", § 12 Absatz 10 AM-RL).
+_GRENZE_DER_NEGATIVAUSKUNFT = (
+    "Daraus folgt allein, dass dieser Ausschlussgrund nicht greift — keine "
+    "Verordnungsfähigkeit. Anlage III ist eine Übersicht und bezeichnet sich nicht als "
+    "abschließend; nicht verschreibungspflichtige Arzneimittel sind zudem schon nach § 34 "
+    "Absatz 1 Satz 1 SGB V ausgeschlossen (Ausnahmen: Anlage I), und Arzneimittel zur "
+    "Erhöhung der Lebensqualität nach § 34 Absatz 1 Satz 7 SGB V (Anlage II, hier nicht "
+    "geprüft)."
+)
+
+
+def _eintrag_block(eintrag: Eintrag) -> str:
+    zeilen = [f"  Nummer {eintrag.nr}: {eintrag.absaetze[0] if eintrag.absaetze else ''}"]
+    for absatz in eintrag.absaetze[1:]:
+        zeilen.append(f"    {absatz}")
+    for hinweis in eintrag.hinweise:
+        zeilen.append(f"    → {hinweis}")
+    return "\n".join(zeilen)
+
+
+def befund_block(befund: Befund) -> str:
+    if not befund.ist_belastbar:
+        return ""
+
+    zeilen: List[str] = [f"{_EINLEITUNG} ({befund.fundstelle}, Stand {befund.stand}):"]
+
+    if befund.status in {"ausgeschlossen", "eingeschraenkt"}:
+        anzahl = len(befund.treffer)
+        wo = "in einem Eintrag" if anzahl == 1 else f"in {anzahl} Einträgen"
+        wie = (
+            "von der Verordnung ausgeschlossen"
+            if befund.status == "ausgeschlossen"
+            else "in der Verordnung eingeschränkt"
+        )
+        zeilen.append(
+            f"{befund.gefragter_stoff} ist in Anlage III {wo} geführt und dort {wie}. "
+            "Maßgeblich ist der Wortlaut des Eintrags samt seiner Ausnahmen; ob eine davon "
+            "im Fall vorliegt, ist eine ärztliche Feststellung."
+        )
+        for eintrag in befund.treffer:
+            zeilen.append(_eintrag_block(eintrag))
+        zeilen.append(_EINZELFALL if befund.einzelfall_moeglich else _KEIN_EINZELFALL)
+        if any(e.kombination for e in befund.treffer):
+            zeilen.append(_KOMBINATIONSVORBEHALT)
+        if any(e.ist_gruppe for e in befund.treffer):
+            zeilen.append(_GRUPPENVORBEHALT)
+    else:  # nicht_gelistet
+        zeilen.append(
+            f"Anlage III führt {befund.gefragter_stoff} nicht. {_GRENZE_DER_NEGATIVAUSKUNFT}"
+        )
+
+    if befund.veraltet:
+        zeilen.append(
+            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Vor einer "
+            "Entscheidung ist die geltende Fassung abzugleichen."
+        )
+    if befund.url:
+        zeilen.append(f"Quelle: {befund.url}")
+
+    return "\n".join(zeilen)
+
+
+def verdikt(befund: Befund) -> str:
+    """Die Antwort in einem Satz — nur wenn die Frage entschieden werden konnte.
+
+    Für „nicht gelistet" bleibt der Satz bewusst leer: die Auskunft trägt hier
+    nicht so weit wie bei Anlage I und taugt nicht als Kurzantwort. Der Block
+    oben nennt sie trotzdem, weil sie einen Ausschlussgrund ausräumt.
+    """
+    nummern = ", ".join(e.nr for e in befund.treffer)
+
+    if befund.status == "ausgeschlossen":
+        satz = (
+            f"{befund.gefragter_stoff} ist nach Anlage III der AM-RL von der Verordnung zu "
+            f"Lasten der GKV ausgeschlossen (Nummer {nummern})"
+        )
+    elif befund.status == "eingeschraenkt":
+        satz = (
+            f"{befund.gefragter_stoff} ist nach Anlage III der AM-RL nur eingeschränkt "
+            f"verordnungsfähig (Nummer {nummern})"
+        )
+    else:
+        return ""
+
+    zusatz = (
+        " — im medizinisch begründeten Einzelfall bleibt die Verordnung mit Begründung möglich"
+        if befund.einzelfall_moeglich
+        else " — auch der medizinisch begründete Einzelfall trägt hier nicht"
+    )
+    return f"{satz}{zusatz} (Listenprüfung oben, Stand {befund.stand})."

src/answer_composer.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Dict, List, Optional, Tuple, Set
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Set
 
-from src.llm_client_groq import ConversationMemory, is_meta_question
+import norm_rang
+from answer_schema import SHORT_ANSWER_HEADING, is_denial, split_sections
+from llm_client_groq import ConversationMemory, is_meta_question
 
 
 # ---------------------------------------------------------------------------
@@ -37,6 +39,44 @@ _ANSWER_REQUEST_PATTERNS = [
 
 _SOURCE_MARKER_RE = re.compile(r"\[Quelle\s+(\d+)\]", re.I)
 _SOURCE_MARKER_MULTI_RE = re.compile(r"\[Quellen\s+([\d,\s]+)\]", re.I)
+
+# A citation as it actually occurs in an answer: the marker plus the
+# enrichment tail the model likes to attach, e.g. "[Quelle 3] (§ 6 Abs. 1)".
+# Removing only the marker leaves the tail behind as a free-floating "(§ 6)".
+#
+# Both the singular and the plural form matter.  "[Quellen 3, 8]" is not a model
+# invention — `build_sources` produces it whenever grouped chunks share a
+# display entry — so a validator that only knows "[Quelle n]" lets every plural
+# marker through unchecked, valid or not.
+_CITATION_ATOM_RE = re.compile(
+    r"\[Quellen?\s+(?P<numbers>\d+(?:\s*,\s*\d+)*)\]"
+    r"(?P<tail>\s*\(§[^)]{1,120}\))?",
+    re.I,
+)
+_MARKER_NUMBER_RE = re.compile(r"\d+")
+
+# Run after removing citation atoms.  A stripped citation takes its text with it
+# but not the punctuation that separated it from the next one, which is how a
+# denial ended up reading "… in den bereitgestellten Quellen , , , , ,.".
+# Ordered: separator runs first, then the leftovers that produces.
+_CITATION_CLEANUP: Tuple[Tuple[re.Pattern[str], str], ...] = (
+    # Empty parentheses from a removed reference tail.
+    (re.compile(r"\(\s*\)"), ""),
+    # A run of separators immediately before sentence punctuation: drop it whole.
+    (re.compile(r"(?:\s*[,;])+\s*(?=[.;:!?])"), ""),
+    # A run of separators inside a sentence collapses to one.
+    (re.compile(r"(?:\s*,){2,}"), ","),
+    # ", und [Quelle n]" — the item between them was removed.
+    (re.compile(r",(\s*\b(?:und|oder)\b\s)", re.I), r"\1"),
+    # "Text und [Quelle n]" — the first item of the list was removed.  The
+    # lookbehind on a word character is what keeps a real list ("[Quelle 1] und
+    # [Quelle 2]", preceded by "]") intact.
+    (re.compile(r"(?<=\w)\s+\b(?:und|oder)\b\s+(?=\[Quelle)", re.I), " "),
+    # A dangling conjunction where the trailing citation was removed.
+    (re.compile(r"\s+\b(?:und|oder)\b\s*(?=[.;:!?])", re.I), ""),
+    (re.compile(r"\s+([,.;:!?])"), r"\1"),
+    (re.compile(r"[ \t]{2,}"), " "),
+)
 _GRANULAR_BUCHSTABE_REF_RE = re.compile(
     r"(§\s*\d{1,3}[a-z]?\s+Abs\.?\s*\d+[a-z]?)\s+"
     r"(?:Buchst\.?|Buchstabe)\s*([a-z])",
@@ -180,6 +220,30 @@ Wenn die bereitgestellte Textstelle nur auf eine externe Norm verweist:
 
 Das ist eine gültige, vollständige Antwort und NICHT "nicht geregelt".
 
+=========================
+NORMRANG
+=========================
+
+Jede Quelle nennt im Feld "Rang", was sie ist: Gesetz, Richtlinie, Vertrag
+oder Anlage. Bei Vertrag und Richtlinie steht dort zusätzlich die Vorschrift,
+auf der das Regelwerk beruht.
+
+Maßgeblich ist die Vorschrift, die die Frage entscheidet — nicht die, die der
+Frage am ähnlichsten klingt.
+
+Wenn der Kontext eine ausführende Regelung (Vertrag, Richtlinie, Anlage) UND
+die Norm enthält, auf der sie beruht:
+
+- Nenne beide unter "Maßgebliche Norm".
+- Nenne zuerst die Norm, aus der sich die Rechtsfolge ergibt, danach die
+  Regelung, die sie ausführt.
+
+Nenne eine Anlage nicht als alleinige maßgebliche Norm, wenn die Vorschrift,
+die auf sie verweist, im Kontext steht.
+
+Erschließe den Rang niemals aus dem Namen eines Dokuments, sondern
+ausschließlich aus dem Feld "Rang".
+
 =========================
 QUELLEN
 =========================
@@ -240,6 +304,21 @@ Keine Quellenliste am Ende.
 """.strip()
 
 
+def _format_source_marker(numbers: Sequence[int]) -> str:
+    """The one place that decides how a citation marker is written.
+
+    The stripper parses these markers back out, so builder and parser have to
+    agree on the format — three separate copies of the f-string were one edit
+    away from drifting apart.
+    """
+    ordered = list(numbers)
+    if not ordered:
+        return ""
+    if len(ordered) == 1:
+        return f"[Quelle {ordered[0]}]"
+    return "[Quellen " + ", ".join(str(n) for n in ordered) + "]"
+
+
 def _normalize(text: str) -> str:
     return (
         " ".join((text or "").lower().strip().split())
@@ -447,6 +526,23 @@ class AnswerComposer:
     def _section(cls, hit: Dict[str, Any]) -> str:
         return str(cls._hit_value(hit, "section", "section_id", default="ohne Abschnitt"))
 
+    @classmethod
+    def _doc_id(cls, hit: Dict[str, Any]) -> str:
+        return str(cls._hit_value(hit, "doc_id", default="") or "")
+
+    @classmethod
+    def _doc_title(cls, hit: Dict[str, Any]) -> str:
+        """Kurzer Dokumentname für Zitate über mehrere Korpora hinweg.
+
+        Ohne diese Angabe ist eine Quelle mehrdeutig: Rahmenvertrag und SGB V
+        teilen sich 34 §-Nummern mit völlig verschiedenem Inhalt (§ 16 ist einmal
+        "Teilmenge, Auseinzelung", einmal "Ruhen des Anspruchs"). Leerer String
+        bei alten Collections ohne doc_title -> Anzeige fällt auf das bisherige
+        Format zurück.
+        """
+        title = str(cls._hit_value(hit, "doc_title", default="") or "").strip()
+        return title or cls._doc_id(hit)
+
     @classmethod
     def _chunk_index(cls, hit: Dict[str, Any]) -> Any:
         return cls._hit_value(hit, "chunk_index", "chunk_index_in_section", default="?")
@@ -591,6 +687,7 @@ class AnswerComposer:
             return ("hash", text_hash)
 
         return (
+            cls._doc_id(hit),
             cls._container(hit),
             cls._section(hit),
             cls._page_range(hit),
@@ -598,8 +695,11 @@ class AnswerComposer:
         )
 
     @classmethod
-    def _source_display_key(cls, hit: Dict[str, Any]) -> Tuple[Any, Any, Any]:
+    def _source_display_key(cls, hit: Dict[str, Any]) -> Tuple[Any, ...]:
+        # doc_id zuerst: sonst könnten gleichnamige Abschnitte aus verschiedenen
+        # Dokumenten zu einer einzigen Quelle verschmelzen.
         return (
+            cls._doc_id(hit),
             cls._container(hit),
             cls._section(hit),
             cls._page_range(hit),
@@ -882,7 +982,13 @@ class AnswerComposer:
             # Chunk, damit die UI die Fundstelle im PDF ansteuern kann.
             page_start, page_end = cls._page_bounds(hit)
             source_file = str(cls._hit_value(hit, "source_file", default="") or "")
-            doc_id = str(cls._hit_value(hit, "doc_id", default="") or "")
+            doc_id = cls._doc_id(hit)
+            doc_title = cls._doc_title(hit)
+            # Vom föderierenden Retriever je Treffer gesetzt. Ohne Durchreichen
+            # weiß die API-Schicht nicht mehr, aus welchem Korpus eine Quelle
+            # stammt; korpusbezogene Hinweise (corpus_amendments.py) laufen dann
+            # ins Leere.
+            corpus_id = str(cls._hit_value(hit, "corpus_id", default="") or "")
             highlight = cls._highlight_text(hit)
             highlight_entry = (
                 {"page_start": page_start, "page_end": page_end, "text": highlight}
@@ -906,6 +1012,8 @@ class AnswerComposer:
                     "page_end": page_end,
                     "source_file": source_file,
                     "doc_id": doc_id,
+                    "doc_title": doc_title,
+                    "corpus_id": corpus_id,
                     "highlights": [highlight_entry] if highlight_entry else [],
                     "path": cls._hit_value(hit, "path", "section_path", default=""),
                     "score": round(cls._score(hit), 4),
@@ -924,6 +1032,8 @@ class AnswerComposer:
                 item["source_file"] = source_file
             if doc_id and not item.get("doc_id"):
                 item["doc_id"] = doc_id
+            if doc_title and not item.get("doc_title"):
+                item["doc_title"] = doc_title
             if highlight_entry is not None:
                 existing_texts = {(h.get("text") or "")[:120] for h in item.get("highlights") or []}
                 if highlight[:120] not in existing_texts:
@@ -933,13 +1043,8 @@ class AnswerComposer:
                 item["source_numbers"].append(number)
                 item["source_numbers"].sort()
                 item["source_number"] = item["source_numbers"][0]
-                if len(item["source_numbers"]) == 1:
-                    item["source_marker"] = f"[Quelle {item['source_numbers'][0]}]"
-                    item["source_label"] = item["source_marker"]
-                else:
-                    joined = ", ".join(str(n) for n in item["source_numbers"])
-                    item["source_marker"] = f"[Quellen {joined}]"
-                    item["source_label"] = item["source_marker"]
+                item["source_marker"] = _format_source_marker(item["source_numbers"])
+                item["source_label"] = item["source_marker"]
 
             if canonical and canonical not in item["canonical_refs"]:
                 item["canonical_refs"].append(canonical)
@@ -954,14 +1059,7 @@ class AnswerComposer:
         sources = list(grouped.values())
 
         for source in sources:
-            numbers = source.get("source_numbers") or []
-            if numbers:
-                if len(numbers) == 1:
-                    label = f"[Quelle {numbers[0]}]"
-                else:
-                    label = "[Quellen " + ", ".join(str(n) for n in numbers) + "]"
-            else:
-                label = ""
+            label = _format_source_marker(source.get("source_numbers") or [])
             source["source_marker"] = label
             source["source_label"] = label
             canonical_refs = source.get("canonical_refs") or []
@@ -1001,14 +1099,7 @@ class AnswerComposer:
             pages = source.get("page_range", "?")
             marker = source.get("source_marker") or source.get("source_label") or ""
             if not marker:
-                numbers = source.get("source_numbers") or []
-                if numbers:
-                    if len(numbers) == 1:
-                        marker = f"[Quelle {numbers[0]}]"
-                    else:
-                        marker = "[Quellen " + ", ".join(str(n) for n in numbers) + "]"
-                else:
-                    marker = "-"
+                marker = _format_source_marker(source.get("source_numbers") or []) or "-"
 
             role = ""
             kinds = set(source.get("retrieval_kinds") or [])
@@ -1049,8 +1140,22 @@ class AnswerComposer:
 
         chunk_kind = cls._hit_value(hit, "chunk_kind", default="")
 
+        # Das Dokument steht bewusst als erste Zeile: das Modell muss § 16 des
+        # Rahmenvertrags von § 16 SGB V unterscheiden können, bevor es zitiert.
+        doc_title = cls._doc_title(hit)
+        doc_line = f"Dokument: {doc_title}\n" if doc_title else ""
+
+        # Und gleich darunter, was das Dokument ist. Ohne diese Zeile stand die
+        # Anlage neben dem Gesetz, ohne dass etwas im Kontext den Unterschied
+        # benannte — und die Antwort führte gelegentlich die Ausführungsregelung
+        # als „Maßgebliche Norm".
+        rang_wert = norm_rang.rang(hit)
+        rang_line = f"Rang: {rang_wert}\n" if rang_wert else ""
+
         return (
             f"[Quelle {index}]\n"
+            f"{doc_line}"
+            f"{rang_line}"
             f"Container: {container}\n"
             f"Abschnitt: {section}\n"
             f"Norm: {canonical_ref}\n"
@@ -1233,6 +1338,28 @@ class AnswerComposer:
                     pass
         return numbers
 
+    @classmethod
+    def cited_hits(cls, answer: str, hits: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Die Treffer, auf die sich die Antwort mit ``[Quelle n]`` beruft.
+
+        Der Trefferpool ist nicht dasselbe wie die herangezogenen Textstellen:
+        das Modell bekommt acht Quellen und zitiert regelmäßig zwei. Wer über
+        die Antwort etwas aussagen will — was sie belegt, worauf sie verweist,
+        wo ihre Grenze liegt —, muss die zitierten meinen und nicht den Pool.
+
+        Die Nummern sind die Ränge aus dem RAG-Kontext. Der Aufruf gehört
+        deshalb **vor** die Umnummerierung für die Anzeige; danach trägt der
+        Antworttext Anzeigenummern und die Treffer weiter ihre Ränge.
+
+        Leere Rückgabe heißt „nicht feststellbar" und nicht „keine": eine
+        Antwort ohne Marker lässt keine Aussage darüber zu, und der Aufrufer
+        entscheidet, was das für ihn bedeutet.
+        """
+        numbers = cls._referenced_source_numbers(answer)
+        if not numbers:
+            return []
+        return [hit for hit in hits or [] if cls._source_number(hit) in numbers]
+
     @classmethod
     def _postprocess_document_answer(
         cls,
@@ -1308,76 +1435,83 @@ class AnswerComposer:
 
         return text
 
-    # Abschnitts-Überschriften, die als leere Reste entfernt werden dürfen.
-    # Enthält die Labels des aktuellen Schemas sowie Alt-Reste.
-    _SECTION_HEADINGS = (
-        "Kurzantwort",
-        "Maßgebliche Norm",
-        "Maßgebliche Norm(en)",
-        "Wortlaut / Kriterien",
-        "Wortlaut",
-        "Einordnung",
-        "Ausnahmen",
-        "Ergebnis",
-        "Heilungen",
-        "Retaxationsgrenzen",
-    )
-
     @classmethod
     def _strip_empty_section_headings(cls, text: str) -> str:
-        """Entfernt Abschnitts-Überschriften, denen kein Inhalt folgt.
+        """Entfernt Abschnitte ohne eigenen Inhalt.
 
-        Eine Überschrift gilt als leer, wenn bis zur nächsten Überschrift oder
-        bis zum Textende keine inhaltliche Zeile folgt. Überschriften mit Inhalt
-        bleiben unangetastet.
+        "Ohne Inhalt" heißt zweierlei: es folgt gar keine Zeile — oder es folgt
+        nur die Feststellung, dass es nichts gibt. Der Prompt verlangt beides
+        wegzulassen ("Abschnitte ohne Evidenz vollständig weglassen"); das Modell
+        hält sich an die Überschriften und schreibt viermal "Es gibt keine ...".
+
+        Die Kurzantwort bleibt immer stehen: sie *ist* die Antwort, auch wenn sie
+        negativ ausfällt. Bliebe sonst überhaupt nichts übrig, bleibt der Text
+        unverändert — eine leere Antwort ist schlechter als eine redundante.
         """
         if not text:
             return text
 
-        label_re = re.compile(
-            r"^(?:#+\s*)?(?:"
-            + "|".join(re.escape(h) for h in cls._SECTION_HEADINGS)
-            + r"):?\s*$",
-            re.I,
-        )
+        blocks = split_sections(text)
+        if not any(heading for heading, _ in blocks):
+            return text
 
-        lines = text.split("\n")
-        keep = [True] * len(lines)
+        parts: List[str] = []
+        for heading, body_lines in blocks:
+            body = "\n".join(body_lines).strip()
 
-        for i, line in enumerate(lines):
-            if not label_re.match(line.strip()):
+            if heading is None:
+                if body:
+                    parts.append(body)
                 continue
 
-            # Nächste nicht-leere Zeile suchen.
-            j = i + 1
-            while j < len(lines) and not lines[j].strip():
-                j += 1
+            if not body:
+                continue
+            if heading != SHORT_ANSWER_HEADING and is_denial(body):
+                continue
 
-            # Leer, wenn Textende erreicht ist oder direkt die nächste
-            # Überschrift folgt.
-            if j >= len(lines) or label_re.match(lines[j].strip()):
-                keep[i] = False
+            parts.append(f"{heading}:\n{body}")
 
-        return "\n".join(line for idx, line in enumerate(lines) if keep[idx])
+        if not parts:
+            return text
+        return "\n\n".join(parts)
 
     @classmethod
     def _strip_invalid_source_markers(cls, answer: str, used_hits: List[Dict[str, Any]]) -> str:
-        """Entfernt Marker wie [Quelle 9], wenn Quelle 9 nicht im Kontext stand."""
+        """Entfernt Marker wie [Quelle 9], wenn Quelle 9 nicht im Kontext stand.
+
+        Entfernt wird die ganze Zitat-Einheit: der Marker, eine angehängte
+        Fundstelle wie "(§ 6 Abs. 1)" und die Trennzeichen, die sie mit dem
+        nächsten Zitat verbanden. Blieben die Trennzeichen stehen, las sich eine
+        Verneinung als „… in den bereitgestellten Quellen , , , , ,." — sechs
+        entfernte Marker, deren Kommata den Eindruck von sechs Belegen
+        hinterließen.
+
+        Sammelmarker werden auf ihren belegten Teil zurückgeführt: aus
+        "[Quellen 3, 8]" wird "[Quelle 3]", wenn nur 3 im Kontext stand. Nur wenn
+        keine einzige Nummer trägt, fällt die ganze Einheit weg. Ein Sammelmarker
+        bündelt mehrere Belege für dieselbe Aussage — der belegte Teil bleibt
+        richtig, auch wenn der Rest erfunden war.
+        """
         valid_numbers = cls._used_source_numbers(used_hits)
-        if not valid_numbers:
-            return _SOURCE_MARKER_RE.sub("", answer or "").strip()
 
         def repl(match: re.Match[str]) -> str:
-            try:
-                number = int(match.group(1))
-            except (TypeError, ValueError):
+            numbers = [int(n) for n in _MARKER_NUMBER_RE.findall(match.group("numbers"))]
+            kept = [n for n in numbers if n in valid_numbers]
+            if not kept:
                 return ""
-            return match.group(0) if number in valid_numbers else ""
-
-        cleaned = _SOURCE_MARKER_RE.sub(repl, answer or "")
-        # Nur überflüssige Leerzeichen vor Satzzeichen bereinigen; Zeilenumbrüche und Schema bleiben erhalten.
-        cleaned = re.sub(r"[ 	]{2,}", " ", cleaned)
-        cleaned = re.sub(r"\s+([,.;:])", r"\1", cleaned)
+            if kept == numbers:
+                return match.group(0)
+            return f"{_format_source_marker(kept)}{match.group('tail') or ''}"
+
+        original = answer or ""
+        cleaned = _CITATION_ATOM_RE.sub(repl, original)
+        if cleaned == original:
+            return cleaned.strip()
+
+        # Zeilenumbrüche und Schema bleiben erhalten; bereinigt wird nur, was das
+        # Entfernen selbst hinterlassen hat.
+        for pattern, replacement in _CITATION_CLEANUP:
+            cleaned = pattern.sub(replacement, cleaned)
         return cleaned.strip()
 
     # ------------------------------------------------------------------

src/answer_schema.py

@@ -0,0 +1,106 @@
+"""The answer schema: its headings, and what an empty section looks like.
+
+`_DOCUMENT_TASK_PROMPT` prescribes a fixed set of section headings and tells the
+model to leave out any section it has no evidence for.  Models keep the headings
+and ignore the omission rule: instead of dropping a section they fill it with
+"Es gibt keine ... in den bereitgestellten Quellen".  A denial therefore arrives
+stated four times over, once per heading.
+
+Two places have to recognise that filler — `answer_composer`, which enforces the
+schema, and `corpus_amendments`, which rewrites a denial once it knows a later
+amendment does regulate the point.  The recognition lives here so neither owns
+it and the two cannot drift apart.  This module deliberately has no imports
+beyond the standard library.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List, Optional, Tuple
+
+# The current schema plus labels from earlier versions of it.  Recognising a
+# stale label costs nothing and lets an old cached answer be cleaned up too.
+SECTION_HEADINGS: Tuple[str, ...] = (
+    "Kurzantwort",
+    "Maßgebliche Norm",
+    "Maßgebliche Norm(en)",
+    "Wortlaut / Kriterien",
+    "Wortlaut",
+    "Einordnung",
+    "Ausnahmen",
+    "Ergebnis",
+    "Heilungen",
+    "Retaxationsgrenzen",
+)
+
+# The one section that is never dropped: it *is* the answer, negative or not.
+SHORT_ANSWER_HEADING = "Kurzantwort"
+
+_HEADING_PREFIX_RE = re.compile(r"^#+\s*")
+_SENTENCE_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")
+
+# Deliberately narrow.  This must match the "nothing found" filler the schema
+# produces and nothing else — a false positive deletes real legal content.
+_DENIAL_RE = re.compile(
+    r"es\s+gibt\s+kein"
+    r"|enthalten\s+(?:hierzu|dazu)\s+kein"
+    r"|liegt\s+(?:hierzu|dazu)?\s*kein"
+    r"|kein\w*\s+(?:relevante[nrs]?\s+)?"
+    r"(?:regelung|norm|vorschrift|textstelle|aussage|angabe|einordnung|information)"
+    r"|nichts?\s+(?:geregelt|enthalten|auffindbar|ersichtlich)"
+    r"|belastbare?\s+juristische\s+antwort",
+    re.I,
+)
+
+
+def heading_key(line: str) -> Optional[str]:
+    """The schema heading a line represents, or None.
+
+    Tolerates a markdown prefix and a missing colon, both of which models
+    produce despite the prompt asking for plain text.
+    """
+    text = _HEADING_PREFIX_RE.sub("", (line or "").strip())
+    if text.endswith(":"):
+        text = text[:-1]
+    text = re.sub(r"\s+", " ", re.sub(r"\s*/\s*", " / ", text.strip()))
+    if not text:
+        return None
+    for heading in SECTION_HEADINGS:
+        if text.lower() == heading.lower():
+            return heading
+    return None
+
+
+def split_sections(answer: str) -> List[Tuple[Optional[str], List[str]]]:
+    """Split an answer into (heading | None, body lines) blocks, in order.
+
+    The first block carries `None` as its heading and holds whatever preceded
+    the first one — usually nothing, but never assume that.
+    """
+    blocks: List[Tuple[Optional[str], List[str]]] = []
+    heading: Optional[str] = None
+    body: List[str] = []
+
+    for line in (answer or "").split("\n"):
+        found = heading_key(line)
+        if found is None:
+            body.append(line)
+            continue
+        blocks.append((heading, body))
+        heading, body = found, []
+
+    blocks.append((heading, body))
+    return blocks
+
+
+def is_denial(body: str) -> bool:
+    """True if every sentence of `body` merely states that nothing was found.
+
+    A single § anywhere disqualifies the body: the model only names a provision
+    when it found one, whatever it then claims about it.
+    """
+    text = (body or "").strip()
+    if not text or "§" in text:
+        return False
+    sentences = [s for s in _SENTENCE_SPLIT_RE.split(text) if s.strip()]
+    return bool(sentences) and all(_DENIAL_RE.search(s) for s in sentences)

src/app.py

@@ -10,25 +10,56 @@ from threading import Lock
 from typing import Any, Callable, Dict, Iterable, List, Literal, Optional, TypedDict
 from uuid import uuid4
 
+# .env laden, bevor irgendein os.getenv() ausgewertet wird.
+#
+# Ohne diesen Schritt ist die gesamte .env tote Konfiguration: CHROMA_COLLECTIONS
+# erreicht specs_from_env() nie, die Registry fällt auf das einzelne
+# CHROMA_COLLECTION zurück und das zweite Korpus (SGB V) wird nie geöffnet.
+#
+# override=False ist Absicht: echte Prozess-Umgebungsvariablen (Render, Docker,
+# HF Spaces) haben Vorrang vor der lokalen Entwicklungsdatei.
+try:
+    from dotenv import load_dotenv
+
+    _ENV_FILE = Path(__file__).resolve().parent.parent / ".env"
+    load_dotenv(_ENV_FILE if _ENV_FILE.exists() else None, override=False)
+except ImportError:  # python-dotenv ist optional; Deployment setzt echte Env-Vars.
+    _ENV_FILE = None
+
 from fastapi import FastAPI, HTTPException, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field
 
-from src.retriever import LegalRetriever
-from src.llm_client_groq import (
+from retriever import LegalRetriever
+from corpus_amendments import (
+    append_amendment_note,
+    describe as describe_amendments,
+    reconcile_negative_answer,
+)
+from corpus_boundary import append_boundary_note, detect_external_references
+import amrl_austauschbarkeit
+import amrl_biosimilars
+import amrl_lifestyle
+import amrl_otc
+import amrl_substitution
+import amrl_tabakentwoehnung
+import amrl_verordnungsausschluss
+import norm_anchors
+import norm_verweise
+from corpus_registry import CorpusRegistry, build_registry
+from corpus_router import explain_routing, mentioned_corpora, route_question
+from federated_retriever import FederatedRetriever
+from llm_client_groq import (
     DEFAULT_SYSTEM_PROMPT,
     ConversationMemory,
     GroqClient,
     classify_question,
     is_meta_question,
 )
-from src.answer_composer import AnswerComposer
-from src.orchestrator import (
-    LegalAnswerOrchestrator,
-    OrchestratorOptions,
-)
+from answer_composer import AnswerComposer
+from orchestrator import NEGATIVE_ANSWER_RE, LegalAnswerOrchestrator, OrchestratorOptions
 
 try:
     from langgraph.graph import StateGraph, END
@@ -113,6 +144,82 @@ INDEX_FILE = _resolve_project_path("INDEX_FILE", Path("static") / "index.html")
 #   1. PDF_DIR (Env, explizit)
 #   2. DATA_DIR/pdfs   -> HF-Dataset-Snapshot auf Spaces (dort pdfs/ ablegen)
 #   3. BASE_DIR/data/pdfs bzw. BASE_DIR/data -> im Docker-Image mitgelieferte PDFs
+# Kuratierte Änderungen zu Korpora, die nur als Grundfassung plus separate
+# Änderungstexte veröffentlicht werden (siehe src/corpus_amendments.py).
+AMENDMENTS_FILE = Path(
+    os.getenv("AMENDMENTS_FILE", str(BASE_DIR / "data" / "amabrv_aenderungen.json"))
+)
+# Teil B der AM-RL-Anlage VII als nachschlagbare Tabelle. Diese Liste wird nicht
+# indiziert: die entscheidende Auskunft ist oft die negative, und die kann ein
+# Vektor-Retrieval nicht belegen (siehe src/amrl_substitution.py).
+AMRL_SUBSTITUTION_FILE = Path(
+    os.getenv(
+        "AMRL_SUBSTITUTION_FILE",
+        str(BASE_DIR / "data" / "amrl_anlage_vii_teil_b.json"),
+    )
+)
+# Teil A derselben Anlage: welche Darreichungsformen desselben Wirkstoffs
+# gegeneinander austauschbar sind. Ebenfalls Lookup statt Index — die Aussage
+# hängt an der Gruppenzugehörigkeit, und die ist nur über die vollständige
+# Tabelle bestimmbar (siehe src/amrl_austauschbarkeit.py).
+AMRL_AUSTAUSCHBARKEIT_FILE = Path(
+    os.getenv(
+        "AMRL_AUSTAUSCHBARKEIT_FILE",
+        str(BASE_DIR / "data" / "amrl_anlage_vii_teil_a.json"),
+    )
+)
+# Anlage VIIa: welches Biosimilar zu welchem Referenzarzneimittel zugelassen ist.
+# Ebenfalls Lookup — die Zuordnung hängt an der Tabellenzeile, und ein Retrieval
+# zeigte Prolia und ein Xgeva-Biosimilar nebeneinander, weil beide unter
+# „Denosumab" stehen (siehe src/amrl_biosimilars.py).
+AMRL_BIOSIMILARS_FILE = Path(
+    os.getenv(
+        "AMRL_BIOSIMILARS_FILE",
+        str(BASE_DIR / "data" / "amrl_anlage_viia.json"),
+    )
+)
+# Anlage I: die OTC-Ausnahmen vom Verordnungsausschluss des § 34 Absatz 1 SGB V.
+# Lookup wie die übrigen — und hier trägt die Negativauskunft ausdrücklich, weil
+# § 12 Absatz 10 AM-RL abschließend regelt (siehe src/amrl_otc.py).
+AMRL_OTC_FILE = Path(
+    os.getenv(
+        "AMRL_OTC_FILE",
+        str(BASE_DIR / "data" / "amrl_anlage_i.json"),
+    )
+)
+# Anlage III: die Verordnungseinschränkungen und -ausschlüsse — das Gegenstück
+# zu Anlage I. Lookup wie die übrigen, aber die Negativauskunft trägt hier
+# *nicht*: die Anlage ist eine Übersicht und nennt sich nirgends abschließend
+# (siehe src/amrl_verordnungsausschluss.py).
+AMRL_VERORDNUNG_FILE = Path(
+    os.getenv(
+        "AMRL_VERORDNUNG_FILE",
+        str(BASE_DIR / "data" / "amrl_anlage_iii.json"),
+    )
+)
+# Anlage II: die Lifestyle-Arzneimittel. Von den drei Listen zur
+# Verordnungsfähigkeit ist ihr Ausschluss der härteste — er ruht auf § 34
+# Absatz 1 Satz 7 SGB V, und der medizinisch begründete Einzelfall des § 16
+# Absatz 5 AM-RL führt an ihm vorbei. Die Negativauskunft trägt hier wie bei
+# Anlage III nicht (siehe src/amrl_lifestyle.py).
+AMRL_LIFESTYLE_FILE = Path(
+    os.getenv(
+        "AMRL_LIFESTYLE_FILE",
+        str(BASE_DIR / "data" / "amrl_anlage_ii.json"),
+    )
+)
+# Anlage IIa: die einzige Ausnahme von Anlage II. Sie gehört mit ihr zusammen —
+# der Ausschluss der Raucherentwöhnung und der Anspruch auf Tabakentwöhnung nach
+# § 34 Absatz 2 SGB V sind dieselbe Frage von zwei Seiten. Anders als bei Anlage
+# II trägt die Negativauskunft hier: § 14a Absatz 3 Satz 1 AM-RL zählt die
+# Ausnahme abschließend auf (siehe src/amrl_tabakentwoehnung.py).
+AMRL_TABAKENTWOEHNUNG_FILE = Path(
+    os.getenv(
+        "AMRL_TABAKENTWOEHNUNG_FILE",
+        str(BASE_DIR / "data" / "amrl_anlage_iia.json"),
+    )
+)
+
 _PDF_ENV_DIR = os.getenv("PDF_DIR")
 
 PDF_SEARCH_DIRS: List[Path] = [
@@ -185,13 +292,62 @@ RERANKER_CANDIDATES = int(os.getenv("RERANKER_CANDIDATES", "20"))
 
 GROQ_MODEL = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
 GROQ_TEMPERATURE = float(os.getenv("GROQ_TEMPERATURE", "0.05"))
-GROQ_MAX_TOKENS = int(os.getenv("GROQ_MAX_TOKENS", "1400"))
+# Bei einem Reasoning-Modell (openai/gpt-oss-*) teilen sich Denk- und
+# Antworttokens dieses Budget. Mit 1400 lief jede Antwort in `finish_reason:
+# length`, und wenn das Denken es aufbrauchte, kam gar keine — gemessen am
+# 19.08.2026: 1046 von 1400 Tokens allein fürs Reasoning. Der Client meldet die
+# Kürzung jetzt im Log und behandelt eine leere Antwort als Fehler.
+#
+# Nach oben begrenzt das **Groq-Kontingent**, nicht das Modell: die
+# Organisation liegt auf dem on_demand-Tier bei 8.000 Tokens pro Minute, und
+# geprüft wird je Anfrage über Prompt **plus** max_tokens. Ein voller Kontext
+# (DEFAULT_RAG_CONTEXT_CHARS=12.000) sind gemessen rund 4.825 Prompt-Tokens;
+# 4.000 Antworttokens ergaben 8.825 und damit HTTP 413. 2.800 lässt gut 350
+# Tokens Luft. Wer mehr braucht, braucht einen höheren Tier — oder einen
+# kleineren Kontext.
+GROQ_MAX_TOKENS = int(os.getenv("GROQ_MAX_TOKENS", "2800"))
+# Nachschlag bei leerer Antwort. Ohne höheres Kontingent ist er ausgeschaltet
+# (Decke = Budget): ein zweiter Aufruf mit mehr Tokens liefe in denselben 413.
+GROQ_MAX_TOKENS_CEILING = int(os.getenv("GROQ_MAX_TOKENS_CEILING", str(GROQ_MAX_TOKENS)))
 GROQ_DEBUG_PROMPTS = os.getenv("GROQ_DEBUG_PROMPTS", "false").lower() == "true"
 
 DEFAULT_TOP_K = int(os.getenv("DEFAULT_TOP_K", "6"))
 DEFAULT_FETCH_K = int(os.getenv("DEFAULT_FETCH_K", "18"))
 DEFAULT_MAX_FINAL_RESULTS = int(os.getenv("DEFAULT_MAX_FINAL_RESULTS", "10"))
 DEFAULT_MAX_SOURCES = int(os.getenv("DEFAULT_MAX_SOURCES", "5"))
+# Garantierte Trefferplätze je abgefragtem Korpus, bevor global gekürzt wird.
+# Ohne diese Untergrenze verliert ein kleines Korpus strukturell: die 106 Chunks
+# der Abrechnungsvereinbarung kamen gegen die 6.670 des SGB V nie an, auch wenn
+# die Regelung nur bei ihnen stand. Auf 0 gesetzt gilt wieder der reine
+# Score-Schnitt. Reserviert wird höchstens die Hälfte der Ergebnisliste.
+MIN_HITS_PER_CORPUS = int(os.getenv("MIN_HITS_PER_CORPUS", "2"))
+# Wie viele Normen ein Lauf nachladen darf, weil der gefundene Text auf sie
+# verweist. Auf 0 gesetzt ist die Verweisauflösung aus, und der Retriever
+# verhält sich wie vorher.
+#
+# **Die Vorgabe ist seit dem 21.08.2026 die 0, und zwar gemessen.** Die Idee war
+# richtig — ein einziger § des SGB V zitiert ein Dutzend andere, und was der Text
+# selbst in Bezug nimmt, ist ein Signal, das die Ähnlichkeitssuche nicht hat.
+# Nur ist das Budget fest: ein nachgeladener Verweis *ergänzt* den Kontext
+# nicht, er *ersetzt* etwas.
+#
+#   19.08.2026, VERWEIS_SCORE 0.97 — Kettenabdeckung 85 % -> 75 %.
+#   21.08.2026, VERWEIS_SCORE 0.50 — auf der damaligen Suite unauffällig (beide
+#     Konfigurationen 100 %), weil die Suite gesättigt war und nichts mehr
+#     trennen konnte. Auf der um fünf Fälle erweiterten Suite: 96,2 % ohne
+#     Verweise, 93,6 % mit.
+#
+# Sichtbar wird es an `kette_off_label_abgabe`: nachgeladen wurden § 3 SGB V
+# (solidarische Finanzierung) und § 300 SGB V (Abrechnung), beide ohne Bezug zur
+# Frage und beide mit dem festen Verweis-Score 0.50 — verdrängt hat das
+# § 31 Abs. 1 SGB V mit Score 0.871. Kein Fall der Suite gewinnt umgekehrt durch
+# die Verweise ein Kettenglied.
+#
+# Modul und Messschalter (`--ohne-verweise`) bleiben: die Frage ist beantwortet,
+# nicht erledigt. Wer den Verweis wieder aufnimmt, braucht ein eigenes Budget
+# **neben** dem Top-k, keinen Platz darin — und muss ihn nach Einschlägigkeit
+# auswählen statt nach Häufigkeit im Text.
+MAX_VERWEIS_NORMEN = int(os.getenv("MAX_VERWEIS_NORMEN", "0"))
 DEFAULT_RAG_CONTEXT_CHARS = int(os.getenv("DEFAULT_RAG_CONTEXT_CHARS", "12000"))
 DEFAULT_MIN_SCORE = float(os.getenv("DEFAULT_MIN_SCORE", "0.0"))
 
@@ -308,48 +464,68 @@ async def session_middleware(request: Request, call_next):
 # RAG-Komponenten
 # -----------------------------------------------------------------------------
 
-def _build_retriever() -> LegalRetriever:
-    """
-    Baut den Retriever und gibt Startdiagnose aus.
+corpus_registry: Optional[CorpusRegistry] = None
 
-    Wichtig für deine Debugging-Schleife:
-    Die Konsole muss idealerweise anzeigen:
-        APP CHROMA COUNT: 163
-    """
-    try:
-        instance = LegalRetriever(
+
+def get_corpus_registry() -> CorpusRegistry:
+    global corpus_registry
+    if corpus_registry is None:
+        corpus_registry = build_registry(
             persist_dir=CHROMA_PERSIST_DIR,
-            collection=CHROMA_COLLECTION,
             model_name=EMBEDDING_MODEL,
-            default_container_id=DEFAULT_CONTAINER_ID,
             enable_reranker=ENABLE_RERANKER,
             reranker_model=RERANKER_MODEL,
             reranker_candidates=RERANKER_CANDIDATES,
         )
-    except TypeError:
-        instance = LegalRetriever(
-            persist_dir=CHROMA_PERSIST_DIR,
-            collection=CHROMA_COLLECTION,
-            model_name=EMBEDDING_MODEL,
-        )
+    return corpus_registry
 
-    try:
-        count = instance.col.count()
-    except Exception:
-        count = "unknown"
+
+def _build_retriever() -> FederatedRetriever:
+    """
+    Baut den Retriever über alle konfigurierten Korpora und gibt Startdiagnose aus.
+
+    Bei genau einem Korpus verhält sich der föderierende Retriever wie der
+    bisherige `LegalRetriever` — die Routing- und Fusionsschritte sind dann
+    Durchreichen.
+    """
+    registry = get_corpus_registry()
+    instance = FederatedRetriever(
+        registry,
+        router=route_question,
+        # Die maßgeblichen Normen werden abgerufen, nicht erhofft. Das Register
+        # liefert nur Adressen; der Retriever bleibt frei von Rechtsinhalten.
+        anchors=norm_anchors.pflichtabruf,
+        # Und die Normen, die der gefundene Text selbst in Bezug nimmt. Das
+        # Register kennt die Kette eines Fragetyps, der Text die Kette seines
+        # eigenen Satzes — „nach Maßgabe der §§ 11 bis 14" löste bis dahin
+        # nichts aus. Seit dem 21.08.2026 steht `MAX_VERWEIS_NORMEN` auf 0 und
+        # damit ist der Abruf aus; die Begründung steht dort.
+        verweise=norm_verweise.abrufziele,
+        # Nennt die Frage ein Regelwerk, führt dessen Treffer die Liste an —
+        # auch gegen den Pflichtabruf. Der Anker behält seinen Platz im
+        # Kontext, aber nicht den ersten.
+        named_corpora=mentioned_corpora,
+        min_hits_per_corpus=MIN_HITS_PER_CORPUS,
+        max_verweis_normen=MAX_VERWEIS_NORMEN,
+    )
 
     print("APP USING CHROMA PATH:", CHROMA_PERSIST_DIR)
-    print("APP USING CHROMA COLLECTION:", CHROMA_COLLECTION)
-    print("APP CHROMA COUNT:", count)
+    for entry in registry.diagnostics()["corpora"]:
+        status = entry.get("count") if entry.get("ok") else entry.get("error")
+        print(f"APP CORPUS {entry['corpus_id']}: collection={entry['collection']} count={status}")
+
+    warning = registry.assert_consistent_embedding()
+    if warning:
+        print("APP WARNING:", warning)
 
     return instance
 
 
-retriever: Optional[LegalRetriever] = None
+retriever: Optional[FederatedRetriever] = None
 retriever_lock = Lock()
 
 
-def get_retriever() -> LegalRetriever:
+def get_retriever() -> FederatedRetriever:
     """Initialisiert Chroma/SentenceTransformer erst beim ersten echten Zugriff.
 
     Vorteil im Deployment: FastAPI kann importieren und starten, auch wenn Chroma
@@ -409,6 +585,7 @@ def _build_llm(session: SessionState) -> GroqClient:
         system_prompt=session.system_prompt,
         temperature=GROQ_TEMPERATURE,
         max_tokens=GROQ_MAX_TOKENS,
+        max_tokens_ceiling=GROQ_MAX_TOKENS_CEILING,
         debug_prompts=GROQ_DEBUG_PROMPTS,
     )
 
@@ -663,6 +840,34 @@ def _source_marker(numbers: List[int]) -> str:
     return "[Quellen " + ", ".join(str(n) for n in numbers) + "]"
 
 
+_SGB_BOOK_RE = re.compile(r"Sozialgesetzbuch.*?\(([IVXLC]+)\)", re.I)
+
+
+def _short_doc_title(title: str, *, max_chars: int = 32) -> str:
+    """Kürzt einen Dokumenttitel auf eine zitierfähige Kurzform.
+
+    Die vollen Titel aus den Chunk-Metadaten sind für eine Quellenzeile zu lang
+    ("Sozialgesetzbuch (SGB) Fünftes Buch (V) - Gesetzliche Krankenversicherung").
+    Das LLM bekommt weiterhin den vollen Titel im Kontext; gekürzt wird nur die
+    Anzeige.
+    """
+    text = " ".join(str(title or "").split())
+    if not text:
+        return ""
+
+    match = _SGB_BOOK_RE.search(text)
+    if match:
+        return f"SGB {match.group(1).upper()}"
+
+    # Untertitel nach Gedankenstrich abschneiden.
+    text = re.split(r"\s+[–—-]\s+", text, maxsplit=1)[0].strip()
+    if text.lower().startswith("rahmenvertrag"):
+        return "Rahmenvertrag"
+    if len(text) <= max_chars:
+        return text
+    return text[:max_chars].rsplit(" ", 1)[0].rstrip(" ,;:-–—") + "…"
+
+
 def _format_source_display_title(source: Dict[str, Any]) -> str:
     """Erzeugt eine UI-fertige, nummernstabile Quellenanzeige."""
     marker = _coalesce(source.get("source_label"), source.get("source_marker")) or _source_marker(
@@ -675,6 +880,12 @@ def _format_source_display_title(source: Dict[str, Any]) -> str:
     if not path:
         path = f"{container}::{section}"
 
+    # Dokumentangabe voranstellen, sobald der Korpus mehr als ein Dokument
+    # enthält. "§ 16" allein ist mehrdeutig: Rahmenvertrag und SGB V teilen sich
+    # 34 §-Nummern mit unterschiedlichem Inhalt.
+    doc = str(_coalesce(source.get("doc_title"), source.get("doc_id")) or "").strip()
+    doc_part = f"{_short_doc_title(doc)} · " if doc else ""
+
     pages = _coalesce(source.get("page_range"), source.get("pages"), "?")
     canonical_refs = [
         str(ref).strip()
@@ -691,7 +902,7 @@ def _format_source_display_title(source: Dict[str, Any]) -> str:
     if kinds == {"neighbor"}:
         role = " · Kontext/Nachbar"
 
-    return f"{marker} {path}{ref_part}, Seiten {pages}{role}".strip()
+    return f"{marker} {doc_part}{path}{ref_part}, Seiten {pages}{role}".strip()
 
 
 def _source_from_hit(hit: Dict[str, Any], *, source_number: Optional[int] = None) -> Dict[str, Any]:
@@ -755,6 +966,11 @@ def _source_from_hit(hit: Dict[str, Any], *, source_number: Optional[int] = None
         "page_end": _int_or_none(_coalesce(hit.get("page_end"), metadata.get("page_end"), hit.get("page_start"), metadata.get("page_start"))),
         "source_file": _coalesce(hit.get("source_file"), metadata.get("source_file")),
         "doc_id": _coalesce(hit.get("doc_id"), metadata.get("doc_id")),
+        "doc_title": _coalesce(hit.get("doc_title"), metadata.get("doc_title")),
+        # Von FederatedRetriever je Treffer gesetzt. Ohne Durchreichen weiß die
+        # API-Schicht nicht mehr, aus welchem Korpus eine Quelle stammt — der
+        # Änderungshinweis in corpus_amendments.py könnte dann nie greifen.
+        "corpus_id": _coalesce(hit.get("corpus_id"), metadata.get("corpus_id")),
         "highlights": _highlights_from_hit(hit),
         "legal_unit_id": _coalesce(hit.get("legal_unit_id"), metadata.get("legal_unit_id")),
         "parent_unit_id": _coalesce(hit.get("parent_unit_id"), metadata.get("parent_unit_id")),
@@ -789,6 +1005,27 @@ def _extract_answer_source_numbers(answer: str) -> List[int]:
     return list(dict.fromkeys(nums))
 
 
+def _answer_reports_nothing_found(answer: str) -> bool:
+    """Die Antwort zitiert nichts, nennt keine Norm und sagt, es gebe nichts.
+
+    Zwei Stellen hängen an dieser Frage: der Reichweiten-Hinweis, dessen Prämisse
+    ist, dass Textstellen herangezogen *wurden*, und die zurückgegebene
+    Quellenliste, die sonst fünf Fundstellen unter eine Aussage setzt, dass es
+    keine gibt.
+
+    Bewusst eng gefasst, damit der gewollte Fallback erhalten bleibt: vergisst das
+    Modell bei einer inhaltlichen Antwort die Marker, sollen seine Quellen weiter
+    erscheinen. Ein § irgendwo im Text heißt deshalb "etwas gefunden", unabhängig
+    davon, was die Antwort darüber behauptet.
+    """
+    text = answer or ""
+    if _extract_answer_source_numbers(text):
+        return False
+    if "§" in text:
+        return False
+    return bool(NEGATIVE_ANSWER_RE.search(text))
+
+
 def _merge_source(existing: Dict[str, Any], incoming: Dict[str, Any]) -> Dict[str, Any]:
     """Führt gruppierbare Quellen zusammen, ohne Nummern/Fundstellen zu verlieren."""
     merged = dict(existing)
@@ -835,6 +1072,7 @@ def _merge_source(existing: Dict[str, Any], incoming: Dict[str, Any]) -> Dict[st
     merged["page_end"] = max(ends) if ends else merged["page_start"]
     merged["source_file"] = _coalesce(existing.get("source_file"), incoming.get("source_file"))
     merged["doc_id"] = _coalesce(existing.get("doc_id"), incoming.get("doc_id"))
+    merged["doc_title"] = _coalesce(existing.get("doc_title"), incoming.get("doc_title"))
 
     highlights: List[Dict[str, Any]] = []
     seen_highlights: set = set()
@@ -869,6 +1107,9 @@ def _source_dedupe_key(src: Dict[str, Any]) -> tuple[Any, ...]:
     canonical_refs = tuple(src.get("canonical_refs") or [])
     return (
         "location",
+        # doc_id zuerst: gleiche §-Nummern in verschiedenen Dokumenten dürfen
+        # nicht zu einer Quelle verschmelzen.
+        src.get("doc_id"),
         src.get("container"),
         src.get("section"),
         src.get("pages") or src.get("page_range"),
@@ -1052,6 +1293,15 @@ def _postprocess_answer(
             logger.debug("Composer marker postprocessing skipped: %s", exc)
 
     text = _sanitize_unsupported_fine_references(text, sources=sources, hits=hits)
+
+    # Zuletzt, damit die vorherigen Schritte erst entfernen können, was einen
+    # Abschnitt nur scheinbar füllt (ungültige Marker, unbelegte Fundstellen).
+    if hasattr(composer, "_strip_empty_section_headings"):
+        try:
+            text = composer._strip_empty_section_headings(text)  # type: ignore[attr-defined]
+        except Exception as exc:
+            logger.debug("Composer section postprocessing skipped: %s", exc)
+
     return text.strip()
 
 
@@ -1073,6 +1323,11 @@ def _normalize_returned_sources(
     max_sources = payload.max_sources or DEFAULT_MAX_SOURCES
     cited_numbers = _extract_answer_source_numbers(answer)
 
+    # Hat die Antwort nichts gefunden, gibt es auch nichts anzuzeigen. Die
+    # kuratierte Liste wäre hier kein Fallback, sondern eine Behauptung.
+    if _answer_reports_nothing_found(answer):
+        return []
+
     normalized = _dedupe_sources(
         sources or [],
         max_sources=max(max_sources, len(cited_numbers), DEFAULT_MAX_SOURCES),
@@ -1155,6 +1410,17 @@ def _renumber_sources_for_display(
     for source in sources:
         old_numbers = _int_list(source.get("source_numbers"), source.get("source_number"))
         if not old_numbers:
+            # Quelle ohne Nummer: entsteht über den Rückfall auf die Roh-Treffer
+            # (`_dedupe_sources(hits, …)`), denn ein Treffer trägt keine
+            # Quellennummer — die vergibt erst der Composer. Übersprungen bekam
+            # sie hier nie `display_title`/`display_label` und erschien in der
+            # UI als **leere Zeile**. Sie bekommt deshalb ihre Anzeige, aber
+            # keinen Marker: zitiert wurde sie nicht, und eine erfundene Nummer
+            # stünde im Antworttext nirgends.
+            source.setdefault("source_marker", "")
+            source.setdefault("source_label", "")
+            source["display_title"] = _format_source_display_title(source)
+            source["display_label"] = source["display_title"]
             continue
 
         assigned: Optional[int] = None
@@ -1190,13 +1456,25 @@ def _debug_hit(hit: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def _collection_count() -> Any:
+    """Chunks über alle Korpora. Bei einem Korpus identisch zum bisherigen Wert."""
     try:
-        return get_retriever().col.count()
+        return get_corpus_registry().total_count()
     except Exception as exc:
         logger.warning("Chroma count unavailable: %s", exc)
         return "unknown"
 
 
+def _corpus_counts() -> Dict[str, Any]:
+    try:
+        return {
+            entry["corpus_id"]: entry.get("count", entry.get("error"))
+            for entry in get_corpus_registry().diagnostics()["corpora"]
+        }
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Korpus-Diagnose nicht verfügbar: %s", exc)
+        return {}
+
+
 # -----------------------------------------------------------------------------
 # Ask Graph Workflow
 # -----------------------------------------------------------------------------
@@ -1255,6 +1533,10 @@ class AskGraphContext:
 
     route: Optional[AskRoute] = None
     hits: Optional[List[Dict[str, Any]]] = None
+    # Die Teilmenge von `hits`, die die Antwort auch zitiert. Wird im
+    # Normalisierungsschritt gesetzt, solange der Antworttext noch die
+    # Retrieval-Ränge trägt (siehe `AnswerComposer.cited_hits`).
+    cited_hits: Optional[List[Dict[str, Any]]] = None
     raw_sources: Optional[List[Dict[str, Any]]] = None
     sources: Optional[List[Dict[str, Any]]] = None
     answer: str = ""
@@ -1272,6 +1554,8 @@ class AskGraphContext:
             self.raw_sources = []
         if self.sources is None:
             self.sources = []
+        if self.cited_hits is None:
+            self.cited_hits = []
         if self.trace is None:
             self.trace = []
 
@@ -1375,12 +1659,23 @@ def _ask_graph_normalize_sources(ctx: AskGraphContext) -> AskGraphStep:
             hits=ctx.hits,
             payload=ctx.payload,
         )
+        # Welche Treffer die Antwort tatsächlich zitiert — noch mit den
+        # Retrieval-Rängen, die gleich umnummeriert werden. Danach wäre die
+        # Zuordnung verloren: der Text trüge Anzeigenummern, die Treffer weiter
+        # ihre Ränge.
+        try:
+            ctx.cited_hits = AnswerComposer.cited_hits(ctx.answer, ctx.hits or [])
+        except Exception as exc:  # noqa: BLE001 - eine Nebenrechnung darf nie die Antwort verhindern.
+            logger.warning("Zitatzuordnung übersprungen: %s", exc)
+            ctx.cited_hits = []
+
         # Anzeige-Nummern stabil auf 1..n abbilden (statt Retrieval-Ränge wie
         # "[Quellen 3, 8]"). Muss als letzter Schritt laufen, damit Antworttext
         # und Quellenliste dieselben Nummern zeigen.
         ctx.answer, ctx.sources = _renumber_sources_for_display(ctx.answer, ctx.sources)
     else:
         ctx.sources = []
+        ctx.cited_hits = []
 
     return AskGraphStep("update_memory", "sources normalized and answer postprocessed")
 
@@ -1401,24 +1696,35 @@ _PAGE_RANGE_RE = re.compile(r"(\d+)\s*[–\-]\s*(\d+)|^(\d+)$")
 def _attach_pdf_locators(sources: List[Dict[str, Any]], hits: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Sicherheitsnetz: fehlende PDF-Locator aus Hits bzw. page_range ableiten.
 
-    Composer/Orchestrator liefern die Felder normalerweise bereits mit. Ältere
-    Pfade (Legacy-Fallbacks) können sie verlieren; da der Korpus derzeit aus
-    einem Dokument besteht, ist source_file aus einem beliebigen Hit belastbar.
+    Composer/Orchestrator liefern die Felder normalerweise bereits mit; ältere
+    Pfade (Legacy-Fallbacks) können sie verlieren.
+
+    Der Fallback wird pro Dokument gebildet, nicht global: bei mehreren Korpora
+    würde "irgendein Hit" sonst das falsche PDF an die Quelle heften und der
+    Viewer bei einer SGB-V-Fundstelle den Rahmenvertrag öffnen.
     """
-    fallback_file = None
-    fallback_doc_id = None
+    by_doc: Dict[str, Dict[str, Any]] = {}
     for hit in hits or []:
         metadata = hit.get("metadata") or {}
-        fallback_file = fallback_file or _coalesce(hit.get("source_file"), metadata.get("source_file"))
-        fallback_doc_id = fallback_doc_id or _coalesce(hit.get("doc_id"), metadata.get("doc_id"))
-        if fallback_file and fallback_doc_id:
-            break
+        doc_id = str(_coalesce(hit.get("doc_id"), metadata.get("doc_id")) or "")
+        entry = by_doc.setdefault(doc_id, {})
+        entry.setdefault("source_file", _coalesce(hit.get("source_file"), metadata.get("source_file")))
+        entry.setdefault("doc_title", _coalesce(hit.get("doc_title"), metadata.get("doc_title")))
+
+    # Nur wenn der Trefferpool eindeutig aus einem Dokument stammt, darf eine
+    # Quelle ohne doc_id daraus ergänzt werden.
+    single_doc = by_doc.get(next(iter(by_doc))) if len(by_doc) == 1 else None
 
     for source in sources or []:
-        if not source.get("source_file") and fallback_file:
-            source["source_file"] = fallback_file
-        if not source.get("doc_id") and fallback_doc_id:
-            source["doc_id"] = fallback_doc_id
+        doc_id = str(source.get("doc_id") or "")
+        entry = by_doc.get(doc_id) if doc_id else single_doc
+        if entry:
+            if not source.get("source_file") and entry.get("source_file"):
+                source["source_file"] = entry["source_file"]
+            if not source.get("doc_title") and entry.get("doc_title"):
+                source["doc_title"] = entry["doc_title"]
+        if not source.get("doc_id") and single_doc is not None:
+            source["doc_id"] = next(iter(by_doc))
 
         if source.get("page_start") is None:
             match = _PAGE_RANGE_RE.search(str(source.get("page_range") or source.get("pages") or ""))
@@ -1436,12 +1742,309 @@ def _attach_pdf_locators(sources: List[Dict[str, Any]], hits: List[Dict[str, Any
     return sources
 
 
+def _listenverdikt(
+    befund: Any,
+    austausch: Any,
+    biosimilar: Any = None,
+    otc: Any = None,
+    verordnung: Any = None,
+    lifestyle: Any = None,
+    tabak: Any = None,
+) -> str:
+    """Welcher der Listenbefunde die Kurzantwort setzt.
+
+    Die fünf Listen beantworten teils dieselbe Frageformulierung, aber
+    verschiedene Fragen — „dasselbe Präparat eines anderen Herstellers?"
+    (Anlage VII Teil B), „eine andere Darreichungsform?" (Teil A), „ein
+    Biosimilar statt des Originals?" (Anlage VIIa), „überhaupt zu Lasten der
+    GKV?" (Anlagen II, III und I). Die Reihenfolge folgt daraus, wie
+    einschneidend die Auskunft ist:
+
+    1. Ein Substitutionsausschluss aus Teil B ist eine harte Schranke und steht
+       über allem anderen.
+    2. Dann Anlage VIIa, wenn sie entschieden hat: ihre Wirkstoffe sind
+       biotechnologisch hergestellt und kommen in keiner der anderen Listen vor
+       (geprüft: die Wirkstoffmengen sind disjunkt). Wer nach Humira und
+       Amgevita fragt, bekommt sonst „Adalimumab steht nicht auf der
+       Substitutionsausschlussliste" — richtig, aber nicht die Frage.
+    3. Sonst Teil A, wenn die Frage zwei Formen benannt hat.
+    4. Dann Anlage IIa, dann Anlage II, danach Anlage III und erst danach
+       Anlage I. Alle vier beantworten dieselbe Frage — „darf das überhaupt zu
+       Lasten der GKV verordnet werden?" —, aber sie tragen verschieden weit.
+
+       Anlage IIa steht vor Anlage II, obwohl sie deren Ausnahme ist und nicht
+       ihre Regel: ihr Verdikt trägt **beide** Hälften („grundsätzlich
+       ausgeschlossen, ausnahmsweise verordnungsfähig, wenn …"), das der Anlage
+       II nur eine. Bei Champix stünde sonst „ist ausgeschlossen" als
+       Kurzantwort über einem Block, der zwei Absätze tiefer den Anspruch nach
+       § 34 Absatz 2 SGB V nennt — genau der Widerspruch, den
+       `antwort_mit_befunden` auflösen soll.
+
+       Anlage II steht vor III und I, weil ihr Ausschluss der härteste ist: er
+       beruht auf § 34 Absatz 1 Satz 7 SGB V, und der medizinisch begründete
+       Einzelfall des § 16 Absatz 5 AM-RL führt an ihm vorbei. Anlage III
+       entscheidet auch für verschreibungspflichtige Arzneimittel, hält den
+       Einzelfall bei ihren Markern 3 bis 6 aber offen; Anlage I urteilt nur
+       über nicht verschreibungspflichtige. Bei Sildenafil steht so „nach
+       Anlage II ausgeschlossen" statt des blasseren „steht nicht in Anlage III".
+    5. Alle drei stehen hinter den Austauschlisten, weil ihre Signale
+       („erstattungsfähig", „Kassenrezept") auch in einer Austauschfrage
+       vorkommen, umgekehrt aber nicht.
+    6. Erst danach das „nicht gelistet" aus Teil B — die schwächste Aussage von
+       allen. Ohne diese Reihenfolge würde eine reine Darreichungsformfrage mit
+       „Ambroxol steht nicht auf der Substitutionsausschlussliste" beantwortet:
+       richtig, aber am Thema vorbei.
+    """
+    if befund is not None and befund.status in {
+        "ausschluss",
+        "ausschluss_bedingt",
+        "ausschluss_zwischen_varianten",
+    }:
+        return amrl_substitution.verdikt(befund)
+
+    for modul, listenbefund in (
+        (amrl_biosimilars, biosimilar),
+        (amrl_austauschbarkeit, austausch),
+        (amrl_tabakentwoehnung, tabak),
+        (amrl_lifestyle, lifestyle),
+        (amrl_verordnungsausschluss, verordnung),
+        (amrl_otc, otc),
+    ):
+        if listenbefund is not None:
+            satz = modul.verdikt(listenbefund)
+            if satz:
+                return satz
+
+    return amrl_substitution.verdikt(befund) if befund is not None else ""
+
+
 def _ask_graph_build_response(ctx: AskGraphContext) -> AskGraphStep:
     """Baut exakt die bisherige API-Response-Struktur."""
     _attach_pdf_locators(ctx.sources or [], ctx.hits or [])
+
+    # Korpusgrenze offenlegen: verweist der herangezogene Kontext auf ein
+    # Regelwerk, das nicht indiziert ist (AM-RL, AMPreisV, …), wird das benannt.
+    # Ohne diesen Hinweis liest sich eine aus § 31 SGB V gebaute Antwort
+    # vollständig, obwohl die Verordnungsausschlüsse der AM-RL fehlen.
+    #
+    # Gelesen werden die *zitierten* Treffer, nicht der ganze Pool. Der Hinweis
+    # spricht von den „herangezogenen Textstellen"; im Ausdruck vom 20.08.2026
+    # stand unter einer Frage zur Austauschbarkeit von Darreichungsformen der
+    # Hinweis auf die BtMVV — sie kommt weder in § 9 Abs. 3 Rahmenvertrag noch
+    # in § 40c AM-RL vor, wohl aber in § 6 Rahmenvertrag, den das Modell
+    # verworfen hatte. Ein Hinweis auf ein Regelwerk, das die Antwort gar nicht
+    # berührt, entwertet die Hinweise, die tragen.
+    #
+    # Ist keine Zuordnung möglich (Antwort ohne Marker), bleibt es beim Pool:
+    # lieber ein Hinweis zu viel als eine verschwiegene Lücke.
+    boundary: List[Dict[str, str]] = []
+    if ctx.route != "meta":
+        try:
+            boundary = detect_external_references(
+                ctx.cited_hits or ctx.hits or [],
+                available_corpora=get_corpus_registry().corpus_ids,
+            )
+        except Exception as exc:  # noqa: BLE001 - ein Hinweis darf nie die Antwort verhindern.
+            logger.warning("Korpusgrenzen-Erkennung übersprungen: %s", exc)
+            boundary = []
+
+    # Stand der zitierten Vorschriften: nennt konkret, welche spätere
+    # Änderungsvereinbarung eine zitierte Norm geändert hat und was jetzt gilt.
+    # Betrifft Korpora, die nur als Grundfassung plus separate Änderungstexte
+    # veröffentlicht werden — dort wäre der indizierte Text sonst still veraltet.
+    # Beide Hinweise unten hängen an derselben Frage. Sie muss vor dem Abgleich
+    # beantwortet werden: reconcile_negative_answer setzt die Fundstelle der
+    # Änderungsvereinbarung in den Text und kippte die Prüfung sonst ins
+    # Gegenteil.
+    nothing_found = _answer_reports_nothing_found(ctx.answer)
+
+    amendments: List[Dict[str, Any]] = []
+    amendment_note = ""
+    if ctx.route != "meta":
+        try:
+            # Bewusst die ungefilterten Quellen: ob eine geänderte Vorschrift
+            # abgerufen wurde, entscheidet der Trefferbestand, nicht die für die
+            # Anzeige gekürzte Liste — die bei einer Verneinung leer ist.
+            amendment_note, amendments = describe_amendments(
+                ctx.raw_sources or ctx.sources or [],
+                path=AMENDMENTS_FILE,
+                question=ctx.question,
+            )
+        except Exception as exc:  # noqa: BLE001 - ein Hinweis darf nie die Antwort verhindern.
+            logger.warning("Änderungshinweis übersprungen: %s", exc)
+            amendment_note, amendments = "", []
+
+    # Das "nicht geregelt" des Modells gilt nur für den indizierten Stand. Folgt
+    # darunter der Änderungshinweis mit der geltenden Regelung, widersprechen
+    # sich beide Aussagen im Text, obwohl jede für sich zutrifft. Deshalb wird
+    # die Verneinung vor dem Anhängen auf ihren Geltungsbereich zurückgeführt.
+    answer = ctx.answer
+    if amendments:
+        try:
+            answer = reconcile_negative_answer(answer, amendments, path=AMENDMENTS_FILE)
+        except Exception as exc:  # noqa: BLE001 - siehe oben: nie die Antwort verhindern.
+            logger.warning("Abgleich mit dem Änderungshinweis übersprungen: %s", exc)
+
+    # Der Reichweiten-Hinweis spricht von den "herangezogenen Textstellen". Hat
+    # die Antwort nichts gefunden, wurde nichts herangezogen: die Verweise
+    # stammen dann aus Treffern, die das Modell verworfen hat, und benennen ein
+    # fremdes Thema. Beim Beispiel Chargendokumentation waren das AM-RL und BtMVV.
+    if boundary and nothing_found:
+        logger.info("Reichweiten-Hinweis unterdrückt: Antwort zitiert keine Quelle.")
+        boundary = []
+
+    # Substitutionsausschluss: deterministische Prüfung gegen AM-RL Anlage VII
+    # Teil B. Die Liste ist bewusst nicht indiziert — über Retrieval wäre die
+    # praktisch wichtigste Auskunft ("steht nicht drauf, also austauschbar")
+    # nicht belegbar, weil top-k immer Treffer liefert.
+    befund = None
+    austausch = None
+    biosimilar = None
+    otc = None
+    verordnung = None
+    lifestyle = None
+    tabak = None
+    if ctx.route != "meta":
+        # Teil A zuerst: seine Wirkstoffliste ist rund achtmal so lang wie die
+        # von Teil B und liefert dessen Negativauskunft den Namen, den die
+        # Endungsheuristik allein nicht sicher erkennt.
+        try:
+            austausch = amrl_austauschbarkeit.pruefe(ctx.question, path=AMRL_AUSTAUSCHBARKEIT_FILE)
+        except Exception as exc:  # noqa: BLE001 - eine Prüfung darf nie die Antwort verhindern.
+            logger.warning("Austauschbarkeitsprüfung übersprungen: %s", exc)
+            austausch = None
+        try:
+            befund = amrl_substitution.pruefe(
+                ctx.question,
+                path=AMRL_SUBSTITUTION_FILE,
+                kandidat=(austausch.wirkstoff if austausch is not None else None),
+            )
+        except Exception as exc:  # noqa: BLE001 - siehe oben.
+            logger.warning("Substitutionsprüfung übersprungen: %s", exc)
+            befund = None
+        try:
+            biosimilar = amrl_biosimilars.pruefe(ctx.question, path=AMRL_BIOSIMILARS_FILE)
+        except Exception as exc:  # noqa: BLE001 - siehe oben.
+            logger.warning("Biosimilar-Prüfung übersprungen: %s", exc)
+            biosimilar = None
+        try:
+            otc = amrl_otc.pruefe(ctx.question, path=AMRL_OTC_FILE)
+        except Exception as exc:  # noqa: BLE001 - siehe oben.
+            logger.warning("OTC-Prüfung übersprungen: %s", exc)
+            otc = None
+        try:
+            verordnung = amrl_verordnungsausschluss.pruefe(
+                ctx.question, path=AMRL_VERORDNUNG_FILE
+            )
+        except Exception as exc:  # noqa: BLE001 - siehe oben.
+            logger.warning("Verordnungsausschluss-Prüfung übersprungen: %s", exc)
+            verordnung = None
+        try:
+            lifestyle = amrl_lifestyle.pruefe(ctx.question, path=AMRL_LIFESTYLE_FILE)
+        except Exception as exc:  # noqa: BLE001 - siehe oben.
+            logger.warning("Lifestyle-Prüfung übersprungen: %s", exc)
+            lifestyle = None
+        try:
+            # Der Wirkstoff wird aus Anlage II übergeben, nicht neu erkannt:
+            # „Champix" steht dort in der Fertigarzneimittelspalte und wird zu
+            # „Vareniclin" aufgelöst, während Anlage IIa gar keine Produkte führt
+            # („alle marktverfügbaren Arzneimittel"). Übergeben wird nur, wenn
+            # der Treffer die Nikotinabhängigkeit betrifft — sonst beantwortete
+            # eine Frage nach Sildenafil eine Frage nach der Tabakentwöhnung.
+            tabak = amrl_tabakentwoehnung.pruefe(
+                ctx.question,
+                path=AMRL_TABAKENTWOEHNUNG_FILE,
+                stoff=(
+                    lifestyle.treffer[0].wirkstoff
+                    if lifestyle is not None and lifestyle.tabakentwoehnung and lifestyle.treffer
+                    else None
+                ),
+            )
+        except Exception as exc:  # noqa: BLE001 - siehe oben.
+            logger.warning("Tabakentwöhnungs-Prüfung übersprungen: %s", exc)
+            tabak = None
+
+    geprueft = [
+        b
+        for b in (befund, austausch, biosimilar, otc, verordnung, lifestyle, tabak)
+        if b is not None and b.ist_belastbar
+    ]
+
+    # Trägt einer der Befunde eine Auskunft, wurde die Liste geprüft — dann darf
+    # der Reichweiten-Hinweis nicht weiter behaupten, sie sei es nicht. Die
+    # übrigen Anlagen (Medizinprodukte, Verordnungsausschlüsse …) bleiben
+    # ungeprüft, deshalb wird nur der eine Eintrag entfernt und nicht der ganze
+    # Hinweis.
+    # Dasselbe gilt, wenn das Normregister eine AM-RL-Anlage als Fundstelle
+    # benennt: der Hinweis meldete die Anlagen als ungeprüft, während die Antwort
+    # sich zwei Absätze darüber auf Anlage VII Teil A berief.
+    anlage_benannt = False
+    if ctx.route != "meta":
+        try:
+            anlage_benannt = norm_anchors.anlagen_geprueft(ctx.question)
+        except Exception as exc:  # noqa: BLE001 - siehe oben.
+            logger.warning("Anlagenprüfung des Normregisters übersprungen: %s", exc)
+
+    if (geprueft or anlage_benannt) and boundary:
+        boundary = [ref for ref in boundary if ref.get("key") != "am_rl_anlagen"]
+
+    # Die Listenbefunde stehen ganz oben: sie sind die Auskunft, das Modell
+    # darunter ordnet ein, was daraus für Abgabe und Abrechnung folgt. Die
+    # Kurzantwort wird dabei angeglichen — ohne die Listen kommt das Modell zur
+    # allgemeinen Ersetzungsregel und widerspricht dem Befund zwei Zeilen darüber.
+    if geprueft:
+        answer = amrl_substitution.antwort_mit_befunden(
+            answer,
+            bloecke=[
+                amrl_substitution.befund_block(befund) if befund is not None else "",
+                amrl_austauschbarkeit.befund_block(austausch) if austausch is not None else "",
+                amrl_biosimilars.befund_block(biosimilar) if biosimilar is not None else "",
+                amrl_lifestyle.befund_block(lifestyle) if lifestyle is not None else "",
+                amrl_tabakentwoehnung.befund_block(tabak) if tabak is not None else "",
+                amrl_verordnungsausschluss.befund_block(verordnung)
+                if verordnung is not None
+                else "",
+                amrl_otc.befund_block(otc) if otc is not None else "",
+            ],
+            verdikt=_listenverdikt(
+                befund, austausch, biosimilar, otc, verordnung, lifestyle, tabak
+            ),
+        )
+
+    # Normebene statt Stoffebene: die vier Listen prüfen, ob ein Wirkstoff auf
+    # einer Anlage steht, und melden bei einer reinen Normfrage planmäßig
+    # `nicht_pruefbar`. Genau dort lagen die beiden schwersten Fehler der
+    # Auswertung — eine OTC-Frage mit § 31 statt § 34 beantwortet, das
+    # Zuweisungsverbot aus § 360 hergeleitet statt aus § 31 Abs. 1 Satz 6.
+    normbefund = None
+    if ctx.route != "meta":
+        try:
+            normbefund = norm_anchors.pruefe(ctx.question, answer)
+        except Exception as exc:  # noqa: BLE001 - ein Abgleich darf nie die Antwort verhindern.
+            logger.warning("Normabgleich übersprungen: %s", exc)
+            normbefund = None
+
+    if normbefund is not None:
+        # Steht die Antwort auf der falschen Vorschrift, werden „Kurzantwort" und
+        # „Maßgebliche Norm" neu gesetzt — ein bloßer Nachtrag stünde neben der
+        # falschen Antwort, und nichts im Text sagte, welcher gilt. Fehlt nur ein
+        # Glied der Kette, bleibt die Antwort stehen und bekommt den Nachtrag.
+        answer = norm_anchors.in_antwort_einsetzen(answer, normbefund)
+
+    # Beide Hinweise erst jetzt: sie werden ans Ende gehängt, und dort steht
+    # ohne eigene Überschrift noch der Abschnitt „Kurzantwort". Setzt ein
+    # Listenbefund diese Kurzantwort, ersetzt `antwort_mit_befunden` den ganzen
+    # Abschnitt — ein vorher angehängter Hinweis steckte darin und wäre spurlos
+    # verschwunden. Die Reihenfolge der beiden zueinander bleibt: der
+    # Änderungshinweis trägt die eigentliche Auskunft und steht deshalb vor dem
+    # Reichweiten-Hinweis, der nur eine Einschränkung benennt.
+    answer = append_amendment_note(answer, amendment_note)
+    if boundary:
+        answer = append_boundary_note(answer, boundary)
+
     ctx.response_body = {
         "question": ctx.question,
-        "answer": ctx.answer,
+        "answer": answer,
         "answer_type": ctx.answer_type,
         "session_id": ctx.request.state.session_id,
         "factual_question_index": ctx.memory.factual_question_count,
@@ -1449,6 +2052,23 @@ def _ask_graph_build_response(ctx: AskGraphContext) -> AskGraphStep:
         "sources": ctx.sources or [],
         "needs_clarification": ctx.needs_clarification,
         "clarification_question": ctx.clarification_question,
+        # Maschinenlesbar für UI/Monitoring: welche Regelwerke fehlten.
+        "corpus_boundary": boundary,
+        # Zitierte Vorschriften, deren indizierter Stand überholt ist.
+        "corpus_amendments": [
+            {"locator": p.get("locator"), "status": p.get("status"), "current_rule": p.get("current_rule")}
+            for p in amendments
+        ],
+        # Welche Norm das Register für maßgeblich hält und ob die Antwort sie nennt.
+        "norm_anchor": normbefund.to_dict() if normbefund is not None else None,
+        # Maschinenlesbare Listenbefunde samt Stand — für UI und Monitoring.
+        "substitutionsausschluss": befund.to_dict() if befund is not None else None,
+        "austauschbarkeit": austausch.to_dict() if austausch is not None else None,
+        "biosimilars": biosimilar.to_dict() if biosimilar is not None else None,
+        "otc_verordnungsfaehigkeit": otc.to_dict() if otc is not None else None,
+        "verordnungsausschluss": verordnung.to_dict() if verordnung is not None else None,
+        "lifestyle_ausschluss": lifestyle.to_dict() if lifestyle is not None else None,
+        "tabakentwoehnung": tabak.to_dict() if tabak is not None else None,
     }
     return AskGraphStep("__end__", "response built")
 
@@ -1715,6 +2335,10 @@ def _ask_graph_debug_payload(ctx: AskGraphContext) -> Dict[str, Any]:
         "chroma_persist_dir": CHROMA_PERSIST_DIR,
         "chroma_collection": CHROMA_COLLECTION,
         "chroma_count": _collection_count(),
+        "corpus_counts": _corpus_counts(),
+        "routed_corpora": sorted({
+            str(hit.get("corpus_id")) for hit in (ctx.hits or []) if hit.get("corpus_id")
+        }),
     }
 
 
@@ -1758,6 +2382,16 @@ def ask(payload: Question, request: Request):
         "sources": ctx.sources or [],
         "needs_clarification": ctx.needs_clarification,
         "clarification_question": ctx.clarification_question,
+        "corpus_boundary": [],
+        # Der Fallback greift nur, wenn der Graph keinen Body gebaut hat; die
+        # Schlüssel bleiben trotzdem stabil, damit die UI nicht zwei Formen kennen muss.
+        "substitutionsausschluss": None,
+        "austauschbarkeit": None,
+        "biosimilars": None,
+        "otc_verordnungsfaehigkeit": None,
+        "verordnungsausschluss": None,
+        "lifestyle_ausschluss": None,
+        "tabakentwoehnung": None,
     }
 
     if payload.debug:
@@ -1820,6 +2454,7 @@ def health():
         "app": APP_TITLE,
         "version": APP_VERSION,
         "collection": CHROMA_COLLECTION,
+        "corpora": _corpus_counts(),
         "chroma_persist_dir": CHROMA_PERSIST_DIR,
         "chroma_count": _collection_count(),
         "default_container_id": DEFAULT_CONTAINER_ID,
@@ -1833,42 +2468,67 @@ def health():
 
 @app.get("/debug/retriever")
 def debug_retriever():
-    sample: List[Dict[str, Any]] = []
-
+    """Diagnose pro Korpus statt für eine einzelne Collection."""
     try:
-        retriever_instance = get_retriever()
-        res = retriever_instance.col.get(limit=5, include=["metadatas", "documents"])
-        docs = res.get("documents") or []
-        metas = res.get("metadatas") or []
-        ids = res.get("ids") or []
-
-        for idx, meta in enumerate(metas):
-            doc = docs[idx] if idx < len(docs) else ""
-            sample.append(
-                {
-                    "id": ids[idx] if idx < len(ids) else None,
-                    "metadata": meta,
-                    "normalized_source": _source_from_hit({"metadata": meta}),
-                    "text_preview": (doc or "")[:250],
-                }
-            )
+        registry = get_corpus_registry()
+        diagnostics = registry.diagnostics()
     except Exception as exc:
         return {
             "ok": False,
             "error": f"{type(exc).__name__}: {exc}",
             "chroma_persist_dir": CHROMA_PERSIST_DIR,
-            "collection": CHROMA_COLLECTION,
         }
 
+    for entry in diagnostics["corpora"]:
+        if not entry.get("ok"):
+            continue
+        try:
+            res = registry.retriever(entry["corpus_id"]).col.get(limit=3, include=["metadatas", "documents"])
+            docs = res.get("documents") or []
+            metas = res.get("metadatas") or []
+            ids = res.get("ids") or []
+            entry["sample"] = [
+                {
+                    "id": ids[idx] if idx < len(ids) else None,
+                    "metadata": meta,
+                    "normalized_source": _source_from_hit({"metadata": meta}),
+                    "text_preview": (docs[idx] if idx < len(docs) else "")[:250],
+                }
+                for idx, meta in enumerate(metas)
+            ]
+        except Exception as exc:  # noqa: BLE001
+            entry["sample_error"] = f"{type(exc).__name__}: {exc}"
+
     return {
         "ok": True,
         "chroma_persist_dir": CHROMA_PERSIST_DIR,
-        "collection": CHROMA_COLLECTION,
         "count": _collection_count(),
-        "sample": sample,
+        "embedding_consistency": registry.assert_consistent_embedding() or "ok",
+        **diagnostics,
     }
 
 
+@app.get("/debug/routing")
+def debug_routing(question: str = ""):
+    """Zeigt, welche Korpora eine Frage erreichen würde — und warum."""
+    try:
+        available = get_corpus_registry().available()
+    except Exception as exc:  # noqa: BLE001
+        return {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
+
+    out: Dict[str, Any] = {"ok": True, **explain_routing(question, available)}
+
+    # Der Router sieht nur den Wortlaut. Ob ein Korpus zusätzlich zwingend
+    # abgefragt wird, entscheidet das Normregister — und genau dieser Fall ist
+    # der, den man debuggen will ("Sonderkennzeichen" nennt kein Korpus).
+    try:
+        out["federation"] = get_retriever().explain_selection(question)
+    except Exception as exc:  # noqa: BLE001
+        out["federation_error"] = f"{type(exc).__name__}: {exc}"
+
+    return out
+
+
 # -----------------------------------------------------------------------------
 # Session System-Prompt
 # -----------------------------------------------------------------------------

src/corpus_amendments.py

@@ -0,0 +1,277 @@
+"""Name the concrete changes a corpus's indexed version does not yet contain.
+
+Some corpora are only published as a base version plus separate amendment
+documents.  The Arzneimittelabrechnungsvereinbarung is the case this was written
+for: the GKV-Spitzenverband offers the Fassung vom 01.07.2023 and five later
+amendment texts, but no consolidated version.
+
+Indexing the base alone would be silently wrong, and the amendment texts are
+useless as retrieval material — they consist of editing instructions ("In § 4
+Absatz 2 werden die Wörter … ersetzt"), not of normative text.  So the amendments
+are curated once into `data/amabrv_aenderungen.json` and surfaced here: whenever
+an answer cites a provision that was later changed, the answer says which
+amendment changed it and what it now says.
+
+This is deliberately narrower than `corpus_boundary`, which reports whole
+regelwerke the index lacks.  Here the corpus *has* the provision — it is just
+older than the law in force.
+
+The note alone is not enough.  When an amendment *introduced* a rule, the model
+answers "dazu gibt es keine Regelung" — true of the indexed text, false of the
+law — and the note then states the rule two lines below.  Both statements are
+correct in their own scope, but nothing in the text marks the scope change, so
+the answer reads as self-contradictory.  `reconcile_negative_answer` therefore
+rewrites the model's bare denial into a scoped one before the note is appended.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence
+
+from answer_schema import SHORT_ANSWER_HEADING, is_denial, split_sections
+
+logger = logging.getLogger(__name__)
+
+_CACHE: Dict[str, Dict[str, Any]] = {}
+
+
+def load_amendments(path: Path) -> Dict[str, Any]:
+    """Read and cache one amendment file. A missing file is not an error."""
+    key = str(path)
+    if key in _CACHE:
+        return _CACHE[key]
+
+    data: Dict[str, Any] = {}
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001 - a broken notice file must not break answers.
+        logger.warning("Änderungsdatei nicht lesbar: %s (%s)", path, exc)
+        data = {}
+
+    _CACHE[key] = data
+    return data
+
+
+def _norm(text: Any) -> str:
+    return " ".join(str(text or "").strip().lower().split())
+
+
+def _hit_corpus(hit: Dict[str, Any]) -> str:
+    metadata = hit.get("metadata") or {}
+    return str(hit.get("corpus_id") or metadata.get("corpus_id") or "")
+
+
+def _hit_container(hit: Dict[str, Any]) -> str:
+    metadata = hit.get("metadata") or {}
+    return str(hit.get("container") or hit.get("container_id") or metadata.get("container_id") or "")
+
+
+def _hit_section(hit: Dict[str, Any]) -> str:
+    metadata = hit.get("metadata") or {}
+    return str(hit.get("section") or hit.get("section_id") or metadata.get("section_id") or "")
+
+
+def affected_provisions(
+    sources: Sequence[Dict[str, Any]],
+    *,
+    amendments: Dict[str, Any],
+    question: str = "",
+) -> List[Dict[str, Any]]:
+    """Provisions that later amendments changed, by citation or by topic.
+
+    Two triggers, because one alone leaves a hole:
+
+    * **Citation** — a cited source sits in an amended provision.  Matching is on
+      corpus + container + section, never on the § number alone: this corpus
+      restarts its § numbering inside every Anlage.
+    * **Topic** — the question names something an amendment *introduced*.  Such a
+      rule is by definition absent from the indexed base text, so nothing can be
+      retrieved and nothing gets cited; without this trigger the user would be
+      told nothing exists when a binding rule does.  The Chargendokumentation
+      beim "Stellen" is exactly that case: added 2024, extended to 31.12.2026.
+    """
+    provisions = amendments.get("provisions") or []
+    corpus_id = _norm(amendments.get("corpus_id"))
+    if not provisions or not corpus_id:
+        return []
+
+    wanted = {(_norm(p.get("container")), _norm(p.get("section"))): p for p in provisions}
+    haystack = _norm(question)
+    seen: set = set()
+    out: List[Dict[str, Any]] = []
+
+    for source in sources or []:
+        if _norm(_hit_corpus(source)) != corpus_id:
+            continue
+        key = (_norm(_hit_container(source)), _norm(_hit_section(source)))
+        if key in wanted and key not in seen:
+            seen.add(key)
+            out.append(wanted[key])
+
+    if haystack:
+        for provision in provisions:
+            key = (_norm(provision.get("container")), _norm(provision.get("section")))
+            if key in seen:
+                continue
+            terms = [_norm(t) for t in provision.get("trigger_terms") or []]
+            if any(term and term in haystack for term in terms):
+                seen.add(key)
+                out.append(provision)
+
+    return out
+
+
+def amendment_note(
+    provisions: Sequence[Dict[str, Any]],
+    *,
+    amendments: Dict[str, Any],
+) -> str:
+    """Spell out, per provision, what changed and what applies now."""
+    if not provisions:
+        return ""
+
+    version = amendments.get("indexed_version_label") or amendments.get("indexed_version") or ""
+    lines: List[str] = [
+        f"Hinweis zum Stand: Der indizierte Text gibt die {version} wieder. "
+        "Zu den folgenden Vorschriften gibt es spätere Änderungsvereinbarungen, "
+        "die nicht im durchsuchten Text enthalten sind:"
+    ]
+
+    for provision in provisions:
+        locator = provision.get("locator") or f"{provision.get('container')} {provision.get('section')}"
+        lines.append("")
+        lines.append(f"{locator} — {provision.get('status') or 'geändert'}:")
+        for change in provision.get("changes") or []:
+            amendment = change.get("amendment") or "Änderungsvereinbarung"
+            kind = change.get("kind") or "geändert"
+            lines.append(f"  - {amendment} ({kind})")
+            verbatim = str(change.get("verbatim") or "").strip()
+            if verbatim:
+                lines.append(f"    „{verbatim}“")
+        current = str(provision.get("current_rule") or "").strip()
+        if current:
+            lines.append(f"  Aktuell gilt danach: {current}")
+
+    return "\n".join(lines)
+
+
+def append_amendment_note(answer: str, note: str) -> str:
+    if not note:
+        return answer
+    text = (answer or "").rstrip()
+    return f"{text}\n\n{note}" if text else note
+
+
+# ---------------------------------------------------------------------------
+# Reconciling a negative answer with the amendment note
+# ---------------------------------------------------------------------------
+
+def _bridge_sentence(
+    provisions: Sequence[Dict[str, Any]],
+    *,
+    amendments: Dict[str, Any],
+) -> str:
+    """The denial, restated with the scope it actually has."""
+    version = amendments.get("indexed_version_label") or amendments.get("indexed_version") or ""
+    scope = f"In der {version}" if version else "In der indizierten Fassung"
+
+    locators: List[str] = []
+    for provision in provisions:
+        locator = provision.get("locator") or " ".join(
+            str(provision.get(key) or "") for key in ("container", "section")
+        ).strip()
+        if locator and locator not in locators:
+            locators.append(locator)
+
+    lead = f"{scope} — dem hier durchsuchten Stand — ist das nicht geregelt."
+    if locators:
+        return (
+            f"{lead} Die Antwort ergibt sich erst aus späteren Änderungsvereinbarungen "
+            f"zu {', '.join(locators)}; ihr Inhalt steht unten unter „Hinweis zum Stand“."
+        )
+    return (
+        f"{lead} Die Antwort ergibt sich erst aus späteren Änderungsvereinbarungen; "
+        "ihr Inhalt steht unten unter „Hinweis zum Stand“."
+    )
+
+
+def reconcile_negative_answer(
+    answer: str,
+    provisions: Sequence[Dict[str, Any]],
+    *,
+    path: Path,
+) -> str:
+    """Scope the model's "nicht geregelt" to the indexed version.
+
+    Only runs when `provisions` is non-empty, i.e. when the amendment note that
+    follows will state a rule the answer just denied.  A genuine "not regulated"
+    answer — no amendment in sight — is left exactly as the model wrote it.
+
+    The leading `Kurzantwort` keeps its heading and gets the scoped statement.
+    Sections that say nothing but "gibt es nicht" are dropped here too; the
+    composer already removes them on every answer, so in the running system this
+    is redundant — it keeps the function correct when called on its own.
+    """
+    if not answer or not provisions:
+        return answer
+
+    amendments = load_amendments(path)
+    if not amendments:
+        return answer
+
+    bridge = _bridge_sentence(provisions, amendments=amendments)
+    blocks = split_sections(answer)
+
+    # No schema at all — e.g. the composer's canned "keine relevante Textstelle".
+    if not any(heading for heading, _ in blocks):
+        return bridge if is_denial(answer) else answer
+
+    parts: List[str] = []
+    replaced = False
+    dropped = False
+
+    for heading, body_lines in blocks:
+        body = "\n".join(body_lines).strip()
+
+        if heading is None:
+            if body:
+                parts.append(body)
+            continue
+
+        if not is_denial(body):
+            parts.append(f"{heading}:\n{body}" if body else f"{heading}:")
+            continue
+
+        if heading == SHORT_ANSWER_HEADING:
+            parts.append(f"{heading}:\n{bridge}")
+            replaced = True
+        else:
+            dropped = True
+
+    if not replaced and not dropped:
+        return answer
+    if not replaced:
+        parts.insert(0, f"{SHORT_ANSWER_HEADING}:\n{bridge}")
+
+    return "\n\n".join(part for part in parts if part.strip())
+
+
+def describe(
+    sources: Sequence[Dict[str, Any]],
+    *,
+    path: Path,
+    question: str = "",
+) -> tuple[str, List[Dict[str, Any]]]:
+    """Convenience wrapper: (note, machine-readable provisions)."""
+    amendments = load_amendments(path)
+    if not amendments:
+        return "", []
+    provisions = affected_provisions(sources, amendments=amendments, question=question)
+    if not provisions:
+        return "", []
+    return amendment_note(provisions, amendments=amendments), provisions

src/corpus_boundary.py

@@ -0,0 +1,273 @@
+"""Make the edge of the indexed corpus visible in the answer.
+
+The retrieved text routinely points at legal sources this assistant does not
+index.  `§ 31 SGB V` grants the claim to medicines "soweit diese nicht … durch
+Richtlinien nach § 92 Absatz 1 Satz 2 Nummer 6 ausgeschlossen sind" — that
+exclusion lives in the Arzneimittel-Richtlinie.  A model that only sees the
+statute will answer confidently and omit the exception.
+
+Since the `amrl` corpus was added, that particular reference is covered and the
+note disappears by itself (`covered_by`).  What did *not* move into the index are
+the AM-RL's Anlagen — the substance and product lists — and they are tracked as
+their own entry.  Splitting the two matters: a single entry would either vanish
+with the directive text and imply the lists were checked, or keep firing on
+answers that were in fact fully covered.
+
+That is the same failure mode `corpus_router` guards against on the way in, one
+step later: not the wrong corpus, but a *missing* one.  The cheap, honest fix is
+to detect the dangling reference in the retrieved context and say so, rather than
+to let the answer imply completeness it does not have.
+
+Detection runs on the retrieved chunks, not on the question. A user asking "Ist
+Ibuprofen erstattungsfähig?" names no source at all — but the § 31 chunk that
+answers it carries the reference to the AM-RL verbatim, which makes the context
+the far more reliable signal.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Optional, Sequence
+
+
+@dataclass(frozen=True)
+class ExternalSource:
+    """A legal source the retrieved text may point at."""
+
+    key: str
+    label: str
+    # What the user should understand is missing, in one clause.
+    scope: str
+    pattern: re.Pattern[str]
+    # Corpus id that would cover this source once indexed.  None = no corpus of
+    # this project will ever cover it (then the note is permanent, not a TODO).
+    covered_by: Optional[str] = None
+
+
+def _rx(pattern: str) -> re.Pattern[str]:
+    return re.compile(pattern, re.I)
+
+
+# Ordered by how often the reference actually decides a pharmacy question.
+EXTERNAL_SOURCES: tuple[ExternalSource, ...] = (
+    # The AM-RL is indexed as its directive text only.  Its Anlagen are substance
+    # and product lists that the G-BA publishes as separate documents, and they
+    # stay out on purpose: the decisive answer about a list is frequently the
+    # negative one ("not listed, so it may be substituted"), and a vector search
+    # cannot establish absence — it always returns the k nearest chunks.  So this
+    # gap is not a TODO, it is a property of the retrieval method, and it is the
+    # sharper of the two AM-RL entries.  It is listed first for that reason.
+    #
+    # Roman numerals are what make the detection specific: the Rahmenvertrag and
+    # the Abrechnungsvereinbarung number their own Anlagen in arabic digits, so
+    # "Anlage VII" in retrieved text always means the AM-RL.  Measured over the
+    # indexed corpora: 57 hits in amrl, 6 in rv129 (§ 9 Abs. 1 points at the
+    # "Substitutions-Ausschlussliste … (Arzneimittel-Richtlinie Anlage VII
+    # Teil B)"), 0 in sgb5 and amabrv.
+    ExternalSource(
+        key="am_rl_anlagen",
+        label="Anlagen der Arzneimittel-Richtlinie (Wirkstoff- und Produktlisten)",
+        # Was hier steht, muss den *verbliebenen* Rest benennen. Sieben Anlagen
+        # sind inzwischen als Lookup nachschlagbar (I, II, IIa, III, VII Teil A
+        # und B, VIIa) und werden vom Aufrufer aus dem Hinweis genommen, sobald
+        # ein Befund vorliegt; nennte der Text sie weiter als ungeprüft, meldete
+        # er eine Lücke, die die Antwort zwei Absätze darüber geschlossen hat.
+        # Anlage IIa stand hier, solange `amrl_lifestyle` den Weg über § 34
+        # Absatz 2 SGB V nur benennen konnte; seit `amrl_tabakentwoehnung` löst
+        # ein eigener Befund ihn ein.
+        #
+        # Die Aufzählung nennt nur die wirkstoff- und produktbezogenen Listen.
+        # Das Muster unten trifft auch die Anlagen VIII bis XII (Analogpräparate,
+        # Festbeträge, Nutzenbewertung) — die sind keine solchen Listen, und der
+        # Hinweis benennt sie deshalb sammelnd am Ende, statt einen Katalog zu
+        # führen, der bei jeder Novelle nachzuziehen wäre.
+        scope="die übrigen wirkstoff- und produktbezogenen Listen — Therapiehinweise "
+        "(Anlage IV), verordnungsfähige Medizinprodukte (Anlage V), Verbandmittel "
+        "(Anlage Va) und der Off-Label-Use (Anlage VI) — sowie die übrigen Anlagen "
+        "der Richtlinie",
+        pattern=_rx(
+            r"Anlage\s+(?:XII|XI|X|IX|VIII|VII|VI|V|IV|III|II|I)a?\b"
+            r"|Substitutions-?\s?Ausschlussliste"
+            r"|Substitutionsausschluss"
+            r"|OTC-?\s?(?:Übersicht|Ausnahmeliste)"
+            r"|§\s*129\s+Abs(?:atz|\.)?\s*1a\s+Satz\s*2"
+        ),
+    ),
+    # The directive text itself: covered once the `amrl` corpus is loaded.  Kept
+    # as a separate entry rather than deleted, so a single-corpus deployment
+    # still discloses the gap.
+    ExternalSource(
+        key="am_rl",
+        label="Arzneimittel-Richtlinie (AM-RL)",
+        scope="Verordnungsfähigkeit, Verordnungsausschlüsse und die Regeln zur "
+        "Austauschbarkeit",
+        pattern=_rx(
+            r"§\s*92\s+Abs(?:atz|\.)?\s*1\s+Satz\s*2\s+Nummer\s*6"
+            r"|§\s*92\s+Abs\.\s*1\s+Satz\s*2\s+Nr\.\s*6"
+            r"|Arzneimittel-?\s?Richtlinie"
+            r"|Richtlinien?\s+nach\s+§\s*92"
+        ),
+        covered_by="amrl",
+    ),
+    ExternalSource(
+        key="ampreisv",
+        label="Arzneimittelpreisverordnung (AMPreisV)",
+        scope="Apothekenzuschläge und Preisbildung",
+        pattern=_rx(r"Arzneimittelpreisverordnung|AMPreisV|Arzneimittelpreisrecht"),
+    ),
+    # Die Verschreibungspflicht selbst steht in keinem der vier Korpora. Der
+    # Rahmenvertrag setzt sie voraus und verweist auf die Formerfordernisse
+    # („wenn die Angaben den §§ 2 Absatz 1 Nummern 4 bis 6 und 7 AMVV … nicht
+    # vollständig entsprechen", § 6); § 48 AMG ordnet sie an. Ohne diese beiden
+    # Einträge beantwortete der Prototyp eine Frage nach der Verschreibungs-
+    # pflicht aus § 31 SGB V — einer Anspruchsnorm, die dazu nichts sagt — und
+    # nichts im Text hätte die Lücke benannt.
+    ExternalSource(
+        key="amvv",
+        label="Arzneimittelverschreibungsverordnung (AMVV)",
+        scope="die Verschreibungspflicht einzelner Stoffe und die Formerfordernisse "
+        "der Verschreibung",
+        pattern=_rx(r"Arzneimittelverschreibungsverordnung|\bAMVV\b"),
+    ),
+    ExternalSource(
+        key="amg",
+        label="Arzneimittelgesetz (AMG)",
+        scope="Zulassung, Verschreibungspflicht nach § 48 und Verkehrsfähigkeit",
+        pattern=_rx(r"Arzneimittelgesetz(?:es)?\b|\bAMG\b"),
+    ),
+    ExternalSource(
+        key="btmvv",
+        label="Betäubungsmittel-Verschreibungsverordnung (BtMVV)",
+        scope="Betäubungsmittelrezepte und deren Formerfordernisse",
+        pattern=_rx(r"Bet[äa]ubungsmittel-?Verschreibungsverordnung|BtMVV"),
+    ),
+    ExternalSource(
+        key="apog",
+        label="Apothekengesetz (ApoG)",
+        scope="Betriebserlaubnis, Zuweisungsverbot und Versandhandel",
+        pattern=_rx(r"Apothekengesetz(?:es)?\b|\bApoG\b"),
+    ),
+    # Der Rahmenvertrag nennt sie ohne Paragraphenzeichen — „die mit dem
+    # kleinsten Packungsgrößenkennzeichen gemäß der PackungsV in Vertrieb
+    # befindliche Packung" (§ 17). Für den Verweisparser ist das kein Verweis,
+    # für die Reichweite sehr wohl: welche Packung N1 ist, steht dort und
+    # nirgends im Bestand.
+    ExternalSource(
+        key="packungsv",
+        label="Packungsgrößenverordnung (PackungsV)",
+        scope="die Packungsgrößenkennzeichen N1, N2 und N3 und ihre Bestimmung",
+        pattern=_rx(r"Packungsgr[öo]ßenverordnung|\bPackungsV\b"),
+    ),
+    ExternalSource(
+        key="apbetro",
+        label="Apothekenbetriebsordnung (ApBetrO)",
+        scope="Betriebspflichten der Apotheke",
+        pattern=_rx(r"Apothekenbetriebsordnung|ApBetrO"),
+    ),
+    # Die Vereinbarung ist indiziert, ihre Technischen Anlagen sind es nicht —
+    # und dort steht, welches Sonderkennzeichen für welchen Sachverhalt gilt.
+    # Deshalb ein eigener Eintrag statt eines Zusatzes beim amabrv-Eintrag: der
+    # verschwindet mit dem geladenen Korpus, die Anlagen bleiben draußen.
+    # Dieselbe Trennung wie bei der AM-RL und ihren Anlagen.
+    ExternalSource(
+        key="amabrv_technische_anlagen",
+        label="Technische Anlagen zur Arzneimittelabrechnungsvereinbarung",
+        scope="die einzelnen Sonderkennzeichen, der Datensatzaufbau und die "
+        "Feldbelegungen",
+        pattern=_rx(r"Technische[nrs]?\s+Anlage\s*\d*"),
+    ),
+    ExternalSource(
+        key="amabrv",
+        label="Arzneimittelabrechnungsvereinbarung (§ 300 Abs. 3 SGB V)",
+        scope="Abrechnungsverfahren, Sonderkennzeichen, Beanstandung und Fristen",
+        pattern=_rx(
+            r"§\s*300\s+Abs(?:atz|\.)?\s*3"
+            r"|Abrechnungsvereinbarung"
+            r"|Vereinbarung\s+nach\s+§\s*300"
+        ),
+        covered_by="amabrv",
+    ),
+    ExternalSource(
+        key="rahmenvertrag",
+        label="Rahmenvertrag nach § 129 Abs. 2 SGB V",
+        scope="Abgaberegeln der Apotheke",
+        pattern=_rx(r"Rahmenvertrag\s+nach\s+§\s*129|Rahmenvertrag(?:es)?\s+über\s+die\s+Arzneimittelversorgung"),
+        covered_by="rv129",
+    ),
+)
+
+
+def _hit_text(hit: Dict[str, Any]) -> str:
+    metadata = hit.get("metadata") or {}
+    parts = [
+        hit.get("text"),
+        hit.get("document"),
+        metadata.get("text"),
+    ]
+    return " ".join(str(p) for p in parts if p)
+
+
+def detect_external_references(
+    hits: Sequence[Dict[str, Any]],
+    *,
+    available_corpora: Iterable[str] = (),
+    max_results: int = 3,
+) -> List[Dict[str, str]]:
+    """External sources the retrieved context leans on but the index lacks.
+
+    A source whose `covered_by` corpus is loaded is not reported: the assistant
+    can answer from it, so there is no gap to disclose.
+    """
+    available = {str(c).lower() for c in available_corpora}
+    blob = " ".join(_hit_text(hit) for hit in hits or [])
+    if not blob.strip():
+        return []
+
+    found: List[Dict[str, str]] = []
+    for source in EXTERNAL_SOURCES:
+        if source.covered_by and source.covered_by.lower() in available:
+            continue
+        if source.pattern.search(blob):
+            found.append({"key": source.key, "label": source.label, "scope": source.scope})
+        if len(found) >= max_results:
+            break
+    return found
+
+
+def boundary_note(references: Sequence[Dict[str, str]]) -> str:
+    """One short paragraph naming what the answer could not consider."""
+    if not references:
+        return ""
+
+    # Die Labels tragen keinen Artikel, damit sie auch in der Aufzählung unten
+    # passen; der Satzbau vermeidet ihn deshalb durch den Doppelpunkt.
+    if len(references) == 1:
+        ref = references[0]
+        return (
+            "Hinweis zur Reichweite: Die herangezogenen Textstellen verweisen auf ein "
+            f"Regelwerk außerhalb des durchsuchten Bestands — {ref['label']}. "
+            f"Damit sind {ref['scope']} hier nicht geprüft."
+        )
+
+    labels = "; ".join(f"{r['label']} ({r['scope']})" for r in references)
+    return (
+        "Hinweis zur Reichweite: Die herangezogenen Textstellen verweisen auf Regelwerke "
+        f"außerhalb des durchsuchten Bestands — {labels}. Diese sind hier nicht geprüft."
+    )
+
+
+def append_boundary_note(answer: str, references: Sequence[Dict[str, str]]) -> str:
+    """Attach the note without disturbing the answer's own structure.
+
+    Appended rather than woven in: the composer's schema (Kurzantwort /
+    Maßgebliche Norm / Wortlaut / Einordnung) is validated elsewhere, and the
+    note is a statement about the index, not about the law.
+    """
+    note = boundary_note(references)
+    if not note:
+        return answer
+    text = (answer or "").rstrip()
+    if not text:
+        return note
+    return f"{text}\n\n{note}"

src/corpus_registry.py

@@ -0,0 +1,295 @@
+"""Registry of the legal corpora the assistant can search.
+
+Each corpus is one Chroma collection inside the shared persist directory and
+gets its own `LegalRetriever`, because the retrieval defaults differ per document
+type: the Rahmenvertrag has a main contract container that explicit § lookups
+should fall back to, a statute does not.
+
+Retrievers are built lazily. A cold start therefore still only pays for the
+collections a request actually touches, and a corpus that is missing from the
+persist directory degrades to a clear error on first use instead of breaking
+application startup.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from threading import Lock
+from typing import Any, Dict, List, Optional, Sequence
+
+from retriever import LegalRetriever
+
+logger = logging.getLogger(__name__)
+
+
+def _env_flag(name: str, default: bool) -> bool:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "ja", "on"}
+
+
+@dataclass(frozen=True)
+class CorpusSpec:
+    """Static description of one searchable corpus."""
+
+    corpus_id: str
+    collection: str
+    # Container the retriever falls back to for explicit § lookups.  Empty for a
+    # statute, whose §§ are spread across Kapitel containers.
+    default_container_id: str = ""
+    label: str = ""
+    # Lower-case keywords that name this corpus in a question.  Used by routing.
+    aliases: tuple[str, ...] = ()
+
+    def with_metadata(self, metadata: Dict[str, Any]) -> "CorpusSpec":
+        """Fill in the label from the collection metadata written at ingest time."""
+        if self.label:
+            return self
+        label = str(metadata.get("doc_title") or metadata.get("doc_id") or self.corpus_id)
+        return CorpusSpec(
+            corpus_id=self.corpus_id,
+            collection=self.collection,
+            default_container_id=self.default_container_id,
+            label=label,
+            aliases=self.aliases,
+        )
+
+
+# Aliases for the corpora this assistant ships with.  Unknown corpora still work;
+# they are simply routed to by name only.
+CORPUS_ALIASES: Dict[str, tuple[str, ...]] = {
+    "rv129": ("rahmenvertrag", "rahmenvertrages", "rahmenvertrag nach § 129", "rv129", "rv 129"),
+    "sgb5": ("sgb v", "sgb 5", "sgb5", "sozialgesetzbuch", "fünftes buch", "fuenftes buch"),
+    # Die Korpus-Id ist bewusst "amabrv", nicht "abrechnung": `mentioned_corpora`
+    # nimmt die Id selbst als Alias, und "Abrechnung" ist ein Alltagswort, das in
+    # Rahmenvertrag und SGB V laufend vorkommt — als Alias würde es jede zweite
+    # Frage auf dieses eine Korpus verengen, statt sie an alle drei zu geben.
+    # Hier stehen deshalb nur Formulierungen, die das Dokument wirklich benennen.
+    "amabrv": (
+        "arzneimittelabrechnungsvereinbarung",
+        "abrechnungsvereinbarung",
+        "vereinbarung nach § 300",
+        "vereinbarung nach §  300",
+        "§ 300 abs. 3",
+        "§ 300 absatz 3",
+    ),
+    # Dieselbe Regel wie bei amabrv: Aliase müssen das Dokument benennen, nicht
+    # sein Thema.  "arzneimittel" oder "richtlinie" allein stehen deshalb nicht
+    # hier — beide kommen in Rahmenvertrag und SGB V laufend vor und würden die
+    # Frage auf dieses eine Korpus verengen.  Indiziert ist der Richtlinientext;
+    # die Anlagen (Wirkstofflisten) sind bewusst nicht enthalten, worauf
+    # `corpus_boundary` in der Antwort hinweist.
+    "amrl": (
+        "arzneimittel-richtlinie",
+        "arzneimittelrichtlinie",
+        "arzneimittel richtlinie",
+        "am-rl",
+        "am rl",
+        "richtlinie nach § 92",
+        "richtlinie nach §  92",
+        "§ 92 abs. 1 satz 2 nr. 6",
+        "§ 92 absatz 1 satz 2 nummer 6",
+    ),
+}
+
+
+def specs_from_env() -> List[CorpusSpec]:
+    """Read the corpus list from the environment.
+
+    `CHROMA_COLLECTIONS` is a comma-separated list; when it is absent the single
+    `CHROMA_COLLECTION` is used, so an existing deployment keeps working without
+    any configuration change.
+
+    `DEFAULT_CONTAINER_ID` applies to the first corpus only — it is the
+    Rahmenvertrag's "Vertrag" and would wrongly restrict a statute.  Per-corpus
+    overrides use `CORPUS_CONTAINER__<corpus_id>`.
+    """
+    raw = os.getenv("CHROMA_COLLECTIONS", "")
+    collections = [c.strip() for c in raw.split(",") if c.strip()]
+    if not collections:
+        collections = [os.getenv("CHROMA_COLLECTION", "rv129").strip()]
+
+    primary_container = os.getenv("DEFAULT_CONTAINER_ID", "Vertrag")
+
+    specs: List[CorpusSpec] = []
+    for index, collection in enumerate(collections):
+        corpus_id = collection
+        container = os.getenv(
+            f"CORPUS_CONTAINER__{corpus_id}",
+            primary_container if index == 0 else "",
+        )
+        specs.append(
+            CorpusSpec(
+                corpus_id=corpus_id,
+                collection=collection,
+                default_container_id=container.strip(),
+                aliases=CORPUS_ALIASES.get(corpus_id.lower(), ()),
+            )
+        )
+    return specs
+
+
+@dataclass
+class CorpusRegistry:
+    """Lazily built `LegalRetriever` per corpus."""
+
+    specs: List[CorpusSpec]
+    persist_dir: str
+    model_name: str = "auto"
+    enable_reranker: bool = True
+    reranker_model: str = "cross-encoder/mmarco-mMiniLMv2-L12-H384-v1"
+    reranker_candidates: int = 20
+
+    _retrievers: Dict[str, LegalRetriever] = field(default_factory=dict, init=False, repr=False)
+    _lock: Lock = field(default_factory=Lock, init=False, repr=False)
+
+    @classmethod
+    def from_env(cls, *, persist_dir: str, **overrides: Any) -> "CorpusRegistry":
+        return cls(specs=specs_from_env(), persist_dir=persist_dir, **overrides)
+
+    # ------------------------------------------------------------------
+    # Access
+    # ------------------------------------------------------------------
+
+    @property
+    def corpus_ids(self) -> List[str]:
+        return [spec.corpus_id for spec in self.specs]
+
+    @property
+    def primary_id(self) -> str:
+        return self.specs[0].corpus_id if self.specs else ""
+
+    def spec(self, corpus_id: str) -> CorpusSpec:
+        for spec in self.specs:
+            if spec.corpus_id == corpus_id:
+                return spec
+        raise KeyError(f"unknown corpus: {corpus_id!r} (known: {self.corpus_ids})")
+
+    def retriever(self, corpus_id: str) -> LegalRetriever:
+        existing = self._retrievers.get(corpus_id)
+        if existing is not None:
+            return existing
+
+        with self._lock:
+            if corpus_id in self._retrievers:
+                return self._retrievers[corpus_id]
+
+            spec = self.spec(corpus_id)
+            instance = self._build(spec)
+            self._retrievers[corpus_id] = instance
+
+            # Adopt the document title the ingestion wrote into the collection
+            # metadata, so labels never drift from the indexed corpus.
+            metadata = dict(getattr(instance.col, "metadata", None) or {})
+            enriched = spec.with_metadata(metadata)
+            if enriched is not spec:
+                self.specs = [enriched if s.corpus_id == corpus_id else s for s in self.specs]
+
+            return instance
+
+    def _build(self, spec: CorpusSpec) -> LegalRetriever:
+        kwargs: Dict[str, Any] = {
+            "persist_dir": self.persist_dir,
+            "collection": spec.collection,
+            "model_name": self.model_name,
+            "default_container_id": spec.default_container_id,
+            "enable_reranker": self.enable_reranker,
+            "reranker_model": self.reranker_model,
+            "reranker_candidates": self.reranker_candidates,
+        }
+        try:
+            return LegalRetriever(**kwargs)
+        except TypeError:
+            # Older retriever signature.
+            return LegalRetriever(
+                persist_dir=self.persist_dir,
+                collection=spec.collection,
+                model_name=self.model_name,
+            )
+
+    def available(self) -> List[str]:
+        """Corpus ids whose collection can actually be opened."""
+        out: List[str] = []
+        for corpus_id in self.corpus_ids:
+            try:
+                self.retriever(corpus_id)
+                out.append(corpus_id)
+            except Exception as exc:  # noqa: BLE001 - a missing corpus must not break the rest.
+                logger.warning("corpus unavailable: %s (%s)", corpus_id, exc)
+        return out
+
+    def diagnostics(self) -> Dict[str, Any]:
+        corpora: List[Dict[str, Any]] = []
+        for spec in self.specs:
+            entry: Dict[str, Any] = {
+                "corpus_id": spec.corpus_id,
+                "collection": spec.collection,
+                "default_container_id": spec.default_container_id,
+                "label": spec.label,
+            }
+            try:
+                instance = self.retriever(spec.corpus_id)
+                entry["count"] = instance.col.count()
+                entry["ok"] = True
+                metadata = dict(getattr(instance.col, "metadata", None) or {})
+                entry["embedding_model"] = metadata.get("embedding_model")
+                entry["doc_title"] = metadata.get("doc_title")
+            except Exception as exc:  # noqa: BLE001
+                entry["ok"] = False
+                entry["error"] = f"{type(exc).__name__}: {exc}"
+            corpora.append(entry)
+        return {"persist_dir": self.persist_dir, "corpora": corpora}
+
+    def total_count(self) -> int:
+        total = 0
+        for corpus_id in self.corpus_ids:
+            try:
+                total += int(self.retriever(corpus_id).col.count())
+            except Exception:  # noqa: BLE001
+                continue
+        return total
+
+    def assert_consistent_embedding(self) -> Optional[str]:
+        """Return an error message if the corpora were not indexed alike.
+
+        Fusing results across corpora only makes sense when their scores are
+        comparable, which requires one embedding model and one distance metric.
+        Mixing them would silently rank one corpus above the other.
+        """
+        models: Dict[str, set] = {"embedding_model": set(), "embedding_dim": set()}
+        for corpus_id in self.corpus_ids:
+            try:
+                metadata = dict(getattr(self.retriever(corpus_id).col, "metadata", None) or {})
+            except Exception:  # noqa: BLE001
+                continue
+            for key in models:
+                value = metadata.get(key)
+                if value is not None:
+                    models[key].add(value)
+
+        mismatched = {key: sorted(map(str, values)) for key, values in models.items() if len(values) > 1}
+        if mismatched:
+            return f"corpora were indexed with different embeddings: {mismatched}"
+        return None
+
+
+def build_registry(
+    *,
+    persist_dir: str,
+    model_name: str,
+    enable_reranker: bool,
+    reranker_model: str,
+    reranker_candidates: int,
+    specs: Optional[Sequence[CorpusSpec]] = None,
+) -> CorpusRegistry:
+    return CorpusRegistry(
+        specs=list(specs) if specs is not None else specs_from_env(),
+        persist_dir=persist_dir,
+        model_name=model_name,
+        enable_reranker=enable_reranker,
+        reranker_model=reranker_model,
+        reranker_candidates=reranker_candidates,
+    )

src/corpus_router.py

@@ -0,0 +1,68 @@
+"""Decide which corpora a question needs to reach.
+
+Deliberately rule-based rather than model-based. Routing here is a cheap,
+verifiable decision on a handful of surface signals, and an LLM call per question
+would add latency and non-determinism to a step a substring match answers
+exactly.
+
+The policy is asymmetric on purpose:
+
+* Narrowing to a subset requires the question to **name** a corpus —
+  "nach dem Rahmenvertrag", "§ 31 SGB V".
+* Everything else queries all corpora and lets score fusion decide.
+
+That asymmetry follows from the cost of being wrong. One corpus too many costs a
+few hundred milliseconds; one corpus too few means the assistant answers
+confidently from the wrong statute, which is the failure mode this pipeline
+exists to prevent. A bare "§ 16" is therefore *not* narrowed even though the
+Rahmenvertrag is the likelier intent — both documents have a § 16, and they say
+entirely different things.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Sequence
+
+from corpus_registry import CORPUS_ALIASES
+
+
+def _normalize(text: str) -> str:
+    return " ".join(str(text or "").lower().split())
+
+
+def mentioned_corpora(question: str, corpus_ids: Sequence[str]) -> List[str]:
+    """Corpora named in the question, in registry order.
+
+    A statute reference such as "§ 31 SGB V" is covered by this same check: the
+    statute name is itself an alias, so no separate norm-reference parsing is
+    needed here. Parsing the § itself is the retriever's job.
+    """
+    haystack = _normalize(question)
+    hits: List[str] = []
+    for corpus_id in corpus_ids:
+        candidates = (*CORPUS_ALIASES.get(corpus_id.lower(), ()), corpus_id.lower())
+        if any(alias and alias in haystack for alias in candidates):
+            hits.append(corpus_id)
+    return hits
+
+
+def route_question(question: str, corpus_ids: Sequence[str]) -> List[str]:
+    """Return the corpora to query. Falls back to all of them without a signal."""
+    available = list(corpus_ids)
+    if len(available) <= 1:
+        return available
+    return mentioned_corpora(question, available) or available
+
+
+def explain_routing(question: str, corpus_ids: Sequence[str]) -> Dict[str, Any]:
+    """Routing decision with its reason, for /debug/routing and tests."""
+    available = list(corpus_ids)
+    named = mentioned_corpora(question, available)
+    selected = route_question(question, available)
+    return {
+        "question": question,
+        "available": available,
+        "named_corpora": named,
+        "selected": selected,
+        "reason": "explicit_mention" if named and len(available) > 1 else "no_signal_query_all",
+    }

src/federated_retriever.py

@@ -0,0 +1,619 @@
+"""Search several legal corpora behind one retriever interface.
+
+The design constraint that shaped this module: `LegalAnswerOrchestrator` and
+`AnswerComposer` already contain the citation-verification logic this assistant
+depends on, and they talk to exactly one object with a `query()` method.  So the
+federation preserves that method's signature and returns the same hit
+dictionaries.  Nothing upstream has to know that there is more than one corpus.
+
+Score fusion is a plain merge by rank_score, which is only defensible because
+every corpus is indexed with the same embedding model and distance metric, and
+the optional cross-encoder scores the query against candidates from all corpora
+with the same model.  `CorpusRegistry.assert_consistent_embedding()` guards that
+precondition.
+
+Fusion by score alone turned out not to be enough, and the counterexample is
+worth keeping: a question about Sonderkennzeichen never reached the
+Arzneimittelabrechnungsvereinbarung, although the rule is in it and the corpus
+was indexed.  With 106 chunks against the SGB V's 6.670, its best hit simply lost
+the similarity contest — a structural defeat that has nothing to do with
+relevance.  Two mechanisms answer that, and both are supplied from outside so
+this module stays a search layer and does not become a legal register:
+
+* a **per-corpus quota** that survives the global cut, so a small corpus cannot
+  be crowded out entirely, and
+* **mandatory fetches** (`anchors`), addresses of norms that are retrieved by
+  metadata regardless of how they embed.
+
+A third mechanism follows the same shape and closes a different gap.  Anchors
+know the chain for a *question type*; they are curated and therefore finite.
+But a legal text names its own chain: § 10 of the Rahmenvertrag says the
+selection is to be made "nach Maßgabe der §§ 11 bis 14", and § 11 selects "aus
+dem Auswahlbereich nach § 9".  Those references were read by nobody — the
+retriever parses § references out of the *question* only.  `verweise` supplies
+the second pass: the references contained in the hits that were already found,
+resolved to addresses and fetched with the same `get_units`.  The provider is
+injected for the same reason as the anchors: which name means which corpus is a
+statement about the corpora, not about searching.
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+from collections import OrderedDict
+from typing import Any, Callable, Dict, List, Optional, Sequence
+
+from corpus_registry import CorpusRegistry
+
+logger = logging.getLogger(__name__)
+
+# A router decides which corpora a question should reach.
+Router = Callable[[str, Sequence[str]], List[str]]
+
+# An anchor provider names norms that must be in the context whatever the
+# ranking says.  It returns plain dicts — corpus_id, container_id, section_id,
+# subsection, max_chunks — so that the curated register stays a stranger here.
+Anchors = Callable[[str], Sequence[Dict[str, Any]]]
+
+# A reference provider reads the hits that were found and returns the addresses
+# they point at — same plain dicts as the anchors, so the fetch below does not
+# have to know which of the two produced a target.
+Verweise = Callable[[Sequence[Dict[str, Any]], Sequence[str]], Sequence[Dict[str, Any]]]
+
+# Referenced norms are fetched, not ranked, so they need a score — and the
+# first value chosen was wrong in a way worth recording.
+#
+# 0.97 was the reasoning: below the anchors' 1.0, above a merely similar
+# passage.  Measured on 19.08.2026 over five chain cases it cost ten points of
+# chain coverage (85% -> 75%).  The budget is fixed, so a referenced norm that
+# ranks high does not *add* to the context, it *replaces* something — and what
+# it replaced was § 6 Rahmenvertrag, itself a member of the chain being
+# measured.  A norm the text merely points at is not worth more than a norm the
+# ranking actually found.
+#
+# 0.50 puts them in the tail: they fill slots that would otherwise go to the
+# weakest semantic hits, and they yield to everything above.
+VERWEIS_SCORE = 0.50
+
+
+def route_to_all(question: str, corpus_ids: Sequence[str]) -> List[str]:
+    """Default policy: ask every corpus and let fusion sort it out."""
+    return list(corpus_ids)
+
+
+def _accepted_kwargs(func: Any, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    """Drop kwargs the callable does not declare, keeping the rest intact."""
+    try:
+        params = inspect.signature(func).parameters
+    except (TypeError, ValueError):  # builtins / C-implemented callables
+        return dict(kwargs)
+    if any(p.kind is inspect.Parameter.VAR_KEYWORD for p in params.values()):
+        return dict(kwargs)
+    return {key: value for key, value in kwargs.items() if key in params}
+
+
+class FederatedRetriever:
+    """Drop-in replacement for `LegalRetriever` that spans several corpora."""
+
+    def __init__(
+        self,
+        registry: CorpusRegistry,
+        *,
+        router: Optional[Router] = None,
+        max_corpora_per_query: int = 4,
+        anchors: Optional[Anchors] = None,
+        min_hits_per_corpus: int = 2,
+        verweise: Optional[Verweise] = None,
+        max_verweis_normen: int = 3,
+        named_corpora: Optional[Router] = None,
+    ) -> None:
+        self.registry = registry
+        self.router = router or route_to_all
+        self.max_corpora_per_query = max_corpora_per_query
+        self.anchors = anchors
+        self.min_hits_per_corpus = min_hits_per_corpus
+        self.verweise = verweise
+        self.max_verweis_normen = max_verweis_normen
+        self.named_corpora = named_corpora
+
+        warning = registry.assert_consistent_embedding()
+        if warning:
+            # Not fatal: a single-corpus deployment is unaffected, and refusing to
+            # start would take the whole assistant down for a ranking problem.
+            logger.warning("federated retrieval may rank badly: %s", warning)
+
+    # ------------------------------------------------------------------
+    # Compatibility surface
+    # ------------------------------------------------------------------
+
+    @property
+    def col(self) -> Any:
+        """Chroma collection of the primary corpus.
+
+        Kept so legacy diagnostics that reach for `.col` keep working; corpus-aware
+        callers should use `registry.diagnostics()` instead.
+        """
+        return self.registry.retriever(self.registry.primary_id).col
+
+    @property
+    def collection_name(self) -> str:
+        return self.registry.spec(self.registry.primary_id).collection
+
+    @property
+    def persist_dir(self) -> str:
+        return self.registry.persist_dir
+
+    def diagnostics(self, *, sample: int = 3) -> Dict[str, Any]:
+        out = self.registry.diagnostics()
+        out["federated"] = True
+        out["router"] = getattr(self.router, "__name__", type(self.router).__name__)
+        out["min_hits_per_corpus"] = self.min_hits_per_corpus
+        out["norm_anchors"] = self.anchors is not None
+        return out
+
+    def explain_selection(self, question: str) -> Dict[str, Any]:
+        """Why these corpora — for /debug/routing and for tests.
+
+        Kept separate from `corpus_router.explain_routing` because the router
+        only sees the question's wording.  Whether a corpus is queried on top of
+        that is this layer's decision, and a debug endpoint that showed only half
+        of it would be misleading in exactly the case worth debugging.
+        """
+        available = self.registry.available()
+        named = [c for c in self.router(question or "", available) if c in available]
+        required = [c for c in self.required_corpora(question) if c in available]
+        return {
+            "available": available,
+            "routed": named,
+            "required": required,
+            "selected": self.select_corpora(question),
+            "anchor_targets": self.anchor_targets(question),
+        }
+
+    # ------------------------------------------------------------------
+    # Retrieval
+    # ------------------------------------------------------------------
+
+    def anchor_targets(self, question: str) -> List[Dict[str, Any]]:
+        """Norms that have to be in the context, whatever the ranking says."""
+        if self.anchors is None:
+            return []
+        try:
+            return [dict(target) for target in self.anchors(question or "") or []]
+        except Exception as exc:  # noqa: BLE001 - a register must never break retrieval.
+            logger.warning("norm anchors skipped (%s)", exc)
+            return []
+
+    def required_corpora(self, question: str) -> List[str]:
+        """Corpora an anchored question must reach even without naming them.
+
+        This is the half of the Sonderkennzeichen fix that routing owns: the word
+        names no corpus, so `route_question` fans out to all of them and the
+        smallest one is then outranked.  Naming it here makes the query
+        unconditional; the quota below makes sure its hits survive the cut.
+        """
+        out: List[str] = []
+        for target in self.anchor_targets(question):
+            corpus_id = str(target.get("corpus_id") or "")
+            if corpus_id and corpus_id not in out:
+                out.append(corpus_id)
+        return out
+
+    def select_corpora(self, question: str) -> List[str]:
+        available = self.registry.available()
+        if not available:
+            return []
+        selected = [c for c in self.router(question or "", available) if c in available]
+        if not selected:
+            selected = available
+
+        # Required corpora go first so the cap below can never drop one, and the
+        # cap yields to them outright rather than silently discarding a norm the
+        # register calls decisive.
+        required = [c for c in self.required_corpora(question) if c in available]
+        ordered = required + [c for c in selected if c not in required]
+        return ordered[: max(self.max_corpora_per_query, len(required))]
+
+    def query(self, question: str = "", **kwargs: Any) -> List[Dict[str, Any]]:
+        # The orchestrator sometimes passes the question positionally, sometimes
+        # as a keyword; accept both like LegalRetriever does.
+        question = question or str(kwargs.pop("question", "") or "")
+        corpora = self.select_corpora(question)
+        if not corpora:
+            return []
+
+        max_final_results = kwargs.get("max_final_results")
+        top_k = kwargs.get("top_k")
+
+        merged: List[Dict[str, Any]] = []
+        for corpus_id in corpora:
+            try:
+                hits = self._query_one(corpus_id, question, kwargs)
+            except Exception as exc:  # noqa: BLE001 - one broken corpus must not kill the answer.
+                # Der Typ gehört in die Meldung: ohne ihn steht dort eine
+                # Fehlerzeile, die nicht sagt, ob das Korpus fehlte, der
+                # Speicher ausging oder die Datenbank gesperrt war — und genau
+                # das ist die Frage, wenn diese Zeile einmal erscheint.
+                logger.warning(
+                    "corpus query failed: %s (%s: %s)", corpus_id, exc.__class__.__name__, exc
+                )
+                continue
+            merged.extend(hits)
+
+        merged.extend(self._fetch_anchors(question, corpora))
+
+        merged = _fuse(merged)
+
+        # Erst nach der Fusion: die Verweise werden aus den *besten* Treffern
+        # gelesen, und welche das sind, steht vor der Fusion noch nicht fest.
+        nachgeladen = self._fetch_referenced_norms(merged, corpora)
+        if nachgeladen:
+            merged = _fuse(merged + nachgeladen)
+
+        limit = max_final_results or top_k
+        ergebnis = _apply_corpus_quota(merged, limit=limit, min_per_corpus=self.min_hits_per_corpus)
+        return self._benanntes_korpus_zuerst(ergebnis, question, corpora)
+
+    def _fetch_anchors(self, question: str, corpora: Sequence[str]) -> List[Dict[str, Any]]:
+        """Retrieve the anchored norms by metadata instead of by similarity.
+
+        These hits are scored 1.0, the same as any explicit section lookup the
+        retriever performs on its own — the register's claim is that they decide
+        the question, so ranking them below a merely similar passage would defeat
+        the purpose.  They stay cheap because the address carries the Absatz: the
+        parent chunk of one Absatz is usually the whole norm.
+        """
+        out: List[Dict[str, Any]] = []
+        for target in self.anchor_targets(question):
+            corpus_id = str(target.get("corpus_id") or "")
+            if corpus_id not in corpora:
+                continue
+            retriever = self.registry.retriever(corpus_id)
+            fetch = getattr(retriever, "get_units", None)
+            if fetch is None:
+                # An older retriever without the targeted lookup. Skipping is the
+                # honest outcome: the rest of the answer is unaffected.
+                continue
+            try:
+                hits = fetch(
+                    target.get("section_id") or "",
+                    container=target.get("container_id") or None,
+                    subsection=target.get("subsection") or None,
+                    max_chunks=int(target.get("max_chunks") or 2),
+                )
+            except Exception as exc:  # noqa: BLE001 - see above.
+                logger.warning(
+                    "norm anchor lookup failed: %s %s (%s: %s)",
+                    corpus_id,
+                    target,
+                    exc.__class__.__name__,
+                    exc,
+                )
+                continue
+
+            if not hits:
+                logger.warning(
+                    "norm anchor matched nothing: %s %s %s",
+                    corpus_id,
+                    target.get("container_id"),
+                    target.get("section_id"),
+                )
+            for hit in hits:
+                hit["corpus_id"] = corpus_id
+                metadata = hit.get("metadata")
+                if isinstance(metadata, dict):
+                    metadata.setdefault("corpus_id", corpus_id)
+                # "section_lookup" keeps the composer's existing preference for
+                # explicit lookups working; "norm_anchor" is what monitoring reads.
+                hit["retrieval_kinds"] = sorted(
+                    {*(hit.get("retrieval_kinds") or []), "norm_anchor", "section_lookup"}
+                )
+                out.append(hit)
+        return out
+
+    def _benanntes_korpus_zuerst(
+        self, hits: List[Dict[str, Any]], question: str, corpora: Sequence[str]
+    ) -> List[Dict[str, Any]]:
+        """Nennt die Frage ein Regelwerk, führt dessen bester Treffer.
+
+        Der Pflichtabruf holt seine Normen mit Score 1.0 und steht damit vorn —
+        richtig, solange die Frage kein Regelwerk nennt. Nennt sie eines, ist es
+        falsch: „Was regelt **die Arzneimittel-Richtlinie** zur Austauschbarkeit
+        von Darreichungsformen?" bekam § 9 des Rahmenvertrags auf Rang 1, weil
+        der Anker `darreichungsform_austausch` ihn als tragende Norm führt. Die
+        Auskunft ist nicht falsch, die Reihenfolge schon: gefragt war, was in
+        der Richtlinie steht.
+
+        Nur die **Reihenfolge** ändert sich, nichts fällt weg — der Anker bleibt
+        im Kontext, er führt ihn nur nicht mehr an. Der Score des vorgezogenen
+        Treffers wird auf den bisherigen Höchstwert gehoben, damit eine spätere
+        Sortierung nach `rank_score` die Entscheidung nicht wieder umdreht.
+        """
+        if self.named_corpora is None or len(hits) < 2:
+            return hits
+
+        try:
+            benannt = [c for c in self.named_corpora(question or "", corpora) if c in corpora]
+        except Exception as exc:  # noqa: BLE001 - eine Reihung darf nie die Suche kippen.
+            logger.warning("named-corpus ordering skipped (%s: %s)", exc.__class__.__name__, exc)
+            return hits
+
+        # Ohne Nennung oder wenn die Frage alle abgefragten Korpora nennt, gibt
+        # es nichts zu entscheiden.
+        if not benannt or len(benannt) >= len(corpora):
+            return hits
+        if str(hits[0].get("corpus_id") or "") in benannt:
+            return hits
+
+        for i, hit in enumerate(hits):
+            if str(hit.get("corpus_id") or "") in benannt:
+                hoechstwert = max(_rank(h) for h in hits)
+                hit["rank_score"] = max(_rank(hit), hoechstwert)
+                return [hit, *hits[:i], *hits[i + 1 :]]
+
+        # Das benannte Korpus hat nichts geliefert. Das ist eine Aussage über
+        # das Korpus und keine über die Reihenfolge — hier bleibt alles stehen.
+        return hits
+
+    def _fetch_referenced_norms(
+        self, hits: Sequence[Dict[str, Any]], corpora: Sequence[str]
+    ) -> List[Dict[str, Any]]:
+        """Die Normen nachladen, auf die die gefundenen Texte selbst verweisen.
+
+        Dieselbe Mechanik wie `_fetch_anchors`, aber die Adressen kommen nicht
+        aus einem Register, sondern aus dem Text.  Der Unterschied steht im
+        Score: ein kuratierter Anker behauptet, *diese* Norm entscheide die
+        Frage; ein Verweis behauptet nur, der gefundene Text nehme sie in Bezug.
+
+        Der Container ist Pflicht, wo das Korpus einen führt.  Ohne ihn holt
+        „§ 10" im Rahmenvertrag auch den § 10 der Anlage 11 — die Adresse wäre
+        dann mehrdeutig, und zwar still.
+        """
+        if self.verweise is None or not hits or self.max_verweis_normen <= 0:
+            return []
+
+        try:
+            ziele = list(self.verweise(hits, corpora) or [])
+        except Exception as exc:  # noqa: BLE001 - a parser must never break retrieval.
+            logger.warning("norm references skipped (%s: %s)", exc.__class__.__name__, exc)
+            return []
+
+        out: List[Dict[str, Any]] = []
+        for ziel in ziele[: self.max_verweis_normen]:
+            corpus_id = str(ziel.get("corpus_id") or "")
+            if corpus_id not in corpora:
+                continue
+            retriever = self.registry.retriever(corpus_id)
+            fetch = getattr(retriever, "get_units", None)
+            if fetch is None:
+                continue
+
+            container = ziel.get("container_id") or self.registry.spec(corpus_id).default_container_id
+            try:
+                treffer = fetch(
+                    ziel.get("section_id") or "",
+                    container=container or None,
+                    subsection=ziel.get("subsection") or None,
+                    max_chunks=int(ziel.get("max_chunks") or 1),
+                )
+            except Exception as exc:  # noqa: BLE001 - see above.
+                logger.warning(
+                    "norm reference lookup failed: %s %s (%s: %s)",
+                    corpus_id,
+                    ziel.get("section_id"),
+                    exc.__class__.__name__,
+                    exc,
+                )
+                continue
+
+            # Ein Verweis, der ins Leere zeigt, ist keine Warnung wert: der Text
+            # darf auf eine Vorschrift verweisen, die es im Bestand nicht gibt
+            # (aufgehobener Paragraph, andere Fassung). Für den Anker gilt das
+            # Gegenteil — dort ist die Adresse eine Behauptung.
+            for hit in treffer:
+                hit["corpus_id"] = corpus_id
+                hit["score"] = VERWEIS_SCORE
+                hit["rank_score"] = VERWEIS_SCORE
+                metadata = hit.get("metadata")
+                if isinstance(metadata, dict):
+                    metadata.setdefault("corpus_id", corpus_id)
+                # Gesetzt, nicht ergänzt: `get_units` schreibt voreingestellt
+                # "norm_anchor" hinein, und das liest die Überwachung als
+                # kuratierten Pflichtabruf. Ein Verweis ist etwas anderes.
+                #
+                # Und bewusst OHNE "section_lookup": der Composer wertet diese
+                # Art in `_hit_relevance_key` mit Faktor 50 auf (expliziter
+                # Paragraphentreffer). Ein Verweis ist kein expliziter Treffer —
+                # niemand hat nach dieser Vorschrift gefragt.
+                hit["retrieval_kinds"] = ["verweis"]
+                out.append(hit)
+
+        return out
+
+    def _query_one(self, corpus_id: str, question: str, kwargs: Dict[str, Any]) -> List[Dict[str, Any]]:
+        retriever = self.registry.retriever(corpus_id)
+        spec = self.registry.spec(corpus_id)
+
+        call_kwargs = dict(kwargs)
+        call_kwargs.pop("question", None)
+
+        # A container filter is corpus-specific: "Vertrag" does not exist in a
+        # statute, and passing it through would return nothing at all.
+        where = call_kwargs.get("where")
+        if isinstance(where, dict) and "container_id" in where:
+            if not spec.default_container_id or where["container_id"] != spec.default_container_id:
+                call_kwargs["where"] = None
+
+        hits = self._call(retriever, question, call_kwargs)
+        for hit in hits:
+            hit["corpus_id"] = corpus_id
+            metadata = hit.get("metadata")
+            if isinstance(metadata, dict):
+                metadata.setdefault("corpus_id", corpus_id)
+        return hits
+
+    @staticmethod
+    def _call(retriever: Any, question: str, kwargs: Dict[str, Any]) -> List[Dict[str, Any]]:
+        # Only the kwargs this retriever actually declares.  The orchestrator
+        # probes for optional features (e.g. `enable_definition_lookup`) and
+        # relies on a TypeError to retry without them — but that TypeError never
+        # reaches it through the federation.  Filtering here keeps the valuable
+        # kwargs (explicit_sections, include_neighbors, max_final_results)
+        # instead of collapsing to the three-parameter emergency fallback below.
+        accepted = _accepted_kwargs(retriever.query, kwargs)
+        try:
+            return list(retriever.query(question=question, **accepted) or [])
+        except TypeError:
+            reduced = {k: v for k, v in accepted.items() if k in {"top_k", "where", "fetch_k"}}
+            try:
+                return list(retriever.query(question=question, **reduced) or [])
+            except TypeError:
+                return list(retriever.query(question, top_k=kwargs.get("top_k", 8)) or [])
+
+    def verify_negative_result(self, question: str, **kwargs: Any) -> Dict[str, Any]:
+        """A negative answer is only safe when no corpus can refute it."""
+        corpora = self.select_corpora(question)
+        results: List[Dict[str, Any]] = []
+        blocking: List[str] = []
+        reasons: List[str] = []
+
+        for corpus_id in corpora:
+            retriever = self.registry.retriever(corpus_id)
+            try:
+                check = retriever.verify_negative_result(question, **kwargs)
+            except TypeError:
+                check = retriever.verify_negative_result(question=question)
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("negative recheck failed for %s (%s)", corpus_id, exc)
+                continue
+
+            for hit in check.get("results") or []:
+                hit["corpus_id"] = corpus_id
+                results.append(hit)
+            if not check.get("safe_to_answer_negative", True):
+                blocking.append(corpus_id)
+                reasons.append(f"{corpus_id}: {check.get('reason', '')}".strip())
+
+        return {
+            "safe_to_answer_negative": not blocking,
+            "reason": " | ".join(reasons)
+            or "Auch der breite Kontrollabruf hat in keinem Korpus belastbare Treffer gefunden.",
+            "results": _fuse(results),
+            "strong_result_count": len(blocking),
+            "corpora_checked": corpora,
+            "corpora_with_findings": blocking,
+        }
+
+
+def _rank(hit: Dict[str, Any]) -> float:
+    try:
+        return float(hit.get("rank_score", hit.get("score", 0.0)) or 0.0)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _key(hit: Dict[str, Any]) -> tuple:
+    metadata = hit.get("metadata") or {}
+    text_hash = metadata.get("text_hash")
+    if text_hash:
+        return ("hash", hit.get("corpus_id"), text_hash)
+    return (
+        "location",
+        hit.get("corpus_id"),
+        metadata.get("container_id") or hit.get("container"),
+        metadata.get("section_id") or hit.get("section"),
+        metadata.get("chunk_index_in_section") or hit.get("chunk_index"),
+        (hit.get("text") or "")[:160],
+    )
+
+
+def _fuse(hits: Sequence[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Merge hits from several corpora into one ranked list."""
+    best: Dict[tuple, Dict[str, Any]] = {}
+    for hit in hits:
+        key = _key(hit)
+        current = best.get(key)
+        if current is None:
+            best[key] = hit
+            continue
+        # The same chunk can arrive twice — once from the semantic pass, once
+        # from a mandatory fetch.  Keeping only the better score would drop the
+        # other's retrieval_kind, and downstream ranking reads exactly that.
+        kinds = sorted({*(current.get("retrieval_kinds") or []), *(hit.get("retrieval_kinds") or [])})
+        winner = hit if _rank(hit) > _rank(current) else current
+        winner["retrieval_kinds"] = kinds
+        best[key] = winner
+    return sorted(best.values(), key=_rank, reverse=True)
+
+
+def _apply_corpus_quota(
+    hits: List[Dict[str, Any]],
+    *,
+    limit: Optional[int],
+    min_per_corpus: int,
+    min_ratio: float = 0.25,
+) -> List[Dict[str, Any]]:
+    """Cut to `limit`, but not before every corpus has had its share.
+
+    Without this the cut is purely global, and a corpus that is an order of
+    magnitude smaller than its neighbours never appears at all — not because it
+    has nothing to say but because it has fewer chances to say it.
+
+    Three limits keep the guarantee from turning into noise:
+
+    * The reservation is capped at **half** the result list.  A floor against
+      structural defeat is not a mandate to fill the context with four documents
+      when the question belongs to one — with four corpora and ten results that
+      is one slot each and six left to the ranking.
+    * Only **whole rounds** are handed out.  The corpus that would lose the last
+      slot of an incomplete round is always the weakest one, which is the one
+      this exists to protect.
+    * A corpus qualifies only if its best hit reaches `min_ratio` of the best hit
+      overall.  Measured on the five live questions, that is the difference
+      between rescuing the Abrechnungsvereinbarung's 0.850 — genuinely
+      comparable, merely outnumbered — and admitting a 0.008 from a corpus that
+      simply has nothing to say.  Having fewer chances is a defeat worth undoing;
+      being irrelevant is not.
+    """
+    if not limit or limit <= 0:
+        return hits
+    if min_per_corpus <= 0 or len(hits) <= limit:
+        return hits[:limit]
+
+    # `hits` is ranked, so insertion order is the order of each corpus's best hit.
+    by_corpus: "OrderedDict[str, List[Dict[str, Any]]]" = OrderedDict()
+    for hit in hits:
+        by_corpus.setdefault(str(hit.get("corpus_id") or ""), []).append(hit)
+    if len(by_corpus) <= 1:
+        return hits[:limit]
+
+    floor = _rank(hits[0]) * min_ratio
+    by_corpus = OrderedDict(
+        (corpus_id, bucket)
+        for corpus_id, bucket in by_corpus.items()
+        if _rank(bucket[0]) >= floor
+    )
+    if len(by_corpus) <= 1:
+        return hits[:limit]
+
+    budget = max(1, limit // 2)
+    reserved: List[Dict[str, Any]] = []
+    chosen: set = set()
+
+    for round_index in range(min_per_corpus):
+        runde = [b[round_index] for b in by_corpus.values() if round_index < len(b)]
+        if not runde or len(reserved) + len(runde) > budget:
+            break
+        for hit in runde:
+            reserved.append(hit)
+            chosen.add(id(hit))
+
+    for hit in hits:
+        if len(reserved) >= limit:
+            break
+        if id(hit) not in chosen:
+            reserved.append(hit)
+            chosen.add(id(hit))
+
+    return sorted(reserved, key=_rank, reverse=True)[:limit]

src/fundstellen.py

@@ -0,0 +1,190 @@
+"""Eine Fundstelle erkennen, gleich wie sie geschrieben ist.
+
+㤠34 Abs. 1 Satz 5 Nr. 1 SGB V", 㤠34 Absatz 1 Satz 5 Nummer 1 SGB V" und
+㤠34 Abs. 1 Satz 5 Nr. 1 des SGB V" sind dieselbe Vorschrift.  㤠34 Abs. 1
+SGB V" ist es **nicht** — die Genauigkeit ist an vielen Stellen gerade der
+Prüfgegenstand.  Dieses Modul entscheidet beides.
+
+Es liegt in `src`, weil zwei Seiten es brauchen: die Antwortprüfung der
+Auswertung (`eval/antwortpruefung.py`) und, wo es einmal so weit ist, das
+Normregister.  `norm_anchors._genannt_in` prüft heute nur den **Paragrafen** —
+eine Antwort mit 㤠92 Abs. 1 Satz 2 Nr. 6" gilt dort als 㤠92 genannt", und
+die richtige Fundstelle wird nicht nachgetragen.  Das darauf umzustellen ändert
+das Verhalten **aller** Anker und gehört gemessen; bis dahin bleibt dieses
+Modul, was es ist: der Matcher, an einer Stelle, an der beide ihn erreichen.
+
+**Kanonisieren statt Muster basteln.**  Forderung und Text gehen durch dieselbe
+Wäsche: Abkürzungen auf je eine Schreibweise, Füllwörter weg, Striche und
+Leerraum vereinheitlicht.  Danach genügt ein schlichtes Muster.  Der erste
+Versuch baute stattdessen aus jeder Fundstelle ein tolerantes Suchmuster
+zusammen und scheiterte an einer Kleinigkeit: `re.escape` maskiert seit
+Python 3.7 auch das Leerzeichen, und der nachträgliche Ersatz des Leerraums
+machte daraus einen doppelten Backslash — danach traf keine Forderung mehr,
+auch die einfachste Wendung nicht.
+
+Vier Fallen sind hier bezahlt und stehen unten an ihrer Stelle: die schmalen
+Leerzeichen und geschützten Bindestriche der Antworten, das „I" von „in" unter
+`re.I`, die Fundstelle, deren Bestandteile nicht zusammenhängen, und die
+Flexion des Deutschen.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, List, Sequence, Union
+
+Forderung = Union[str, Sequence[str]]
+
+
+# ---------------------------------------------------------------------------
+# Treffer im Text
+# ---------------------------------------------------------------------------
+
+# Normtexte tragen schmale und geschützte Leerzeichen. Ein Muster, das nur das
+# gewöhnliche kennt, verfehlt „§ 34" im Zitat und trifft es in der Frage.
+_LEERRAUM = re.compile("[\\s   ]+")
+
+_WAESCHE = tuple(
+    (re.compile(muster, re.I), ersatz)
+    for muster, ersatz in (
+        # Regelwerke zuerst, und der lange Name vor dem kurzen.
+        (r"Arzneimittel-?\s*Richtlinie", " amrl "),
+        (r"\bAM-?\s?RL\b", " amrl "),
+        # Ohne Ausschluss von „SGB VI": die Wortgrenze hinter dem V leistet das
+        # schon. Ein zusätzliches `(?!\s*I)` tat unter `re.I` das Gegenteil und
+        # verwarf „SGB V in Verbindung mit …" — das I von „in".
+        (r"\bSGB\s*V\b", " sgbv "),
+        (r"F[üu]nften?\s+Buch(?:es)?\s+Sozialgesetzbuch(?:es)?", " sgbv "),
+        (r"\bRahmenvertrag(?:es|s)?\b", " rahmenvertrag "),
+        (r"\bArzneimittelabrechnungsvereinbarung\b|\bAbrechnungsvereinbarung\b", " amabrv "),
+        # Gliederungsbezeichnungen auf je eine Form. Der Lookahead auf die
+        # Nummer verhindert, dass „Absatz" im Fließtext ohne Bezug fällt.
+        (r"\bAbs(?:atz|\.)?(?=\s*\d)", " abs "),
+        (r"\bN(?:r\.?|ummer)(?=\s*\d)", " nr "),
+        (r"\bHalbs(?:atz|\.)?(?=\s*\d)|\bHs\.?(?=\s*\d)", " halbsatz "),
+        (r"\bBuchst(?:abe|\.)?(?=\s*[a-z]\b)", " buchst "),
+        (r"\bS\.(?=\s*\d)", " satz "),
+        # Füllwörter zwischen den Bestandteilen: „nach § 34" und „des § 34"
+        # sollen dieselbe Fundstelle sein wie 㤠34". Die Wortgrenzen sind
+        # hier nicht Kosmetik — ohne sie fiele „in" mitten aus „Verbindung".
+        (r"\b(?:der|des|die|dem|den|das|nach|gemäß|gemaess|vom|im|in)\b", " "),
+        # Doppeltes Paragraphenzeichen kündigt mehrere an; für den Vergleich
+        # einer einzelnen Fundstelle ist es dasselbe Zeichen.
+        (r"§+", " § "),
+    )
+)
+
+
+# Die Antworten tragen den geschützten Bindestrich U+2011 („AM‑RL"), die
+# Normtexte den Halbgeviertstrich. Ein Muster mit ASCII-Bindestrich verfehlt
+# beides — gemessen am 21.08.2026, als „§ 40c AM-RL" gegen „§ 40c Abs. 1,
+# Abs. 3 (Arzneimittel‑Richtlinie)" nicht traf.
+_STRICHE = str.maketrans({c: "-" for c in "‐‑‒–—―−­"})
+
+
+def _glatt(text: str) -> str:
+    return _LEERRAUM.sub(" ", str(text or "").translate(_STRICHE)).strip()
+
+
+def kanonisch(text: str) -> str:
+    """Text und Forderung in derselben Schreibweise — klein, ohne Füllwörter."""
+    gewaschen = _glatt(text).lower()
+    for erkenner, ersatz in _WAESCHE:
+        gewaschen = erkenner.sub(ersatz, gewaschen)
+    return _glatt(gewaschen)
+
+
+# Eine Zahl am Ende eines Bestandteils darf nicht in eine längere hineinlaufen:
+# „§ 34" träfe sonst „§ 340", „nr 1" träfe „nr 12".
+_ZAHL_AM_ENDE = re.compile(r"\d[a-z]?$", re.I)
+
+_GLIEDERUNG = ("abs", "satz", "nr", "halbsatz", "buchst")
+
+
+def _wortmuster(wort: str) -> str:
+    """Ein Wort der Forderung als Muster, mit Grenze nach hinten.
+
+    Die Grenze nur, wo sie eine ist: `\\b` hinter „12." verlangt ein Wortzeichen
+    dahinter und verfehlte damit „vollendeten 12. Lebensjahr" — vor dem
+    Leerzeichen steht keine Wortgrenze mehr, die Grenze liegt schon vor dem
+    Punkt.
+    """
+    stueck = re.escape(wort)
+    if _ZAHL_AM_ENDE.search(wort):
+        return stueck + r"(?![0-9a-z])"
+    # Keine Wortgrenze, sondern eine erlaubte Endung: das Deutsche flektiert.
+    # „unverändert abgegeben" soll „unverändert abgegebene Fertigarzneimittel"
+    # treffen und „parenterale Zubereitung" auch „parenteralen Zubereitungen".
+    # Gemessen am 21.08.2026, als an beidem eine erfüllte Abgrenzung als fehlend
+    # gemeldet wurde. Die Genauigkeit, auf die es ankommt, sichert die
+    # Zahlengrenze darüber — nicht die Wortgrenze.
+    return stueck + r"[a-zäöüß]*"
+
+
+def _muster(wendung: str) -> "re.Pattern[str]":
+    """Das Suchmuster zu einer Forderung ohne Paragraphenzeichen: Wort für Wort."""
+    stuecke = [_wortmuster(w) for w in kanonisch(wendung).split(" ") if w]
+    if not stuecke:
+        # Eine leere Forderung darf nicht auf alles passen.
+        return re.compile(r"(?!)")
+    return re.compile(r"\s+".join(stuecke), re.I)
+
+
+def _zerlegt(wendung: str) -> Any:
+    """Eine Fundstelle als (Paragraf, geforderte Bestandteile) — oder None.
+
+    Die erste Fassung suchte die Fundstelle als **zusammenhängende** Wortkette
+    und verfehlte damit genau die Schreibweise, die Modelle bevorzugen:
+    „§ 40c Abs. 1, Abs. 3 (Arzneimittel-Richtlinie)" erfüllt eine Forderung nach
+    㤠40c AM-RL", denn zwischen Nummer und Regelwerk steht nur mehr Genauigkeit.
+    Gemessen am 21.08.2026: die Prüfung meldete § 40c als „nicht genannt", obwohl
+    er im Normabschnitt stand — und § 40b als nicht beanstandet, obwohl er dort
+    an erster Stelle stand.
+
+    Gesucht wird deshalb zweistufig: erst der Paragraf, dann seine Bestandteile
+    **im Fenster bis zum nächsten Paragraphenzeichen**. Das Fenster ist der
+    ganze Trick — ohne es verbände die Suche „§ 40b Abs. 1" mit dem „AM-RL"
+    einer später genannten anderen Vorschrift.
+    """
+    woerter = [w for w in kanonisch(wendung).split(" ") if w]
+    if not woerter or woerter[0] != "§" or len(woerter) < 2:
+        return None
+    paragraf = woerter[1]
+    rest = woerter[2:]
+
+    gefordert: List[str] = []
+    i = 0
+    while i < len(rest):
+        wort = rest[i]
+        if wort in _GLIEDERUNG and i + 1 < len(rest):
+            # Bestandteil und Wert gehören zusammen: „abs 1" darf nicht durch
+            # „abs 5 … satz 1" erfüllt werden.
+            gefordert.append(rf"{re.escape(wort)}\s+{_wortmuster(rest[i + 1])}")
+            i += 2
+            continue
+        gefordert.append(_wortmuster(wort))
+        i += 1
+    return paragraf, gefordert
+
+
+def _fundstelle_trifft(wendung: str, gewaschen: str) -> bool:
+    zerlegt = _zerlegt(wendung)
+    if zerlegt is None:
+        return _muster(wendung).search(gewaschen) is not None
+    paragraf, gefordert = zerlegt
+    anker = re.compile(rf"§\s+{re.escape(paragraf)}(?![0-9a-z])", re.I)
+    for treffer in anker.finditer(gewaschen):
+        naechster = gewaschen.find("§", treffer.end())
+        fenster = gewaschen[treffer.end(): naechster if naechster != -1 else len(gewaschen)]
+        if all(re.search(m, fenster, re.I) for m in gefordert):
+            return True
+    return False
+
+
+def trifft(forderung: Forderung, text: str) -> bool:
+    """Erfüllt der Text die Forderung — eine der Alternativen genügt."""
+    wendungen = [forderung] if isinstance(forderung, str) else list(forderung)
+    gewaschen = kanonisch(text)
+    return any(_fundstelle_trifft(w, gewaschen) for w in wendungen if str(w).strip())
+
+

src/llm_client_groq.py

@@ -406,6 +406,20 @@ class ConversationMemory:
 # GroqClient
 # ---------------------------------------------------------------------------
 
+def _reasoning_tokens(response: Any) -> Optional[int]:
+    """Wie viele der verbrauchten Tokens ins Denken gingen, wenn das Modell es meldet.
+
+    Nur fürs Log, und deshalb bewusst zahnlos: ein Modell ohne
+    `completion_tokens_details` ist keine Störung, sondern der Normalfall bei
+    den nicht-reasoning-Modellen.
+    """
+    try:
+        details = getattr(getattr(response, "usage", None), "completion_tokens_details", None)
+        return getattr(details, "reasoning_tokens", None)
+    except Exception:  # noqa: BLE001 - eine Logzeile darf nie die Antwort kosten.
+        return None
+
+
 class GroqClient:
     """
     Robuster Client-Wrapper um Groq Chat Completions.
@@ -428,8 +442,10 @@ class GroqClient:
         model: str = "llama-3.3-70b-versatile",
         system_prompt: str = DEFAULT_SYSTEM_PROMPT,
         temperature: float = 0.05,
-        max_tokens: int = 1400,
+        max_tokens: int = 4000,
         max_retries: int = 2,
+        # Obergrenze für den Nachschlag bei leerer Antwort. Siehe `_call`.
+        max_tokens_ceiling: int = 8000,
         retry_backoff_base: float = 0.8,
         history_for_factual_questions: bool = False,
         max_factual_history_chars: int = 8000,
@@ -447,6 +463,7 @@ class GroqClient:
         self.system_prompt = (system_prompt or "").strip()
         self.temperature = temperature
         self.max_tokens = max_tokens
+        self.max_tokens_ceiling = max(max_tokens, max_tokens_ceiling)
         self.max_retries = max_retries
         self.retry_backoff_base = retry_backoff_base
         self.history_for_factual_questions = history_for_factual_questions
@@ -530,6 +547,18 @@ class GroqClient:
         )
 
         last_err: Optional[Exception] = None
+        # Ein Reasoning-Modell teilt sich `max_tokens` zwischen Denk- und
+        # Antworttokens. Reicht das Budget nicht, kommt eine **leere** Antwort
+        # zurück — mit HTTP 200 und `finish_reason: "length"`.
+        #
+        # Gemessen am 19.08.2026 mit `openai/gpt-oss-120b` und dem damaligen
+        # Budget von 1400: dieselbe Frage nach der Austauschbarkeit von
+        # Darreichungsformen lieferte einmal 0 Zeichen (reasoning_tokens 1400
+        # von 1400) und einmal 1143 (reasoning_tokens 1046). Die alte Zeile
+        # `return content or ""` machte daraus eine erfolgreiche Antwort; beim
+        # Nutzer kam der Reichweiten-Hinweis an und sonst nichts, und nichts im
+        # System hat es bemerkt. Ein leerer Inhalt ist kein Ergebnis.
+        versuchsbudget = max_tokens
 
         for attempt in range(self.max_retries + 1):
             try:
@@ -537,10 +566,42 @@ class GroqClient:
                     model=actual_model,
                     messages=messages,
                     temperature=temperature,
-                    max_tokens=max_tokens,
+                    max_tokens=versuchsbudget,
+                )
+                choice = response.choices[0]
+                content = (choice.message.content or "").strip()
+                finish_reason = getattr(choice, "finish_reason", None)
+
+                if finish_reason == "length":
+                    # Auch mit Inhalt: die Antwort endet dann mitten im Satz.
+                    # Das gehört ins Log, weil es sonst als fachliche
+                    # Unvollständigkeit gelesen wird.
+                    logger.warning(
+                        "Groq response hit the token limit",
+                        extra={
+                            "groq_model": actual_model,
+                            "max_tokens": versuchsbudget,
+                            "content_chars": len(content),
+                            "reasoning_tokens": _reasoning_tokens(response),
+                        },
+                    )
+
+                if content:
+                    return content
+
+                if versuchsbudget < self.max_tokens_ceiling and attempt < self.max_retries:
+                    versuchsbudget = min(versuchsbudget * 2, self.max_tokens_ceiling)
+                    logger.warning(
+                        "Groq returned no content; retrying with a larger budget",
+                        extra={"groq_model": actual_model, "next_max_tokens": versuchsbudget},
+                    )
+                    continue
+
+                last_err = RuntimeError(
+                    f"Groq lieferte keinen Inhalt (finish_reason={finish_reason!r}, "
+                    f"max_tokens={versuchsbudget})"
                 )
-                content = response.choices[0].message.content
-                return content or ""
+                break
 
             except Exception as exc:
                 last_err = exc

src/norm_rang.py

@@ -0,0 +1,86 @@
+"""Welchen Rang eine Fundstelle hat — damit die Antwort sie einordnen kann.
+
+Der Quellenblock nennt bisher das Dokument („Rahmenvertrag nach § 129 Absatz 2
+SGB V"), und das reicht, um § 16 des Vertrages von § 16 SGB V zu unterscheiden.
+Es reicht nicht, um zu entscheiden, welche der beiden die Frage **trägt**.
+
+Die Metadaten helfen dabei nicht: `container_type` steht bei rv129, amabrv
+*und* amrl auf „vertrag" — die Richtlinie ist über denselben Ingest-Pfad
+gelaufen wie die Vertragswerke. Wer den Rang daraus liest, hält die
+Arzneimittel-Richtlinie für einen Vertrag. Deshalb eine kuratierte Zuordnung
+über die Korpus-Id, wie bei den übrigen Registern dieses Projekts.
+
+**Warum der Rang in den Kontext gehört.** Die Auswertung zeigte Antworten, die
+eine Anlage oder eine Ausführungsregelung als „Maßgebliche Norm" führten,
+obwohl die tragende Vorschrift im selben Kontext stand. Das ist kein
+Zitierfehler, sondern eine falsche Herleitung: Anlage VII Teil A sagt, welche
+Darreichungsformen austauschbar sind, aber *dass* ausgetauscht werden darf,
+ordnet § 129 Abs. 1 SGB V an und konkretisiert § 40 AM-RL. Wer nur die Anlage
+nennt, nennt das Ergebnis ohne seinen Grund.
+
+**Der Rang ist eine Angabe, keine Rangfolge.** Dieses Modul sagt, was eine
+Quelle *ist* — Gesetz, Richtlinie, Vertrag, Anlage. Es sagt nicht, welche
+Vorschrift vorgeht; das hängt am Fall und bleibt beim Modell und beim
+Ankerregister. Eine automatische Regel „Gesetz schlägt Vertrag" wäre hier
+falsch: der Rahmenvertrag konkretisiert § 129 SGB V bindend, und für die Frage,
+welches Fertigarzneimittel abzugeben ist, ist er die genauere Vorschrift.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+# Korpus-Id -> Rang, mit der Norm, auf der das Regelwerk beruht.  Die Klammer
+# ist der eigentliche Nutzen: sie nennt dem Modell die Ermächtigungsgrundlage,
+# die es sonst erraten müsste.
+RANG_JE_KORPUS: Dict[str, str] = {
+    "sgb5": "Gesetz",
+    "rv129": "Vertrag nach § 129 Abs. 2 SGB V",
+    "amabrv": "Vertrag nach § 300 Abs. 3 SGB V",
+    "amrl": "Richtlinie nach § 92 Abs. 1 Satz 2 Nr. 6 SGB V",
+}
+
+# Fällt die Korpus-Id aus (Einzelkorpus-Betrieb, alte Trefferdicts), trägt die
+# doc_id dieselbe Auskunft — sie wird vom Ingest aus dem Dokument gebildet.
+_RANG_JE_DOC_PREFIX = (
+    ("SGB_V", "Gesetz"),
+    ("RV_129", "Vertrag nach § 129 Abs. 2 SGB V"),
+    ("AMAbrV", "Vertrag nach § 300 Abs. 3 SGB V"),
+    ("AM_RL", "Richtlinie nach § 92 Abs. 1 Satz 2 Nr. 6 SGB V"),
+)
+
+
+def _wert(hit: Dict[str, Any], *keys: str) -> str:
+    metadata = hit.get("metadata") or {}
+    for key in keys:
+        value = hit.get(key) or metadata.get(key)
+        if value:
+            return str(value)
+    return ""
+
+
+def rang(hit: Dict[str, Any]) -> str:
+    """Der Rang einer Fundstelle, als eine Zeile für den Quellenblock.
+
+    Anlagen werden gesondert ausgewiesen, weil sie im Index Container ihres
+    eigenen Regelwerks sind: § 10 gibt es im Rahmenvertrag und in dessen Anlage
+    11. Eine Fundstelle aus der Anlage als „Vertrag" auszuweisen, verwischt
+    genau den Unterschied, den die Zeile sichtbar machen soll.
+    """
+    korpus = _wert(hit, "corpus_id")
+    grundrang = RANG_JE_KORPUS.get(korpus, "")
+
+    if not grundrang:
+        doc_id = _wert(hit, "doc_id")
+        for prefix, wert in _RANG_JE_DOC_PREFIX:
+            if doc_id.startswith(prefix):
+                grundrang = wert
+                break
+
+    container = _wert(hit, "container", "container_id")
+    if container.strip().lower().startswith("anlage"):
+        return f"Anlage zum Regelwerk ({container})" if not grundrang else (
+            f"Anlage zu: {grundrang} ({container})"
+        )
+
+    return grundrang

src/norm_verweise.py

@@ -0,0 +1,347 @@
+"""Verweise als Abrufauftrag — was der Treffertext selbst nennt.
+
+Das Retrieval liest §-Angaben bisher nur aus der **Frage**
+(`LegalRetriever._parse_norm_refs`). Was ein gefundener Text selbst zitiert,
+löst nichts aus. Für ein Vertragswerk, das seine Regelungen über ein Dutzend
+Vorschriften verteilt, ist das die eigentliche Lücke:
+
+    § 10 Rahmenvertrag  „Die Auswahl ist nach Maßgabe der §§ 11 bis 14 zu
+                        treffen."
+    § 11 Rahmenvertrag  „… aus dem Auswahlbereich nach § 9 …"
+    § 17 Rahmenvertrag  „Die Regelungen nach den §§ 10 bis 15 gelten …"
+
+Findet die Ähnlichkeitssuche § 11, steht die Rangfolge im Kontext, aber weder
+der Auswahlbereich, aus dem gewählt wird, noch die Vorschriften, die die
+Auswahl ausführen. Die Antwort ist dann richtig und unvollständig zugleich —
+und das ist die Fehlerklasse, die in der Auswertung am häufigsten übrig blieb.
+
+Dieses Modul liest die Verweise aus dem Text und gibt sie als Adressen zurück.
+Abgerufen werden sie im `FederatedRetriever`, mit demselben `get_units`, das
+schon die kuratierten Anker holt.
+
+**Der Gesetzesname steht hinter der Nummer, nicht davor.** Das ist die Falle,
+an der ein naiver Parser scheitert. § 6 des Rahmenvertrags enthält den Satz
+
+    „… die Angaben den §§ 2 Absatz 1 Nummern 4 bis 6 und 7 AMVV bzw. 9 Absatz 1
+    Nummern 3 bis 6 BtMVV nicht vollständig entsprechen."
+
+Wer nur „§ 2" liest, holt § 2 des Rahmenvertrags (Definitionen) statt § 2 AMVV
+— eine Vorschrift, die mit der Frage nichts zu tun hat, dafür aber wie eine
+Fundstelle aussieht. Deshalb wird hinter jeder Nummer nach einem
+Regelwerksnamen gesucht, bevor entschieden wird, wohin der Verweis zeigt.
+
+**Drei Ausgänge, und der dritte ist so wichtig wie die ersten beiden:**
+
+1. Der Verweis zeigt in ein indiziertes Korpus → Adresse zum Abruf.
+2. Der Verweis nennt kein Regelwerk → er meint das eigene; Adresse im Korpus
+   des zitierenden Treffers.
+3. Der Verweis zeigt auf ein Regelwerk, das nicht im Bestand ist (AMG, AMVV,
+   BtMVV, ApoG, AMPreisV …) → nicht abrufbar, aber **benennbar**. Diese Liste
+   ist die Grundlage der Reichweitenangabe: „die entscheidende Vorschrift liegt
+   außerhalb des Bestandes" ist eine belastbare Auskunft, „nicht geregelt" wäre
+   an derselben Stelle falsch.
+
+**Die Namensliste ist kuratiert, nicht geraten** — dieselbe Bauweise wie
+`norm_anchors` und die Listenmodule. Ein unbekannter Name führt nicht zu einer
+Vermutung, sondern dazu, dass der Verweis als korpuseigen gilt; deshalb stehen
+in `_FREMDE_REGELWERKE` die Namen, die in den vier Korpora tatsächlich
+vorkommen, und nicht alles, was denkbar wäre.
+
+**Budget statt Vollständigkeit.** Ein einziger § des SGB V kann zwanzig andere
+zitieren. Würden alle abgerufen, verdrängte die Kette genau die Treffer, für
+die sie gebaut wurde. Deshalb: nur die vordersten Treffer werden gelesen, ein
+Verweis zählt häufiger, wenn ihn mehrere Treffer nennen, und die Zahl der
+nachgeladenen Normen ist gedeckelt.
+"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple
+
+# ---------------------------------------------------------------------------
+# Regelwerksnamen
+# ---------------------------------------------------------------------------
+
+# Indizierte Regelwerke: Name im Text -> Korpus-Id.  Die Reihenfolge ist
+# bedeutsam, weil der erste Treffer im Fenster gewinnt: "SGB V" muss vor
+# "Sozialgesetzbuch" stehen, sonst schluckt der längere Name den kürzeren nicht.
+_INDIZIERTE_REGELWERKE: Tuple[Tuple[str, str], ...] = (
+    (r"SGB\s*V\b(?!\s*I)", "sgb5"),
+    (r"SGB\s*5\b", "sgb5"),
+    (r"F[üu]nften?\s+Buch(?:es)?\s+Sozialgesetzbuch", "sgb5"),
+    (r"Arzneimittel-?Richtlinie", "amrl"),
+    (r"\bAM-?RL\b", "amrl"),
+    (r"Arzneimittelabrechnungsvereinbarung", "amabrv"),
+    (r"Abrechnungsvereinbarung", "amabrv"),
+    (r"Rahmenvertrag(?:es|s)?", "rv129"),
+)
+
+# Regelwerke, die im Text vorkommen und nicht im Bestand sind.  Der Wert ist
+# der Name, unter dem die Reichweitenangabe sie nennt — abgekürzt zitiert der
+# Vertrag, ausgeschrieben liest es die Apotheke.
+_FREMDE_REGELWERKE: Tuple[Tuple[str, str], ...] = (
+    (r"\bAMVV\b", "AMVV (Arzneimittelverschreibungsverordnung)"),
+    (r"\bBtMVV\b", "BtMVV (Betäubungsmittel-Verschreibungsverordnung)"),
+    (r"\bBtMG\b", "BtMG (Betäubungsmittelgesetz)"),
+    (r"\bAMG\b", "AMG (Arzneimittelgesetz)"),
+    (r"\bApoG\b", "ApoG (Apothekengesetz)"),
+    (r"\bApBetrO\b", "ApBetrO (Apothekenbetriebsordnung)"),
+    (r"\bAMPreisV\b", "AMPreisV (Arzneimittelpreisverordnung)"),
+    (r"\bPackungsV\b", "PackungsV (Packungsgrößenverordnung)"),
+    (r"\bMPG\b", "MPG (Medizinproduktegesetz)"),
+    (r"\bHWG\b", "HWG (Heilmittelwerbegesetz)"),
+    (r"\bTFG\b", "TFG (Transfusionsgesetz)"),
+    (r"SGB\s*X\b", "SGB X"),
+    (r"SGB\s*XI\b", "SGB XI"),
+    (r"SGB\s*I\b(?!\s*V|\s*X)", "SGB I"),
+    (r"SGB\s*IV\b", "SGB IV"),
+    (r"\bBGB\b", "BGB"),
+)
+
+_INDIZIERT_RX: Tuple[Tuple[re.Pattern[str], str], ...] = tuple(
+    (re.compile(muster, re.I), korpus) for muster, korpus in _INDIZIERTE_REGELWERKE
+)
+_FREMD_RX: Tuple[Tuple[re.Pattern[str], str], ...] = tuple(
+    (re.compile(muster), name) for muster, name in _FREMDE_REGELWERKE
+)
+
+# ---------------------------------------------------------------------------
+# Erkennung im Text
+# ---------------------------------------------------------------------------
+
+# Eine Nummer, wie sie hinter dem Paragraphenzeichen steht: 129, 40c, 12a.
+_NUMMER = r"\d{1,3}[a-z]?"
+
+# Ein Verweis beginnt am Paragraphenzeichen.  Das doppelte § kündigt mehrere
+# an; der Bereich wird nur erkannt, wenn "bis" unmittelbar auf die erste Nummer
+# folgt — "§§ 2 Absatz 1 Nummern 4 bis 6" ist ein Nummernbereich und kein
+# Paragraphenbereich, und der Unterschied entscheidet, ob vier Vorschriften
+# abgerufen werden oder eine.
+_VERWEIS_RX = re.compile(
+    rf"§§?\s*(?P<von>{_NUMMER})"
+    rf"(?:\s*(?:bis|–|—|-)\s*(?P<bis>{_NUMMER}))?"
+)
+
+# Wie weit hinter der Nummer nach einem Regelwerksnamen gesucht wird.  Gemessen
+# an den Zitaten in den vier Korpora reicht das für "§ 129 Absatz 2 Satz 1
+# SGB V" und bleibt vor dem übernächsten Satz stehen.
+_NAMENSFENSTER = 90
+
+# Ein Bereich über mehr als so viele Paragraphen ist kein Kettenglied mehr,
+# sondern eine Verweisung auf einen ganzen Abschnitt.  "§§ 10 bis 15" sind
+# sechs Vorschriften und gemeint; "§§ 1 bis 68" ist der halbe Vertrag.
+_MAX_BEREICH = 8
+
+
+@dataclass(frozen=True)
+class Verweis:
+    """Eine Fundstelle, auf die ein Treffertext zeigt."""
+
+    section_id: str
+    # Leer, wenn das Regelwerk nicht im Bestand ist.
+    corpus_id: str = ""
+    # Der Name, unter dem die Reichweitenangabe das fremde Regelwerk nennt.
+    regelwerk: str = ""
+
+    @property
+    def abrufbar(self) -> bool:
+        return bool(self.corpus_id)
+
+    def als_ziel(self, max_chunks: int = 1) -> Dict[str, Any]:
+        """Die Adresse als schlichtes dict — wie bei `norm_anchors.Norm`."""
+        return {
+            "corpus_id": self.corpus_id,
+            "section_id": self.section_id,
+            "max_chunks": max_chunks,
+            "zitat": f"{self.section_id} {self.regelwerk}".strip(),
+        }
+
+
+def _regelwerk_hinter(text: str, ab: int) -> Tuple[Optional[str], Optional[str]]:
+    """Welches Regelwerk die Nummer meint — gelesen hinter der Nummer.
+
+    Rückgabe: ``(korpus_id, fremdname)``. Genau eines ist gesetzt, oder beide
+    sind ``None``: dann nennt der Verweis kein Regelwerk und meint das eigene.
+    """
+    fenster = text[ab : ab + _NAMENSFENSTER]
+    # Am nächsten Paragraphenzeichen abschneiden: was dahinter steht, gehört
+    # zum nächsten Verweis. Ohne diesen Schnitt erbte "§ 9" in "… nach § 9
+    # sowie § 129 SGB V" das SGB V des Nachbarn.
+    schnitt = fenster.find("§")
+    if schnitt >= 0:
+        fenster = fenster[:schnitt]
+
+    treffer: List[Tuple[int, Optional[str], Optional[str]]] = []
+    for rx, korpus in _INDIZIERT_RX:
+        m = rx.search(fenster)
+        if m:
+            treffer.append((m.start(), korpus, None))
+    for rx, name in _FREMD_RX:
+        m = rx.search(fenster)
+        if m:
+            treffer.append((m.start(), None, name))
+
+    if not treffer:
+        return None, None
+    treffer.sort(key=lambda t: t[0])
+    _, korpus, name = treffer[0]
+    return korpus, name
+
+
+def _nummern(von: str, bis: Optional[str]) -> List[str]:
+    if not bis:
+        return [von]
+    # Ein Bereich läuft nur über reine Zahlen. "§§ 12a bis 12c" kommt in den
+    # Korpora nicht vor, und geraten wäre hier schlimmer als ausgelassen.
+    if not von.isdigit() or not bis.isdigit():
+        return [von, bis]
+    start, ende = int(von), int(bis)
+    if ende < start or ende - start + 1 > _MAX_BEREICH:
+        return [von, bis]
+    return [str(n) for n in range(start, ende + 1)]
+
+
+def verweise_im_text(text: str, *, korpus: str = "") -> List[Verweis]:
+    """Alle Verweise eines Textes, in Lesereihenfolge und ohne Dubletten.
+
+    `korpus` ist das Korpus des zitierenden Treffers: ein Verweis ohne
+    Regelwerksnamen meint das eigene Regelwerk.
+    """
+    gesehen: Set[Tuple[str, str, str]] = set()
+    out: List[Verweis] = []
+
+    for m in _VERWEIS_RX.finditer(str(text or "")):
+        ziel_korpus, fremdname = _regelwerk_hinter(text, m.end())
+        if fremdname:
+            corpus_id, regelwerk = "", fremdname
+        elif ziel_korpus:
+            corpus_id, regelwerk = ziel_korpus, ""
+        else:
+            corpus_id, regelwerk = korpus, ""
+
+        for nummer in _nummern(m.group("von"), m.group("bis")):
+            verweis = Verweis(
+                section_id=f"§ {nummer}",
+                corpus_id=corpus_id,
+                regelwerk=regelwerk,
+            )
+            schluessel = (verweis.section_id, verweis.corpus_id, verweis.regelwerk)
+            if schluessel in gesehen:
+                continue
+            gesehen.add(schluessel)
+            out.append(verweis)
+
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Auswahl über eine Trefferliste
+# ---------------------------------------------------------------------------
+
+def _hit_text(hit: Dict[str, Any]) -> str:
+    metadata = hit.get("metadata") or {}
+    return str(hit.get("text") or hit.get("document") or metadata.get("text") or "")
+
+
+def _hit_adresse(hit: Dict[str, Any]) -> Tuple[str, str]:
+    metadata = hit.get("metadata") or {}
+    korpus = str(hit.get("corpus_id") or metadata.get("corpus_id") or "")
+    section = str(metadata.get("section_id") or hit.get("section") or "")
+    return korpus, section
+
+
+def verweise_aus_hits(
+    hits: Sequence[Dict[str, Any]],
+    *,
+    gelesene_treffer: int = 6,
+    max_normen: int = 3,
+    verfuegbare_korpora: Optional[Iterable[str]] = None,
+) -> Tuple[List[Verweis], List[Verweis]]:
+    """Was aus einer Trefferliste nachzuladen ist — und was nur zu benennen.
+
+    Rückgabe: ``(abrufbar, ausserhalb)``.
+
+    Gelesen werden nur die vordersten Treffer: ein Verweis in Rang 14 sagt
+    weniger über die Frage als einer in Rang 1, und jeder gelesene Text
+    vergrößert die Kandidatenmenge. Mehrfach genannte Verweise stehen vorn —
+    dass zwei Vorschriften dieselbe dritte in Bezug nehmen, ist das stärkste
+    Signal, das der Text über seine eigene Kette hergibt.
+    """
+    verfuegbar = set(verfuegbare_korpora) if verfuegbare_korpora is not None else None
+
+    # Was schon im Kontext liegt, muss nicht nachgeladen werden.
+    vorhanden: Set[Tuple[str, str]] = {_hit_adresse(hit) for hit in hits}
+
+    haeufigkeit: Counter = Counter()
+    reihenfolge: Dict[Tuple[str, str, str], int] = {}
+    kandidaten: Dict[Tuple[str, str, str], Verweis] = {}
+    ausserhalb: Dict[str, Verweis] = {}
+
+    for rang, hit in enumerate(hits[:gelesene_treffer]):
+        korpus, section = _hit_adresse(hit)
+        for verweis in verweise_im_text(_hit_text(hit), korpus=korpus):
+            if not verweis.abrufbar:
+                # Fremdes Regelwerk: nicht abrufbar, aber für die Reichweite.
+                ausserhalb.setdefault(
+                    f"{verweis.section_id} {verweis.regelwerk}", verweis
+                )
+                continue
+            # Ein Paragraph, der sich selbst nennt, ist kein Kettenglied.
+            if (verweis.corpus_id, verweis.section_id) == (korpus, section):
+                continue
+            if (verweis.corpus_id, verweis.section_id) in vorhanden:
+                continue
+            if verfuegbar is not None and verweis.corpus_id not in verfuegbar:
+                continue
+            schluessel = (verweis.corpus_id, verweis.section_id, verweis.regelwerk)
+            kandidaten[schluessel] = verweis
+            haeufigkeit[schluessel] += 1
+            reihenfolge.setdefault(schluessel, rang)
+
+    geordnet = sorted(
+        kandidaten,
+        key=lambda k: (-haeufigkeit[k], reihenfolge[k], k[1]),
+    )
+    abrufbar = [kandidaten[k] for k in geordnet[:max_normen]]
+    return abrufbar, list(ausserhalb.values())
+
+
+# ---------------------------------------------------------------------------
+# Die beiden Schnittstellen nach außen
+# ---------------------------------------------------------------------------
+
+def abrufziele(
+    hits: Sequence[Dict[str, Any]],
+    korpora: Sequence[str] = (),
+    *,
+    max_normen: int = 3,
+) -> List[Dict[str, Any]]:
+    """Adressen zum Nachladen — die Form, die der `FederatedRetriever` erwartet.
+
+    Dieselbe Signatur wie `norm_anchors.pflichtabruf`, damit der Retriever nicht
+    unterscheiden muss, woher eine Adresse kommt.
+    """
+    abrufbar, _ = verweise_aus_hits(
+        hits,
+        max_normen=max_normen,
+        verfuegbare_korpora=korpora or None,
+    )
+    return [verweis.als_ziel() for verweis in abrufbar]
+
+
+# Die zweite Hälfte — die Regelwerke außerhalb des Bestandes — hat hier bewusst
+# **keine** eigene Schnittstelle. `corpus_boundary` erkennt sie schon, und zwar
+# besser: es führt zu jedem Regelwerk ein Label und einen Satz darüber, was
+# damit ungeprüft bleibt („die Verschreibungspflicht einzelner Stoffe und die
+# Formerfordernisse der Verschreibung"), und es erkennt auch die Nennungen ohne
+# Paragraphenzeichen — § 17 des Rahmenvertrags verweist auf „die PackungsV"
+# ohne §, und für diesen Parser ist das nichts.
+#
+# Zwei Register für dieselbe Auskunft wären eines zu viel. Was der Parser
+# beiträgt, ist die Gegenprobe: `tests/test_reichweite_verweise.py` hält beide
+# gegen dieselbe Zitatliste, damit ein Regelwerk nicht in einem der beiden
+# fehlt. `verweise_aus_hits` gibt die Fremdverweise deshalb weiterhin zurück —
+# als Rückgabewert für diesen Test, nicht als zweite Quelle der Wahrheit.

src/orchestrator.py

@@ -4,10 +4,10 @@ import re
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING
 
-from src.llm_client_groq import classify_question, is_meta_question
+from llm_client_groq import classify_question, is_meta_question
 
 if TYPE_CHECKING:
-    from src.llm_client_groq import ConversationMemory
+    from llm_client_groq import ConversationMemory
 else:
     ConversationMemory = Any  # type: ignore[assignment]
 
@@ -33,7 +33,7 @@ SOURCE_MARKER_WITH_OPTIONAL_REF_RE = re.compile(
 )
 ORPHAN_LEGAL_REF_PAREN_RE = re.compile(r"\(§\s*\d{1,3}[a-z]?(?:\s+[^)]{0,80})?\)", re.I)
 NEGATIVE_ANSWER_RE = re.compile(
-    r"\b(keine\s+(relevante\s+)?textstelle|nicht\s+(geregelt|enthalten|auffindbar)|"
+    r"\b(keine\s+(relevante\s+)?textstelle|nichts?\s+(geregelt|enthalten|auffindbar)|"
     r"keine\s+(regelung|informationen|aussage)|nicht\s+belastbar\s+ableitbar|"
     r"kann\s+.*?nicht\s+(festgestellt|beantwortet)\s+werden)\b",
     re.I,

src/retriever.py

@@ -736,6 +736,50 @@ class LegalRetriever:
 
         return out[:max_chunks]
 
+    def get_units(
+        self,
+        section: str,
+        *,
+        container: Optional[str] = None,
+        subsection: Optional[str] = None,
+        max_chunks: int = 2,
+        retrieval_kind: str = "norm_anchor",
+    ) -> List[Dict[str, Any]]:
+        """Fetch one norm by its address, independent of any question.
+
+        Two things `get_section` cannot do, and both are needed for a mandatory
+        fetch driven by a curated register:
+
+        * No container is assumed.  A statute's §§ live in Kapitel containers,
+          and `get_section` would filter on "Vertrag" and return nothing.
+        * The Absatz can be narrowed.  "§ 129 SGB V" is eighty chunks;
+          "§ 129 Abs. 1" is two, and both of them carry.
+
+        Parent units are preferred over their children because the parent chunk
+        holds the full text of the Absatz while the children repeat fragments of
+        it — one chunk is then usually the whole answer.
+        """
+        where = {
+            "container_id": container or None,
+            "section_id": {"$in": self._section_variants(section)},
+            "subsection": str(subsection) if subsection else None,
+        }
+
+        try:
+            res = self.col.get(where=self._build_where(where), include=["documents", "metadatas"])
+        except Exception as exc:  # noqa: BLE001 - a missing norm must not break the answer.
+            logger.debug("norm unit lookup failed", exc_info=exc)
+            return []
+
+        formatted = self._format_get(res, retrieval_kind=retrieval_kind, score=1.0)
+        formatted.sort(
+            key=lambda hit: (
+                0 if (hit.get("metadata") or {}).get("chunk_kind") == "parent" else 1,
+                hit.get("chunk_index", 0),
+            )
+        )
+        return formatted[:max_chunks]
+
     def verify_negative_result(
         self,
         question: str,