feat(agb): wire validated routed AGB engine into live check path

Consolidate the AGB C-lean engine (71% FP -> ~0, validated vs 7-company
Opus GT) onto the canonical checker library and into the live check path.

- AGBAgent.evaluate now runs routed C-lean: keyword (L1/L2) -> business-
  model gate -> per-item decision_method routing (embedding/reference/llm
  via services/checkers/) -> severity re-tiering (LOW -> recommendation),
  honoring context.skip_llm.
- New agb/_pipeline.py orchestrates the routing; agent.py stays thin.
- Remove the 3 AGB-local checker duplicates (_reference_check,
  _embedding_rescue, _llm_judge); services/checkers/ is now canonical.
- Wire "agb" into _agent_outputs._TOPIC_AGENTS so the live check emits a
  validated AGB tab (was snapshot-only).
- Run topic agents concurrently (asyncio.gather) + emit each tab via SSE
  as it finishes -> progressive results, no wait on the slowest agent.
- Tests: checker units (mocked), routed agent (gate/rescue/re-tier),
  topic wiring; existing AGB tests made offline-safe.

dev-only, no deploy.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

backend-compliance/compliance/tests/test_agb_agent.py

@@ -1,12 +1,27 @@
-"""AGBAgent — kuratierte §§-305-ff-BGB-Checkliste (ChecklistAgent-Subclass)."""
-
-from __future__ import annotations
-
+"""AGBAgent (v2, routed). Embedding/LLM offline-gestubbt → kein Netzwerk."""
 import asyncio
 
+import pytest
+
+import compliance.services.specialist_agents.agb._pipeline as pipeline
+from compliance.services.checkers.base import CheckResult
 from compliance.services.specialist_agents import REGISTRY, AgentInput
 
 
+class _Stub:
+    def __init__(self, present):
+        self._p = present
+
+    async def check(self, ctrl, doc):
+        return CheckResult(present=self._p)
+
+
+@pytest.fixture(autouse=True)
+def _offline(monkeypatch):
+    monkeypatch.setattr(pipeline, "_EMB", _Stub(None))
+    monkeypatch.setattr(pipeline, "_LLM", _Stub(None))
+
+
 def _run(text: str):
     return asyncio.run(
         REGISTRY.get("agb").evaluate(AgentInput(doc_type="agb", text=text)))

backend-compliance/compliance/tests/test_agb_routed_agent.py

@@ -0,0 +1,62 @@
+"""AGB routed-Pipeline: Gate, Reference-/Embedding-Rescue, LLM-skip, Re-Tiering.
+Embedding + LLM offline-gestubbt → deterministisch, kein Netzwerk (Reference = echtes Regex)."""
+import asyncio
+from types import SimpleNamespace
+
+import pytest
+
+import compliance.services.specialist_agents.agb._pipeline as pipeline
+from compliance.services.checkers.base import CheckResult
+from compliance.services.specialist_agents._base import AgentInput
+from compliance.services.specialist_agents.agb.agent import AGBAgent
+
+
+class _Stub:
+    def __init__(self, present):
+        self._p = present
+
+    async def check(self, ctrl, doc):
+        return CheckResult(present=self._p)
+
+
+@pytest.fixture(autouse=True)
+def _offline(monkeypatch):
+    monkeypatch.setattr(pipeline, "_EMB", _Stub(None))
+    monkeypatch.setattr(pipeline, "_LLM", _Stub(None))
+
+
+def _routed(field_ids, text, context=None):
+    findings = [SimpleNamespace(field_id=fid) for fid in field_ids]
+    return asyncio.run(pipeline.run_routed(findings, text, context or {}))
+
+
+def test_gate_termination_na_for_oneoff_shop():
+    text = "Widerrufsbelehrung: Sie koennen binnen 14 Tagen widerrufen. " * 5
+    kept, resolved, gated = _routed(["termination", "termination_form"], text)
+    assert set(gated) == {"termination", "termination_form"}
+    assert kept == []
+
+
+def test_reference_rescues_data_protection():
+    text = "Einzelheiten zur Verarbeitung in unserer Datenschutzerklaerung. " * 5
+    kept, resolved, gated = _routed(["data_protection"], text)
+    assert "data_protection" in resolved and kept == []
+
+
+def test_embedding_rescue_resolves(monkeypatch):
+    monkeypatch.setattr(pipeline, "_EMB", _Stub(True))
+    kept, resolved, gated = _routed(["scope"], "x" * 200)
+    assert "scope" in resolved
+
+
+def test_llm_skipped_keeps_finding():
+    kept, resolved, gated = _routed(["delivery_timeframe"], "x" * 200, {"skip_llm": True})
+    assert [f.field_id for f in kept] == ["delivery_timeframe"] and resolved == []
+
+
+def test_evaluate_retiers_low_out_of_findings():
+    text = ("Allgemeine Geschaeftsbedingungen. Vertragsschluss durch Bestellung. "
+            "Haftung beschraenkt. Gerichtsstand Muenchen. ") * 6
+    out = asyncio.run(AGBAgent().evaluate(AgentInput(doc_type="agb", text=text)))
+    assert out.agent == "agb" and out.agent_version == "2.0"
+    assert all(f.severity in ("HIGH", "MEDIUM") for f in out.findings)

backend-compliance/compliance/tests/test_agent_outputs_topics.py

@@ -0,0 +1,10 @@
+"""AGB muss im LIVE-Pfad verdrahtet sein (_TOPIC_AGENTS), nicht nur per Snapshot."""
+from compliance.api.agent_check._agent_outputs import _TOPIC_AGENTS
+
+
+def test_agb_wired_into_live_topic_agents():
+    assert _TOPIC_AGENTS.get("agb") == "agb"
+
+
+def test_impressum_still_wired():
+    assert _TOPIC_AGENTS.get("impressum") == "impressum"

backend-compliance/compliance/tests/test_checkers.py

@@ -0,0 +1,83 @@
+"""Unit-Tests der Prüfer-Library. Embedding + LLM gemockt → kein Netzwerk."""
+import asyncio
+
+import compliance.services.llm_cascade as cascade_mod
+import compliance.services.mc_embedding_matcher as emb_mod
+from compliance.services.checkers.base import (
+    ControlSpec,
+    DecisionMethod,
+    DocContext,
+    VerificationMethod,
+)
+from compliance.services.checkers.embedding_checker import EmbeddingChecker
+from compliance.services.checkers.llm_checker import LLMChecker
+from compliance.services.checkers.reference_checker import ReferenceChecker
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def test_reference_present_and_absent():
+    rc = ReferenceChecker()
+    spec = ControlSpec("data_protection", VerificationMethod.REFERENCE,
+                       DecisionMethod.LINK_RESOLVER,
+                       patterns=[r"datenschutz(erkl|bestimmung|hinweis)"])
+    r = _run(rc.check(spec, DocContext(
+        text="Details in unserer Datenschutzerklaerung: https://x.de/datenschutz")))
+    assert r.present is True
+    assert r.detail.get("link", "").startswith("https://")
+    r2 = _run(rc.check(spec, DocContext(text="Keine Angabe zum Datenschutz-Thema.")))
+    assert r2.present is False
+
+
+def test_embedding_threshold(monkeypatch):
+    monkeypatch.setattr(emb_mod, "DIM", 3, raising=False)
+    monkeypatch.setattr(emb_mod, "_chunk_text", lambda t: [t], raising=False)
+
+    async def _embed(texts):
+        return [[1.0, 0.0, 0.0] for _ in texts]
+
+    monkeypatch.setattr(emb_mod, "_embed_texts", _embed, raising=False)
+    ec = EmbeddingChecker()
+    spec = ControlSpec("scope_t", VerificationMethod.CONTENT, DecisionMethod.EMBEDDING,
+                       paraphrases=["Geltungsbereich"], embed_threshold=0.58)
+    monkeypatch.setattr(emb_mod, "_cosine", lambda a, b: 0.90, raising=False)
+    r = _run(ec.check(spec, DocContext(text="x" * 200)))
+    assert r.present is True and r.confidence >= 0.58
+    monkeypatch.setattr(emb_mod, "_cosine", lambda a, b: 0.20, raising=False)
+    r2 = _run(ec.check(spec, DocContext(text="x" * 200)))
+    assert r2.present is False
+
+
+def test_embedding_offline_returns_none(monkeypatch):
+    async def _boom(texts):
+        raise ConnectionError("embedding-service down")
+
+    monkeypatch.setattr(emb_mod, "_embed_texts", _boom, raising=False)
+    ec = EmbeddingChecker()
+    spec = ControlSpec("scope_off", VerificationMethod.CONTENT, DecisionMethod.EMBEDDING,
+                       paraphrases=["x"], embed_threshold=0.6)
+    r = _run(ec.check(spec, DocContext(text="y" * 200)))
+    assert r.present is None  # fail-safe
+
+
+def test_llm_present_and_absent(monkeypatch):
+    lc = LLMChecker()
+    spec = ControlSpec("delivery_timeframe", VerificationMethod.CONTENT, DecisionMethod.LLM,
+                       topic_regex=r"liefer", question="Konkrete Lieferfrist?")
+    doc = DocContext(text=("1. Lieferung\nDie Ware wird innerhalb von 2 Werktagen "
+                           "geliefert.\n") * 4)
+
+    async def _erfuellt(system, user, **kw):
+        return {"text": '{"verdict":"ERFUELLT","zitat":"2 Werktagen","begruendung":"x"}',
+                "source": "qwen", "confidence": 0.7}
+
+    monkeypatch.setattr(cascade_mod, "call_with_cascade", _erfuellt, raising=False)
+    assert _run(lc.check(spec, doc)).present is True
+
+    async def _fehlt(system, user, **kw):
+        return {"text": '{"verdict":"FEHLT"}', "source": "qwen"}
+
+    monkeypatch.setattr(cascade_mod, "call_with_cascade", _fehlt, raising=False)
+    assert _run(lc.check(spec, doc)).present is False