update

backend/config.py

@@ -62,11 +62,8 @@ TIMEOUTS = {
     "lese_check":    (300, 10),   # pro Section im Paket
     "grafik":        (600, 60),   # Graph-Grafik je Baustein (Knoten/Kanten), n = Subbausteine
     "grafik_check":  (300, 15),   # Grafik-Prüfung/Fix je Baustein, n = Subbausteine
-    "onepager_recherche": (900, 0),
+    "roadmap":       (600, 0),   # Roadmap-Graph aus der Baustein-Übersicht bauen
-    "onepager_mapping":   (600, 0),  # Konsolidierung der Recherchen
+    "roadmap_check": (300, 0),   # Judge prüft/fixt den Roadmap-Graph
-    "onepager_bauen":     (300, 0),
-    "onepager_judge":     (600, 0),  # Judge über die Karten-Sätze
-    "onepager_verify":    (300, 0),
 }
 
 # Auswahl-Auftrag je Format: (Mindest-Anteil, Maximal-Anteil, Mindestanzahl, Zweck).

backend/elements.py

@@ -71,7 +71,7 @@ def _topic_context(topic: str, limit: int = 12000) -> str:
     bp = bausteine_path(topic)
     if bp.exists():
         parts.append(bp.read_text(encoding="utf-8"))
-    for fmt in ("Guide", "OnePager"):
+    for fmt in ("Guide",):  # Roadmap ist ein Graph ohne Prosa-Sections → kein Text-Kontext
         content = _json_datei(guide_content_path(topic, fmt))
         if content:
             for ch in content.get("chapters", []):

backend/guide.py

@@ -1,4 +1,4 @@
-"""Guide-Generierung als Konsens-Pipeline (OnePager hat einen eigenen Weg).
+"""Guide-Generierung als Konsens-Pipeline (Roadmap hat einen eigenen Weg).
 
 Auswahl: 5 Agenten (min. 3, Grace) → Code-Voting (Mehrheit = Konsens) →
 Mapping-Agent sortiert Strittiges → Klärungs-Loop (max. KONSENS_MAX_RUNDEN).
@@ -24,7 +24,7 @@ import lesbarkeit
 from database import list_guides, update_guide
 from fsutil import atomic_write_json
 from jsonio import read_json_file as _json_datei
-from onepager import _generate_onepager
+from roadmap import _generate_roadmap
 from paths import bausteine_path, guide_content_path, project_dir, subbausteine_path
 from pipeline import (
     CANCELLED, FAILED, GenContext, _claude_error, _extra,
@@ -172,6 +172,20 @@ def _resolve_gliederung(data, entries: dict[int, str], soll_min: int, soll_max:
     return chapters
 
 
+def _fallback_gliederung(entries: dict[int, str]) -> list[dict]:
+    """Deterministische Gliederung, wenn die Agenten keine liefern: ein Kapitel mit
+    allen gewählten Bausteinen in Reihenfolge. Garantiert vollständige Abdeckung."""
+    return [{"title": "Inhalte", "nums": list(entries)}]
+
+
+def _mit_resten(plan: list[dict], entries: dict[int, str]) -> list[dict]:
+    """Stellt sicher, dass JEDER gewählte Baustein im Plan steht — fehlende landen in
+    einem Kapitel „Weitere" (gegen Agenten/Judge, die Bausteine weglassen)."""
+    drin = {num for ch in plan for num in ch.get("nums", [])}
+    fehlen = [num for num in entries if num not in drin]
+    return [*plan, {"title": "Weitere", "nums": fehlen}] if fehlen else plan
+
+
 def _voting(stimmen: list[list[int]]) -> tuple[list[int], dict[int, int]]:
     """Mehrheit (> Hälfte der Stimmen) → Konsens; ≥1 Stimme → Rest mit Votenzahl."""
     zaehler: dict[int, int] = {}
@@ -433,7 +447,8 @@ async def _generate_sections(
     soll = len(sel_entries)
     sel_liste = "\n".join(f"- {t}" for t in sel_entries.values())
 
-    # Schritt 1: Gliederung — 5 Vorschläge (min. 3, Grace), ein Judge wählt.
+    # Schritt 1: Gliederung — bis zu 5 Vorschläge (Grace), ein Judge wählt. Bricht NIE ab:
+    # 0 gültige → Code-Fallback, 1 → direkt, ≥2 → Judge (mit Vorschlag als Rückfall).
     # Gültiges gliederung.json (auch aus Altläufen) überspringt den Schritt.
     plan = _resolve_gliederung(_json_datei(files["gliederung"]), sel_entries, soll, soll)
     if plan is None:
@@ -447,7 +462,7 @@ async def _generate_sections(
                 vorschlaege.append(res)
             else:
                 offen.append((i, path))
-        if len(vorschlaege) < 3:
+        if len(vorschlaege) < 3 and offen:
             slots = [
                 {
                     "key": f"{guide_id}-gliederung-{i}",
@@ -461,17 +476,21 @@ async def _generate_sections(
                 }
                 for i, path in offen
             ]
+            # Quorum 1: nimm, was kommt — kein Mindestzwang, kein Abbruch.
             neue = await _race(
-                topic, "Gliederung", slots, 3 - len(vorschlaege), _timeout("plan", soll),
+                topic, "Gliederung", slots, 1, _timeout("plan", soll),
                 provider, cancelled=is_cancelled, grace=KONSENS_GRACE,
             )
             if is_cancelled():
                 return None
-            if neue is None:
+            vorschlaege += neue or []
-                await _fail(guide_id, "Gliederung fehlgeschlagen (Minimum nicht erreicht)")
-                return None
-            vorschlaege += neue
 
+        if not vorschlaege:
+            _log(topic, "Gliederung: kein gültiger Vorschlag — deterministischer Fallback")
+            plan = _fallback_gliederung(sel_entries)
+        elif len(vorschlaege) == 1:
+            plan = vorschlaege[0]  # ein Vorschlag → kein Judge nötig
+        else:
             await _set_step(guide_id, 1, "Wähle beste Gliederung…")
             bloecke = "\n\n".join(
                 f"### Vorschlag {i}\n"
@@ -493,9 +512,12 @@ async def _generate_sections(
             )
             if status == CANCELLED:
                 return None
-        if status == FAILED:
+            if status == FAILED or plan is None:
-            await _fail(guide_id, "Gliederung fehlgeschlagen (Judge ohne gültiges Ergebnis)")
+                _log(topic, "Gliederung-Judge ohne Ergebnis — bester Vorschlag bleibt")
-            return None
+                plan = vorschlaege[0]
+
+    # Garantie: jeder gewählte Baustein steht im Plan (gegen weglassende Agenten/Judges).
+    plan = _mit_resten(plan, sel_entries)
 
     # Chunks festlegen — Inhalte, Inhalts-Prüfung, Writer und Lese-Check nutzen
     # dieselbe Aufteilung: 1 Agent je ~30 Bausteine (gedeckelt).
@@ -817,8 +839,11 @@ async def generate_guide(guide_id: str, topic: str, format_name: str, instructio
                 for p_alt in guide_slot_dateien(content_path):
                     p_alt.unlink(missing_ok=True)
 
-            if format_name == "OnePager":
+            if format_name == "Roadmap":
-                chapters = await _generate_onepager(guide_id, topic, instructions, provider, project, content_path)
+                graph = await _generate_roadmap(guide_id, topic, instructions, provider, content_path)
+                if graph is None or is_guide_cancelled(guide_id):
+                    return
+                content = {"topic": topic, "format": format_name, "graph": graph}
             else:
                 alle = _lade_bausteine(bausteine_path(topic).read_text(encoding="utf-8"))
                 if not alle:
@@ -832,8 +857,9 @@ async def generate_guide(guide_id: str, topic: str, format_name: str, instructio
                 )
                 if chapters is None or is_guide_cancelled(guide_id):
                     return
+                content = {"topic": topic, "format": format_name, "chapters": chapters}
 
-            atomic_write_json(content_path, {"topic": topic, "format": format_name, "chapters": chapters}, indent=1)
+            atomic_write_json(content_path, content, indent=1)
 
             now = datetime.now(timezone.utc).isoformat()
             await update_guide(guide_id, status="done", progress=None, step=None, updated_at=now)

backend/models.py

@@ -2,7 +2,7 @@ from pydantic import BaseModel, Field
 from typing import Literal
 
 FormatType = Literal[
-    "OnePager",
+    "Roadmap",
     "Guide",
 ]
 

backend/onepager.py

@@ -1,244 +0,0 @@
-"""OnePager-Pipeline als Konsens-Kette (7 Karten im 3×3-Raster).
-
-Recherche: 3 Agenten (min. 2, Grace) → Mapping konsolidiert zu EINER Faktenbasis.
-Bauen: 3 Agenten bauen je einen Karten-Satz → ein Judge wählt und kombiniert.
-Prüfung: Verify→Fix-Loop (max. KONSENS_MAX_RUNDEN); Runde 1 ist fatal, danach
-bleibt bei Fehlern die letzte gültige Version. Schritt-Dateien bleiben liegen →
-Abbruch erhält Fortschritt, ▶ setzt am offenen Schritt fort.
-"""
-
-from pathlib import Path
-
-from config import KONSENS_GRACE, KONSENS_MAX_RUNDEN
-from jsonio import read_json_file as _json_datei
-from pipeline import (
-    CANCELLED, FAILED, GenContext, _extra, _fail, _log, _probleme_schema,
-    _prompt, _race, _set_step, _timeout, is_guide_cancelled, run_single_slot,
-)
-
-ONEPAGER_STEPS = ("Recherche", "Bauen", "Prüfung")
-
-
-async def _generate_onepager(
-    guide_id: str, topic: str, instructions: str, provider: str,
-    project: Path | None, content_path: Path,
-) -> list[dict] | None:
-    is_cancelled = lambda: is_guide_cancelled(guide_id)
-    ctx = GenContext(topic=topic, provider=provider, is_cancelled=is_cancelled, guide_id=guide_id)
-
-    # 3×3-Raster: 7 Karten mit festen Schlüsseln (Reihenfolge = Lesereihenfolge mobil)
-    KARTEN_KEYS = ("info", "eigenschaften", "beispiel", "zusammenhaenge", "voraussetzungen", "modern", "veraltet")
-
-    def karten_schema(data):
-        """{"karten": {key: {titel, md}}} → Liste · sonst None."""
-        if not isinstance(data, dict):
-            return None
-        karten = data.get("karten")
-        if not isinstance(karten, dict):
-            return None
-        out = []
-        for key in KARTEN_KEYS:
-            k = karten.get(key)
-            if not isinstance(k, dict) or not isinstance(k.get("titel"), str) or not isinstance(k.get("md"), str):
-                return None
-            titel, md = k["titel"].strip(), k["md"].strip()
-            if not titel or len(md) < 5:  # abgebrochene/leere Karten sind ungültig
-                return None
-            out.append({"key": key, "titel": titel, "md": md})
-        return out
-
-    d, stem = content_path.parent, content_path.stem
-    recherche_slots = [d / f"{stem}.recherche-{i}.md" for i in (1, 2, 3)]
-    recherche_path = d / f"{stem}.recherche.md"   # konsolidierte Faktenbasis
-    karten_slots = [d / f"{stem}.karten-{i}.json" for i in (1, 2, 3)]
-    karten_path = d / f"{stem}.karten.json"        # Judge-Ausgabe
-    verify_paths = {n: d / f"{stem}.verify-r{n}.json" for n in range(1, KONSENS_MAX_RUNDEN + 1)}
-    fix_paths = {n: d / f"{stem}.karten-fix-r{n}.json" for n in range(1, KONSENS_MAX_RUNDEN + 1)}
-
-    # Projekte bekommen eigene Recherche-Dimensionen — Produkt-Fragen
-    # (Version, Lizenz, Alternativen) laufen dort ins Leere.
-    if project:
-        source = _prompt("OnePager-Quelle-Projekt", project=project)
-        recherche_template = "OnePager-Recherche-Projekt"
-    else:
-        source = _prompt("OnePager-Quelle-Thema", topic=topic)
-        recherche_template = "OnePager-Recherche"
-
-    def text_payload(path: Path):
-        if not path.exists():
-            return None
-        text = path.read_text(encoding="utf-8").strip()
-        return text or None
-
-    # Schritt 0: Recherche — 3 Agenten (min. 2, Grace), Mapping konsolidiert.
-    # Eine gültige recherche.md (auch aus Altläufen) überspringt den Schritt.
-    recherche = text_payload(recherche_path)
-    if recherche is None:
-        await _set_step(guide_id, 0, "Recherchiere (3 Agenten)…")
-        recherchen = []
-        offen = []
-        for i, path in enumerate(recherche_slots, 1):
-            text = text_payload(path)
-            if text is not None:
-                recherchen.append(text)
-            else:
-                offen.append((i, path))
-        if len(recherchen) < 2:
-            slots = [
-                {
-                    "key": f"{guide_id}-recherche-{i}",
-                    "prompt": _prompt(recherche_template, topic=topic, source=source, out_path=path, extra=_extra(instructions)),
-                    "role": "quick", "capabilities": "files" if project else "full",
-                    "payload": (lambda result, p=path: text_payload(p)),
-                }
-                for i, path in offen
-            ]
-            neue = await _race(
-                topic, "OnePager-Recherche", slots, 2 - len(recherchen),
-                _timeout("onepager_recherche"), provider, cancelled=is_cancelled, grace=KONSENS_GRACE,
-            )
-            if is_cancelled():
-                return None
-            if neue is None:
-                await _fail(guide_id, "OnePager-Recherche fehlgeschlagen (Minimum nicht erreicht)")
-                return None
-            recherchen += neue
-
-        await _set_step(guide_id, 0, "Konsolidiere Recherche…")
-        recherchen_block = "\n\n".join(f"### Recherche {i}\n\n{text}" for i, text in enumerate(recherchen, 1))
-        status, recherche = await run_single_slot(
-            ctx, "Recherche-Mapping",
-            key=f"{guide_id}-recherche-mapping",
-            prompt=_prompt(
-                "OnePager-Recherche-Mapping",
-                topic=topic, n=len(recherchen), recherchen=recherchen_block, out_path=recherche_path,
-            ),
-            role="judge", capabilities="files",
-            payload=lambda result: text_payload(recherche_path),
-            timeout=_timeout("onepager_mapping"),
-        )
-        if status == CANCELLED:
-            return None
-        if status == FAILED:
-            await _fail(guide_id, "Recherche-Konsolidierung fehlgeschlagen")
-            return None
-
-    # Schritt 1: Bauen — 3 Entwürfe (min. 2, Grace), ein Judge kombiniert.
-    # Gültiges karten.json (auch aus Altläufen) überspringt den Schritt.
-    karten = karten_schema(_json_datei(karten_path))
-    if karten is None:
-        await _set_step(guide_id, 1, "Baue OnePager (3 Entwürfe)…")
-        entwuerfe = []
-        offen = []
-        for i, path in enumerate(karten_slots, 1):
-            res = karten_schema(_json_datei(path))
-            if res is not None:
-                entwuerfe.append(res)
-            else:
-                offen.append((i, path))
-        if len(entwuerfe) < 2:
-            slots = [
-                {
-                    "key": f"{guide_id}-bauen-{i}",
-                    "prompt": _prompt("OnePager-Bauen", topic=topic, recherche=recherche, out_path=path, extra=_extra(instructions)),
-                    "role": "fast", "capabilities": "files",
-                    "payload": (lambda result, p=path: karten_schema(_json_datei(p))),
-                }
-                for i, path in offen
-            ]
-            neue = await _race(
-                topic, "OnePager-Bauen", slots, 2 - len(entwuerfe),
-                _timeout("onepager_bauen"), provider, cancelled=is_cancelled, grace=KONSENS_GRACE,
-            )
-            if is_cancelled():
-                return None
-            if neue is None:
-                await _fail(guide_id, "OnePager-Bau fehlgeschlagen (Minimum nicht erreicht)")
-                return None
-            entwuerfe += neue
-
-        await _set_step(guide_id, 1, "Wähle besten Entwurf…")
-        saetze_block = "\n\n".join(
-            f"## Entwurf {i}\n\n" + "\n\n".join(f"### {k['titel']} [{k['key']}]\n{k['md']}" for k in satz)
-            for i, satz in enumerate(entwuerfe, 1)
-        )
-        status, karten = await run_single_slot(
-            ctx, "Bauen-Judge",
-            key=f"{guide_id}-bauen-judge",
-            prompt=_prompt(
-                "OnePager-Bauen-Judge",
-                topic=topic, n=len(entwuerfe), recherche=recherche, kartensaetze=saetze_block,
-                out_path=karten_path, extra=_extra(instructions),
-            ),
-            role="judge", capabilities="files",
-            payload=lambda result: karten_schema(_json_datei(karten_path)),
-            timeout=_timeout("onepager_judge"),
-        )
-        if status == CANCELLED:
-            return None
-        if status == FAILED:
-            await _fail(guide_id, "OnePager-Bau fehlgeschlagen (Judge ohne gültiges Ergebnis)")
-            return None
-
-    def karten_block() -> str:
-        return "\n\n".join(f"### {k['titel']} [{k['key']}]\n{k['md']}" for k in karten)
-
-    # Schritt 2: Prüf-Loop — Verify notiert Probleme, Fix behebt; max. Runden-Cap.
-    # Runde 1 ist fatal (wie früher der Einzel-Check), danach bleibt bei Fehlern
-    # die letzte gültige Version stehen.
-    for runde in range(1, KONSENS_MAX_RUNDEN + 1):
-        probleme = _probleme_schema(_json_datei(verify_paths[runde]))
-        if probleme is None:
-            await _set_step(guide_id, 2, f"Prüfe OnePager (Runde {runde}/{KONSENS_MAX_RUNDEN})…")
-            verify_paths[runde].unlink(missing_ok=True)
-            status, probleme = await run_single_slot(
-                ctx, f"OnePager-Prüfung r{runde}",
-                key=f"{guide_id}-verify-r{runde}",
-                prompt=_prompt("OnePager-Verifikation", topic=topic, recherche=recherche, karten=karten_block(), out_path=verify_paths[runde]),
-                role="judge", capabilities="files",
-                payload=lambda result, p=verify_paths[runde]: _probleme_schema(_json_datei(p)),
-                timeout=_timeout("onepager_verify"),
-            )
-            if status == CANCELLED:
-                return None
-            if status == FAILED:
-                if runde == 1:
-                    await _fail(guide_id, "OnePager-Prüfung fehlgeschlagen")
-                    return None
-                _log(topic, f"OnePager-Prüfung Runde {runde} fehlgeschlagen — letzte gültige Version bleibt")
-                break
-        if not probleme:
-            break
-        if runde == KONSENS_MAX_RUNDEN:
-            _log(topic, f"OnePager-Prüfung: {len(probleme)} Problem(e) bleiben nach Runde {runde} stehen")
-            break
-
-        _log(topic, f"OnePager-Prüfung Runde {runde}: {len(probleme)} Problem(e) notiert")
-        fixed = karten_schema(_json_datei(fix_paths[runde]))  # Resume
-        if fixed is None:
-            await _set_step(guide_id, 2, f"Überarbeite OnePager (Runde {runde})…")
-            status, fixed = await run_single_slot(
-                ctx, f"OnePager-Fix r{runde}",
-                key=f"{guide_id}-karten-fix-r{runde}",
-                prompt=_prompt(
-                    "OnePager-Fix",
-                    topic=topic, recherche=recherche, karten=karten_block(),
-                    probleme="\n".join(f"- {p}" for p in probleme),
-                    out_path=fix_paths[runde], extra=_extra(instructions),
-                ),
-                role="fast", capabilities="files",
-                payload=lambda result, p=fix_paths[runde]: karten_schema(_json_datei(p)),
-                timeout=_timeout("onepager_bauen"),
-            )
-            if status == CANCELLED:
-                return None
-            if status == FAILED:
-                _log(topic, f"OnePager-Fix Runde {runde} ungültig — letzte gültige Version bleibt")
-                break
-        karten = fixed
-
-    sections = [
-        {"num": i, "title": k["titel"], "md": k["md"], "key": k["key"]}
-        for i, k in enumerate(karten, 1)
-    ]
-    return [{"title": topic, "sections": sections}]

backend/regeln.py

@@ -1,11 +1,10 @@
 """Lernschulden-Regeln: Progression und Deckel für offene Guides — die EINZIGE Quelle.
 
-Regeln (nur Neu-Erstellungen; Themen, Bausteine, OnePager unbegrenzt):
+Regeln (nur Neu-Erstellungen; Themen, Bausteine, Roadmap unbegrenzt):
-- JE Format (MiniGuide/Guide/FullGuide) höchstens 3 erstellte, nicht absolvierte Guides
+- Format „Guide": höchstens 3 erstellte, nicht absolvierte Guides
-- Progression pro Thema: Guide erst nach absolviertem MiniGuide, FullGuide erst nach absolviertem Guide
+- Keine Progression/Vorstufe mehr (nur ein Guide-Format).
-- Absolviert (Mini/Guide/FullGuide): ALLE Bausteine (Section-Titel) des neuesten
+- Absolviert: ALLE Bausteine (Section-Titel) des neuesten fertigen Guides haben
-  fertigen Guides haben eine bestandene Prüfung (baustein_progress). Das
+  eine bestandene Prüfung. Roadmap ist read-only (kein Fortschritt, keine Prüfung).
-  Kapitel-Häkchen ist nur noch eine Lese-Markierung. OnePager: Kapitel-Häkchen.
 Alle Funktionen arbeiten auf einmal geladenen Daten (lade_lernstand) — keine
 Query-Schleifen mehr pro Guide.
 """
@@ -19,7 +18,7 @@ from textkit import _norm_titel
 
 MAX_OFFENE_GUIDES = 3
 # Nur noch EIN Format „Guide" (alle relevanten Bausteine, Prüfung 0–30). Keine Progression,
-# keine Vorstufe → der Guide ist immer freischaltbar. „Rest"/OnePager separat.
+# keine Vorstufe → der Guide ist immer freischaltbar. „Rest"/Roadmap separat.
 VORSTUFE: dict[str, str] = {}
 FREISCHALT_LEVEL: dict[str, str] = {}
 FORMATE = ("Guide",)
@@ -85,10 +84,7 @@ def _neueste_done(guides: list[dict], fmt: str) -> dict[str, dict]:
 
 
 def _guide_alle(g: dict, progress: dict[str, set[str]], levelset: dict[str, set[str]]) -> bool:
-    """Sind ALLE Bausteine (bzw. OnePager-Kapitel) des Guides auf dem geforderten Niveau?"""
+    """Sind ALLE Bausteine des Guides auf dem geforderten Niveau?"""
-    if g["format"] == "OnePager":
-        titles = _kapitel_titel(g["topic"], g["format"])
-        return bool(titles) and titles <= progress.get(g["id"], set())
     sections = _section_titel(g["topic"], g["format"])
     return bool(sections) and sections <= levelset.get(g["topic"], set())
 
@@ -125,13 +121,13 @@ def guide_lock(topic: str, fmt: str, guides: list[dict], progress: dict[str, set
     Exakt die Regeln aus POST /guides: Bausteine nötig, kein Duplikat-Start,
     Lernschulden nur für echte Neu-Erstellungen (Resume/Regenerieren frei).
     """
-    if fmt != "OnePager" and not bausteine_path(topic).exists():
+    if not bausteine_path(topic).exists():
         return "Erst Bausteine erstellen"
     for g in guides:
         if g["topic"] == topic and g["format"] == fmt and g["status"] in ("queued", "generating"):
             return "Generierung läuft bereits"
     content = guide_content_path(topic, fmt)
-    if fmt != "OnePager" and not content.exists() and not guide_slot_dateien(content):
+    if not content.exists() and not guide_slot_dateien(content):
         vorstufe = VORSTUFE.get(fmt)
         if vorstufe:
             stufe = FREISCHALT_LEVEL[fmt]  # absolviert=10 · verstanden=20 · gemeistert=30

backend/roadmap.py

@@ -0,0 +1,127 @@
+"""Roadmap-Generierung: ein read-only Übersichts-Graph pro Thema (Advance Organizer).
+
+Quelle = vorhandene Bausteine (keine Web-Recherche). Zwei Schritte:
+Bauen (1 Agent synthetisiert aus der Baustein-Übersicht einen gerichteten Graph aus
+Bereichen) und Prüfung (1 Judge fixt Struktur/Knappheit). Schritt-Dateien bleiben liegen →
+Abbruch erhält Fortschritt, ▶ setzt am offenen Schritt fort.
+"""
+
+import json
+from pathlib import Path
+
+from bausteine import lade_uebersicht
+from config import KONSENS_MAX_RUNDEN
+from jsonio import read_json_file as _json_datei
+from pipeline import (
+    CANCELLED, FAILED, GenContext, _extra, _fail, _log,
+    _prompt, _set_step, _timeout, is_guide_cancelled, run_single_slot,
+)
+
+ROADMAP_STEPS = ("Bauen", "Prüfung")
+
+_PRIO = ("grund", "kern", "vertiefung")
+
+
+def _roadmap_schema(data) -> dict | None:
+    """{"richtung", "knoten":[{id,title,text,prioritaet}], "kanten":[{von,nach,typ}]} →
+    bereinigtes Graph-Dict · sonst None. IDs eindeutig, Kanten referenzieren echte Knoten."""
+    if not isinstance(data, dict) or not isinstance(data.get("knoten"), list):
+        return None
+    knoten, ids = [], set()
+    for k in data["knoten"]:
+        if not isinstance(k, dict):
+            return None
+        kid = str(k.get("id", "")).strip()
+        title = str(k.get("title", "")).strip()
+        text = str(k.get("text", "")).strip()
+        if not kid or not title or kid in ids:
+            continue
+        ids.add(kid)
+        prio = k.get("prioritaet") if k.get("prioritaet") in _PRIO else "kern"
+        knoten.append({"id": kid, "title": title, "text": text, "prioritaet": prio})
+    if not knoten:
+        return None
+    kanten = []
+    for e in (data.get("kanten") or []):
+        if not isinstance(e, dict):
+            continue
+        von, nach = str(e.get("von", "")).strip(), str(e.get("nach", "")).strip()
+        if von not in ids or nach not in ids or von == nach:
+            continue  # hängende/Selbst-Kante verwerfen
+        typ = e.get("typ") if e.get("typ") in ("prereq", "optional") else "prereq"
+        kanten.append({"von": von, "nach": nach, "typ": typ})
+    richtung = data.get("richtung") if data.get("richtung") in ("TB", "LR") else "TB"
+    return {"richtung": richtung, "knoten": knoten, "kanten": kanten}
+
+
+def _uebersicht_block(topic: str) -> str:
+    """Baustein-Übersicht (nur Bausteine mit ≥1 relevantem Subbaustein) als Prompt-Text."""
+    zeilen = []
+    for b in lade_uebersicht(topic):
+        rel = [s["titel"] for s in b["subbausteine"] if s.get("relevanz") != "rand"]
+        if not rel:
+            continue
+        kopf = f"{b['num']}. {b['titel']}"
+        if b.get("beschreibung"):
+            kopf += f" — {b['beschreibung']}"
+        zeilen.append(kopf)
+        zeilen += [f"   - {t}" for t in rel]
+    return "\n".join(zeilen)
+
+
+async def _generate_roadmap(
+    guide_id: str, topic: str, instructions: str, provider: str, content_path: Path,
+) -> dict | None:
+    is_cancelled = lambda: is_guide_cancelled(guide_id)
+    ctx = GenContext(topic=topic, provider=provider, is_cancelled=is_cancelled, guide_id=guide_id)
+
+    uebersicht = _uebersicht_block(topic)
+    if not uebersicht.strip():
+        await _fail(guide_id, "Keine relevanten Bausteine für die Roadmap")
+        return None
+
+    d, stem = content_path.parent, content_path.stem
+    bau_path = d / f"{stem}.roadmap-bau.json"
+    check_path = d / f"{stem}.roadmap-check.json"
+
+    # Schritt 0: Bauen — 1 Agent synthetisiert den Graph. Gültige Datei überspringt.
+    graph = _roadmap_schema(_json_datei(bau_path))
+    if graph is None:
+        await _set_step(guide_id, 0, "Baue Roadmap…")
+        status, _ = await run_single_slot(
+            ctx, "Roadmap-Bauen",
+            key=f"{guide_id}-roadmap-bau",
+            prompt=_prompt("Roadmap-Bauen", topic=topic, uebersicht=uebersicht,
+                           out_path=bau_path, extra=_extra(instructions)),
+            role="guide", capabilities="files",
+            payload=lambda result: _roadmap_schema(_json_datei(bau_path)),
+            timeout=_timeout("roadmap"),
+        )
+        if status == CANCELLED:
+            return None
+        if status == FAILED:
+            await _fail(guide_id, "Roadmap-Bau fehlgeschlagen")
+            return None
+        graph = _roadmap_schema(_json_datei(bau_path))
+
+    # Schritt 1: Prüfung — Judge fixt Struktur/Knappheit; Fallback = Bau-Graph.
+    geprueft = _roadmap_schema(_json_datei(check_path))
+    if geprueft is None:
+        await _set_step(guide_id, 1, "Prüfe Roadmap…")
+        status, _ = await run_single_slot(
+            ctx, "Roadmap-Prüfung",
+            key=f"{guide_id}-roadmap-check",
+            prompt=_prompt("Roadmap-Check", topic=topic, uebersicht=uebersicht,
+                           graph=json.dumps(graph, ensure_ascii=False, indent=1),
+                           out_path=check_path, extra=_extra(instructions)),
+            role="judge", capabilities="files",
+            payload=lambda result: _roadmap_schema(_json_datei(check_path)),
+            timeout=_timeout("roadmap_check"),
+        )
+        if status == CANCELLED:
+            return None
+        if status == FAILED:
+            _log(topic, "Roadmap-Prüfung fehlgeschlagen — Bau-Graph bleibt")
+        geprueft = _roadmap_schema(_json_datei(check_path))
+
+    return geprueft or graph

backend/routes.py

@@ -478,7 +478,7 @@ async def list_all():
 async def guide_locks(topic: str):
     """Sperr-Gründe pro Format für den ▶-Button — None = erstellbar."""
     guides, progress, levels = await lade_lernstand()
-    return {fmt: guide_lock(topic, fmt, guides, progress, levels) for fmt in ("OnePager", *FORMATE)}
+    return {fmt: guide_lock(topic, fmt, guides, progress, levels) for fmt in ("Roadmap", *FORMATE)}
 
 
 @router.get("/guides/{guide_id}", response_model=GuideResponse)

frontend/src/App.vue

@@ -181,7 +181,7 @@ async function loadBausteine() {
   }
 }
 
-const FORMAT_ORDER = ['Guide', 'OnePager']
+const FORMAT_ORDER = ['Guide', 'Roadmap']
 
 function autoPreview() {
   const map = doneByFormat.value

frontend/src/components/RoadmapView.vue

@@ -0,0 +1,146 @@
+<script setup>
+import { ref, computed, watch, nextTick } from 'vue'
+import { VueFlow, useVueFlow, Handle, Position, MarkerType } from '@vue-flow/core'
+import '@vue-flow/core/dist/style.css'
+import dagre from '@dagrejs/dagre'
+import { renderMarkdownInline } from '../markdown.js'
+
+// Roadmap = read-only Übersichts-Graph: {knoten:[{id,title,text,prioritaet}],
+// kanten:[{von,nach,typ}], richtung}. Layout via dagre, Knoten-Text via KaTeX.
+const props = defineProps({
+  graph: { type: Object, default: null },
+  height: { type: String, default: '78vh' },
+})
+
+let _seq = 0
+const flowId = `rm-${++_seq}-${Math.floor(performance.now())}`
+const { findNode, fitView, onNodesInitialized } = useVueFlow(flowId)
+
+const nodes = ref([])
+const edges = ref([])
+const bereit = ref(false)
+const fehler = ref(false)
+
+const richtung = computed(() => (props.graph?.richtung === 'LR' ? 'LR' : 'TB'))
+const istLR = computed(() => richtung.value === 'LR')
+const targetPos = computed(() => (istLR.value ? Position.Left : Position.Top))
+const sourcePos = computed(() => (istLR.value ? Position.Right : Position.Bottom))
+
+function build() {
+  bereit.value = false
+  const g = props.graph
+  const kn = g && Array.isArray(g.knoten) ? g.knoten : []
+  if (!kn.length) {
+    fehler.value = true
+    nodes.value = []
+    edges.value = []
+    return
+  }
+  fehler.value = false
+  const ids = new Set(kn.map((k) => String(k.id)))
+  nodes.value = kn.map((k) => ({
+    id: String(k.id),
+    type: 'roadmap',
+    position: { x: 0, y: 0 },
+    data: {
+      title: String(k.title || ''),
+      text: String(k.text || ''),
+      prioritaet: ['grund', 'kern', 'vertiefung'].includes(k.prioritaet) ? k.prioritaet : 'kern',
+    },
+  }))
+  edges.value = (g.kanten || [])
+    .filter((e) => ids.has(String(e.von)) && ids.has(String(e.nach)))
+    .map((e, i) => {
+      const optional = e.typ === 'optional'
+      return {
+        id: `e${i}`,
+        source: String(e.von),
+        target: String(e.nach),
+        type: 'smoothstep',
+        markerEnd: MarkerType.ArrowClosed,
+        style: optional ? { strokeDasharray: '6 4', opacity: 0.7 } : {},
+      }
+    })
+}
+
+// Two-Pass: Vue Flow misst die Knoten, dann rechnet dagre das Layout.
+function layout() {
+  const g = new dagre.graphlib.Graph()
+  g.setDefaultEdgeLabel(() => ({}))
+  g.setGraph({ rankdir: richtung.value, nodesep: 50, ranksep: 70 })
+  for (const n of nodes.value) {
+    const dim = findNode(n.id)?.dimensions
+    g.setNode(n.id, { width: dim?.width || 180, height: dim?.height || 56 })
+  }
+  for (const e of edges.value) g.setEdge(e.source, e.target)
+  dagre.layout(g)
+  nodes.value = nodes.value.map((n) => {
+    const p = g.node(n.id)
+    return { ...n, position: { x: p.x - p.width / 2, y: p.y - p.height / 2 } }
+  })
+}
+
+onNodesInitialized(async () => {
+  if (!nodes.value.length) return
+  await document.fonts.ready
+  layout()
+  bereit.value = true
+  await nextTick()
+  fitView({ padding: 0.2 })
+})
+
+watch(() => props.graph, build, { immediate: true })
+</script>
+
+<template>
+  <div class="roadmap-view" :style="{ height }">
+    <p v-if="fehler" class="rm-fallback">Roadmap nicht verfügbar — neu generieren.</p>
+    <VueFlow
+      v-else
+      :id="flowId"
+      :nodes="nodes"
+      :edges="edges"
+      :style="{ opacity: bereit ? 1 : 0 }"
+      :nodes-draggable="false"
+      :nodes-connectable="false"
+      :elements-selectable="false"
+      :zoom-on-scroll="false"
+      :zoom-on-double-click="false"
+      :min-zoom="0.2"
+      :max-zoom="2"
+      fit-view-on-init
+    >
+      <template #node-roadmap="{ data }">
+        <Handle type="target" :position="targetPos" />
+        <div class="rm-node" :class="'prio-' + data.prioritaet">
+          <div class="rm-title">{{ data.title }}</div>
+          <div v-if="data.text" class="rm-text markdown" v-html="renderMarkdownInline(data.text)"></div>
+        </div>
+        <Handle type="source" :position="sourcePos" />
+      </template>
+    </VueFlow>
+  </div>
+</template>
+
+<style scoped>
+.roadmap-view { width: 100%; position: relative; }
+.rm-fallback { color: var(--text-muted); font-size: 0.85rem; padding: 1rem 0; }
+.rm-node {
+  padding: 0.5rem 0.75rem;
+  border: 1px solid var(--border-strong, #999);
+  border-left: 4px solid var(--rm-accent, #8b5cf6);
+  border-radius: 8px;
+  background: color-mix(in srgb, var(--rm-accent, #8b5cf6) 7%, var(--panel, #fff));
+  color: var(--text, #111);
+  max-width: 260px;
+  white-space: normal;
+  overflow-wrap: anywhere;
+}
+.rm-title { font-weight: 600; font-size: 0.85rem; line-height: 1.25; }
+.rm-text { font-size: 0.74rem; color: var(--text-muted, #555); line-height: 1.3; margin-top: 0.2rem; }
+.rm-text :deep(.katex) { white-space: normal; }
+/* Prioritäts-Farben: grund=grün (Fundament), kern=lila (Hauptstoff), vertiefung=grau (später). */
+.prio-grund { --rm-accent: #22c55e; }
+.prio-kern { --rm-accent: #8b5cf6; }
+.prio-vertiefung { --rm-accent: #94a3b8; }
+</style>

frontend/src/components/TopicDetail.vue

@@ -6,6 +6,7 @@ import { useChat } from '../composables/useChat.js'
 import BausteinPanel from './BausteinPanel.vue'
 import BausteinFokus from './BausteinFokus.vue'
 import GraphView from './GraphView.vue'
+import RoadmapView from './RoadmapView.vue'
 
 const props = defineProps({
   previewGuide: { type: Object, default: null },
@@ -19,9 +20,9 @@ const props = defineProps({
 
 const emit = defineEmits(['progressChanged', 'setAnsicht'])
 
-const isOnePager = computed(() => props.previewGuide?.format === 'OnePager')
+const isRoadmap = computed(() => props.previewGuide?.format === 'Roadmap')
 
-// Rotierende Kapitel-Akzentfarben (passend zum OnePager-Cheat-Sheet, ohne Rot)
+// Rotierende Kapitel-Akzentfarben (ohne Rot)
 const CH_COLORS = ['#3b82f6', '#8b5cf6', '#14b8a6', '#f59e0b', '#22c55e', '#6366f1']
 
 // --- Inhalt laden ---
@@ -47,7 +48,7 @@ async function loadContent() {
     loadError.value = 'Inhalt nicht verfügbar — die Datei fehlt. Guide neu generieren (▶).'
     return
   }
-  if (g.format !== 'OnePager') {
+  if (g.format !== 'Roadmap') {
     try {
       lernstand.value = (await fetchBausteinLernstand(g.topic)).bausteine || {}
     } catch { /* offline → leer */ }
@@ -68,7 +69,7 @@ function onBausteinStatus(baustein, status) {
 const fokusIndex = ref(null)        // Index in der flachen Baustein-Liste; null = zu
 const fokusTab = ref('pruefung')
 const bausteine = computed(() =>
-  isOnePager.value || !content.value ? [] : content.value.chapters.flatMap((ch) => ch.sections),
+  isRoadmap.value || !content.value ? [] : content.value.chapters.flatMap((ch) => ch.sections),
 )
 const fokusBaustein = computed(() => (fokusIndex.value === null ? null : bausteine.value[fokusIndex.value]))
 
@@ -178,14 +179,18 @@ function extractContext() {
 <template>
   <div class="detail">
     <div v-if="previewGuide && content" ref="scrollEl" class="guide-scroll">
-      <div class="guide-content" :class="{ onepager: isOnePager }">
+      <div class="guide-content" :class="{ roadmap: isRoadmap }">
         <header class="guide-head">
           <h1>{{ previewGuide.topic }}</h1>
           <span class="guide-format">{{ previewGuide.format }}</span>
           <span v-if="themaAbgeschlossen" class="thema-done" title="Alle Bausteine gemeistert (18/18)">✓ Thema abgeschlossen</span>
         </header>
+
+        <RoadmapView v-if="isRoadmap" :graph="content.graph || null" height="100%" />
+
         <section
           v-for="(ch, ci) in content.chapters"
+          v-else
           :key="ch.title"
           class="chapter"
           :style="{ '--ch-accent': CH_COLORS[ci % CH_COLORS.length] }"
@@ -195,19 +200,17 @@ function extractContext() {
             <article
               v-for="s in ch.sections"
               :key="s.num"
-              :class="['section-card', isOnePager && s.key ? 'op-card op-' + s.key : '', lernstand[s.title]?.gemeistert ? 'gemeistert' : (lernstand[s.title]?.verstanden ? 'verstanden' : (lernstand[s.title]?.absolviert ? 'absolviert' : ''))]"
+              :class="['section-card', lernstand[s.title]?.gemeistert ? 'gemeistert' : (lernstand[s.title]?.verstanden ? 'verstanden' : (lernstand[s.title]?.absolviert ? 'absolviert' : ''))]"
-              :style="isOnePager && s.key ? { gridArea: s.key } : null"
             >
-              <h3 :class="{ 'baustein-klick': !isOnePager }" @click="!isOnePager && openFokus(s, 'pruefung')">
+              <h3 class="baustein-klick" @click="openFokus(s, 'pruefung')">
                 {{ s.title }}
                 <span v-if="lernstand[s.title]?.gemeistert" class="baustein-done gemeistert" title="Gemeistert (25/25)">✓✓✓ Gemeistert</span>
                 <span v-else-if="lernstand[s.title]?.verstanden" class="baustein-done verstanden" title="Vollständig verstanden (10/10)">✓✓ Verstanden</span>
                 <span v-else-if="lernstand[s.title]?.absolviert" class="baustein-done" title="Prüfung bestanden">✓ Absolviert</span>
               </h3>
-              <GraphView v-if="!isOnePager && ansichtModus === 'grafik'" :graph="grafiken[s.title] || null" />
+              <GraphView v-if="ansichtModus === 'grafik'" :graph="grafiken[s.title] || null" />
-              <div v-else class="section-body markdown" v-html="renderMarkdown(!isOnePager && ansichtModus === 'kompakt' ? (s.kompakt || s.md) : s.md)"></div>
+              <div v-else class="section-body markdown" v-html="renderMarkdown(ansichtModus === 'kompakt' ? (s.kompakt || s.md) : s.md)"></div>
               <BausteinPanel
-                v-if="!isOnePager"
                 mode="trigger"
                 :baustein="s.title"
                 :status="lernstand[s.title]"
@@ -394,7 +397,7 @@ function extractContext() {
 }
 
 /* Absolvierte Bausteine: Karte kippt sichtbar auf Grün */
-.guide-content:not(.onepager) .section-card.absolviert {
+.guide-content:not(.roadmap) .section-card.absolviert {
   border-color: var(--success-border);
   border-top: 3px solid var(--success);
   background: color-mix(in srgb, var(--success) 5%, var(--panel));
@@ -406,7 +409,7 @@ function extractContext() {
   border-color: #8b5cf6;
   color: #6d28d9;
 }
-.guide-content:not(.onepager) .section-card.verstanden {
+.guide-content:not(.roadmap) .section-card.verstanden {
   border-color: #8b5cf6;
   border-top: 3px solid #8b5cf6;
   background: color-mix(in srgb, #8b5cf6 7%, var(--panel));
@@ -418,14 +421,14 @@ function extractContext() {
   border-color: #d4af37;
   color: #8a6d12;
 }
-.guide-content:not(.onepager) .section-card.gemeistert {
+.guide-content:not(.roadmap) .section-card.gemeistert {
   border-color: #d4af37;
   border-top: 3px solid #d4af37;
   background: color-mix(in srgb, #d4af37 8%, var(--panel));
 }
 
-/* Guides: Karten tragen die Kapitel-Akzentfarbe (OnePager hat eigene op-card-Farben) */
+/* Guides: Karten tragen die Kapitel-Akzentfarbe */
-.guide-content:not(.onepager) .section-card {
+.guide-content:not(.roadmap) .section-card {
   border-top: 3px solid color-mix(in srgb, var(--ch-accent, var(--accent)) 65%, transparent);
   background: color-mix(in srgb, var(--ch-accent, var(--accent)) 3%, var(--panel));
 }
@@ -442,9 +445,8 @@ function extractContext() {
 .section-card h3.baustein-klick { cursor: pointer; width: fit-content; }
 .section-card h3.baustein-klick:hover { color: var(--accent); }
 
-/* OnePager: festes 3×3-Raster über volle Breite und Höhe.
+/* Roadmap: read-only Übersichts-Graph über die volle Fläche, kein Lese-Zoom. */
-   Kein Lese-Zoom (bricht 100%-Höhen) — stattdessen sind die Schriften unten 1.2× skaliert. */
+.guide-content.roadmap {
-.guide-content.onepager {
   max-width: none;
   height: 100%;
   zoom: 1;
@@ -452,96 +454,9 @@ function extractContext() {
   display: flex;
   flex-direction: column;
 }
-
+.guide-content.roadmap .roadmap-view {
-.guide-content.onepager .guide-head,
-.guide-content.onepager .chapter-title {
-  display: none; /* Thema steht in der Info-Karte — Platz fürs Raster */
-}
-
-.guide-content.onepager .chapter {
   flex: 1;
   min-height: 0;
-  margin-bottom: 0;
-}
-
-.guide-content.onepager .sections {
-  height: 100%;
-  display: grid;
-  grid-template-columns: repeat(3, 1fr);
-  grid-template-rows: repeat(3, 1fr);
-  grid-template-areas:
-    "info beispiel voraussetzungen"
-    "eigenschaften beispiel modern"
-    "eigenschaften zusammenhaenge veraltet";
-  gap: 0.6rem;
-}
-
-.guide-content.onepager .section-card {
-  margin-bottom: 0;
-  padding: 0.7rem 0.9rem;
-  min-height: 0;
-  overflow-y: auto;
-
-  h3 {
-    font-size: 1.06rem;
-    margin-bottom: 0.3rem;
-  }
-
-  .section-body {
-    font-size: 0.98rem;
-  }
-}
-
-/* Farbkodiertes Cheat-Sheet: feste Akzentfarbe + Icon pro Karte */
-.op-info { --op-accent: #3b82f6; }
-.op-eigenschaften { --op-accent: #8b5cf6; --op-icon: "☰"; }
-.op-beispiel { --op-accent: #64748b; --op-icon: "❯"; }
-.op-zusammenhaenge { --op-accent: #14b8a6; --op-icon: "⇄"; }
-.op-voraussetzungen { --op-accent: #f59e0b; --op-icon: "✓"; }
-.op-modern { --op-accent: #22c55e; --op-icon: "✦"; }
-.op-veraltet { --op-accent: #ef4444; --op-icon: "⚠"; }
-
-.guide-content.onepager .section-card.op-card {
-  border-top: 3px solid var(--op-accent);
-  background: color-mix(in srgb, var(--op-accent) 5%, var(--panel));
-
-  h3 {
-    color: var(--op-accent);
-    font-size: 0.95rem;
-    font-weight: 700;
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-  }
-
-  h3::before {
-    content: var(--op-icon, "");
-    margin-right: 7px;
-  }
-}
-
-/* Info-Karte: Thema als große Headline statt Uppercase-Label */
-.guide-content.onepager .op-card.op-info h3 {
-  font-size: 1.5rem;
-  text-transform: none;
-  letter-spacing: 0;
-  color: var(--text);
-}
-
-/* Mobil: eine Spalte in Quellreihenfolge (info → … → veraltet) */
-@media (max-width: 900px) {
-  .guide-content.onepager {
-    height: auto;
-  }
-
-  .guide-content.onepager .sections {
-    height: auto;
-    display: flex;
-    flex-direction: column;
-  }
-
-  .guide-content.onepager .section-card {
-    overflow-y: visible;
-  }
 }
 
 .empty-preview {
@@ -583,12 +498,6 @@ function extractContext() {
   max-width: 70ch;
 }
 
-.onepager .section-card .markdown :deep(p),
-.onepager .section-card .markdown :deep(ul),
-.onepager .section-card .markdown :deep(ol) {
-  max-width: none; /* OnePager-Zellen sind selbst schmal genug */
-}
-
 /* --- Chat --- */
 .chat-fab {
   position: fixed;

frontend/src/components/TopicSidebar.vue

@@ -52,7 +52,7 @@ const trackerItems = computed(() => {
 })
 
 const formats = [
-  { key: 'OnePager', label: 'OnePager' },
+  { key: 'Roadmap', label: 'Roadmap' },
   { key: 'Guide', label: 'Guide' },
 ]
 
@@ -119,12 +119,12 @@ function guideStatus(format) {
 
 // Schritt-Kugeln der Guide-Pipelines
 const GUIDE_STEPS = ['Auswahl', 'Gliederung', 'Inhalte', 'Inhalts-Check', 'Schreiben', 'Lese-Prüfung']
-const ONEPAGER_STEPS = ['Recherche', 'Bauen', 'Prüfung']
+const ROADMAP_STEPS = ['Bauen', 'Prüfung']
 
 // Kugeln werden wie bei den Bausteinen immer angezeigt:
 // fertig = alle grün, laufend = live, abgebrochen = Teilfortschritt, sonst grau
 function guideSteps(format) {
-  const labels = format === 'OnePager' ? ONEPAGER_STEPS : GUIDE_STEPS
+  const labels = format === 'Roadmap' ? ROADMAP_STEPS : GUIDE_STEPS
   const st = guideStatus(format)
   if (st === 'generating' || st === 'queued') {
     // Clamp: alte DB-Läufe können step-Werte oberhalb der neuen Listen haben
@@ -409,8 +409,8 @@ function saveQuelle() {
           <span class="format-error-text">{{ bausteine.error }}</span>
         </div>
       </div>
-<!-- OnePager (unabhängig von Bausteinen) steht per CSS-order vor der Bausteine-Zeile -->
+<!-- Roadmap (Überblick zuerst lesen) steht per CSS-order vor der Bausteine-Zeile -->
-      <div v-for="f in formats" :key="f.key" :style="{ order: f.key === 'OnePager' ? 1 : 3 }">
+      <div v-for="f in formats" :key="f.key" :style="{ order: f.key === 'Roadmap' ? 1 : 3 }">
         <div :class="['format-row', 'fmt-' + guideStatus(f.key), { 'fmt-paused': abgebrochen(f.key), 'row-open': isOpen('fmt-' + f.key) }]">
           <button class="format-name" @click="handleFormatClick(f.key)">
             <span class="format-label">{{ f.label }}</span>
@@ -788,7 +788,7 @@ function saveQuelle() {
   max-height: 60vh;
   overflow-y: auto;
   padding: 0.5rem 0;
-  /* flex + order: OnePager (order 1) vor Bausteine (order 2) vor den restlichen Formaten (order 3) */
+  /* flex + order: Roadmap (order 1) vor Bausteine (order 2) vor den restlichen Formaten (order 3) */
   display: flex;
   flex-direction: column;
 }

templates/Prompt/OnePager-Bauen-Judge.md

@@ -1,19 +0,0 @@
-{n} Agenten haben aus derselben Faktenbasis je einen vollständigen 7-Karten-Satz für den OnePager zum Thema "{topic}" gebaut. Wähle pro Karte die beste Fassung und kombiniere sie zum finalen Satz.
-
-FAKTENBASIS (alleinige Quelle — Maßstab für Faktentreue):
-{recherche}
-
-DIE ENTWÜRFE:
-{kartensaetze}
-
-Regeln:
-- Pro Karte (Schlüssel in eckigen Klammern) die beste Fassung wählen: faktentreu zur Faktenbasis, kompakt, klarste Stichpunkte.
-- Karten dürfen wörtlich übernommen werden. Kleine Verbesserungen beim Kombinieren sind erlaubt, nichts hinzuerfinden.
-- Kompaktheit gilt: max. 5 Stichpunkte pro Karte, je max. ~8 Wörter; keine Tabellen, keine Einleitungssätze.
-- Alle 7 Karten müssen vorhanden sein (JSON-Schlüssel exakt): info, eigenschaften, beispiel, zusammenhaenge, voraussetzungen, modern, veraltet.
-
-Schreibe NUR die JSON-Datei nach: {out_path}
-
-Format:
-{{"karten": {{"info": {{"titel": "{topic}", "md": "…"}}, "eigenschaften": {{"titel": "Kerneigenschaften", "md": "…"}}, "beispiel": {{"titel": "Beispiel", "md": "…"}}, "zusammenhaenge": {{"titel": "Zusammenhänge", "md": "…"}}, "voraussetzungen": {{"titel": "Voraussetzungen", "md": "…"}}, "modern": {{"titel": "Neu & aktuell", "md": "…"}}, "veraltet": {{"titel": "Veraltet & überholt", "md": "…"}}}}}}
-{extra}

templates/Prompt/OnePager-Bauen.md

@@ -1,29 +0,0 @@
-Baue aus der Faktenbasis einen OnePager zum Thema "{topic}" — ein Übersichtsblatt im 3×3-Raster auf einer Seite.
-
-FAKTENBASIS (alleinige Quelle, nichts hinzuerfinden):
-{recherche}
-
-Erstelle GENAU diese 7 Karten (JSON-Schlüssel exakt so):
-- "info" — Titel: "{topic}". Kurzbeschreibung in 1–2 Sätzen, darunter Eckdaten als Stichpunkte (je nach Thema: Art/Typ, Version/Lizenz/Verbreitung ODER Ursprung/Stand/Anwendungsfelder).
-- "eigenschaften" — Titel: "Kerneigenschaften". Was einen IM Thema erwartet: kleine Übersicht der Inhalte/Teilgebiete.
-- "beispiel" — Titel: "Beispiel". EIN anschauliches, typisches Beispiel mit einem Satz Erklärung — Markdown-Codeblock bei Code-Themen, sonst Beispielsätze oder Mini-Szenario als normaler Text.
-- "zusammenhaenge" — Titel: "Zusammenhänge". Mit welchen ANDEREN Themen es zusammenhängt — Nachbarthemen außerhalb dieses Themas, keine Inhalte des Themas selbst.
-- "voraussetzungen" — Titel: "Voraussetzungen". Welche Themen man vorher bearbeitet haben sollte, um hier klarzukommen.
-- "modern" — Titel: "Neu & aktuell". NUR was in den letzten Jahren neu dazugekommen ist (Features, Erkenntnisse, Empfehlungen). Gibt es nichts Neues: ehrlich "Keine." mit einem Satz Begründung.
-- "veraltet" — Titel: "Veraltet & überholt". Was nicht mehr verwendet wird bzw. als überholt gilt. Gibt es nichts Veraltetes: ehrlich "Keine." mit einem Satz Begründung — nichts erfinden.
-
-KOMPAKTHEIT — der OnePager muss OHNE Scrollen auf eine Bildschirmseite passen:
-- Maximal 5 Stichpunkte pro Karte, je maximal ~8 Wörter (Schlagwort + halber Satz).
-- Nur das Wichtigste — nicht alle Varianten aufzählen. Weglassen schlägt Vollständigkeit.
-- Keine Tabellen, keine verschachtelten Listen, keine Einleitungssätze.
-- Beispiel maximal ~12 kurze Zeilen (Code) bzw. ~5 Zeilen (Prosa).
-
-Inhalt auf DEUTSCH, alles aus der Faktenbasis belegbar.
-Stichpunkte als Markdown-Liste mit fettem Schlagwort: `- **Schlagwort**: Rest` (kein rohes •).
-Code-Bezeichner und HTML-Tags im Text IMMER in Backticks (`<p>`, `src`) — nie roh.
-
-Schreibe NUR die JSON-Datei nach: {out_path}
-
-Format:
-{{"karten": {{"info": {{"titel": "{topic}", "md": "…"}}, "eigenschaften": {{"titel": "Kerneigenschaften", "md": "…"}}, "beispiel": {{"titel": "Beispiel", "md": "…"}}, "zusammenhaenge": {{"titel": "Zusammenhänge", "md": "…"}}, "voraussetzungen": {{"titel": "Voraussetzungen", "md": "…"}}, "modern": {{"titel": "Neu & aktuell", "md": "…"}}, "veraltet": {{"titel": "Veraltet & überholt", "md": "…"}}}}}}
-{extra}

templates/Prompt/OnePager-Fix.md

@@ -1,18 +0,0 @@
-Korrigiere die Karten eines OnePagers zum Thema "{topic}".
-
-FAKTENBASIS (alleinige Quelle, nichts hinzuerfinden):
-{recherche}
-
-BISHERIGE KARTEN:
-{karten}
-
-NOTIERTE PROBLEME (von der Prüfung):
-{probleme}
-
-Behebe NUR die notierten Probleme — alle anderen Karten bleiben unverändert.
-
-Schreibe NUR die vollständige, korrigierte JSON-Datei (alle 7 Karten) nach: {out_path}
-
-Format:
-{{"karten": {{"info": {{"titel": "…", "md": "…"}}, "eigenschaften": {{"titel": "…", "md": "…"}}, "beispiel": {{"titel": "…", "md": "…"}}, "zusammenhaenge": {{"titel": "…", "md": "…"}}, "voraussetzungen": {{"titel": "…", "md": "…"}}, "modern": {{"titel": "…", "md": "…"}}, "veraltet": {{"titel": "…", "md": "…"}}}}}}
-{extra}

templates/Prompt/OnePager-Quelle-Projekt.md

@@ -1 +0,0 @@
-Das Thema ist das Projekt unter {project}. Verschaffe dir mit Bash (ls/find) einen Überblick und lies README, Doku und den relevanten Quellcode mit dem Read-Tool. PDFs liegen als gleichnamige .txt-Dateien vor — lies IMMER die .txt, nie das PDF. Erfasse Zweck, Architektur und die wichtigsten Konzepte — nichts Erfundenes.

templates/Prompt/OnePager-Quelle-Thema.md

@@ -1 +0,0 @@
-Recherchiere per Websuche: aktuellen Stand (Version bzw. Forschungs-/Praxisstand), die Kernkonzepte und die wichtigsten Fakten zu "{topic}". Nimm nur auf, was du in der Recherche belegt hast.

templates/Prompt/OnePager-Recherche-Mapping.md

@@ -1,13 +0,0 @@
-{n} Agenten haben unabhängig die Faktenbasis für einen OnePager zum Thema "{topic}" recherchiert. Konsolidiere ihre Ergebnisse zu EINER Faktenbasis.
-
-{recherchen}
-
-Regeln:
-- Behalte die Struktur der 7 Dimensionen (Kurzbeschreibung, Eckdaten, Inhaltsübersicht, Beispiel, Zusammenhänge, Voraussetzungen, Neuerungen vs. Veraltetes).
-- Mehrfach belegte Fakten haben Vorrang. Dubletten zusammenführen, nicht wiederholen.
-- Widersprüche zugunsten der besser belegten bzw. aktuelleren Version auflösen.
-- Nur einmal Genanntes übernehmen, wenn es eine Quelle hat und plausibel ist — sonst weglassen.
-- Quellenangaben pro Punkt behalten. Nichts hinzuerfinden.
-- Wähle das beste Beispiel der Recherchen, nicht mehrere.
-
-Schreibe NUR die Markdown-Datei nach: {out_path}

templates/Prompt/OnePager-Recherche-Projekt.md

@@ -1,17 +0,0 @@
-Sammle die Faktenbasis für einen OnePager — ein Übersichtsblatt auf einer Seite — zum Projekt "{topic}".
-
-{source}
-
-Erfasse gezielt diese Dimensionen:
-1. Kurzbeschreibung: Was ist "{topic}" in 1–2 Sätzen (Art des Projekts, Gegenstand)?
-2. Technische Daten: Technologie/Format, Umfang (Dateien/Seiten/Module), Stand/Aktualität.
-3. Inhaltsübersicht: Was erwartet einen — die wichtigsten Inhalte/Teilgebiete des Projekts.
-4. Beispiel: ein typisches, konkretes Beispiel aus dem Projekt (zentraler Code-Flow bzw. Kerninhalt).
-5. Zusammenhänge: mit welchen ANDEREN Themen es zusammenhängt (Nachbarthemen außerhalb des Projektinhalts).
-6. Voraussetzungen: welche Themen man vorher bearbeitet haben sollte, um das Projekt zu verstehen.
-7. Neuerungen vs. Veraltetes: was im Themenfeld in den letzten Jahren neu dazugekommen ist — und was nicht mehr verwendet wird (falls es nichts gibt, jeweils ausdrücklich notieren).
-
-Schreibe NUR die Markdown-Datei nach: {out_path}
-
-Kompakt, faktenorientiert, mit Quelle (Dateipfad) pro Punkt. Nichts Erfundenes — nur was in den Projektdateien belegt ist. Die Datei ist die alleinige Faktenbasis für den OnePager.
-{extra}

templates/Prompt/OnePager-Recherche.md

@@ -1,17 +0,0 @@
-Sammle die Faktenbasis für einen OnePager — ein Übersichtsblatt auf einer Seite — zum Thema "{topic}".
-
-{source}
-
-Recherchiere gezielt diese Dimensionen:
-1. Kurzbeschreibung: Was ist "{topic}" in 1–2 Sätzen?
-2. Eckdaten: Art/Typ des Themas; bei Software: aktuelle Version, Lizenz/Kosten, Verbreitung; bei Sprachen, Methoden, Theorien: Ursprung/Urheber, heutiger Stand, typische Anwendungsfelder.
-3. Inhaltsübersicht: Was erwartet einen im Thema — die wichtigsten Inhalte/Teilgebiete.
-4. Beispiel: ein minimales, typisches Beispiel im themengerechten Format (Code-Beispiel, Beispielsätze/Mini-Dialog oder Mini-Szenario).
-5. Zusammenhänge: mit welchen ANDEREN Themen es zusammenhängt (Nachbarthemen außerhalb von "{topic}").
-6. Voraussetzungen: welche Themen man vorher bearbeitet haben sollte.
-7. Neuerungen vs. Veraltetes: was in den letzten Jahren neu dazugekommen ist — und was nicht mehr verwendet wird (falls es nichts gibt, jeweils ausdrücklich notieren).
-
-Schreibe NUR die Markdown-Datei nach: {out_path}
-
-Kompakt, faktenorientiert, mit Quelle (URL bzw. Dateipfad) pro Punkt. Die Datei ist die alleinige Faktenbasis für den OnePager.
-{extra}

templates/Prompt/OnePager-Verifikation.md

@@ -1,22 +0,0 @@
-Prüfe einen OnePager zum Thema "{topic}" gegen seine Faktenbasis.
-
-FAKTENBASIS:
-{recherche}
-
-ONEPAGER-KARTEN:
-{karten}
-
-Prüfe:
-1. Sind alle 7 Karten vollständig ausgefüllt (keine abgebrochenen oder leeren Inhalte, keine Platzhalter)?
-2. Stimmen alle Aussagen mit der Faktenbasis überein? Nichts Erfundenes?
-3. Ist jede Karte KOMPAKT — maximal 5 kurze Stichpunkte (je ~8 Wörter), keine Tabellen, Beispiel maximal ~12 Zeilen? Zu lange Karten sind ein Problem.
-4. Ist jede Karte für sich verständlich? Ist das Beispiel konkret und plausibel — lauffähig wirkender Code bzw. realistische Sätze/realistisches Szenario?
-
-Du PRÜFST nur und notierst Probleme — du änderst nichts. Nenne die betroffene Karte über ihren Schlüssel (info, eigenschaften, beispiel, zusammenhaenge, voraussetzungen, modern, veraltet).
-
-Schreibe NUR die JSON-Datei nach: {out_path}
-
-Format — alles in Ordnung:
-{{"ok": true}}
-Sonst (kurz und konkret, maximal 10 Punkte):
-{{"probleme": ["beispiel: …", "fakten in info veraltet: …"]}}

templates/Prompt/Roadmap-Bauen.md

@@ -0,0 +1,31 @@
+Du baust eine **Roadmap** zum Thema "{topic}": einen gerichteten Übersichts-Graphen, den ein Lerner VOR dem Detaillernen liest. Ziel ist NICHT, Fakten zu vermitteln, sondern **Architektur, Flows und Andockpunkte** zu zeigen — die große Struktur auf einen Blick. Der Lerner soll Ankerpunkte bilden, bevor er die Bausteine durcharbeitet.
+
+BAUSTEIN-ÜBERSICHT (Quelle — daraus die Struktur ableiten, KEINE neuen Inhalte erfinden):
+{uebersicht}
+
+AUFGABE:
+- Fasse die Bausteine zu **thematischen Bereichen** (Knoten) zusammen — **wenige große Knoten**, Richtwert 5–10, höchstens 12. Keine atomaren Einzelpunkte.
+- Verbinde die Bereiche mit **gerichteten Kanten** „baut auf auf" (`typ: "prereq"`). Was nur ergänzend/optional ist: `typ: "optional"`.
+- Reihenfolge sichtbar machen: Einstieg oben, Aufbauendes darunter (`richtung: "TB"`).
+- Pro Knoten:
+  - `title`: kurzer Bereichsname (1–3 Wörter).
+  - `text`: EINE Zeile — was der Bereich abdeckt; nenne die zentralen Bausteine als **Andockpunkte**.
+  - `prioritaet`: `grund` (Fundament, zuerst) | `kern` (Hauptstoff) | `vertiefung` (später/optional).
+- **Schlank halten.** Keine Deko, keine Fakten-Details, keine Wiederholung. Beziehungen zählen, nicht Stichwort-Listen.
+
+MATHE: kompakte Symbole als KaTeX in Dollarzeichen erlaubt (`$\Sigma$`, `$\Sigma^*$`). **Verboten:** `\\`, `\text{…}`, `$$…$$`, mehrteilige Formeln.
+{extra}
+
+Schreibe das Ergebnis als JSON in die Datei {out_path} (nutze dein Schreib-Werkzeug), GENAU in diesem Format:
+{{
+  "richtung": "TB",
+  "knoten": [
+    {{"id": "grund", "title": "Grundlagen", "text": "Alphabet, Sprache, $\\Sigma^*$", "prioritaet": "grund"}},
+    {{"id": "ent", "title": "Entscheidung", "text": "Entscheidungsproblem, Sprachen als Mengen", "prioritaet": "kern"}}
+  ],
+  "kanten": [
+    {{"von": "grund", "nach": "ent", "typ": "prereq"}}
+  ]
+}}
+
+Gib sonst keinen Text aus.

templates/Prompt/Roadmap-Check.md

@@ -0,0 +1,31 @@
+Du prüfst und korrigierst eine **Roadmap** (gerichteter Übersichts-Graph als JSON) zum Thema "{topic}". Sie soll einem Lerner VOR dem Detaillernen Architektur, Flows und Andockpunkte zeigen — schlank und sofort lesbar.
+
+BAUSTEIN-ÜBERSICHT (Quelle):
+{uebersicht}
+
+AKTUELLE ROADMAP (JSON):
+{graph}
+
+PRÜFE und korrigiere:
+- **Struktur:** jede Kante referenziert mit `von`/`nach` gültige Knoten-`id`s; keine hängenden Kanten; keine Zyklen (gerichtet, azyklisch); IDs eindeutig.
+- **Abdeckung:** die wichtigen Bereiche der Übersicht kommen vor; nichts Erfundenes.
+- **Flows/Andockpunkte:** Kanten geben „baut auf auf" korrekt wieder; `text` nennt die zentralen Bausteine.
+- **Knappheit:** wenige große Knoten (≤ 12); `title` 1–3 Wörter; `text` genau eine Zeile. Kürze überladene Knoten.
+- **Mathe:** kompakte KaTeX-Symbole in `$…$`; **verboten** `\\`, `\text{…}`, `$$…$$`, mehrteilige Formeln — korrigiere Verstöße.
+- `prioritaet` ∈ grund | kern | vertiefung; `typ` ∈ prereq | optional.
+
+Ist die Roadmap bereits gut, gib sie unverändert zurück.
+{extra}
+
+Schreibe die geprüfte Roadmap als JSON in die Datei {out_path} (nutze dein Schreib-Werkzeug), GENAU in diesem Format:
+{{
+  "richtung": "TB",
+  "knoten": [
+    {{"id": "grund", "title": "Grundlagen", "text": "Alphabet, Sprache, $\\Sigma^*$", "prioritaet": "grund"}}
+  ],
+  "kanten": [
+    {{"von": "grund", "nach": "ent", "typ": "prereq"}}
+  ]
+}}
+
+Gib sonst keinen Text aus.