update

backend/database.py

@@ -65,6 +65,7 @@ CREATE TABLE IF NOT EXISTS baustein_progress (
     baustein TEXT NOT NULL,
     gute_antworten INTEGER NOT NULL DEFAULT 0,
     absolviert TEXT,
+    verstanden TEXT,
     updated_at TEXT NOT NULL,
     PRIMARY KEY (topic, baustein)
 )
@@ -96,6 +97,10 @@ async def init_db():
         await db.execute("ALTER TABLE guides ADD COLUMN step INTEGER")
     except aiosqlite.OperationalError:
         pass
+    try:  # Migration für Bestands-DBs ohne verstanden-Spalte (Mastery-Stufe)
+        await db.execute("ALTER TABLE baustein_progress ADD COLUMN verstanden TEXT")
+    except aiosqlite.OperationalError:
+        pass
     # Migration: alte vertiefungen-Tabelle → baustein_texte (Bestand = lange Form, art 'deepdive')
     cursor = await db.execute("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'vertiefungen'")
     if await cursor.fetchone():
@@ -333,29 +338,41 @@ async def list_vertiefungen(topic: str) -> dict[str, set[str]]:
 async def list_baustein_progress(topic: str) -> list[dict]:
     db = await get_db()
     cursor = await db.execute(
-        "SELECT baustein, gute_antworten, absolviert FROM baustein_progress WHERE topic = ?", (topic,)
+        "SELECT baustein, gute_antworten, absolviert, verstanden FROM baustein_progress WHERE topic = ?", (topic,)
     )
     rows = await cursor.fetchall()
-    return [{"baustein": b, "gute_antworten": n, "absolviert": a} for b, n, a in rows]
+    return [{"baustein": b, "gute_antworten": n, "absolviert": a, "verstanden": v} for b, n, a, v in rows]
 
 
-async def add_gute_antwort(topic: str, baustein: str) -> int:
-    """Zählt eine gut bewertete Antwort und liefert den neuen Stand."""
+async def set_baustein_score(topic: str, baustein: str, score: int) -> int:
+    """Setzt den Score absolut (vom Aufrufer geclampt) und liefert ihn zurück."""
     db = await get_db()
     await db.execute(
         """INSERT INTO baustein_progress (topic, baustein, gute_antworten, updated_at)
-           VALUES (?, ?, 1, ?)
+           VALUES (?, ?, ?, ?)
            ON CONFLICT(topic, baustein) DO UPDATE SET
-               gute_antworten = gute_antworten + 1, updated_at = excluded.updated_at""",
-        (topic, baustein, _now()),
+               gute_antworten = excluded.gute_antworten, updated_at = excluded.updated_at""",
+        (topic, baustein, score, _now()),
     )
     await db.commit()
-    cursor = await db.execute(
-        "SELECT gute_antworten FROM baustein_progress WHERE topic = ? AND baustein = ?",
-        (topic, baustein),
+    return score
+
+
+async def set_baustein_verstanden(topic: str, baustein: str) -> bool:
+    """Markiert verstanden (Mastery); True nur beim ersten Mal. Sticky wie absolviert."""
+    db = await get_db()
+    now = _now()
+    await db.execute(
+        "INSERT OR IGNORE INTO baustein_progress (topic, baustein, gute_antworten, updated_at) VALUES (?, ?, 0, ?)",
+        (topic, baustein, now),
     )
-    row = await cursor.fetchone()
-    return row[0] if row else 0
+    cursor = await db.execute(
+        "UPDATE baustein_progress SET verstanden = ?, updated_at = ? "
+        "WHERE topic = ? AND baustein = ? AND verstanden IS NULL",
+        (now, now, topic, baustein),
+    )
+    await db.commit()
+    return cursor.rowcount > 0
 
 
 async def set_baustein_absolviert(topic: str, baustein: str) -> bool:

backend/lernen.py

@@ -19,13 +19,29 @@ from textkit import _norm_titel
 
 log = logging.getLogger("creator.lernen")
 
-NOETIG = 3  # gute Antworten bis "absolviert"
+NOETIG = 3   # gute Antworten bis "absolviert" (Tier 1)
+MASTERY = 10  # Score bis "verstanden" (Tier 2)
 VERTIEFUNG_TIMEOUT = 600
 CHAT_TIMEOUT = 240
 PRUEFUNG_TIMEOUT = 120  # kurze JSON-Turns; deckelt die Serien-Latenz pro Prüfungs-Schritt
 KRITIK_MAX_RUNDEN = 2   # Generator → Kritiker → ggf. Neu, höchstens so oft
 
 
+def score_berechnen(score_vor_frage: int, gut: bool, tier2: bool, absolviert: bool) -> int:
+    """Neuer Score nach einer Antwort · driftfrei (immer aus dem Basis-Score gerechnet).
+
+    Tier 1 (tier2=False): +1 bei richtig, KEINE Strafe bei falsch, Deckel NOETIG (3).
+    Tier 2 (tier2=True):  +1 bei richtig (Deckel MASTERY=10), −1 bei falsch.
+    Boden ist NOETIG, sobald der Baustein absolviert ist — sonst 0 (kann nicht
+    unter 3 fallen, absolviert bleibt erhalten). Re-Bewertung nutzt denselben
+    Basis-Score und ersetzt so das vorige Ergebnis (kein Doppelzählen).
+    """
+    delta = 1 if gut else (-1 if tier2 else 0)
+    floor = NOETIG if absolviert else 0
+    cap = MASTERY if tier2 else NOETIG
+    return max(floor, min(cap, score_vor_frage + delta))
+
+
 def _transcript(messages: list[dict]) -> str:
     return "\n".join(
         f"{'Nutzer' if m.get('role') == 'user' else 'Assistent'}: {m.get('content', '')}"

backend/models.py

@@ -194,7 +194,8 @@ class BausteinPruefungRequest(BaseModel):
     aktion: Literal["frage", "diskussion", "antwort"] = "frage"
     frage: str = Field(default="", max_length=2000)  # aktuell geprüfte Frage (für diskussion/antwort)
     letzte_bewertung: str = Field(default="", max_length=2000)  # Feedback der letzten Bewertung (Kontext für diskussion)
-    frage_schon_gut: bool = False  # diese Frage wurde schon einmal "gut" bewertet → nicht doppelt zählen
+    score_vor_frage: int = 0  # Score, als die Frage gestellt wurde → driftfreies (Re-)Bewerten
+    tier2: bool = False  # Mastery-Modus (ganzer Guide absolviert) → −1 bei falsch, Deckel 10
     messages: list[ChatMessage] = []  # Dialog bisher; leer = erste Frage
     provider: ProviderType = "claude"
 
@@ -206,11 +207,13 @@ class BausteinPruefungResponse(BaseModel):
     bewertung: Literal["gut", "schlecht"] | None = None
     gute_antworten: int
     absolviert: bool
+    verstanden: bool = False
 
 
 class BausteinLernstand(BaseModel):
     gute_antworten: int
     absolviert: bool
+    verstanden: bool
     vertiefung: bool
     deepdive: bool
 

backend/routes.py

@@ -14,11 +14,11 @@ from database import (
     list_progress, set_progress, delete_progress,
     create_element, list_elements, get_element, update_element, delete_element,
     get_vertiefung, set_vertiefung, list_vertiefungen,
-    list_baustein_progress, add_gute_antwort, set_baustein_absolviert, delete_baustein_daten,
+    list_baustein_progress, set_baustein_score, set_baustein_absolviert, set_baustein_verstanden, delete_baustein_daten,
 )
 from bausteine import generate_bausteine, cancel_bausteine, bausteine_status, active_bausteine, reset_bausteine
 from elements import generate_element, chat_with_guide, chat_with_element, check_element, style_element, refine_suggestion
-from lernen import NOETIG, baustein_chat, baustein_diskussion, baustein_element_anlegen, pruefung_bewertung, pruefung_frage, vertiefung_generieren
+from lernen import NOETIG, MASTERY, baustein_chat, baustein_diskussion, baustein_element_anlegen, pruefung_bewertung, pruefung_frage, score_berechnen, vertiefung_generieren
 from guide import generate_guide, guide_slot_dateien
 from pipeline import cancel_guide
 from regeln import FORMATE, formate_stats, guide_lock, ist_absolviert, lade_lernstand
@@ -161,6 +161,7 @@ async def baustein_lernstand(topic: str):
         p["baustein"]: {
             "gute_antworten": p["gute_antworten"],
             "absolviert": p["absolviert"] is not None,
+            "verstanden": p["verstanden"] is not None,
             "vertiefung": "vertiefung" in texte.get(p["baustein"], set()),
             "deepdive": "deepdive" in texte.get(p["baustein"], set()),
         }
@@ -169,7 +170,7 @@ async def baustein_lernstand(topic: str):
     for b, arten in texte.items():
         if b not in bausteine:
             bausteine[b] = {
-                "gute_antworten": 0, "absolviert": False,
+                "gute_antworten": 0, "absolviert": False, "verstanden": False,
                 "vertiefung": "vertiefung" in arten, "deepdive": "deepdive" in arten,
             }
     return {"bausteine": bausteine}
@@ -208,10 +209,11 @@ async def baustein_chat_route(req: BausteinChatRequest):
 async def baustein_pruefung_route(req: BausteinPruefungRequest):
     stand = next(
         (p for p in await list_baustein_progress(req.topic) if p["baustein"] == req.baustein),
-        {"gute_antworten": 0, "absolviert": None},
+        {"gute_antworten": 0, "absolviert": None, "verstanden": None},
     )
     gute = stand["gute_antworten"]
     absolviert = stand["absolviert"] is not None
+    verstanden = stand["verstanden"] is not None
     vertiefung = await _bester_text(req.topic, req.baustein)
     msgs = [m.model_dump() for m in req.messages]
 
@@ -219,7 +221,7 @@ async def baustein_pruefung_route(req: BausteinPruefungRequest):
         frage = await pruefung_frage(req.topic, req.baustein, req.section, vertiefung, msgs, provider=req.provider)
         if frage is None:
             raise HTTPException(502, "Frage fehlgeschlagen — bitte erneut versuchen")
-        return {"frage": frage, "gute_antworten": gute, "absolviert": absolviert}
+        return {"frage": frage, "gute_antworten": gute, "absolviert": absolviert, "verstanden": verstanden}
 
     if req.aktion == "diskussion":
         if not req.frage.strip():
@@ -230,7 +232,7 @@ async def baustein_pruefung_route(req: BausteinPruefungRequest):
         )
         if reply is None:
             raise HTTPException(502, "Diskussion fehlgeschlagen — bitte erneut versuchen")
-        return {"reply": reply, "gute_antworten": gute, "absolviert": absolviert}
+        return {"reply": reply, "gute_antworten": gute, "absolviert": absolviert, "verstanden": verstanden}
 
     # aktion == "antwort" — mindestens eine Nutzer-Antwort muss im Dialog stehen
     # (nach einer Diskussion endet der Dialog mit dem Tutor; Re-Bewertung bleibt erlaubt).
@@ -244,14 +246,17 @@ async def baustein_pruefung_route(req: BausteinPruefungRequest):
     if data is None:
         raise HTTPException(502, "Bewertung fehlgeschlagen — bitte erneut versuchen")
 
-    if data["bewertung"] == "gut" and not req.frage_schon_gut:
-        gute = await add_gute_antwort(req.topic, req.baustein)
-    if gute >= NOETIG or data["bestanden"]:
-        frisch = await set_baustein_absolviert(req.topic, req.baustein)
+    # Score driftfrei aus dem Basis-Score rechnen (Re-Bewertung ersetzt das vorige Ergebnis).
+    score = score_berechnen(req.score_vor_frage, data["bewertung"] == "gut", req.tier2, absolviert)
+    gute = await set_baustein_score(req.topic, req.baustein, score)
+    if score >= NOETIG and not absolviert:
         absolviert = True
-        if frisch:
+        if await set_baustein_absolviert(req.topic, req.baustein):
             asyncio.create_task(baustein_element_anlegen(req.topic, req.baustein, req.section, req.provider))
-    return {"feedback": data["feedback"], "bewertung": data["bewertung"], "gute_antworten": gute, "absolviert": absolviert}
+    if score >= MASTERY and not verstanden:
+        await set_baustein_verstanden(req.topic, req.baustein)
+        verstanden = True
+    return {"feedback": data["feedback"], "bewertung": data["bewertung"], "gute_antworten": gute, "absolviert": absolviert, "verstanden": verstanden}
 
 
 # --- Guides ---