init

backend/engine.py

@@ -0,0 +1,360 @@
+"""Task-Engine (R8): DB ist die einzige Wahrheit/Queue. Scheduler blockiert auf
+einem Wecker-Event + 2-s-Fallback-Poll. Claim per UPDATE…WHERE status='offen'.
+Resume = derselbe Codepfad (Loop starten, DB lesen); Zombie-Reset beim Start.
+Ergebnis + status='fertig' + Folgetasks entstehen in EINER Transaktion."""
+import asyncio
+import hashlib
+import importlib
+from contextlib import suppress
+from dataclasses import dataclass, field
+
+from . import config, db, graph
+from .llm import BudgetErschoepft, LaufPause
+
+WORKER: dict[str, object] = {}
+_laeufe: dict[str, asyncio.Task] = {}
+_wecker: dict[int, asyncio.Event] = {}
+
+
+def worker(name: str, buendel: bool = False):
+    def deco(fn):
+        fn.buendel = buendel  # opt-in: Worker verarbeitet t["_buendel"]-Listen
+        WORKER[name] = fn
+        return fn
+    return deco
+
+
+@dataclass
+class Ergebnis:
+    """Rückgabe jedes Workers. neue_tasks: {knoten, item, payload?, art?, runde?}
+    — Ziel muss über eine Kante vom eigenen Knoten erreichbar sein."""
+    daten: dict = field(default_factory=dict)
+    neue_tasks: list = field(default_factory=list)
+    befunde: list = field(default_factory=list)      # nur Gates: {art, item, detail}
+    gate_status: str = ""                            # nur Gates: gruen | rot
+    teil_status: dict = field(default_factory=dict)  # Bündel: task_id → fertig | neu
+
+
+def module_laden() -> None:
+    """Worker-Module importieren → Registrierung; danach Graph validieren."""
+    for mod in ("suche", "laden", "korpus", "inventar", "dedup",
+                "struktur", "guide", "redundanz", "montage"):
+        importlib.import_module(f"backend.{mod}")
+    graph.laden(set(WORKER))
+
+
+def wecken(run_id: int) -> None:
+    ev = _wecker.get(run_id)
+    if ev:
+        ev.set()
+
+
+# ── Lauf-Verwaltung ──
+
+def lauf_starten(topic: str, budget: int | None = None) -> int:
+    if topic in _laeufe and not _laeufe[topic].done():
+        raise RuntimeError("Lauf läuft bereits")
+    run = db.one("SELECT * FROM runs WHERE topic=? AND status IN "
+                 "('paused','budget') ORDER BY id DESC LIMIT 1", topic)
+    if run:  # Resume: gleicher Run, gleiche Tasks
+        run_id = run["id"]
+        felder = {"status": "running", "grund": ""}
+        if budget is not None:  # Budget-Nachschlag beim Fortsetzen
+            felder["budget_tokens"] = budget
+        db.update("runs", "id=?", (run_id,), **felder)
+    else:
+        run_id = db.insert("runs", topic=topic, status="running",
+                           gestartet=db.now(),
+                           budget_tokens=budget if budget is not None
+                           else config.RUN_BUDGET_TOKENS)
+    _laeufe[topic] = asyncio.ensure_future(_lauf(topic, run_id))
+    return run_id
+
+
+def lauf_pausieren(topic: str) -> None:
+    run = _aktiver_run(topic)
+    if run:
+        db.update("runs", "id=?", (run["id"],), status="paused", grund="manuell")
+        wecken(run["id"])
+
+
+def lauf_stoppen(topic: str) -> None:
+    run = _aktiver_run(topic)
+    if run:
+        db.update("runs", "id=?", (run["id"],), status="stopped", beendet=db.now())
+        wecken(run["id"])
+    task = _laeufe.get(topic)
+    if task and not task.done():
+        task.cancel()
+
+
+def _aktiver_run(topic: str) -> dict | None:
+    return db.one("SELECT * FROM runs WHERE topic=? AND status='running' "
+                  "ORDER BY id DESC LIMIT 1", topic)
+
+
+# ── Kern-Loop ──
+
+async def _lauf(topic: str, run_id: int) -> None:
+    g = graph.get()
+    ev = _wecker[run_id] = asyncio.Event()
+    sem_global = asyncio.Semaphore(config.MAX_PARALLEL_GLOBAL)
+    sems = {k.id: asyncio.Semaphore(k.max_parallel) for k in g.knoten.values()}
+    laufende: set[asyncio.Task] = set()
+    # Zombie-Reset: ein Prozess ⇒ beim Start ist garantiert nichts in Arbeit
+    db.execute("UPDATE tasks SET status='offen', fehler='zombie' "
+               "WHERE topic=? AND status='laufend'", topic)
+    _start_tasks(topic, run_id)
+    try:
+        while True:
+            run = db.one("SELECT * FROM runs WHERE id=?", run_id)
+            if run["status"] != "running":
+                break
+            stufe_i = _aktuelle_stufe(g, topic)
+            db.update("runs", "id=? AND stufe!=?", (run_id, g.stufen[stufe_i]),
+                      stufe=g.stufen[stufe_i])
+            _gate_pruefen(g, topic, run_id, stufe_i)
+            gestartet = _dispatch(g, topic, run_id, stufe_i, sems, sem_global,
+                                  laufende, ev)
+            if not gestartet and not laufende and _leer(topic):
+                _abschliessen(g, topic, run_id)
+                break
+            with suppress(asyncio.TimeoutError):
+                await asyncio.wait_for(ev.wait(), timeout=config.POLL_SEKUNDEN)
+            ev.clear()
+            laufende = {t for t in laufende if not t.done()}
+        # Pause/Stop: Laufende sanft auslaufen lassen
+        if laufende:
+            await asyncio.gather(*laufende, return_exceptions=True)
+    finally:
+        _wecker.pop(run_id, None)
+
+
+def _leer(topic: str) -> bool:
+    return not db.one("SELECT id FROM tasks WHERE topic=? AND "
+                      "status IN ('offen','laufend') LIMIT 1", topic)
+
+
+def _aktuelle_stufe(g: graph.Graph, topic: str) -> int:
+    for i, stufe in enumerate(g.stufen):
+        gate = g.gate_der_stufe(stufe)
+        if gate is None:
+            return i
+        gruen = db.one("SELECT id FROM gate_laeufe WHERE topic=? AND knoten=? "
+                       "AND status='gruen'", topic, gate.id)
+        if not gruen:
+            return i
+    return len(g.stufen) - 1
+
+
+def _dispatch(g, topic, run_id, stufe_i, sems, sem_global, laufende, ev) -> int:
+    offen = db.query(
+        "SELECT * FROM tasks WHERE topic=? AND status='offen' ORDER BY runde, id",
+        topic)
+    n = 0
+    for t in offen:
+        kn = g.knoten.get(t["knoten"])
+        if kn is None or g.stufen_index(kn.stufe) > stufe_i:
+            continue
+        if sems[kn.id].locked() or sem_global.locked():
+            continue
+        if kn.barriere and _vorarbeit_offen(g, topic, kn, ausser=t["id"]):
+            continue
+        if kn.typ == "gate" and _vorarbeit_offen(g, topic, kn, ausser=t["id"]):
+            continue
+        if db.execute("UPDATE tasks SET status='laufend', gestartet=? "
+                      "WHERE id=? AND status='offen'", db.now(), t["id"]) != 1:
+            continue
+        t = dict(t)
+        t["_buendel"] = _buendel_claimen(g, t, kn)
+        task = asyncio.create_task(
+            _ausfuehren(g, t, kn, sems[kn.id], sem_global, ev))
+        laufende.add(task)
+        n += 1
+    return n
+
+
+def _buendel_claimen(g, t: dict, kn: graph.Knoten) -> list[dict]:
+    """Bis zu buendel−1 weitere offene Tasks gleicher (knoten, art) mit-claimen.
+    Nur für Worker mit buendel-Opt-in — sonst blieben Mitglieder 'laufend' hängen."""
+    fn = WORKER[kn.worker]
+    if kn.buendel <= 1 or not getattr(fn, "buendel", False):
+        return []
+    mitglieder = []
+    kandidaten = db.query(
+        "SELECT * FROM tasks WHERE topic=? AND knoten=? AND art=? AND "
+        "status='offen' AND id!=? ORDER BY runde, id LIMIT ?",
+        t["topic"], t["knoten"], t["art"], t["id"], kn.buendel - 1)
+    for k in kandidaten:
+        if db.execute("UPDATE tasks SET status='laufend', gestartet=? "
+                      "WHERE id=? AND status='offen'", db.now(), k["id"]) == 1:
+            mitglieder.append(dict(k))
+    return mitglieder
+
+
+def _vorarbeit_offen(g: graph.Graph, topic: str, kn: graph.Knoten,
+                     ausser: int) -> bool:
+    """Barriere/Gate: wartet, bis KEIN offener/laufender Task an Knoten der
+    eigenen oder früherer Stufen existiert (außer sich selbst)."""
+    max_i = g.stufen_index(kn.stufe)
+    ids = [k.id for k in g.knoten.values()
+           if g.stufen_index(k.stufe) <= max_i and k.id != kn.id]
+    qs = ",".join("?" for _ in ids)
+    return bool(db.one(
+        f"SELECT id FROM tasks WHERE topic=? AND status IN ('offen','laufend') "
+        f"AND knoten IN ({qs}) AND id!=? LIMIT 1", topic, *ids, ausser))
+
+
+def _gate_pruefen(g: graph.Graph, topic: str, run_id: int, stufe_i: int) -> None:
+    """Stufe leer gelaufen → Gate-Task für Runde N anlegen (idempotent)."""
+    gate = g.gate_der_stufe(g.stufen[stufe_i])
+    if gate is None:
+        return
+    vorhanden = db.one("SELECT id FROM tasks WHERE topic=? AND knoten=? AND "
+                       "status IN ('offen','laufend')", topic, gate.id)
+    if vorhanden:
+        return
+    if _vorarbeit_offen(g, topic, gate, ausser=-1):
+        return
+    runde = (db.one("SELECT COUNT(*) c FROM gate_laeufe WHERE topic=? AND knoten=?",
+                    topic, gate.id) or {"c": 0})["c"] + 1
+    if runde > config.GATE_RUNDEN_MAX.get(gate.id, 3):
+        _pausieren(run_id, f"gate_cap:{gate.id}:{runde}")
+        return
+    db.insert("tasks", ignore=True, run_id=run_id, topic=topic, knoten=gate.id,
+              item=f"runde:{runde}", runde=runde, erzeugt_von="engine")
+
+
+async def _ausfuehren(g, t: dict, kn: graph.Knoten, sem, sem_global, ev) -> None:
+    fn = WORKER[kn.worker]
+    alle = [t] + t.get("_buendel", [])
+    try:
+        async with sem_global, sem:
+            erg: Ergebnis = await fn(t)
+    except (LaufPause, BudgetErschoepft) as e:
+        status = "budget" if isinstance(e, BudgetErschoepft) else "paused"
+        for m in alle:
+            db.update("tasks", "id=?", (m["id"],), status="offen",
+                      fehler=str(e)[:300])
+        _pausieren(t["run_id"], f"{status}:{e}", status=status)
+        ev.set()
+        return
+    except asyncio.CancelledError:
+        for m in alle:
+            db.update("tasks", "id=?", (m["id"],), status="offen", fehler="abbruch")
+        raise
+    except Exception as e:  # Inhaltsfehler: begrenzte Neuversuche, dann sichtbar
+        for m in alle:
+            _task_neu(m, kn, f"{type(e).__name__}: {e}"[:300])
+        ev.set()
+        return
+    _abschluss_schreiben(g, t, kn, erg)
+    ev.set()
+
+
+def _task_neu(t: dict, kn: graph.Knoten, fehler: str) -> None:
+    versuch = t["versuch"] + 1
+    status = "offen" if versuch < kn.max_versuche else "fehler"
+    db.update("tasks", "id=?", (t["id"],), status=status, versuch=versuch,
+              fehler=fehler)
+
+
+def _abschluss_schreiben(g, t: dict, kn: graph.Knoten, erg: Ergebnis) -> None:
+    erlaubt = g.erlaubte_ziele(kn.id)
+    # Bündel-Mitglieder: kaputte Teil-Antworten → neuer Versuch, nie verwerfen
+    for m in t.get("_buendel", []):
+        if erg.teil_status.get(m["id"]) == "neu":
+            _task_neu(m, kn, "buendel_teil_kaputt")
+        else:
+            db.update("tasks", "id=?", (m["id"],), status="fertig",
+                      ergebnis=db.j({"buendel_mit": t["id"]}), beendet=db.now())
+    with db.tx() as c:
+        if erg.teil_status.get(t["id"]) == "neu":
+            c.execute("UPDATE tasks SET status=?, versuch=?, fehler=? WHERE id=?",
+                      ("offen" if t["versuch"] + 1 < kn.max_versuche else "fehler",
+                       t["versuch"] + 1, "buendel_teil_kaputt", t["id"]))
+        else:
+            c.execute(
+                "UPDATE tasks SET status='fertig', ergebnis=?, beendet=? WHERE id=?",
+                (db.j(erg.daten), db.now(), t["id"]))
+        eingefuegt = 0
+        for nt in erg.neue_tasks:
+            if nt["knoten"] not in erlaubt:
+                raise graph.GraphFehler(
+                    f"{kn.id} darf keine Tasks für {nt['knoten']} erzeugen")
+            cur = c.execute(
+                "INSERT OR IGNORE INTO tasks(run_id, topic, knoten, item, art, "
+                "runde, payload, erzeugt_von) VALUES(?,?,?,?,?,?,?,?)",
+                (t["run_id"], t["topic"], nt["knoten"], nt["item"],
+                 nt.get("art", ""), nt.get("runde", t["runde"]),
+                 db.j(nt.get("payload", {})), kn.id))
+            eingefuegt += cur.rowcount
+        if kn.typ == "gate":
+            _gate_abschluss(c, t, kn, erg, eingefuegt)
+
+
+def _gate_abschluss(c, t: dict, kn: graph.Knoten, erg: Ergebnis,
+                    neu_eingefuegt: int = 0) -> None:
+    befunde = sorted(f"{b['art']}|{b['item']}|{b.get('detail', '')[:200]}"
+                     for b in erg.befunde)
+    fingerprint = hashlib.sha256("\n".join(befunde).encode()).hexdigest()[:16]
+    c.execute("INSERT OR REPLACE INTO gate_laeufe(run_id, topic, knoten, runde, "
+              "status, fingerprint, befunde, ts) VALUES(?,?,?,?,?,?,?,?)",
+              (t["run_id"], t["topic"], kn.id, t["runde"], erg.gate_status,
+               fingerprint, db.j(erg.befunde), db.now()))
+    for b in erg.befunde:
+        # Spiegel-Zeile nur, wenn kein identischer Befund schon offen ist
+        schon = c.execute(
+            "SELECT id FROM befunde WHERE art=? AND item=? AND "
+            "substr(detail,1,200)=? AND status='offen'",
+            (b["art"], b["item"], b.get("detail", "")[:200])).fetchone()
+        if not schon:
+            c.execute("INSERT INTO befunde(run_id, stufe, knoten, art, item, "
+                      "detail, runde) VALUES(?,?,?,?,?,?,?)",
+                      (t["run_id"], kn.stufe, kn.id, b["art"], b["item"],
+                       b.get("detail", "")[:500], t["runde"]))
+    if erg.gate_status == "gruen":
+        # Stufe bestanden → offene Befunde dieser Stufe sind Geschichte
+        c.execute("UPDATE befunde SET status='behoben' WHERE status='offen' AND "
+                  "stufe=? AND run_id IN (SELECT id FROM runs WHERE topic=?)",
+                  (kn.stufe, t["topic"]))
+    if erg.gate_status == "rot":
+        # Stillstand: identischer Fingerprint n-mal hintereinander UND keine
+        # NEUEN Reparatur-Tasks entstanden (die Eskalations-Kette kann bei
+        # gleicher Befundmenge trotzdem vorankommen: fix → klaerung → neu)
+        alte = [r["fingerprint"] for r in c.execute(
+            "SELECT fingerprint FROM gate_laeufe WHERE topic=? AND knoten=? "
+            "ORDER BY runde DESC LIMIT ?",
+            (t["topic"], kn.id, config.STILLSTAND_N)).fetchall()]
+        if neu_eingefuegt == 0:
+            grund = (f"stillstand:{kn.id}:r{t['runde']}"
+                     if len(alte) >= config.STILLSTAND_N and len(set(alte)) == 1
+                     else f"gate_rot_ohne_reparatur:{kn.id}")
+            c.execute("UPDATE runs SET status='paused', grund=? WHERE id=?",
+                      (grund, t["run_id"]))
+
+
+def _pausieren(run_id: int, grund: str, status: str = "paused") -> None:
+    db.update("runs", "id=? AND status='running'", (run_id,),
+              status=status, grund=grund[:200])
+
+
+def _abschliessen(g: graph.Graph, topic: str, run_id: int) -> None:
+    """Kein Task mehr offen: done, wenn alle Gates grün + Montage fertig."""
+    fertig = db.one("SELECT id FROM tasks WHERE topic=? AND knoten='montage' "
+                    "AND status='fertig'", topic)
+    offen_fehler = db.one("SELECT id FROM tasks WHERE topic=? AND status='fehler' "
+                          "LIMIT 1", topic)
+    if fertig and not offen_fehler:
+        db.update("runs", "id=?", (run_id,), status="done", beendet=db.now())
+    else:
+        grund = "tasks_mit_fehler" if offen_fehler else "leerlauf_ohne_montage"
+        _pausieren(run_id, grund)
+
+
+def _start_tasks(topic: str, run_id: int) -> None:
+    """Initiale Tasks der Stufe 1 (idempotent — Resume ist ein No-Op)."""
+    for lens in config.RECHERCHE_LENSES:
+        db.insert("tasks", ignore=True, run_id=run_id, topic=topic,
+                  knoten="recherche_plan", item=f"r1:lens:{lens}", runde=1,
+                  payload=db.j({"lens": lens}), erzeugt_von="start")