update

backend/bausteine.py

@@ -24,11 +24,11 @@ from jsonio import read_json_file as _json_datei
 from paths import arbeit_dir, bausteine_path, project_dir, subbausteine_path, quelle_path, quelle_crawl_dir, safe_ordner
 from crawl import crawl
 from pipeline import (
-    CANCELLED, FAILED, GenContext, _extra, _log, _prompt, _race, _rest_schema,
+    CANCELLED, FAILED, GenContext, _extra, _log, _prompt, _race, _relevanz_schema, _rest_schema,
     _runde_schema, _semaphore, _str_liste, _stufen_schema, _timeout, run_single_slot,
 )
 from textkit import (
-    _eindeutige_titel, _norm_titel, _parse_auswahl, _parse_subbausteine, _titel,
+    _eindeutige_titel, _lade_bausteine, _norm_titel, _parse_auswahl, _parse_subbausteine, _titel,
     _titel_aufloesen, _titel_index, _vormerge,
 )
 
@@ -50,6 +50,7 @@ BAUSTEINE_STEPS = (
     "Recherche", "Konsolidierung", "Klärung",
     "Subbausteine finden", "Subbausteine wählen", "Subbausteine klären",
     "Stufen finden", "Stufen wählen", "Stufen klären",
+    "Relevanz finden", "Relevanz wählen", "Relevanz klären",
 )
 
 
@@ -78,6 +79,36 @@ def _crawl_fertig(topic: str) -> bool:
     return (quelle_crawl_dir(topic) / ".done").exists()  # Marker erst bei sauberem Abschluss
 
 
+_STUFEN = ("einfach", "mittel", "schwer")
+
+
+def lade_uebersicht(topic: str) -> list[dict]:
+    """Strukturierte Baustein-Liste für die Übersicht: Titel + Beschreibung + Subbausteine/Stufen.
+
+    Verbindet bausteine.md (Nummer/Titel/Beschreibung) mit der Sidecar subbausteine.json
+    (Key = Titel). Fehlt die Sidecar, sind die Subbaustein-Listen leer.
+    """
+    entries = _lade_bausteine(_read(bausteine_path(topic)))
+    sidecar = _json_datei(subbausteine_path(topic))
+    sidecar = sidecar if isinstance(sidecar, dict) else {}
+    out = []
+    for num, entry in entries.items():
+        titel = _titel(entry)
+        teile = entry.split(" — ", 1)
+        beschreibung = teile[1].strip() if len(teile) == 2 else ""
+        subbausteine = [
+            {
+                "titel": t,
+                "stufe": s.get("stufe") if s.get("stufe") in _STUFEN else "mittel",
+                "relevanz": s.get("relevanz") if s.get("relevanz") in ("relevant", "rand") else None,
+            }
+            for s in (sidecar.get(titel) or [])
+            if isinstance(s, dict) and (t := str(s.get("titel", "")).strip())
+        ]
+        out.append({"num": num, "titel": titel, "beschreibung": beschreibung, "subbausteine": subbausteine})
+    return out
+
+
 def _bausteine_steps(topic: str) -> tuple:
     """Schritte je Quelle: link bekommt vorne „Quelle laden", projekt zusätzlich „Ergänzung".
 
@@ -89,6 +120,7 @@ def _bausteine_steps(topic: str) -> tuple:
     rest = (
         "Subbausteine finden", "Subbausteine wählen", "Subbausteine klären",
         "Stufen finden", "Stufen wählen", "Stufen klären",
+        "Relevanz finden", "Relevanz wählen", "Relevanz klären",
     )
     mitte = base + (("Ergänzung",) if q["type"] == "projekt" else ()) + rest
     return (("Quelle laden",) if q["type"] == "link" else ()) + mitte
@@ -117,7 +149,7 @@ def _bausteine_files(topic: str) -> dict:
 def _alle_slot_dateien(files: dict) -> list[Path]:
     arbeit = files["arbeit"]
     # Subbaustein-/Stufen-Slots sind pro Chunk dynamisch — per Glob einsammeln.
-    dyn = (list(arbeit.glob("subbaustein-*")) + list(arbeit.glob("stufe-*"))) if arbeit.is_dir() else []
+    dyn = (list(arbeit.glob("subbaustein-*")) + list(arbeit.glob("stufe-*")) + list(arbeit.glob("relevanz-*"))) if arbeit.is_dir() else []
     return [
         *files["recherche"], files["recherche_mapping"],
         *(p for slots in files["auswahl"].values() for p in slots),
@@ -153,8 +185,12 @@ def _resume_step(topic: str) -> int:
         return _step_idx(topic, "Klärung")
     if q["type"] == "projekt" and not files["ergaenzung"].exists():
         return _step_idx(topic, "Ergänzung")
-    if _sidecar_schema(_json_datei(files["sidecar"])) is not None:
-        return len(_bausteine_steps(topic))
+    sidecar = _json_datei(files["sidecar"])
+    if _sidecar_schema(sidecar) is not None:
+        # Stufen fertig; nur noch Relevanz offen?
+        if _relevanz_komplett(sidecar):
+            return len(_bausteine_steps(topic))
+        return _step_idx(topic, "Relevanz finden")
     if _sub_roh_schema(_json_datei(files["sub_roh"])) is None:
         return _step_idx(topic, "Subbausteine finden")
     return _step_idx(topic, "Stufen finden")
@@ -287,7 +323,7 @@ def _sub_roh_schema(data):
 
 
 def _sidecar_schema(data):
-    """{Baustein-Titel: [{titel, stufe}, …]} → dict · sonst None (finale Sidecar)."""
+    """{Baustein-Titel: [{titel, stufe}, …]} → dict · sonst None (Sidecar mit Stufen)."""
     if not isinstance(data, dict) or not data:
         return None
     for v in data.values():
@@ -299,6 +335,17 @@ def _sidecar_schema(data):
     return data
 
 
+def _relevanz_komplett(data) -> bool:
+    """Jeder Subbaustein der Sidecar trägt eine gültige Relevanz (relevant/rand)?"""
+    if not isinstance(data, dict) or not data:
+        return False
+    return all(
+        isinstance(s, dict) and s.get("relevanz") in ("relevant", "rand")
+        for v in data.values() if isinstance(v, list)
+        for s in v
+    )
+
+
 def _read(p: Path) -> str:
     return p.read_text(encoding="utf-8") if p.exists() else ""
 
@@ -574,6 +621,115 @@ async def _stufen_block(ctx: GenContext, set_p, files: dict, roh: dict, instruct
     return sidecar
 
 
+async def _relevanz_block(ctx: GenContext, set_p, files: dict, sidecar: dict, instructions: str) -> dict | None:
+    """Block D: drei Phasen mit Barriere — Finden (relevant/rand), Wählen (Vote), Klären.
+    Items aus der Sidecar; lokale IDs 1..n pro Paket → globale gid.
+    → {gid: relevanz} oder None bei Abbruch/Recherche-Fehler. Default bei Lücke/Streit: 'relevant'."""
+    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
+    arbeit = files["arbeit"]
+    items = [(titel, sub["titel"]) for titel, subs in sidecar.items() for sub in subs]  # globale id = index+1
+    if not items:
+        return {}
+    chunks = _chunk_nums(list(range(len(items))), _n_chunks(len(items), STUFE_CHUNK))
+    n = len(chunks)
+
+    def rater_paths(c):
+        return [arbeit / f"relevanz-c{c}-{i}.json" for i in (1, 2, 3)]
+
+    def lset(item_idxs):
+        return set(range(1, len(item_idxs) + 1))
+
+    # Phase „Relevanz finden": pro Paket 3 Rater (min. 2), lokale IDs.
+    async def _rate(c, item_idxs):
+        local_set = lset(item_idxs)
+        paths = rater_paths(c)
+        vorhanden = sum(1 for p in paths if _relevanz_schema(_json_datei(p), local_set))
+        if vorhanden >= 2:
+            return True
+        enum = "\n".join(f"{k}. [{items[j][0]}] {items[j][1]}" for k, j in enumerate(item_idxs, 1))
+        offen = [(i, p) for i, p in enumerate(paths, 1) if not _relevanz_schema(_json_datei(p), local_set)]
+        slots = [{
+            "key": f"bausteine-{topic}-relevanz-c{c}-{i}",
+            "prompt": _prompt("Relevanz-Recherche", topic=topic, subbausteine=enum, out_path=p, extra=_extra(instructions)),
+            "role": "fast", "capabilities": "files",
+            "payload": (lambda result, p=p, ids=local_set: _relevanz_schema(_json_datei(p), ids)),
+        } for i, p in offen]
+        neu = await _race(topic, f"Relevanz Paket {c}", slots, 2 - vorhanden, _timeout("relevanz", len(item_idxs)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
+        return not is_cancelled() and neu is not None
+
+    set_p(f"Relevanz finden ({n} Pakete)…", step=_step_idx(topic, "Relevanz finden"))
+    oks = await asyncio.gather(*[_rate(c, idxs) for c, idxs in enumerate(chunks, 1)], return_exceptions=True)
+    if is_cancelled():
+        return None
+    if not all(ok is True for ok in oks):
+        _bausteine_errors[topic] = "Relevanz fehlgeschlagen (Recherche)"
+        return None
+
+    # Phase „Relevanz wählen": Code-Vote je Paket → (ergebnis, strittig).
+    set_p(f"Relevanz wählen ({n} Pakete)…", step=_step_idx(topic, "Relevanz wählen"))
+    vote_by_c = {}
+    for c, item_idxs in enumerate(chunks, 1):
+        local_set = lset(item_idxs)
+        rater = [d for p in rater_paths(c) if (d := _relevanz_schema(_json_datei(p), local_set))]
+        ergebnis: dict[int, str] = {}
+        strittig: dict[int, list[str]] = {}
+        for k in range(1, len(item_idxs) + 1):
+            stimmen = [d[k] for d in rater if k in d]
+            zaehler: dict[str, int] = {}
+            for s in stimmen:
+                zaehler[s] = zaehler.get(s, 0) + 1
+            best = max(zaehler.values(), default=0)
+            gewinner = [s for s, v in zaehler.items() if v == best]
+            if len(gewinner) == 1 and best >= 2:
+                ergebnis[k] = gewinner[0]
+            else:
+                strittig[k] = stimmen
+        vote_by_c[c] = (ergebnis, strittig)
+
+    # Phase „Relevanz klären": Judge je Paket mit Strittigem, alle parallel.
+    async def _klaere(c, item_idxs):
+        ergebnis, strittig = vote_by_c[c]
+        if strittig:
+            judge_path = arbeit / f"relevanz-final-c{c}.json"
+            entsch = _relevanz_schema(_json_datei(judge_path), set(strittig))
+            if entsch is None:
+                strittig_block = "\n".join(
+                    f"{k}. [{items[item_idxs[k - 1]][0]}] {items[item_idxs[k - 1]][1]} — Stimmen: {', '.join(stimmen) or 'keine'}"
+                    for k, stimmen in strittig.items()
+                )
+                status, entsch = await run_single_slot(
+                    ctx, f"Relevanz-Klärung {c}",
+                    key=f"bausteine-{topic}-relevanz-final-c{c}",
+                    prompt=_prompt("Relevanz-Mapping", topic=topic, strittig=strittig_block, out_path=judge_path, extra=_extra(instructions)),
+                    role="judge", capabilities="files",
+                    payload=lambda result, p=judge_path, ids=set(strittig): _relevanz_schema(_json_datei(p), ids),
+                    timeout=_timeout("relevanz_check", len(strittig)),
+                )
+                if status == FAILED:
+                    _log(topic, f"Relevanz-Klärung Paket {c} fehlgeschlagen — Default 'relevant'")
+                entsch = entsch if isinstance(entsch, dict) else {}
+            # Strittige ohne Entscheid → 'relevant' (nie versehentlich ausschließen).
+            ergebnis = {**{k: "relevant" for k in strittig}, **ergebnis, **entsch}
+        return {item_idxs[k - 1] + 1: rel for k, rel in ergebnis.items()}
+
+    set_p(f"Relevanz klären ({n} Pakete)…", step=_step_idx(topic, "Relevanz klären"))
+    parts = await asyncio.gather(*[_klaere(c, idxs) for c, idxs in enumerate(chunks, 1)], return_exceptions=True)
+    if is_cancelled():
+        return None
+    relevanz_by_id: dict[int, str] = {}
+    for c, part in enumerate(parts, 1):
+        if not isinstance(part, dict):
+            # Klärung ist nicht fatal: Vote-Ergebnis + Default 'relevant' für Strittige.
+            if isinstance(part, BaseException):
+                _log(topic, f"Relevanz-Klärung Paket {c}: {type(part).__name__}: {part}")
+            ergebnis, strittig = vote_by_c[c]
+            item_idxs = chunks[c - 1]
+            merged = {**{k: "relevant" for k in strittig}, **ergebnis}
+            part = {item_idxs[k - 1] + 1: s for k, s in merged.items()}
+        relevanz_by_id.update(part)
+    return relevanz_by_id
+
+
 async def generate_bausteine(topic: str, instructions: str = "", provider: str = DEFAULT_PROVIDER) -> None:
     if topic in _bausteine_progress:
         return
@@ -834,6 +990,24 @@ async def generate_bausteine(topic: str, instructions: str = "", provider: str =
                 if sidecar is None:
                     return
                 atomic_write_json(files["sidecar"], sidecar, indent=1)
+
+            # Block D: Relevanz je Subbaustein (relevant/rand) → in die Sidecar mergen.
+            # Eigene Phase nach den Stufen; treibt das ProGuide-Format (alle Bausteine
+            # mit ≥1 relevantem Subbaustein) und filtert Rand-Subs aus den Guides.
+            sidecar = _json_datei(files["sidecar"])
+            if _sidecar_schema(sidecar) is not None and not _relevanz_komplett(sidecar):
+                relevanz_by_id = await _relevanz_block(ctx, set_p, files, sidecar, instructions)
+                if is_cancelled():
+                    abgebrochen()
+                    return
+                if relevanz_by_id is None:
+                    return  # Fehler ist gesetzt
+                gid = 0
+                for subs in sidecar.values():
+                    for sub in subs:
+                        gid += 1
+                        sub["relevanz"] = relevanz_by_id.get(gid, "relevant")
+                atomic_write_json(files["sidecar"], sidecar, indent=1)
     except Exception as e:
         log.exception("[%s] Bausteine-Generierung fehlgeschlagen", topic)
         _bausteine_errors[topic] = str(e)[:2000]

backend/config.py

@@ -6,6 +6,7 @@ STORAGE_DIR = PROJECT_ROOT / "storage"
 FRONTEND_DIST = PROJECT_ROOT / "frontend" / "dist"
 DB_PATH = STORAGE_DIR / "creator.db"
 PROJECTS_DIR = PROJECT_ROOT / "projects"
+UNI_DIR = PROJECT_ROOT / "uni"
 
 MAX_CONCURRENT_GENERATIONS = 10
 
@@ -42,6 +43,8 @@ TIMEOUTS = {
     "subbaustein_check": (300, 15),  # Judge entscheidet strittige Subbausteine im Chunk
     "stufe":             (300, 10),  # Subbausteine einstufen je Chunk
     "stufe_check":       (300, 10),  # Judge entscheidet strittige Stufen im Chunk
+    "relevanz":          (300, 10),  # Subbausteine relevant/rand je Chunk
+    "relevanz_check":    (300, 10),  # Judge entscheidet strittige Relevanz im Chunk
     "writer":        (600, 120),  # pro Section im Chunk
     "lese_check":    (300, 10),   # pro Section im Paket
     "onepager_recherche": (900, 0),
@@ -55,6 +58,7 @@ TIMEOUTS = {
 FORMAT_ANTEIL = {
     "MiniGuide": (0.05, 0.10, 8, "einen kompakten Anfänger-Guide — der schnelle Einstieg ins Thema"),
     "Guide":     (0.25, 0.35, 20, "einen ausführlichen Anfänger-Guide — ein solides Fundament im Thema"),
+    "ProGuide":  (0.0, 1.0, 0, "einen fokussierten Guide — alles Relevante ohne Randthemen"),
     "FullGuide": (0.90, 1.00, 0, "einen Komplett-Guide — das ganze Thema"),
 }
 

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 ("FullGuide", "Guide", "MiniGuide", "OnePager"):
+    for fmt in ("FullGuide", "ProGuide", "Guide", "MiniGuide", "OnePager"):
         content = _json_datei(guide_content_path(topic, fmt))
         if content:
             for ch in content.get("chapters", []):

backend/guide.py

@@ -407,13 +407,26 @@ async def _generate_sections(
         "Wähle, was diesem Zweck dient — lass weg, was dafür nicht nötig ist."
     )
 
-    # Schritt 0: Auswahl-Konsens (5 Agenten → Voting → Mapping → Klärungs-Loop)
-    auswahl = await _konsens_auswahl(
-        ctx, files, entries, k_min, k_max, auswahl_auftrag, format_name,
-        bausteine_liste, instructions,
-    )
-    if auswahl is None:
-        return None
+    # Subbausteine je Baustein (Sidecar) — früh geladen: ProGuide wählt darüber aus,
+    # Nicht-FullGuide filtert später Rand-Subbausteine. Fehlt sie → {} (Fallback).
+    subs_raw = _load_subbausteine(topic)
+
+    # Schritt 0: Auswahl. ProGuide ist deterministisch — alle Bausteine mit ≥1
+    # relevantem Subbaustein. Fallback (keine Relevanz-Daten): alle Bausteine.
+    if format_name == "ProGuide":
+        auswahl = [num for num in entries
+                   if any(s.get("relevanz") == "relevant" for s in subs_raw.get(_titel(entries[num]), []))]
+        if not auswahl:
+            _log(topic, "ProGuide: keine Relevanz-Daten — alle Bausteine genommen")
+            auswahl = list(entries)
+    else:
+        # Auswahl-Konsens (5 Agenten → Voting → Mapping → Klärungs-Loop)
+        auswahl = await _konsens_auswahl(
+            ctx, files, entries, k_min, k_max, auswahl_auftrag, format_name,
+            bausteine_liste, instructions,
+        )
+        if auswahl is None:
+            return None
 
     sel_entries = {num: entries[num] for num in auswahl}
     soll = len(sel_entries)
@@ -487,9 +500,16 @@ async def _generate_sections(
     # dieselbe Aufteilung: 1 Agent je ~30 Bausteine (gedeckelt).
     total_sections = sum(len(c["nums"]) for c in plan)
     chunks = _split_chunks(plan, min(WRITER_MAX, max(1, math.ceil(total_sections / WRITER_SECTIONS))))
-    # Subbausteine je Baustein (Sidecar). Fehlt sie → leer → Inhalte/Writer laufen
-    # auf Baustein-Granularität weiter (Fallback für Alt-Themen ohne Sidecar).
-    subs_by_titel = _load_subbausteine(topic)
+    # Subbausteine je Baustein. Rand-Subbausteine fliegen aus allen Guides AUSSER
+    # FullGuide (Fokus). Subs ohne Relevanz-Feld (Alt-Themen) bleiben erhalten.
+    # Fehlt die Sidecar → leer → Inhalte/Writer laufen auf Baustein-Granularität.
+    subs_by_titel = subs_raw
+    if format_name != "FullGuide":
+        subs_by_titel = {
+            t: [s for s in subs if s.get("relevanz") != "rand"]
+            for t, subs in subs_raw.items()
+        }
+        subs_by_titel = {t: subs for t, subs in subs_by_titel.items() if subs}
     zuteilungen = [_zuteilung_subs(chunk, entries, subs_by_titel) for chunk in chunks]
     chunk_sizes = [sum(len(c["nums"]) for c in chunk) for chunk in chunks]
     writer_count = len(chunks)

backend/models.py

@@ -5,6 +5,7 @@ FormatType = Literal[
     "OnePager",
     "MiniGuide",
     "Guide",
+    "ProGuide",
     "FullGuide",
 ]
 
@@ -50,6 +51,37 @@ class ProjectResponse(BaseModel):
     name: str
 
 
+class FolderResponse(BaseModel):
+    name: str
+    ort: str  # relativer Pfad ab Repo-Root (z.B. "projects/foo")
+
+
+class BausteineQuelleUpdate(BaseModel):
+    topic: str = Field(min_length=1, max_length=100)
+    type: SourceType = "thema"
+    ort: str = Field(default="", max_length=2000)
+    spec: str = Field(default="", max_length=2000)
+
+
+class BausteineQuelleResponse(BaseModel):
+    type: SourceType
+    ort: str
+    spec: str
+
+
+class SubbausteinInfo(BaseModel):
+    titel: str
+    stufe: Literal["einfach", "mittel", "schwer"]
+    relevanz: Literal["relevant", "rand"] | None = None
+
+
+class BausteinUebersicht(BaseModel):
+    num: int
+    titel: str
+    beschreibung: str = ""
+    subbausteine: list[SubbausteinInfo] = []
+
+
 class ProviderInfo(BaseModel):
     id: str
     available: bool

backend/pipeline.py

@@ -158,6 +158,32 @@ def _stufen_schema(data, ids: set[int] | None = None):
     return out
 
 
+_RELEVANZ = ("relevant", "rand")
+
+
+def _relevanz_schema(data, ids: set[int] | None = None):
+    """{"relevanz": {"1": "relevant", …}} → {id: relevanz} · sonst None.
+
+    Relevanz ∈ {relevant, rand} (binär). Wie `_stufen_schema`: sind `ids` gegeben,
+    müssen mindestens diese abgedeckt sein (Extras erlaubt).
+    """
+    if not isinstance(data, dict) or not isinstance(data.get("relevanz"), dict) or not data["relevanz"]:
+        return None
+    out: dict[int, str] = {}
+    for k, v in data["relevanz"].items():
+        try:
+            num = int(k)
+        except (ValueError, TypeError):
+            return None
+        wert = str(v).strip().casefold()
+        if wert not in _RELEVANZ:
+            return None
+        out[num] = wert
+    if ids is not None and not ids <= set(out):
+        return None
+    return out
+
+
 _MAX_RESTARTS = 2
 
 

backend/regeln.py

@@ -18,10 +18,11 @@ from paths import bausteine_path, guide_content_path
 from textkit import _norm_titel
 
 MAX_OFFENE_GUIDES = 3
-VORSTUFE = {"Guide": "MiniGuide", "FullGuide": "Guide"}
+VORSTUFE = {"Guide": "MiniGuide", "ProGuide": "Guide", "FullGuide": "Guide"}
 # Welches Niveau die Vorstufe erreichen muss, um das Format freizuschalten.
-FREISCHALT_LEVEL = {"Guide": "absolviert", "FullGuide": "verstanden"}
-FORMATE = ("MiniGuide", "Guide", "FullGuide")
+# ProGuide hängt parallel zu FullGuide an „Guide absolviert" — kein Pflicht-Gate vor FullGuide.
+FREISCHALT_LEVEL = {"Guide": "absolviert", "ProGuide": "absolviert", "FullGuide": "verstanden"}
+FORMATE = ("MiniGuide", "Guide", "ProGuide", "FullGuide")
 
 
 async def lade_lernstand() -> tuple[list[dict], dict[str, set[str]], dict[str, dict[str, set[str]]]]:

backend/routes.py

@@ -7,7 +7,7 @@ from fastapi import APIRouter, HTTPException
 from fastapi.responses import FileResponse
 
 from agents import provider_available
-from config import PROJECTS_DIR, PROVIDERS
+from config import PROJECTS_DIR, UNI_DIR, PROVIDERS
 from database import (
     create_guide, delete_guide, get_guide, list_guides,
     create_topic, list_topics as db_list_topics, delete_topic,
@@ -16,7 +16,7 @@ from database import (
     get_vertiefung, set_vertiefung, list_vertiefungen,
     list_baustein_progress, set_baustein_score, set_baustein_streak, set_baustein_absolviert, set_baustein_verstanden, set_baustein_gemeistert, delete_baustein_daten,
 )
-from bausteine import generate_bausteine, cancel_bausteine, bausteine_status, active_bausteine, reset_bausteine
+from bausteine import generate_bausteine, cancel_bausteine, bausteine_status, active_bausteine, reset_bausteine, lade_quelle, lade_uebersicht
 from elements import generate_element, chat_with_guide, chat_with_element, check_element, style_element, refine_suggestion
 from lernen import NOETIG, MASTERY, MEISTERN, baustein_chat, baustein_diskussion, baustein_element_anlegen, pruefung_bewertung, pruefung_bewertung_schnell, pruefung_frage, score_berechnen, streak_berechnen, vertiefung_generieren
 from guide import generate_guide, guide_slot_dateien
@@ -31,6 +31,7 @@ from models import (
     ElementUpdateRequest, ElementCheckRequest, ElementCheckResponse, ElementStyleResponse,
     ElementRefineRequest, ElementRefineResponse,
     ProgressUpdate, ProgressResponse, ProjectResponse, ProviderInfo,
+    FolderResponse, BausteineQuelleUpdate, BausteineQuelleResponse, BausteinUebersicht,
     VertiefungRequest, VertiefungResponse,
     BausteinChatRequest, BausteinChatResponse,
     BausteinPruefungRequest, BausteinPruefungResponse, BausteinLernstandResponse,
@@ -113,6 +114,18 @@ async def remove_project(name: str):
     return {"ok": True}
 
 
+@router.get("/folders", response_model=list[FolderResponse])
+async def list_folders(kind: str):
+    """Ordner für die Quellen-Auswahl: kind=projekt → projects/, kind=uni → uni/."""
+    base = {"projekt": (PROJECTS_DIR, "projects"), "uni": (UNI_DIR, "uni")}.get(kind)
+    if base is None:
+        raise HTTPException(400, "kind muss 'projekt' oder 'uni' sein")
+    root, prefix = base
+    if not root.is_dir():
+        return []
+    return [{"name": e.name, "ort": f"{prefix}/{e.name}"} for e in sorted(root.iterdir()) if e.is_dir()]
+
+
 # --- Bausteine ---
 
 @router.get("/bausteine/status", response_model=BausteineStatusResponse)
@@ -161,6 +174,39 @@ async def remove_bausteine(topic: str):
     return {"ok": True}
 
 
+def _validate_quelle(typ: str, ort: str) -> None:
+    """Quellen-Eingabe prüfen (gleiche Regeln wie beim Erstellen)."""
+    if typ in ("projekt", "uni"):
+        ordner = safe_ordner(ort)
+        if ordner is None or not ordner.is_dir():
+            raise HTTPException(400, "Ordner ungültig oder nicht gefunden (Pfad relativ zum Projekt-Root, kein ../).")
+    elif typ == "link":
+        if not ort.lower().startswith(("http://", "https://")):
+            raise HTTPException(400, "Link muss mit http:// oder https:// beginnen.")
+
+
+@router.get("/bausteine/quelle", response_model=BausteineQuelleResponse)
+async def get_bausteine_quelle(topic: str):
+    return lade_quelle(topic)
+
+
+@router.put("/bausteine/quelle", response_model=BausteineQuelleResponse)
+async def update_bausteine_quelle(req: BausteineQuelleUpdate):
+    """Nur speichern — KEINE Neugenerierung. Quellen-/Spec-Wahl überschreiben."""
+    topic, typ, ort = req.topic.strip(), req.type, req.ort.strip()
+    _validate_quelle(typ, ort)
+    qp = quelle_path(topic)
+    qp.parent.mkdir(parents=True, exist_ok=True)
+    daten = {"type": typ, "ort": ort, "spec": req.spec.strip()}
+    atomic_write_json(qp, daten)
+    return daten
+
+
+@router.get("/bausteine/uebersicht", response_model=list[BausteinUebersicht])
+async def get_bausteine_uebersicht(topic: str):
+    return lade_uebersicht(topic)
+
+
 # --- Baustein-Lernen: Vertiefung, Chat, Prüfung ---
 
 async def _bester_text(topic: str, baustein: str) -> str | None: