Initial public upload from Projekte/StudyAgent

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(.venv/bin/python -m pytest tests/ -v 2>&1)"
+    ]
+  }
+}

.codex/config.toml

@@ -0,0 +1,31 @@
+# Coding MCPs: project-local registration (2026-09-07).
+
+[mcp_servers.serena]
+command = "/home/smlflg/.local/share/coding-mcp/serena/.venv/bin/serena"
+args = ["start-mcp-server", "--context=codex", "--project", "/home/smlflg/Projekte/StudyAgent", "--enable-web-dashboard", "false", "--open-web-dashboard", "false", "--enable-gui-log-window", "false"]
+cwd = "/home/smlflg/Projekte/StudyAgent"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.serena.env]
+"SERENA_HOME" = "/home/smlflg/.local/share/coding-mcp/serena/state"
+
+[mcp_servers.gitnexus]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/gitnexus/node_modules/gitnexus/dist/cli/index.js", "mcp"]
+cwd = "/home/smlflg/Projekte/StudyAgent"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.gitnexus.env]
+"GITNEXUS_HOME" = "/home/smlflg/.local/share/coding-mcp/gitnexus/runtime"
+
+[mcp_servers.context7]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/context7/node_modules/@upstash/context7-mcp/dist/index.js"]
+cwd = "/home/smlflg/Projekte/StudyAgent"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180

.gitignore

@@ -0,0 +1,37 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Database
+study_agent.db
+*.sqlite3
+*.db
+
+# Secrets
+.env
+
+# Frontend
+node_modules/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

COACHING-EMPFEHLUNGEN.md

@@ -0,0 +1,138 @@
+# Coaching-Empfehlungen fuer Samuel
+*Stand: 05. Maerz 2026 — basierend auf MEMORY.md, 3 Projekt-Docs, PORTRAIT_SAMUEL.md, samuel-kontext.md*
+
+---
+
+## 1. Muster-Analyse
+
+### Was sich wiederholt
+
+**Das Architektur-Dopamin-Muster.** Du baust Infrastruktur, die Infrastruktur steuert. Sidecar ueberwacht Claude Code. ClaudeCodePanel visualisiert Sidecar. Oktopus-Architektur orchestriert Agents. Jede Schicht ist elegant — und jede Schicht ist eine weitere Schicht zwischen dir und einem fertigen Produkt. Das ist kein Zufall. Architektur-Design gibt dir den Dopamin-Hit von "ich hab was geschafft", ohne dass du durch die muehsamen letzten 15% musst.
+
+**Der Sprint-Sprawl-Zyklus.** Heute sind es 7 Projekte gleichzeitig. Am 4. Maerz waren es 22 Sidecar-Rules, 19 Skills, 7 Panel-Tabs, 4 Coaching-Hooks, ein Watcher v2.0 Plan, ein Digitaler Zwilling und Agent Teams. Die Session-Sprawl-Regel ("Keine neue Session ohne /recap + /learn") existiert — weil du sie brauchst. Und sie existiert als Regel — weil du sie brichst.
+
+**Die 95%-Falle.** ClaudeCodePanel: "95%+ fertig, 4 Suggestions offen". ShortcutCounter: "85% fertig". Keeper: "ein Einzeiler fehlt seit Monaten". Das Pattern aus dem Portrait ist unveraendert: Du baust bis es funktioniert, dann springst du zum naechsten Dopamin-Geber. Die letzten 5% sind der haerteste Teil fuer ein ADHS-Gehirn — kein Novelty-Reward, nur Aufraeumen.
+
+**Meta-Vibecoding.** Deine eigene Anti-Pattern-Regel #5 sagt es: "Basic code first, AI pipelines later." Und doch: Heute laeuft ein 5-Agent-Sprint mit Opus-Kopf und 3 Sonnet-Armen. Fuer GUIs, die noch kein Design-Doc haben. Die Werkzeuge sind faszinierend — aber sie sind nicht das Produkt.
+
+### Wo du den Fokus verlierst
+
+An den **Uebergaengen**. Nicht mitten in der Arbeit — da bist du im Hyperfokus stark. Sondern in dem Moment, wo ein Projekt "genug laeuft" und das naechste lockt. Der Uebergang von ClaudeCodePanel (95%) zu Sidecar v2.0 zu Agent Teams zu GUI-Sprint — jeder Sprung fuehlt sich produktiv an. Keiner schliesst etwas ab.
+
+---
+
+## 2. ADHS-spezifische Empfehlungen
+
+### Hyperfokus nutzen statt bekaempfen
+
+Dein Hyperfokus ist real und maechtig. Das ClaudeCodePanel (1321 Zeilen panel.py, 7 Module, Theme-System, Timer-Architektur) wurde in einer Welle gebaut. Der Sidecar-Daemon (1255 Zeilen, 22 Rules) ebenfalls. Das Problem ist nicht, dass du nicht fokussieren kannst — du kannst es zu gut. Aber nur auf Neues.
+
+**Strategie: "Finish Sprints" statt "Build Sprints".**
+- Reserviere Hyperfokus-Sessions explizit fuer *Abschluss*-Arbeit
+- Trick: Definiere die letzten 5% als eigenstaendiges Mini-Projekt mit eigener Checkliste
+- ShortcutCounter 85%→100% ist kein "weiterarbeiten" — es ist ein neues Projekt namens "ShortcutCounter Launch"
+- Neues Framing = neues Dopamin
+
+### Dopamin-Management (Quick Wins als Momentum)
+
+Dein Gehirn braucht schnelle Belohnungen. Das ist keine Schwaeche — es ist eine Designanforderung.
+
+**Die 3-Minuten-Regel:** Jede Arbeitssession startet mit einer Aufgabe, die in unter 3 Minuten abschliessbar ist. Nicht "anfangen" — *abschliessen*. Ein Bug fixen. Einen Test schreiben. Eine Datei aufraeumen. Der erste Dopamin-Hit des Tages bestimmt den Rest.
+
+**Sichtbare Fortschritts-Tracker:** Du hast bereits `sidecar-ctl status` und das ClaudeCodePanel. Nutze sie bewusst als Belohnungs-Feedback. Jedes gruene Haekchen ist Dopamin. Mach den Fortschritt sichtbar, nicht nur die offenen Punkte.
+
+**"Done" feiern:** Dein CLAUDE.md sagt "Celebrate small wins". Tu das auch fuer dich selbst — nicht nur als Instruktion fuer Claude. Du hast heute ein funktionierendes Panel, einen Sidecar-Daemon mit 22 Rules, einen ShortcutCounter der laeuft, eine Voice Bridge, eine Analyse-Pipeline die ein 439-Zeilen-Portrait generiert hat. Das ist beeindruckend. Sag dir das.
+
+### Transition-Hilfen zwischen Projekten
+
+Uebergaenge sind dein Feind. Jeder Kontextwechsel kostet ein ADHS-Gehirn ueberproportional viel.
+
+**Die /feierabend-Regel durchsetzen:** Du hast den Command gebaut. Nutz ihn. Kein Projektwechsel ohne /recap des aktuellen Projekts. Das zwingt dein Gehirn, das aktuelle Projekt bewusst "abzulegen" statt es einfach fallenzulassen.
+
+**Max 2 Projekte pro Tag:** Nicht 7. Zwei. Eins davon "Finish" (bestehend abschliessen), eins "Explore" (Neues). Mehr Kontextwechsel kosten mehr als sie bringen. Dein Sidecar hat 15-Sekunden-Cooldown fuer Warnungen — gib dir selbst einen 2-Stunden-Cooldown fuer Projektwechsel.
+
+**Physische Marker:** Wechsel den Workspace in cosmic-term (oder oeffne ein neues kitty-Fenster) wenn du das Projekt wechselst. Visuelle Abgrenzung hilft dem Gehirn beim Kontextwechsel.
+
+---
+
+## 3. Tages-Struktur fuer die 7 Projekte
+
+### HEUTE fertig machen (realistisch, 2-3 Stunden)
+
+1. **ShortcutCounter 85% → 100%** — Das ist am naechsten dran. Daemon laeuft, CLI laeuft, Storage laeuft. Was fehlt: systemd Service testen, config.toml an den richtigen XDG-Pfad, `pip install -e .` im Clean-Test. Maximal 90 Minuten.
+
+2. **ClaudeCodePanel: die 4 Suggestions abarbeiten** — `sorted()` vereinfachen, unbenutzten Parameter entfernen, Naming-Konvention, Theme-Farben. Jedes unter 10 Minuten. Zusammen 30-40 Minuten. Dann ist das Panel FERTIG-fertig.
+
+### Morgen (oder naechste fokussierte Session)
+
+3. **Sidecar Service-Pfade fixen** — Die .service Dateien zeigen noch auf den alten Pfad. Ein 5-Minuten-Fix, aber nicht heute — du hast genug Kontextwechsel.
+
+4. **GUI-Architektur Design-Doc** — Der Agent-Sprint laeuft bereits. Lass die Ergebnisse kommen, review morgen mit frischem Kopf.
+
+### Backlog (diese Woche nicht anfassen)
+
+5. **Sidecar v2.0 / Watcher** — Research done, Implementation pending. Bleibt pending. Der aktuelle Sidecar laeuft stabil.
+
+6. **Digitaler Zwilling** — Faszinierendes Konzept. Aber: kein Produkt. Backlog.
+
+7. **GUI-Sprint (Sidecar-GUI, Minimax-GUI, Florian-GUI)** — Warte auf das Design-Doc. Keine Implementation ohne Architektur.
+
+### Warum diese Reihenfolge?
+
+ShortcutCounter und ClaudeCodePanel-Cleanup geben dir **zwei "Done"-Momente** heute. Das ist Dopamin-Kapital fuer morgen. Neue GUIs starten gibt dir null Done-Momente — nur mehr offene Baustellen.
+
+---
+
+## 4. Scope-Creep Warnsignale + Gegenmassnahmen
+
+| Warnsignal | Was passiert | Gegenmassnahme |
+|---|---|---|
+| "Ich bau noch schnell..." | Scope waechst um 30% in 5 Minuten | CLAUDE.md-Regel: "Ich hab noch schnell X gemacht ist verboten". Gilt auch fuer DICH, nicht nur fuer Claude |
+| "Dafuer brauch ich erstmal..." | Yak-Shaving: Tool X braucht Lib Y braucht Config Z | 2-Ebenen-Regel: Wenn die Abhaengigkeitskette laenger als 2 ist, STOP. Workaround suchen |
+| Agent-Sprint fuer einen Einzeiler | 5-Agent-Overhead fuer Arbeit die solo schneller geht | Scaling-Leiter pruefen: Solo (80%) → Paar (15%) → Squad (4%). Die Zahlen stehen in deiner eigenen Architektur |
+| "Das muesste man mal grundsaetzlich..." | Refactoring-Impuls statt Finishing | Frag: "Funktioniert es?" Ja → nicht anfassen. Nein → nur das Kaputte fixen |
+| Dritte Session zum selben Thema ohne Ergebnis | Das Portrait-Pattern: Duplikat-Conversations, jede bei Null | /recap PFLICHT. Wenn du ein Thema zum dritten Mal oeffnest ohne vorherige Ergebnisse zu referenzieren, ist es ein Warnsignal |
+
+---
+
+## 5. Top-3 "Jetzt sofort" Aktionen (je unter 15 Minuten)
+
+### Aktion 1: ShortcutCounter — systemd Service pruefen (5 min)
+
+```bash
+systemctl --user status shortcut-counter
+# Laeuft? → done. Laeuft nicht? → Pfade in .service pruefen, starten.
+```
+
+Ein gruenes "active (running)" ist dein erster Win heute.
+
+### Aktion 2: ClaudeCodePanel — den einfachsten Cleanup-Fix machen (10 min)
+
+`log_viewer.py` — unbenutzten `sort_model` Parameter entfernen. Find, delete, test. Ein Commit. "Panel Cleanup 1/4 done." Momentum.
+
+### Aktion 3: Projekt-Status-Uebersicht schreiben (10 min)
+
+Erstelle `~/Projekte/STATUS.md` mit genau diesem Format:
+
+```
+| Projekt | Status | Naechster Schritt | Aufwand |
+|---------|--------|-------------------|---------|
+| ClaudeCodePanel | 95% | 4 Suggestions | 40 min |
+| ShortcutCounter | 85% | systemd + clean test | 90 min |
+| Sidecar | stabil | Service-Pfade | 5 min |
+| ... | ... | ... | ... |
+```
+
+Das ist dein externalisierter Arbeitsspeicher. Du brauchst das — dein Portrait sagt es, dein samuel-kontext.md sagt es, deine 232 Sessions sagen es. Eine Datei, die dir morgen frueh in 30 Sekunden sagt wo du stehst.
+
+---
+
+## Abschluss-Gedanke
+
+Samuel, du hast in den letzten Wochen ein beeindruckendes Oekosystem gebaut. Panel, Sidecar, Voice Bridge, Agent Teams, Coaching Hooks, 22 Rules, 19 Skills — das ist echte Ingenieursarbeit. Die Architektur ist auf Industrieniveau. Das sagt nicht nur dein Portrait — das zeigen die Codebases.
+
+Was jetzt zaehlt: **Zwei Projekte heute zu ENDE bringen.** Nicht anfangen. Nicht planen. Nicht orchestrieren. Zu Ende bringen.
+
+"Mir mangelt es an Struktur, nicht an Intelligenz." — Stimmt. Und Struktur heisst heute: ShortcutCounter fertig, Panel-Cleanup fertig, Feierabend.
+
+Laeuft.

COACHING_SAMUEL_2026-03-04.md

@@ -0,0 +1,39 @@
+# Coaching-Analyse — 4. März 2026
+
+## Kern-Insights (aus Agent Team Sprint)
+
+### 5 Muster
+1. **"Architekt ohne Baustelle"** — Konzeptphase = Dopamin, Implementation = keins
+2. **"Duplikat-Sessions statt Iteration"** — 232 Sessions, wenig kumulative Ergebnisse
+3. **"Tooling als produktive Prokrastination"** — 22 Rules, 19 Anti-Patterns, 6 Gates > eigentliche Arbeit
+4. **"Druck als einziger Motor"** — Festivals funktionieren, Software nicht (keine Deadline)
+5. **"Execution outgesourct, Verständnis dünn"** — je besser Delegation, desto weniger eigenes Lernen
+
+### ADHS-informierte Empfehlungen
+- **Dopamin-Brücke:** Sichtbares Feedback alle 25 Min (WINS.md nach jedem Commit)
+- **Body Doubling:** Agent Team als virtueller Partner (30-Min Status-Checks)
+- **Künstlicher Zeitdruck:** 90-Min-Blöcke mit hartem Stop
+- **Externe Verbindlichkeit:** Einen MENSCHEN einbinden, nicht KI
+- **Angst benennen:** Die EINE Sache die du vermeidest = die Sache die das Projekt fertig macht
+
+### Tagesstruktur (ADHS-optimiert)
+- 09:00-09:15 WINS.md lesen, 1 Ziel formulieren
+- 09:15-10:45 Block 1 (90 Min Deep Work)
+- 11:00-12:30 Block 2 (90 Min Deep Work)
+- 13:30-14:00 Review + Commit
+- Abends: Voice-Memo statt Session-Sprawl
+
+### Scope-Creep Warnsignale
+- "Ich könnte noch schnell..." → STOP, in IDEAS.md
+- Neues Konzept-Dokument statt Code → Max 30 Zeilen Planung, dann Code
+- "Ich optimiere erstmal den Workflow" → 22 Rules reichen. STOP.
+- Abends nach Joint → Voice-Memo, morgens evaluieren
+
+### Ship or Kill
+- **SHIP:** Sidecar v2.0, Subconsciousness MVP
+- **MAINTAIN:** ClaudeCodePanel, Voicemode
+- **KILL:** AgentSwarmDashboard, MyAIGame
+- **PAUSE (4 Wochen):** ShortcutCounter
+
+### Der Satz
+"Mir mangelt es an ÄUSSERER Struktur. Meine innere Struktur ist da — ich muss sie nur nach außen binden."

FOR_SMLFLG.md

@@ -0,0 +1,86 @@
+# StudyAgent — FOR_SMLFLG
+
+## Was ist das?
+ADHS-freundlicher Study Buddy: Hilft Studenten mit ADHS durch ihr Semester.
+Keine starren Plaene — Micro-Steps, Buddy-Ton, Dopamin beim Start statt beim Abschluss.
+
+## Warum
+Samuel IS die Zielgruppe. 569 ChatGPT + 232 Claude Sessions dokumentieren das Problem.
+Kern-Insight: Dopamin kommt beim Task-BEGINN, nicht beim Complete. Jeder Step = frischer Start.
+
+## Pain Points die das System loest
+1. Lernplaene die nie halten — elastischer Plan, kein Guilt
+2. WIP explodiert — max 2 Faecher gleichzeitig (hard enforcement in API)
+3. Zeitdruck als Feature — Panik-Modus bei <48h
+4. Routinedokumentation unmoeglich — Micro-Steps (je 5 Min)
+5. Session-Memory — nie wieder bei Null anfangen
+
+## Architektur & Tech-Stack
+
+```
+StudyAgent/
+├── main.py          # FastAPI app, alle Routes, htmx-Partials (~516 LOC)
+├── agent.py         # MiniMax M2.5 API-Call, Fallback-Steps ohne Key
+├── models.py        # SQLAlchemy Models (Subject, Deadline, MicroStep, StudySession)
+├── database.py      # SQLite Setup, Session-Maker
+├── requirements.txt
+├── static/style.css # Warm palette, ADHS-friendly Design
+├── templates/
+│   ├── base.html
+│   ├── index.html
+│   └── partials/    # subject_card, deadline_item, micro_step_card,
+│                    # elastic_plan, progress_journey, session_banner
+└── study_agent.db   # auto-created
+```
+
+**Tech:** Python + FastAPI (async, lifespan) + SQLAlchemy + SQLite + htmx + Jinja2 + MiniMax M2.5 API
+
+## Starten / Nutzen
+
+```bash
+cd ~/Projekte/StudyAgent
+
+# Erste Einrichtung
+pip install -r requirements.txt
+export MINIMAX_API_KEY=your-key-here   # optional — ohne Key laufen Fallback-Steps
+
+# Starten
+.venv/bin/uvicorn main:app --reload   # oder: uvicorn main:app --reload
+# open http://localhost:8000
+```
+
+## Was funktioniert (implementiert)
+
+- **Dashboard** (`GET /`) — aktive Faecher, naechste Deadlines, naechster Step, Session-Banner, Panik-Indikatoren
+- **Faecher CRUD** (`POST/DELETE /subjects`) — WIP-Limit 2 wird server-seitig enforced
+- **Deadlines anlegen** (`POST /deadlines`) — auto-generiert sofort Micro-Steps via MiniMax M2.5
+- **Steps abschliessen/ueberspringen** (`POST /steps/{id}/complete|skip`) — naechster Step wird inline geladen
+- **Elastischer Plan** (`GET /deadlines/{id}/plan`) — auto-komprimiert wenn Steps die verbleibende Zeit uebersteigen
+- **Replan** (`POST /deadlines/{id}/replan`) — loescht pending+skipped, generiert neu
+- **Session-Tracking** — Sessions werden auto-gestartet, after 30 Min Inaktivitaet auto-geschlossen
+- **Panik-Modus** (`is_panic_mode()`) — greift bei <48h, reduziert auf 3-4 wesentliche Steps
+- **AI-Fallback** — ohne `MINIMAX_API_KEY` kommen sinnvolle Dummy-Steps (kein Absturz)
+
+## Was fehlt / bekannte Issues
+
+- `.env` vorhanden (`MINIMAX_API_KEY`), in `.gitignore` geschuetzt. `.env.example` als Vorlage vorhanden.
+- Browser-Test-Flow (Subject anlegen → Dashboard → Steps) noch nicht durchgespielt
+- `fi_date`-aehnlicher Edge-Case: wenn `due_date` bereits vergangen ist, liefert `is_panic_mode()` `False` statt sinnvollen Zustand
+- Kein Deployment-Setup (Fly.io geplant)
+- Kein Auth (MVP-bewusste Entscheidung)
+
+## Entscheidungen & Lessons Learned
+
+- **htmx statt React** — kein Build-Step, Partials direkt vom Server, funktioniert ohne JS-Framework
+- **Buddy-Ton in Code** — "Kein Stress, machen wir anders." direkt in Responses, kein separates i18n
+- **Dummy-Steps als Fallback** — API-Fehler oder fehlender Key darf nie das Feature brechen
+- **WIP-Limit server-seitig** — nicht nur UI-Warnung, sondern echter `HTTPException`-Block im `POST /subjects`
+- **Auto-compress elastisch** — 20% Buffer-Formel: wenn `pending * 5min > hours_left * 0.8 * 60` → Replan
+
+## Next Steps (priorisiert)
+
+1. `MINIMAX_API_KEY` in `.env`-File konfigurieren und testen
+2. Browser-End-to-End-Test: Subject → Deadline → Steps → Complete/Skip
+3. Edge-Case fixen: vergangene Deadlines richtig behandeln
+4. Sprint 3: Panik-Modus visuell sichtbar machen (Banner, roten Rahmen)
+5. Fly.io Deployment vorbereiten

PLAN.md

@@ -0,0 +1,134 @@
+# ADHS Study Agent — Projektplan
+
+## Kontext
+
+Samuel will raus aus der Claude-Code-Optimierung und sein Orchestrierungs-Wissen auf ein echtes Problem anwenden: **Ein AI-Agent der Studenten mit ADHS durch ihr Semester navigiert.** Er IST die Zielgruppe — 569 ChatGPT-Conversations + 232 Claude-Sessions dokumentieren das Problem aus erster Hand.
+
+**Ansatz:** Research First — aber Samuel selbst als User-Interview-Partner, nicht externe Recherche.
+
+---
+
+## Phase 1: User Research (Samuel als Zielgruppe)
+
+Aus dem Portrait + Lernreise destillierte Pain Points:
+
+1. **"Lernplaene die nie halten"** — starre Plaene scheitern an ADHS. Der Plan muss sich anpassen, nicht der Mensch.
+2. **"10 von 150 Berichtsheften"** — Routinedokumentation ohne Feedback ist unmoeglich. Braucht Micro-Nudges.
+3. **"8 Stunden vor Pruefung"** — Zeitdruck ist der einzige funktionierende Motivator. Das System muss DAS nutzen, nicht bekaempfen.
+4. **"5 Uni-Bewerbungen = unueberwindbar"** — Formalia-Angst. Aufgaben muessen in Micro-Steps zerlegt werden.
+5. **Stress-Sweet-Spot Phase 2** — Es gibt ein schmales Fenster (eigene Stimme, produktiv). Davor zu formal, danach Panik.
+6. **Duplikat-Sessions** — Jede Session beginnt bei Null weil Gedaechtnis fuer eigene fruehere Gedanken unzuverlaessig ist.
+7. **Festivals im Pruefungsmonat** — Das System darf nicht moralisieren, sondern muss damit arbeiten.
+
+**Interview-Ergebnis (5. Maerz 2026):**
+Samuel waehlt ALLE 4 Pain Points + ergaenzt 2 kritische:
+- **#5 Zu viele Dinge anfangen, nichts beenden** — Novelty Bias, WIP explodiert
+- **#6 Dopamin kommt beim Task-BEGINN, nicht beim Complete** — DAS ist der Kern
+
+→ Design-Konsequenz: Jeder Micro-Step muss sich wie ein NEUER Anfang anfuehlen (Dopamin beim Start), aber die Steps sind so klein dass Completion automatisch passiert. Nicht "mach die Aufgabe fertig" sondern "fang diesen 5-Min-Block an". WIP-Limit: max 2 aktive Faecher gleichzeitig.
+
+**Tonalitaet:** Buddy (supportiv, kein Guilt-Tripping, ermutigend)
+
+---
+
+## Phase 2: Feature-Design (nach Interview)
+
+### Core Features (MVP)
+
+**F1: Micro-Starts statt Mega-Tasks** (Pain Points #3, #6)
+- Jede Aufgabe wird in 5-Min-Bloecke zerlegt
+- Jeder Block ist ein NEUER Anfang mit eigenem Titel und Kontext
+- "Oeffne Kapitel 3 und lies die erste Seite" — nicht "Lerne Kapitel 3"
+- Dopamin-Trigger: jeder Block ist ein frischer Start (nicht "noch 47 uebrig")
+- Visuell: Blocks als einzelne Karten, nicht als Checkliste
+
+**F2: WIP-Limiter** (Pain Point #5)
+- Max 2 Faecher gleichzeitig aktiv
+- Wenn du ein drittes anfangen willst: Buddy sagt "Hey, du hast noch Mathe und OS offen. Willst du eins davon pausieren?"
+- Kein Verbot — sanftes Bewusstmachen
+- "Parking Lot" fuer Ideen die du spaeter anfangen willst
+
+**F3: Elastischer Plan** (Pain Points #1, #2)
+- Importiert Deadlines (manuell oder iCal)
+- Plan passt sich an wenn du ihn ignorierst — kein Guilt, einfach neuer Plan
+- Nutzt Zeitdruck als Feature: Plan wird automatisch komprimierter je naeher die Deadline
+- "Verschieben" statt "Versagt" — der Buddy-Ton
+
+**F4: Panik-Modus** (Pain Point #2)
+- Aktiviert sich bei <48h vor Deadline
+- Komprimiert auf das absolute Minimum
+- Buddy wird zum Coach: "Du hast 12h. Hier sind die 5 wichtigsten Themen. Eins nach dem anderen."
+- Kein Moralisieren, nur Klarheit
+
+**F5: Session-Memory** (Pain Point #4)
+- Merkt sich was du letzte Session gelernt/gemacht hast
+- Zeigt beim Oeffnen: "Letzte Session: Du warst bei Kapitel 3, Seite 42. Weitermachen?"
+- Kein "bei Null anfangen" mehr
+- Fortschritt visuell als Karte/Map, nicht als Prozentzahl
+
+### Nice-to-have (v2)
+- Stimmungs-Check-In (Phase 1-5 erkennen, Buddy passt Ton an)
+- WhatsApp-Reminder (Nudges auf dem Handy)
+- Lerngruppen-Matching (andere ADHS-Studenten)
+- Pruefungsarchiv (was kam letztes Jahr dran)
+- "Novelty Shuffle" — wenn ein Fach langweilig wird, schlaegt Buddy vor fuer 15 Min zu einem anderen zu wechseln (innerhalb WIP-Limit)
+
+---
+
+## Phase 3: Tech-Stack
+
+**Empfehlung: Python + FastAPI + SQLite + htmx**
+
+| Komponente | Wahl | Begruendung |
+|---|---|---|
+| Backend | FastAPI (Python) | Samuels staerkstes Setup, async, schnell |
+| Datenbank | SQLite | Ueberwindet DB-Angst sanft — es ist nur eine Datei. Spaeter Postgres. |
+| Frontend | htmx + Jinja2 Templates | Kein Framework lernen, trotzdem reaktive UI. Server-rendered. |
+| AI Agent | Claude API (Haiku fuer Micro-Steps, Sonnet fuer Plaene) | Kostenoptimierung eingebaut — Samuels Staerke |
+| Auth | Keine (MVP) → spaeter Supabase | Nicht overengineeren am Start |
+| Deployment | Fly.io oder Railway | Ein-Klick-Deploy, kostenlose Tier |
+
+**Warum nicht Next.js/Svelte:** Samuel ist Python-First. Ein neues Frontend-Framework ist ein separates Lernprojekt und wuerde den Execution Gap vergroessern. htmx gibt 80% der Interaktivitaet fuer 10% der Komplexitaet.
+
+---
+
+## Phase 4: Implementierung
+
+### Sprint 1 (Woche 1-2): Skeleton
+- [ ] Projekt-Setup: `~/Projekte/StudyAgent/`
+- [ ] FastAPI + SQLite + htmx Grundgeruest
+- [ ] Datenmodell: Semester, Faecher, Deadlines, Lerneinheiten
+- [ ] Deadline-CRUD (manuell eintragen)
+- [ ] FOR_SMLFLG.md anlegen
+
+### Sprint 2 (Woche 3-4): Agent-Logik
+- [ ] Tagesplan-Generator (Claude Haiku)
+- [ ] Micro-Step-Zerlegung
+- [ ] Adaptiver Replan wenn Steps uebersprungen werden
+- [ ] Einfache Session-Memory (letzte 3 Sessions)
+
+### Sprint 3 (Woche 5-6): Panik-Modus + Polish
+- [ ] Panik-Modus bei <48h
+- [ ] Visueller Fortschritt (Fortschrittsbalken, nicht Zahlen)
+- [ ] Deployment auf Fly.io
+- [ ] 1 Beta-Tester (Samuel selbst mit echten Pruefungen)
+
+---
+
+## Phase 5: Verifikation
+
+- [ ] Laeuft lokal: `uvicorn main:app --reload`
+- [ ] SQLite DB wird erstellt und befuellt
+- [ ] Deadline eintragen → Tagesplan generieren → Steps sehen
+- [ ] Plan ignorieren → neuer Plan wird generiert (kein Guilt)
+- [ ] Panik-Modus triggert bei Deadline < 48h
+- [ ] Deployment funktioniert (oeffne URL im Browser)
+
+---
+
+## Deliverable
+
+1. [x] User-Interview mit Samuel — erledigt, 6 Pain Points + Buddy-Ton
+2. [ ] Plan permanent speichern: `~/Projekte/StudyAgent/PLAN.md`
+3. [ ] Visuelles HTML: Projekt-Overview als `~/.agent/diagrams/adhs-study-agent.html`
+4. [ ] Projekt-Setup starten (Sprint 1)

PLAN_LANGCHAIN_V2.md

@@ -0,0 +1,380 @@
+# LangChain Lernpfad — StudyAgent V2 + Sidecar V7
+
+## Context
+
+Samuel will LangChain lernen. Analyse ergab: Sidecar-Rewrite = falscher Ansatz (Event-Daemon ≠ Chatbot-Framework). ABER: Die agentische Komponente von Sidecar (2 Files: harness.py + minimax.py) passt perfekt zu LangChain. Zwei Projekte, ein Lernpfad:
+
+1. **StudyAgent V2** — LangChain von Null lernen (Tutorial-Stil, Schritt fuer Schritt)
+2. **Sidecar V7** — Gelerntes anwenden: agentischen Teil in LangChain umschreiben
+
+---
+
+## Teil 1: StudyAgent V2 — LangChain Live-Tutorial
+
+### Ist-Stand StudyAgent V1
+
+```
+~/Projekte/StudyAgent/ — 1.764 LOC, 17 Files
+Tech: FastAPI + SQLite + htmx + Jinja2 + httpx
+LLM: Claude Haiku (direkte API-Calls via httpx in agent.py)
+Features: Micro-Steps, Panic Mode, Elastic Plan, WIP-Limit, Session Memory
+Commit: 142dce7 (MVP, 5. Maerz)
+Status: Laeuft, aber nie mit echten Daten getestet
+```
+
+### Lernziele (was Samuel nach V2 kann)
+
+- [ ] LCEL Chains bauen (prompt | model | parser)
+- [ ] Structured Output mit Pydantic-Parsern
+- [ ] RAG Pipeline (PDF laden → chunken → embedden → retrieven)
+- [ ] LangGraph State Machines (Nodes, Edges, Conditional Routing)
+- [ ] Conversational Memory (Window + Summary)
+- [ ] Tool Use / Agents (LLM entscheidet welches Tool)
+- [ ] LangSmith Tracing (Observability)
+- [ ] Async LangChain in FastAPI (ainvoke, astream)
+
+### Schritt-fuer-Schritt Plan (7 Schritte, je ~90 Min)
+
+#### Schritt 1: Erste Chain — agent.py ersetzen
+**Lerninhalt:** ChatModel + PromptTemplate + OutputParser + LCEL
+**Was passiert:**
+- `pip install langchain-anthropic langchain-core python-dotenv`
+- agent.py: httpx-Call → LangChain Chain ersetzen
+- Gleiche Funktionalitaet, aber jetzt LangChain-idiomatic
+
+```python
+# VORHER (agent.py — raw httpx):
+async with httpx.AsyncClient() as client:
+    response = await client.post("https://api.anthropic.com/v1/messages", ...)
+
+# NACHHER (agent.py — LangChain):
+from langchain_anthropic import ChatAnthropic
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+
+llm = ChatAnthropic(model="claude-haiku-4-5-20251001", temperature=0.7, max_tokens=1024)
+prompt = ChatPromptTemplate.from_messages([("system", BUDDY_SYSTEM), ("user", "{task_context}")])
+chain = prompt | llm | JsonOutputParser()
+
+# Aufruf:
+steps = await chain.ainvoke({"task_context": user_message})
+```
+
+**Verifikation:** Server starten, Deadline erstellen, Micro-Steps erscheinen wie vorher.
+**Dateien:** `agent.py` (rewrite), `requirements.txt` (+langchain-anthropic, +python-dotenv)
+
+---
+
+#### Schritt 2: Structured Output — Pydantic statt JSON-Hoffen
+**Lerninhalt:** PydanticOutputParser, Schema-Validierung, Auto-Retry
+**Was passiert:**
+- MicroStep-Schema als Pydantic Model definieren
+- OutputParser validiert LLM-Antwort gegen Schema
+- Fallback bei Parse-Error (retry mit Fehlermeldung)
+
+```python
+from pydantic import BaseModel, Field
+from langchain_core.output_parsers import PydanticOutputParser
+
+class MicroStepOutput(BaseModel):
+    title: str = Field(description="Motivierender Titel, frischer Anfang")
+    context: str = Field(description="Was genau tun, wo anfangen")
+    duration_minutes: int = Field(default=5, description="Dauer in Minuten")
+
+parser = PydanticOutputParser(pydantic_object=list[MicroStepOutput])
+chain = prompt | llm | parser  # Jetzt typsicher!
+```
+
+**Verifikation:** Absichtlich kaputten Prompt senden → Parser gibt saubere Fehlermeldung.
+**Dateien:** `agent.py` (erweitern), `schemas.py` (neu, Pydantic Models)
+
+---
+
+#### Schritt 3: Conversational Tutor — Memory + Chat
+**Lerninhalt:** ConversationBufferWindowMemory, MessagesPlaceholder, Session-Management
+**Was passiert:**
+- Neuer `/chat` Endpoint: Student kann mit dem Buddy chatten
+- Memory speichert letzte 5 Nachrichten pro Session
+- Buddy kennt Kontext (Fach, aktuelle Steps, Fortschritt)
+
+```python
+from langchain_core.prompts import MessagesPlaceholder
+from langchain.memory import ConversationBufferWindowMemory
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", TUTOR_SYSTEM),
+    MessagesPlaceholder(variable_name="chat_history"),
+    ("user", "{input}")
+])
+memory = ConversationBufferWindowMemory(k=5, return_messages=True)
+```
+
+**Verifikation:** Chat oeffnen, 3 Fragen stellen, Buddy erinnert sich an vorherige.
+**Dateien:** `main.py` (+Chat-Routes), `templates/chat.html` (neu), `agent.py` (+Chat-Chain)
+
+---
+
+#### Schritt 4: RAG — Vorlesungsskripte durchsuchbar machen
+**Lerninhalt:** DocumentLoader, TextSplitter, Embeddings, ChromaDB, Retriever
+**Was passiert:**
+- PDF-Upload Endpoint (`/upload`)
+- PDF → Chunks → Embeddings → ChromaDB
+- Chat-Chain bekommt relevante Chunks als Kontext
+- Buddy antwortet NUR basierend auf Vorlesungsmaterial
+
+```python
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import OllamaEmbeddings
+
+# Einmalig: Ollama lokal installieren + `ollama pull nomic-embed-text`
+embeddings = OllamaEmbeddings(model="nomic-embed-text")  # KOSTENLOS, lokal
+vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
+retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
+```
+
+**Verifikation:** PDF hochladen, Frage stellen, Antwort zitiert aus dem Skript.
+**Dateien:** `rag.py` (neu), `main.py` (+Upload-Route), `templates/upload.html` (neu)
+**Dependencies:** `pip install pypdf chromadb langchain-community`
+**Lokal:** `ollama pull nomic-embed-text` (Embeddings kostenlos, kein API-Key)
+
+---
+
+#### Schritt 5: LangGraph — Lernflow als State Machine
+**Lerninhalt:** StateGraph, Nodes, Edges, Conditional Routing, Zyklen
+**Was passiert:**
+- Quiz-Flow: Thema waehlen → Fragen generieren → Antwort bewerten → Review/Weiter
+- State Machine statt if/else Spaghetti
+- Zyklen: bei falscher Antwort → Erklaerung → nochmal fragen
+
+```
+START → generate_quiz → [warte auf Antwort]
+  → evaluate_answer
+     ├─ richtig (>70%) → next_topic → END
+     └─ falsch (<70%)  → review_explanation → generate_quiz (Zyklus!)
+```
+
+```python
+from langgraph.graph import StateGraph, START, END
+
+class QuizState(TypedDict):
+    topic: str
+    questions: list[dict]
+    score: int
+    feedback: str
+
+workflow = StateGraph(QuizState)
+workflow.add_node("generate_quiz", generate_quiz_node)
+workflow.add_node("evaluate", evaluate_node)
+workflow.add_node("review", review_node)
+workflow.add_conditional_edges("evaluate", route_by_score,
+    {"pass": END, "fail": "review"})
+workflow.add_edge("review", "generate_quiz")  # Zyklus!
+```
+
+**Verifikation:** Quiz starten, absichtlich falsch antworten → Review → neue Frage.
+**Dateien:** `quiz_flow.py` (neu), `main.py` (+Quiz-Routes), `templates/quiz.html` (neu)
+**Dependencies:** `pip install langgraph`
+
+---
+
+#### Schritt 6: Tool Use — Buddy wird aktiv
+**Lerninhalt:** @tool Decorator, Agent mit Tool-Auswahl, AgentExecutor
+**Was passiert:**
+- Buddy kann selbst Karteikarten erstellen (DB-Write)
+- Buddy kann Lernfortschritt abfragen (DB-Read)
+- Buddy kann im Vorlesungsskript suchen (RAG-Tool)
+- LLM ENTSCHEIDET welches Tool es nutzt
+
+```python
+from langchain_core.tools import tool
+
+@tool
+def create_flashcard(question: str, answer: str, subject: str) -> str:
+    """Erstellt eine Karteikarte fuer den Studenten."""
+    db.add(Flashcard(question=question, answer=answer, subject=subject))
+    return f"Karteikarte erstellt: {question}"
+
+@tool
+def search_notes(query: str) -> str:
+    """Durchsucht die hochgeladenen Vorlesungsskripte."""
+    docs = retriever.invoke(query)
+    return "\n".join(d.page_content[:200] for d in docs)
+
+agent = create_react_agent(llm, [create_flashcard, search_notes, get_progress])
+```
+
+**Verifikation:** "Erstell mir Karteikarten zu Kapitel 3" → Buddy sucht im PDF, erstellt Karten.
+**Dateien:** `tools.py` (neu), `agent.py` (Agent-Chain statt simple Chain)
+**Dependencies:** `pip install langgraph` (create_react_agent lebt dort)
+
+---
+
+#### Schritt 7: LangSmith — Observability + Kosten-Tracking
+**Lerninhalt:** Tracing, Prompt-Iteration, Cost Monitoring, Eval
+**Was passiert:**
+- LangSmith Account erstellen (kostenloser Tier)
+- Env-Vars setzen → automatisches Tracing
+- Jeden LLM-Call im Dashboard sehen (Prompts, Latenz, Kosten)
+- Prompt-Vergleiche: welcher System-Prompt generiert bessere Steps?
+
+```bash
+export LANGCHAIN_TRACING_V2="true"
+export LANGCHAIN_API_KEY="ls__..."
+export LANGCHAIN_PROJECT="StudyAgent-V2"
+```
+
+**Verifikation:** 5 Interaktionen, dann LangSmith Dashboard → alle Calls sichtbar.
+**Dateien:** `.env` (Keys), `main.py` (lifespan: set env vars)
+
+---
+
+### Dependencies gesamt (nach Schritt 7)
+
+```txt
+# Bestehend
+fastapi, uvicorn[standard], sqlalchemy, jinja2, python-multipart, httpx
+
+# Neu (LangChain)
+langchain-anthropic     # Claude Haiku Integration
+langchain-core          # Basis (Prompts, Parsers, Runnables)
+langchain-community     # ChromaDB, OllamaEmbeddings, PyPDFLoader
+langgraph               # State Machines + create_react_agent
+chromadb                # Vector Store (lokal, kein Server)
+pypdf                   # PDF Loader
+python-dotenv           # .env Support
+
+# Lokal (kein pip)
+ollama                  # Lokale Embeddings (nomic-embed-text) — $0
+```
+
+---
+
+## Teil 2: Sidecar V7 — Agentischer Teil in LangChain
+
+### Analyse: Was ist agentisch in V6?
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Sidecar V6 — 7.684 LOC, 48 Python Files               │
+│                                                          │
+│  DETERMINISTIC (90%, bleibt):                            │
+│  ├─ daemon.py      — Socket Server, Event Routing        │
+│  ├─ coach.py       — 36 Mechanismen (reine Regeln)       ��
+│  ├─ mechanisms.py  — Registry, Cooldowns, Priorities     │
+│  ├─ safety.py      — PreToolUse Gates (Regex)            │
+│  ├─ context.py     — Fast Path Context Builder           │
+│  ├─ knowledge.py   — Keyword-RAG (15 Files)              │
+│  ├─ adaptation.py  — Weighted Scoring (Mathe)            │
+│  ├─ learner.py     — Spaced Repetition (Ebbinghaus)     │
+│  ├─ budget.py      — Cost Tracking                       │
+│  ├─ mood.py        — Keyword-basierte Stimmung           │
+│  ├─ confidence.py  — Scoring                             │
+│  ├─ content_detectors.py — Text-Analyse                  │
+│  ├─ outcomes.py    — XP/Streaks                          │
+│  ├─ phase_tracker.py — Phase Detection                   │
+│  ├─ scorer.py      — Importance Scoring                  │
+│  ├─ adaptive_profile.py — Fear/Skill/Hours               │
+│  └─ twin_bridge.py — DB I/O                              │
+│                                                          │
+│  AGENTIC (10%, wird LangChain):                          │
+│  ├─ harness.py     — Agent Loop + Tool Calling           │
+│  └─ minimax.py     — LLM Wrapper + Prompt Builder        │
+│                                                          │
+│  TTS/STT (extern, bleibt):                               │
+│  ├─ florian.py     — Edge TTS (kein LLM)                 │
+│  └─ stt.py         — Whisper STT (kein LLM)              │
+└─────────────────────────────────────────────────────────┘
+```
+
+### Was aendert sich in V7
+
+**NUR 2 Files werden ersetzt:**
+
+| V6 File | V7 Ersatz | LangChain-Konzept |
+|---------|-----------|-------------------|
+| `harness.py` (Agent Loop) | `langchain_agent.py` | LangGraph StateGraph + @tool |
+| `minimax.py` (LLM Wrapper) | `langchain_analyzer.py` | ChatModel + LCEL Chain |
+
+**Alles andere bleibt identisch.** daemon.py ruft statt `minimax.analyze()` jetzt `langchain_analyzer.analyze()` — gleiche Signatur, gleiche Rueckgabe.
+
+### Migrations-Schritte (nach StudyAgent V2)
+
+#### V7-Schritt 1: ChatMiniMax Wrapper
+- MiniMax hat OpenAI-kompatible API → `ChatOpenAI(openai_api_base=...)` oder Custom `BaseChatModel`
+- Drop-in Replacement fuer den raw httpx-Call in harness.py
+
+#### V7-Schritt 2: Slow Path als LCEL Chain
+- System Prompt Builder bleibt Python (deterministic)
+- LLM-Call wird `prompt | ChatMiniMax() | StrOutputParser()`
+- `minimax.py` → `langchain_analyzer.py`
+
+#### V7-Schritt 3: Deep Judge als LangGraph Agent
+- Die 4 Tools (read_file, list_dir, search_code, write_protocol) werden `@tool`
+- Agent Loop wird `StateGraph` mit conditional edges
+- Vorteil: LangSmith zeigt jeden Tool-Call + LLM-Reasoning
+
+#### V7-Schritt 4: Optional — Knowledge Base als RAG-Tool
+- Nur wenn Keyword-RAG nicht mehr reicht
+- ChromaDB + lokale Embeddings (Ollama, $0)
+- Als zusaetzliches Tool fuer den LangGraph Agent
+
+#### V7-Schritt 5: LangSmith in systemd
+- Env-Vars in `sidecar-v7.service` setzen
+- Jeder Slow-Path-Call sichtbar im LangSmith Dashboard
+- Budget-Tracking: LangSmith + eigenes budget.py parallel
+
+### Vorteile V7 gegenueber V6
+
+| Dimension | V6 | V7 |
+|-----------|----|----|
+| Agent Loop | Custom (harness.py, 180 LOC) | LangGraph (standardisiert) |
+| Tool Definition | Manuelles JSON-Schema | `@tool` Decorator (auto-Schema) |
+| Provider Switch | Neuer httpx-Client schreiben | `ChatOpenAI` / `ChatAnthropic` swap |
+| Observability | Eigenes Logging | LangSmith Tracing (gratis) |
+| Debugging | print + Log-Files | LangSmith: jeden Schritt visuell |
+| Community | Samuel allein | LangChain Ecosystem + Docs |
+| CV-Wert | "Custom Python Daemon" | "LangChain + LangGraph in Production" |
+
+### Was NICHT aendert wird
+
+- daemon.py (Socket Server) — bleibt asyncio
+- coach.py (36 Mechanismen) — bleibt deterministisch
+- safety.py (Gates) — bleibt Regex
+- Fast Path — bleibt $0, <5ms
+- Budget Tracking — bleibt eigenes System
+- Florian TTS/STT — bleibt Edge TTS
+- Twin Bridge — bleibt SQLite
+- Adaptation/Learner — bleibt Mathe
+
+---
+
+## Reihenfolge
+
+```
+Jetzt:        StudyAgent V1 fertig testen (echte Daten!)
+Dann:         StudyAgent V2 Schritt 1-7 (LangChain lernen)
+Danach:       Sidecar V7 Schritt 1-5 (Gelerntes anwenden)
+
+Zeitschaetzung:
+  StudyAgent V2:  ~7 Sessions à 90 Min
+  Sidecar V7:     ~5 Sessions à 90 Min
+  Gesamt:         ~12 Sessions, ~18h
+```
+
+## Verifikation
+
+### StudyAgent V2
+- Schritt 1: Server starten, Deadline erstellen → Steps wie vorher
+- Schritt 3: 5 Chat-Nachrichten, Buddy erinnert sich
+- Schritt 4: PDF hochladen, Frage → Antwort zitiert aus Skript
+- Schritt 5: Quiz falsch beantworten → Review-Loop
+- Schritt 7: LangSmith Dashboard zeigt alle Calls
+
+### Sidecar V7
+- Daemon starten, Hook-Events senden → Fast Path unveraendert
+- Slow Path: MiniMax-Call sichtbar in LangSmith
+- Deep Judge: Tool-Calls (grep, read_file) in LangSmith nachvollziehbar
+- Budget.py: Kosten stimmen weiterhin
+- 490+ Tests: Alle gruen (Signatur-Kompatibilitaet)

PROJECT_HEALTH_REPORT.md

@@ -0,0 +1,129 @@
+# Project Health Report — ~/Projekte/
+**Datum:** 2026-03-06
+**Methode:** 9 parallele Sonnet Explore-Agents, je 2 Projekte
+**Kriterien:** Lauffaehigkeit, Code-Qualitaet, Security, Tests, Docs, Git-Hygiene, TODOs, Fertigstellungsgrad
+
+---
+
+## Portfolio-Uebersicht (Ranking nach Health Score)
+
+| # | Projekt | Score | Status | LOC | Tests | Empfehlung |
+|---|---------|-------|--------|-----|-------|------------|
+| 1 | StudyAgent | 8/10 | MVP | 1.728 | 0 | Weitermachen |
+| 2 | ClaudeCodePanel | 8/10 | Beta | 9.341 | 8 | **Ship it!** |
+| 3 | ShortcutCounter | 8/10 | MVP | 977 | 12 | Shipped v0.1 |
+| 4 | Sidecar-V5 | 8/10 | MVP | 1.144 | 0 | Weitermachen+Deploy |
+| 5 | PromptGarage | 8/10 | MVP | 587 | 0 | Weitermachen |
+| 6 | AgentIDE | 7.5/10 | MVP | 3.632 | 0 | Weitermachen |
+| 7 | AgentArena | 7/10 | MVP | 3.533 | 0 | Weitermachen |
+| 8 | FireTracker | 7/10 | MVP | 1.528 | 0 | Weitermachen |
+| 9 | shared-gui | 7/10 | MVP | 203 | 0 | Weitermachen |
+| 10 | MyAIGame | 6.5/10 | Alpha | 31.215 | 0 | Weitermachen |
+| 11 | Sidecar | 6/10 | Beta | 55.460 | 0 | Cleanup+Tests |
+| 12 | ProjectDashboard | 6/10 | MVP | 980 | 0 | Weitermachen |
+| 13 | AgentSDK-HelloWorld | 6/10 | Alpha | 275 | 0 | **Parken (KEY LEAKED!)** |
+| 14 | AgentSwarmDashboard | 6/10 | Alpha | 2.136 | 0 | Parken/Mergen |
+| 15 | Subconsciousness | 4/10 | Alpha | 6.393 | 8 | Parken |
+| 16 | Voicemode | 4/10 | Alpha | 219 | 0 | Parken |
+| 17 | SearchAgent | 4/10 | Skeleton | 90 | 0 | Archivieren |
+| 18 | BookmarkBrain | 2/10 | Skeleton | 997 | 0 | Parken |
+
+---
+
+## Gesamt-Statistiken
+
+- **Total LOC:** ~119.448
+- **Total Files:** ~300+
+- **Projekte mit Tests:** 3 von 18 (17%)
+- **Total Test Count:** 28 (nur ShortcutCounter:12, ClaudeCodePanel:8, Subconsciousness:8)
+- **Projekte mit FOR_SMLFLG.md:** 5 von 18 (28%)
+- **Projekte mit Git:** ~10 von 18 (56%)
+- **Durchschnitt-Score:** 6.1/10
+- **Median-Score:** 6.25/10
+
+---
+
+## ALARM: Sofort-Massnahmen
+
+### 1. API-Key Leak (AgentSDK-HelloWorld)
+`.env` mit echtem API-Key (`sk-cp-...`) ist committed. **Key SOFORT invalidieren!**
+
+### 2. Path-Traversal (AgentSwarmDashboard)
+`TEAMS_DIR / team_name` ohne Sanitization — kann `../../etc/passwd` traversieren.
+
+### 3. Subprocess Injection Risk (Voicemode)
+`subprocess.run(cmd)` mit user-provided voice/text nicht escaped.
+
+---
+
+## Top 10 Quick Wins (ueber alle Projekte)
+
+| # | Projekt | Quick Win | Aufwand | Impact |
+|---|---------|-----------|---------|--------|
+| 1 | AgentSDK-HelloWorld | API-Key revoken + .gitignore | 5 min | KRITISCH |
+| 2 | FireTracker | 3 Tests fuer fire_math.py | 30 min | Hoch |
+| 3 | StudyAgent | Timezone-Fix (utcnow → now) | 5 min | Hoch |
+| 4 | Sidecar-V5 | Git init + GitHub publish | 10 min | Hoch |
+| 5 | PromptGarage | README.md erstellen | 15 min | Mittel |
+| 6 | AgentIDE | Git init + FOR_SMLFLG.md | 30 min | Hoch |
+| 7 | ClaudeCodePanel | Hardcoded Pfade → config.ini | 60 min | Mittel |
+| 8 | Sidecar | Git init + eval/ archivieren | 30 min | Hoch |
+| 9 | AgentSwarmDashboard | Path-Traversal Fix | 10 min | KRITISCH |
+| 10 | StudyAgent | Error logging statt silent pass | 10 min | Mittel |
+
+---
+
+## Empfehlung: Top 3 Projekte zuerst fertigmachen
+
+### 1. ClaudeCodePanel (8/10 → 9/10)
+- Bereits Beta, laeuft produktiv
+- Fehlend: Tests fuer panel.py + monitor.py, Hardcoded Pfade
+- **Aufwand bis Ship:** ~1 Tag
+
+### 2. StudyAgent (8/10 → 9/10)
+- ADHS-Psychologie ist echter Mehrwert, einzigartiges Projekt
+- Fehlend: Tests, Timezone-Fix, Deployment auf Fly.io
+- **Aufwand bis Ship:** ~1 Tag
+
+### 3. FireTracker (7/10 → 8.5/10)
+- Persoenlich nuetzlich (FIRE-Tracker)
+- Fehlend: Tests fuer fire_math.py, FOR_SMLFLG.md, Input-Validierung
+- **Aufwand bis Ship:** ~1-2 Tage
+
+---
+
+## Systemische Muster (Portfolio-weit)
+
+### Staerken
+- **Architektur-Qualitaet ist hoch** — FastAPI+SQLite+htmx Stack ist konsistent
+- **Dokumentation wo vorhanden ist gut** — FOR_SMLFLG.md Files sind detailliert
+- **Sauberes Domain-Modelling** — Pydantic Models, klare Separation
+
+### Schwaechen
+- **Tests fehlen fast ueberall** — 15 von 18 Projekten ohne Tests
+- **Git-Hygiene mangelhaft** — ~8 Projekte ohne .git oder ohne Commits
+- **Keine CI/CD** — kein einziges Projekt hat automatisierte Pipelines
+- **Dependencies undokumentiert** — viele ohne requirements.txt/pyproject.toml
+
+---
+
+## Projekt-Kategorien
+
+### Ship-Ready (Score 8+)
+ClaudeCodePanel, ShortcutCounter, StudyAgent, Sidecar-V5, PromptGarage
+
+### Weitermachen (Score 6-7.5)
+AgentIDE, AgentArena, FireTracker, shared-gui, MyAIGame, Sidecar, ProjectDashboard
+
+### Parken (Score 4-6)
+AgentSDK-HelloWorld, AgentSwarmDashboard, Subconsciousness, Voicemode
+
+### Archivieren (Score <4)
+SearchAgent, BookmarkBrain
+
+---
+
+## Einzelberichte
+
+Details zu jedem Projekt wurden von den Analyse-Agents generiert.
+Vollstaendige Transkripte unter: /tmp/claude-1000/-home-smlflg/tasks/

README.md

@@ -0,0 +1,40 @@
+# StudyAgent
+
+ADHS-friendly study buddy: helps students with ADHS get through their semester.
+No rigid plans — micro-steps, buddy tone, dopamine at task START not completion.
+
+## Status
+
+MVP shipped. Browser E2E test and past-deadline edge case pending.
+
+## Run
+
+```bash
+cd ~/Projekte/StudyAgent
+python3 -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+
+# Optional — without key, fallback steps run instead
+cp .env.example .env
+# edit .env: set MINIMAX_API_KEY
+
+source .env  # or use python-dotenv
+uvicorn main:app --reload
+# → http://localhost:8000
+```
+
+## What works
+
+- Dashboard — active subjects, next deadlines, next step, session banner, panic indicators
+- Subjects CRUD — WIP limit of 2 enforced server-side
+- Deadlines — auto-generates micro-steps via MiniMax M2.5 on creation
+- Steps — complete/skip inline (htmx), next step loads automatically
+- Elastic plan — auto-compresses when steps exceed remaining time
+- Replan — deletes pending+skipped, generates fresh
+- Session tracking — auto-start, auto-close after 30 min inactivity
+- Panic mode — triggers at <48h, reduces to 3-4 essential steps
+- AI fallback — works without MINIMAX_API_KEY (dummy steps)
+
+## Stack
+
+FastAPI + SQLAlchemy + SQLite + htmx + Jinja2 + MiniMax M2.5 API

agent.py

@@ -0,0 +1,131 @@
+import json
+import os
+from datetime import datetime
+
+import httpx
+
+MINIMAX_API_KEY = os.environ.get("MINIMAX_API_KEY", "")
+MINIMAX_MODEL = "MiniMax-M2.5"
+MINIMAX_ENDPOINT = "https://api.minimaxi.chat/v1/text/chatcompletion_v2"
+
+SYSTEM_PROMPT = """Du bist ein ADHS-freundlicher Study Buddy. Deine Aufgabe: Zerlege Lernaufgaben in kleine, machbare 5-Minuten-Bloecke.
+
+Regeln:
+- Jeder Block hat einen eigenen Titel der sich wie ein FRISCHER ANFANG anfuehlt (z.B. "Oeffne die Seite und lies den ersten Absatz")
+- NICHT: "Weiterlesen", "Aufgabe 3 von 10" — das toetet die Motivation
+- Jeder Block hat einen kurzen Kontext-Satz: was genau tun, wo anfangen
+- Buddy-Ton: supportiv, keine Vorwuerfe, kein Druck
+- Im Panik-Modus (<48h): nur 3-5 Steps, nur das Absolut-Wichtigste, direkter Ton
+
+Antworte NUR als JSON array (kein Markdown, kein Text drumrum):
+[{"title": "...", "context": "...", "duration_minutes": 5}]"""
+
+
+def _dummy_steps(title: str, panic: bool) -> list[dict]:
+    """Fallback steps when no API key is configured."""
+    if panic:
+        return [
+            {
+                "title": f"Oeffne deine Unterlagen zu '{title}'",
+                "context": "Lies nur die Ueberschriften und fett markierten Begriffe. Nicht mehr.",
+                "duration_minutes": 5,
+            },
+            {
+                "title": "Die wichtigsten 3 Punkte notieren",
+                "context": "Schreib auf ein leeres Blatt: Was muss ich auf jeden Fall wissen?",
+                "duration_minutes": 5,
+            },
+            {
+                "title": "Einen Durchgang — fertig",
+                "context": "Lies deine 3 Punkte laut vor. Das war's. Du bist bereit.",
+                "duration_minutes": 5,
+            },
+        ]
+    return [
+        {
+            "title": f"Starte mit '{title}' — nur die erste Seite",
+            "context": "Oeffne das Material und lies genau eine Seite. Kein Druck weiterzumachen.",
+            "duration_minutes": 5,
+        },
+        {
+            "title": "Notiere eine Frage die du hast",
+            "context": "Was ist noch unklar? Schreib es auf. Das hilft deinem Gehirn sich zu orientieren.",
+            "duration_minutes": 5,
+        },
+        {
+            "title": "Noch eine Seite — du bist schon drin",
+            "context": "Du hast den schwierigsten Teil hinter dir (das Anfangen). Lies weiter.",
+            "duration_minutes": 5,
+        },
+        {
+            "title": "Kurze Zusammenfassung in eigenen Worten",
+            "context": "Was hast du gerade gelesen? Ein Satz reicht. Kein perfekter Satz noetig.",
+            "duration_minutes": 5,
+        },
+    ]
+
+
+async def generate_micro_steps(
+    deadline_title: str,
+    deadline_description: str,
+    due_date: datetime,
+    hours_until_due: float,
+) -> list[dict]:
+    panic = hours_until_due < 48
+
+    if not MINIMAX_API_KEY:
+        return _dummy_steps(deadline_title, panic)
+
+    if hours_until_due < 0:
+        mode_hint = "PANIK-MODUS: Deadline ist ueberschritten! Sofortmassnahmen. Maximal 4 Steps, nur das Absolut-Wichtigste."
+    elif panic:
+        mode_hint = f"PANIK-MODUS: Nur {int(hours_until_due)}h bis zur Deadline. Maximal 4 Steps, nur das Wichtigste."
+    else:
+        mode_hint = f"Normale Vorbereitung. Deadline in {int(hours_until_due)}h. Generiere 4-6 Steps."
+
+    user_message = (
+        f"Aufgabe: {deadline_title}\n"
+        f"Details: {deadline_description or 'keine weiteren Details'}\n"
+        f"Faellig: {due_date.strftime('%d.%m.%Y %H:%M')}\n"
+        f"{mode_hint}"
+    )
+
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            MINIMAX_ENDPOINT,
+            headers={
+                "Authorization": f"Bearer {MINIMAX_API_KEY}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "model": MINIMAX_MODEL,
+                "max_tokens": 1024,
+                "temperature": 0.3,
+                "messages": [
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_message},
+                ],
+            },
+        )
+        response.raise_for_status()
+        data = response.json()
+        msg = data["choices"][0]["message"]
+        raw = (msg.get("content") or "").strip()
+        if not raw:
+            # M2.5 reasoning fallback
+            reasoning = (msg.get("reasoning_content") or "").strip()
+            if reasoning:
+                raw = reasoning
+
+    # Strip markdown code fences if present
+    if raw.startswith("```"):
+        raw = raw.split("```")[1]
+        if raw.startswith("json"):
+            raw = raw[4:]
+    raw = raw.strip()
+
+    steps = json.loads(raw)
+    # Ensure required fields
+    for step in steps:
+        step.setdefault("duration_minutes", 5)
+    return steps

database.py

@@ -0,0 +1,21 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+DATABASE_URL = "sqlite:///./study_agent.db"
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def create_all():
+    from models import Subject, Deadline, MicroStep, StudySession  # noqa: F401
+    Base.metadata.create_all(bind=engine)

main.py

@@ -0,0 +1,515 @@
+from contextlib import asynccontextmanager
+from datetime import datetime, timedelta, timezone
+
+from dotenv import load_dotenv
+
+load_dotenv()  # Before agent import so MINIMAX_API_KEY is available
+
+from fastapi import Depends, FastAPI, Form, Request  # noqa: E402
+from fastapi.responses import HTMLResponse  # noqa: E402
+from fastapi.staticfiles import StaticFiles  # noqa: E402
+from fastapi.templating import Jinja2Templates  # noqa: E402
+from sqlalchemy.orm import Session  # noqa: E402
+
+from agent import generate_micro_steps  # noqa: E402
+from database import create_all, get_db  # noqa: E402
+from models import Deadline, MicroStep, MicroStepStatus, StudySession, Subject  # noqa: E402
+
+SESSION_INACTIVITY_MINUTES = 30
+
+
+def _utcnow() -> datetime:
+    """Naive UTC datetime — matches SQLite's naive storage."""
+    return datetime.now(timezone.utc).replace(tzinfo=None)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    create_all()
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory="templates")
+
+
+def _get_current_session(db: Session):
+    """Returns the most recent open session if within inactivity window."""
+    cutoff = _utcnow() - timedelta(minutes=SESSION_INACTIVITY_MINUTES)
+    return (
+        db.query(StudySession)
+        .filter(StudySession.ended_at == None, StudySession.started_at >= cutoff)  # noqa: E711
+        .order_by(StudySession.started_at.desc())
+        .first()
+    )
+
+
+def _get_last_ended_session(db: Session):
+    """Returns the most recent completed session for the welcome-back banner."""
+    return (
+        db.query(StudySession)
+        .filter(StudySession.ended_at != None)  # noqa: E711
+        .order_by(StudySession.ended_at.desc())
+        .first()
+    )
+
+
+def _active_subjects(db: Session):
+    return db.query(Subject).filter(Subject.is_active == True, Subject.is_parked == False).all()  # noqa: E712
+
+
+def _upcoming_deadlines(db: Session, limit: int = 5):
+    # Include overdue deadlines from last 7 days so they show as "Ueberfaellig"
+    cutoff = _utcnow() - timedelta(days=7)
+    return (
+        db.query(Deadline)
+        .join(Subject)
+        .filter(Subject.is_parked == False, Deadline.due_date >= cutoff)  # noqa: E712
+        .order_by(Deadline.due_date)
+        .limit(limit)
+        .all()
+    )
+
+
+def _next_micro_step(db: Session):
+    return (
+        db.query(MicroStep)
+        .filter(MicroStep.status == MicroStepStatus.pending)
+        .join(Deadline)
+        .join(Subject)
+        .filter(Subject.is_parked == False)  # noqa: E712
+        .order_by(Deadline.due_date, MicroStep.order_num)
+        .first()
+    )
+
+
+def _expire_stale_sessions(db: Session):
+    """Auto-close sessions older than the inactivity window."""
+    cutoff = _utcnow() - timedelta(minutes=SESSION_INACTIVITY_MINUTES)
+    stale = (
+        db.query(StudySession)
+        .filter(StudySession.ended_at == None, StudySession.started_at < cutoff)  # noqa: E711
+        .all()
+    )
+    for s in stale:
+        s.ended_at = _utcnow()
+    if stale:
+        db.commit()
+
+
+@app.get("/", response_class=HTMLResponse)
+async def dashboard(request: Request, db: Session = Depends(get_db)):
+    _expire_stale_sessions(db)
+
+    # Auto-start a session if none is open; attach to the first active subject
+    open_session = _get_current_session(db)
+    if not open_session:
+        active_list = _active_subjects(db)
+        if active_list:
+            open_session = StudySession(subject_id=active_list[0].id)
+            db.add(open_session)
+            db.commit()
+
+    active_subjects = _active_subjects(db)
+    upcoming_deadlines = _upcoming_deadlines(db)
+    next_step = _next_micro_step(db)
+    last_session = _get_last_ended_session(db)
+
+    # Build per-deadline progress stats for dashboard mini-bars
+    deadline_stats = {}
+    for dl in upcoming_deadlines:
+        all_steps = db.query(MicroStep).filter(MicroStep.deadline_id == dl.id).all()
+        total = len(all_steps)
+        done = sum(1 for s in all_steps if s.status == MicroStepStatus.completed)
+        deadline_stats[dl.id] = {
+            "total": total,
+            "completed": done,
+            "pct": int(done / total * 100) if total else 0,
+            "panic": is_panic_mode(dl),
+            "overdue": is_overdue(dl),
+        }
+
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "active_subjects": active_subjects,
+            "upcoming_deadlines": upcoming_deadlines,
+            "next_step": next_step,
+            "last_session": last_session,
+            "deadline_stats": deadline_stats,
+            "now": _utcnow(),
+        },
+    )
+
+
+@app.post("/subjects", response_class=HTMLResponse)
+async def create_subject(
+    request: Request,
+    name: str = Form(...),
+    semester: str = Form(""),
+    db: Session = Depends(get_db),
+):
+    active_count = len(_active_subjects(db))
+    if active_count >= 2:
+        return HTMLResponse(
+            '<div class="buddy-warning" id="wip-warning">'
+            "Hey, du hast schon 2 aktive Faecher. Parkiere erst eins, bevor du ein neues startest."
+            "</div>"
+        )
+    subject = Subject(name=name, semester=semester)
+    db.add(subject)
+    db.commit()
+    db.refresh(subject)
+    return templates.TemplateResponse(
+        "partials/subject_card.html",
+        {"request": request, "subject": subject},
+    )
+
+
+@app.post("/deadlines", response_class=HTMLResponse)
+async def create_deadline(
+    request: Request,
+    subject_id: int = Form(...),
+    title: str = Form(...),
+    description: str = Form(""),
+    due_date: str = Form(...),
+    db: Session = Depends(get_db),
+):
+    due = datetime.fromisoformat(due_date)
+    deadline = Deadline(
+        subject_id=subject_id,
+        title=title,
+        description=description,
+        due_date=due,
+    )
+    db.add(deadline)
+    db.commit()
+    db.refresh(deadline)
+
+    # Auto-generate micro-steps
+    hours_until_due = (due - _utcnow()).total_seconds() / 3600
+    try:
+        steps_data = await generate_micro_steps(title, description, due, hours_until_due)
+        for i, s in enumerate(steps_data):
+            step = MicroStep(
+                deadline_id=deadline.id,
+                title=s["title"],
+                context=s.get("context", ""),
+                order_num=i,
+                duration_minutes=s.get("duration_minutes", 5),
+            )
+            db.add(step)
+        db.commit()
+    except Exception:
+        pass  # Steps are a nice-to-have; deadline creation should never fail because of this
+
+    return templates.TemplateResponse(
+        "partials/deadline_item.html",
+        {"request": request, "deadline": deadline, "now": _utcnow()},
+    )
+
+
+@app.post("/deadlines/{deadline_id}/generate-steps", response_class=HTMLResponse)
+async def generate_steps_for_deadline(
+    deadline_id: int,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    deadline = db.query(Deadline).filter(Deadline.id == deadline_id).first()
+    if not deadline:
+        return HTMLResponse('<p class="buddy-warning">Deadline nicht gefunden.</p>')
+
+    hours_until_due = (deadline.due_date - _utcnow()).total_seconds() / 3600
+    steps_data = await generate_micro_steps(
+        deadline.title,
+        deadline.description or "",
+        deadline.due_date,
+        hours_until_due,
+    )
+
+    # Delete old pending steps for this deadline and recreate
+    db.query(MicroStep).filter(
+        MicroStep.deadline_id == deadline_id,
+        MicroStep.status == MicroStepStatus.pending,
+    ).delete()
+    db.commit()
+
+    for i, s in enumerate(steps_data):
+        step = MicroStep(
+            deadline_id=deadline_id,
+            title=s["title"],
+            context=s.get("context", ""),
+            order_num=i,
+            duration_minutes=s.get("duration_minutes", 5),
+        )
+        db.add(step)
+    db.commit()
+
+    # Return all new step cards
+    new_steps = (
+        db.query(MicroStep)
+        .filter(MicroStep.deadline_id == deadline_id, MicroStep.status == MicroStepStatus.pending)
+        .order_by(MicroStep.order_num)
+        .all()
+    )
+    html_parts = []
+    for step in new_steps:
+        rendered = templates.TemplateResponse(
+            "partials/micro_step_card.html",
+            {"request": request, "step": step},
+        )
+        html_parts.append(rendered.body.decode())
+    return HTMLResponse("".join(html_parts))
+
+
+@app.delete("/subjects/{subject_id}", response_class=HTMLResponse)
+async def park_subject(subject_id: int, db: Session = Depends(get_db)):
+    subject = db.query(Subject).filter(Subject.id == subject_id).first()
+    if subject:
+        subject.is_parked = True
+        subject.is_active = False
+        db.commit()
+    return HTMLResponse("")
+
+
+@app.post("/steps/{step_id}/complete", response_class=HTMLResponse)
+async def complete_step(step_id: int, request: Request, db: Session = Depends(get_db)):
+    step = db.query(MicroStep).filter(MicroStep.id == step_id).first()
+    if step:
+        step.status = MicroStepStatus.completed
+        db.commit()
+        open_session = _get_current_session(db)
+        if open_session:
+            open_session.steps_completed += 1
+            db.commit()
+    # Return next pending step
+    next_step = _next_micro_step(db)
+    if next_step:
+        return templates.TemplateResponse(
+            "partials/micro_step_card.html",
+            {"request": request, "step": next_step},
+        )
+    return HTMLResponse('<p class="buddy-message">Super! Keine weiteren Steps gerade. Goennung verdient.</p>')
+
+
+@app.post("/steps/{step_id}/skip", response_class=HTMLResponse)
+async def skip_step(step_id: int, request: Request, db: Session = Depends(get_db)):
+    step = db.query(MicroStep).filter(MicroStep.id == step_id).first()
+    if step:
+        step.status = MicroStepStatus.skipped
+        db.commit()
+    next_step = _next_micro_step(db)
+    if next_step:
+        buddy_msg = '<p class="buddy-skip-msg">Kein Stress, machen wir anders.</p>'
+        card = templates.TemplateResponse(
+            "partials/micro_step_card.html",
+            {"request": request, "step": next_step},
+        )
+        return HTMLResponse(buddy_msg + card.body.decode())
+    return HTMLResponse('<p class="buddy-message">Alles verschoben fuer jetzt — kein Stress.</p>')
+
+
+@app.get("/steps/next", response_class=HTMLResponse)
+async def next_step_partial(request: Request, db: Session = Depends(get_db)):
+    step = _next_micro_step(db)
+    if step:
+        return templates.TemplateResponse(
+            "partials/micro_step_card.html",
+            {"request": request, "step": step},
+        )
+    return HTMLResponse('<p class="buddy-message">Keine offenen Steps. Gut gemacht.</p>')
+
+
+# ── session endpoints ──────────────────────────────────────────────────────
+
+@app.get("/session/current", response_class=HTMLResponse)
+async def session_current(request: Request, db: Session = Depends(get_db)):
+    _expire_stale_sessions(db)
+    last_session = _get_last_ended_session(db)
+    next_step = _next_micro_step(db)
+    return templates.TemplateResponse(
+        "partials/session_banner.html",
+        {"request": request, "last_session": last_session, "next_step": next_step},
+    )
+
+
+@app.get("/session/history", response_class=HTMLResponse)
+async def session_history(request: Request, db: Session = Depends(get_db)):
+    sessions = (
+        db.query(StudySession)
+        .filter(StudySession.ended_at != None)  # noqa: E711
+        .order_by(StudySession.ended_at.desc())
+        .limit(5)
+        .all()
+    )
+    return templates.TemplateResponse(
+        "partials/progress_journey.html",
+        {"request": request, "sessions": sessions},
+    )
+
+
+@app.post("/session/start", response_class=HTMLResponse)
+async def session_start(
+    request: Request,
+    subject_id: int = Form(...),
+    db: Session = Depends(get_db),
+):
+    _expire_stale_sessions(db)
+    existing = _get_current_session(db)
+    if existing and existing.subject_id == subject_id:
+        return HTMLResponse("")  # already open
+    session = StudySession(subject_id=subject_id)
+    db.add(session)
+    db.commit()
+    return HTMLResponse("")
+
+
+@app.post("/session/end", response_class=HTMLResponse)
+async def session_end(db: Session = Depends(get_db)):
+    open_session = _get_current_session(db)
+    if open_session:
+        open_session.ended_at = _utcnow()
+        db.commit()
+    return HTMLResponse("")
+
+
+# ── Elastic Plan + Panic Mode ───────────────────────────────────────────────
+
+def is_panic_mode(deadline: Deadline) -> bool:
+    """True when fewer than 48 hours remain or deadline is overdue."""
+    return (deadline.due_date - _utcnow()).total_seconds() < 48 * 3600
+
+
+def is_overdue(deadline: Deadline) -> bool:
+    """True when the deadline is in the past."""
+    return deadline.due_date < _utcnow()
+
+
+def _deadline_steps(db: Session, deadline_id: int):
+    """All non-skipped steps ordered by position."""
+    return (
+        db.query(MicroStep)
+        .filter(
+            MicroStep.deadline_id == deadline_id,
+            MicroStep.status != MicroStepStatus.skipped,
+        )
+        .order_by(MicroStep.order_num)
+        .all()
+    )
+
+
+def _should_auto_compress(deadline: Deadline, pending_count: int) -> bool:
+    """True when pending steps take longer than remaining time (with 20% buffer).
+    Overdue deadlines with pending steps always trigger a replan.
+    """
+    hours_left = (deadline.due_date - _utcnow()).total_seconds() / 3600
+    if hours_left <= 0:
+        return pending_count > 0  # overdue with pending steps → always compress
+    return pending_count * 5 > hours_left * 60 * 0.8
+
+
+@app.get("/deadlines/{deadline_id}/plan", response_class=HTMLResponse)
+async def deadline_plan(deadline_id: int, request: Request, db: Session = Depends(get_db)):
+    deadline = db.query(Deadline).filter(Deadline.id == deadline_id).first()
+    if not deadline:
+        return HTMLResponse('<p class="buddy-warning">Deadline nicht gefunden.</p>')
+
+    steps = _deadline_steps(db, deadline_id)
+    pending = [s for s in steps if s.status == MicroStepStatus.pending]
+    buddy_message = None
+
+    # Auto-compress when pending steps exceed available time
+    if pending and _should_auto_compress(deadline, len(pending)):
+        hours_until_due = (deadline.due_date - _utcnow()).total_seconds() / 3600
+        try:
+            new_steps_data = await generate_micro_steps(
+                deadline.title,
+                deadline.description or "",
+                deadline.due_date,
+                hours_until_due,
+            )
+            db.query(MicroStep).filter(
+                MicroStep.deadline_id == deadline_id,
+                MicroStep.status == MicroStepStatus.pending,
+            ).delete(synchronize_session=False)
+            db.commit()
+            completed_count = db.query(MicroStep).filter(
+                MicroStep.deadline_id == deadline_id,
+                MicroStep.status == MicroStepStatus.completed,
+            ).count()
+            for i, s in enumerate(new_steps_data):
+                db.add(MicroStep(
+                    deadline_id=deadline_id,
+                    title=s["title"],
+                    context=s.get("context", ""),
+                    order_num=completed_count + i,
+                    duration_minutes=s.get("duration_minutes", 5),
+                ))
+            db.commit()
+            steps = _deadline_steps(db, deadline_id)
+            buddy_message = "Ich hab den Plan etwas gestrafft — passt besser zur verbleibenden Zeit."
+        except Exception:
+            pass
+
+    return templates.TemplateResponse(
+        "partials/elastic_plan.html",
+        {
+            "request": request,
+            "deadline": deadline,
+            "steps": steps,
+            "buddy_message": buddy_message,
+            "now": _utcnow(),
+        },
+    )
+
+
+@app.post("/deadlines/{deadline_id}/replan", response_class=HTMLResponse)
+async def replan_deadline(deadline_id: int, request: Request, db: Session = Depends(get_db)):
+    deadline = db.query(Deadline).filter(Deadline.id == deadline_id).first()
+    if not deadline:
+        return HTMLResponse('<p class="buddy-warning">Deadline nicht gefunden.</p>')
+
+    hours_until_due = (deadline.due_date - _utcnow()).total_seconds() / 3600
+
+    # Remove skipped + pending; keep completed
+    db.query(MicroStep).filter(
+        MicroStep.deadline_id == deadline_id,
+        MicroStep.status.in_([MicroStepStatus.pending, MicroStepStatus.skipped]),
+    ).delete(synchronize_session=False)
+    db.commit()
+
+    new_steps_data = await generate_micro_steps(
+        deadline.title,
+        deadline.description or "",
+        deadline.due_date,
+        hours_until_due,
+    )
+
+    completed_count = db.query(MicroStep).filter(
+        MicroStep.deadline_id == deadline_id,
+        MicroStep.status == MicroStepStatus.completed,
+    ).count()
+
+    for i, s in enumerate(new_steps_data):
+        db.add(MicroStep(
+            deadline_id=deadline_id,
+            title=s["title"],
+            context=s.get("context", ""),
+            order_num=completed_count + i,
+            duration_minutes=s.get("duration_minutes", 5),
+        ))
+    db.commit()
+
+    steps = _deadline_steps(db, deadline_id)
+    return templates.TemplateResponse(
+        "partials/elastic_plan.html",
+        {
+            "request": request,
+            "deadline": deadline,
+            "steps": steps,
+            "buddy_message": "Plan angepasst! Hier ist dein neuer Fahrplan.",
+            "now": _utcnow(),
+        },
+    )

models.py

@@ -0,0 +1,70 @@
+import enum
+from datetime import datetime, timezone
+
+from sqlalchemy import Boolean, Column, DateTime, Enum, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import relationship
+
+from database import Base
+
+
+class MicroStepStatus(enum.Enum):
+    pending = "pending"
+    in_progress = "in_progress"
+    completed = "completed"
+    skipped = "skipped"
+
+
+class Subject(Base):
+    __tablename__ = "subjects"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(200), nullable=False)
+    semester = Column(String(50))
+    is_active = Column(Boolean, default=True)
+    is_parked = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc).replace(tzinfo=None))
+
+    deadlines = relationship("Deadline", back_populates="subject", cascade="all, delete-orphan")
+    study_sessions = relationship("StudySession", back_populates="subject", cascade="all, delete-orphan")
+
+
+class Deadline(Base):
+    __tablename__ = "deadlines"
+
+    id = Column(Integer, primary_key=True, index=True)
+    subject_id = Column(Integer, ForeignKey("subjects.id"), nullable=False)
+    title = Column(String(200), nullable=False)
+    description = Column(Text)
+    due_date = Column(DateTime, nullable=False)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc).replace(tzinfo=None))
+
+    subject = relationship("Subject", back_populates="deadlines")
+    micro_steps = relationship("MicroStep", back_populates="deadline", cascade="all, delete-orphan")
+
+
+class MicroStep(Base):
+    __tablename__ = "micro_steps"
+
+    id = Column(Integer, primary_key=True, index=True)
+    deadline_id = Column(Integer, ForeignKey("deadlines.id"), nullable=False)
+    title = Column(String(300), nullable=False)
+    context = Column(Text)  # what exactly to do — fresh-start framing
+    order_num = Column(Integer, default=0)
+    duration_minutes = Column(Integer, default=5)
+    status = Column(Enum(MicroStepStatus), default=MicroStepStatus.pending)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc).replace(tzinfo=None))
+
+    deadline = relationship("Deadline", back_populates="micro_steps")
+
+
+class StudySession(Base):
+    __tablename__ = "study_sessions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    subject_id = Column(Integer, ForeignKey("subjects.id"), nullable=False)
+    started_at = Column(DateTime, default=lambda: datetime.now(timezone.utc).replace(tzinfo=None))
+    ended_at = Column(DateTime)
+    steps_completed = Column(Integer, default=0)
+    notes = Column(Text)
+
+    subject = relationship("Subject", back_populates="study_sessions")

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.135.1
+uvicorn[standard]==0.41.0
+sqlalchemy==2.0.48
+jinja2==3.1.6
+python-multipart==0.0.22
+httpx==0.28.1
+python-dotenv==1.2.2
+pytest==9.0.2
+playwright
+pytest-playwright

static/style.css

@@ -0,0 +1,444 @@
+/* CSS Variables — warm ADHS-friendly palette */
+:root {
+    --bg: #faf7f5;
+    --bg-card: #ffffff;
+    --bg-card-hover: #f5f1ee;
+    --text-primary: #2c2420;
+    --text-secondary: #7a6a62;
+    --text-muted: #b0a09a;
+    --accent-warm: #c97d4e;
+    --accent-soft: #e8c4a0;
+    --accent-green: #6a9e7a;
+    --accent-amber: #d4a843;
+    --accent-panic: #c97d4e;
+    --border: #e8e0da;
+    --border-card: #ede6e0;
+    --radius: 12px;
+    --radius-sm: 8px;
+    --shadow: 0 2px 8px rgba(44, 36, 32, 0.06);
+    --shadow-card: 0 4px 16px rgba(44, 36, 32, 0.08);
+    --font-serif: 'Instrument Serif', Georgia, serif;
+    --font-mono: 'JetBrains Mono', 'Courier New', monospace;
+}
+
+/* Reset + Base */
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+    font-family: var(--font-mono);
+    background: var(--bg);
+    color: var(--text-primary);
+    font-size: 15px;
+    line-height: 1.6;
+    min-height: 100vh;
+}
+
+/* App Shell */
+.app-shell {
+    max-width: 780px;
+    margin: 0 auto;
+    padding: 0 1.5rem 4rem;
+}
+
+/* Header */
+.app-header {
+    padding: 2rem 0 1rem;
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 1.5rem;
+}
+.header-inner { display: flex; align-items: baseline; gap: 1rem; }
+.logo {
+    font-family: var(--font-serif);
+    font-size: 1.8rem;
+    color: var(--text-primary);
+    font-style: italic;
+}
+.header-sub {
+    font-size: 0.8rem;
+    color: var(--text-muted);
+    letter-spacing: 0.04em;
+}
+
+/* Buddy Area */
+.buddy-area {
+    margin-bottom: 1.5rem;
+}
+.buddy-message {
+    background: linear-gradient(135deg, #fff8f0, #fef3e8);
+    border: 1px solid var(--accent-soft);
+    border-radius: var(--radius);
+    padding: 1rem 1.25rem;
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+    line-height: 1.5;
+}
+.buddy-warning {
+    background: #fff8ec;
+    border: 1px solid var(--accent-amber);
+    border-radius: var(--radius-sm);
+    padding: 0.75rem 1rem;
+    font-size: 0.85rem;
+    color: #8a6010;
+    margin-top: 0.75rem;
+}
+
+/* Sections */
+.section {
+    margin-bottom: 2.5rem;
+}
+.section-title {
+    font-family: var(--font-serif);
+    font-size: 1.3rem;
+    font-weight: normal;
+    color: var(--text-primary);
+    margin-bottom: 1rem;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+.wip-badge {
+    font-family: var(--font-mono);
+    font-size: 0.75rem;
+    background: var(--border);
+    color: var(--text-secondary);
+    padding: 0.15rem 0.5rem;
+    border-radius: 999px;
+}
+
+/* Subject Cards */
+.subjects-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+    gap: 1rem;
+    margin-bottom: 1rem;
+}
+.subject-card {
+    background: var(--bg-card);
+    border: 1px solid var(--border-card);
+    border-radius: var(--radius);
+    padding: 1.25rem;
+    box-shadow: var(--shadow);
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    transition: box-shadow 0.15s;
+}
+.subject-card:hover { box-shadow: var(--shadow-card); }
+.subject-card-header { display: flex; flex-direction: column; gap: 0.25rem; }
+.subject-name { font-weight: 500; font-size: 1rem; }
+.subject-semester { font-size: 0.75rem; color: var(--text-muted); }
+
+/* Micro-Step Card — THE key UI element */
+.micro-step-card {
+    background: var(--bg-card);
+    border: 1.5px solid var(--accent-soft);
+    border-radius: var(--radius);
+    padding: 1.75rem;
+    box-shadow: var(--shadow-card);
+    position: relative;
+    max-width: 520px;
+}
+.step-fresh-tag {
+    display: inline-block;
+    font-size: 0.7rem;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    color: var(--accent-warm);
+    background: #fff4eb;
+    border: 1px solid var(--accent-soft);
+    border-radius: 999px;
+    padding: 0.2rem 0.75rem;
+    margin-bottom: 0.75rem;
+}
+.step-title {
+    font-family: var(--font-serif);
+    font-size: 1.4rem;
+    font-weight: normal;
+    font-style: italic;
+    color: var(--text-primary);
+    margin-bottom: 0.5rem;
+    line-height: 1.3;
+}
+.step-context {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    margin-bottom: 1rem;
+    line-height: 1.6;
+}
+.step-meta {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 1.25rem;
+    font-size: 0.78rem;
+    color: var(--text-muted);
+}
+.step-duration::before { content: "⏱ "; }
+.step-actions { display: flex; gap: 0.75rem; flex-wrap: wrap; }
+
+/* Deadline Items */
+.deadlines-list { display: flex; flex-direction: column; gap: 0.5rem; margin-bottom: 1rem; }
+.deadline-item {
+    background: var(--bg-card);
+    border: 1px solid var(--border-card);
+    border-radius: var(--radius-sm);
+    padding: 0.875rem 1.1rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 1rem;
+}
+.deadline-panic {
+    border-color: var(--accent-panic);
+    background: #fff9f5;
+}
+.deadline-main { display: flex; flex-direction: column; gap: 0.15rem; }
+.deadline-title { font-size: 0.9rem; font-weight: 500; }
+.deadline-subject { font-size: 0.75rem; color: var(--text-muted); }
+.deadline-date { font-size: 0.8rem; color: var(--text-secondary); }
+.badge-panic {
+    font-size: 0.75rem;
+    background: var(--accent-panic);
+    color: white;
+    padding: 0.2rem 0.6rem;
+    border-radius: 999px;
+}
+.empty-hint { font-size: 0.85rem; color: var(--text-muted); font-style: italic; }
+
+/* Forms */
+.inline-form {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.6rem;
+    align-items: flex-start;
+    margin-top: 1rem;
+    padding: 1rem;
+    background: var(--bg-card);
+    border: 1px dashed var(--border);
+    border-radius: var(--radius-sm);
+}
+.deadline-form { flex-direction: column; }
+.input-field {
+    font-family: var(--font-mono);
+    font-size: 0.85rem;
+    padding: 0.55rem 0.85rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    background: var(--bg);
+    color: var(--text-primary);
+    outline: none;
+    transition: border-color 0.15s;
+    flex: 1;
+    min-width: 160px;
+}
+.input-field:focus { border-color: var(--accent-warm); }
+.input-small { max-width: 140px; flex: none; }
+.input-textarea { min-height: 60px; resize: vertical; width: 100%; }
+
+/* Buttons */
+.btn {
+    font-family: var(--font-mono);
+    font-size: 0.85rem;
+    padding: 0.55rem 1.1rem;
+    border-radius: var(--radius-sm);
+    border: none;
+    cursor: pointer;
+    transition: opacity 0.15s, background 0.15s;
+    white-space: nowrap;
+}
+.btn:hover { opacity: 0.85; }
+.btn-primary {
+    background: var(--accent-warm);
+    color: white;
+}
+.btn-secondary {
+    background: var(--accent-green);
+    color: white;
+}
+.btn-ghost {
+    background: transparent;
+    border: 1px solid var(--border);
+    color: var(--text-secondary);
+}
+.btn-small { font-size: 0.78rem; padding: 0.35rem 0.75rem; }
+
+/* ── Deadline mini progress bar ─────────────────────────────────────────── */
+.deadline-title-row { display: flex; align-items: center; gap: 0.5rem; flex-wrap: wrap; }
+.badge-endspurt {
+    font-size: 0.7rem;
+    font-weight: 600;
+    letter-spacing: 0.04em;
+    background: var(--accent-amber);
+    color: #5a3a00;
+    padding: 0.15rem 0.55rem;
+    border-radius: 999px;
+}
+.deadline-date--panic { color: var(--accent-amber); font-weight: 600; }
+.deadline-mini-progress {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-top: 0.35rem;
+}
+.mini-progress-track {
+    flex: 1;
+    height: 4px;
+    background: var(--border);
+    border-radius: 999px;
+    overflow: hidden;
+    min-width: 60px;
+}
+.mini-progress-fill {
+    height: 100%;
+    background: var(--accent-green);
+    border-radius: 999px;
+    transition: width 0.3s ease;
+}
+.mini-progress-fill--panic { background: var(--accent-amber); }
+.mini-progress-label { font-size: 0.72rem; color: var(--text-muted); white-space: nowrap; }
+
+/* ── Elastic Plan ────────────────────────────────────────────────────────── */
+.elastic-plan {
+    background: var(--bg-card);
+    border: 1px solid var(--border-card);
+    border-radius: var(--radius);
+    padding: 1.5rem;
+    box-shadow: var(--shadow-card);
+    margin-bottom: 1.5rem;
+}
+.elastic-plan--panic {
+    border-color: var(--accent-amber);
+    background: linear-gradient(135deg, #fffcf0, #fff8e0);
+}
+.plan-header { margin-bottom: 1.25rem; }
+.plan-title-row {
+    display: flex;
+    align-items: baseline;
+    gap: 0.75rem;
+    flex-wrap: wrap;
+    margin-bottom: 0.5rem;
+}
+.plan-title {
+    font-family: var(--font-serif);
+    font-size: 1.4rem;
+    font-weight: normal;
+    font-style: italic;
+}
+.plan-subject { font-size: 0.8rem; color: var(--text-muted); }
+.plan-time-bar { margin-bottom: 0.75rem; }
+.time-badge {
+    display: inline-block;
+    font-size: 0.78rem;
+    background: var(--border);
+    color: var(--text-secondary);
+    padding: 0.2rem 0.65rem;
+    border-radius: 999px;
+}
+.time-badge--panic {
+    background: var(--accent-amber);
+    color: #5a3a00;
+    font-weight: 600;
+}
+.time-badge--soon { background: #f0f7ee; color: var(--accent-green); }
+.plan-buddy {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    padding: 0.75rem 1rem;
+    background: #faf7f5;
+    border-radius: var(--radius-sm);
+    border-left: 3px solid var(--accent-soft);
+}
+.plan-buddy--panic { border-left-color: var(--accent-amber); background: #fffbf0; }
+
+/* Progress bar */
+.plan-progress {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    margin-bottom: 1.5rem;
+}
+.progress-track {
+    flex: 1;
+    height: 6px;
+    background: var(--border);
+    border-radius: 999px;
+    overflow: hidden;
+}
+.progress-fill {
+    height: 100%;
+    background: var(--accent-green);
+    border-radius: 999px;
+    transition: width 0.4s ease;
+}
+.progress-label { font-size: 0.78rem; color: var(--text-muted); white-space: nowrap; }
+
+/* Timeline */
+.plan-timeline { display: flex; flex-direction: column; gap: 0; margin-bottom: 1.5rem; }
+.timeline-step {
+    display: flex;
+    gap: 1rem;
+    position: relative;
+    padding-bottom: 1.25rem;
+}
+.timeline-step:last-child { padding-bottom: 0; }
+.timeline-step::before {
+    content: '';
+    position: absolute;
+    left: 7px;
+    top: 16px;
+    bottom: 0;
+    width: 2px;
+    background: var(--border);
+}
+.timeline-step:last-child::before { display: none; }
+.timeline-dot {
+    width: 16px;
+    height: 16px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    margin-top: 2px;
+    position: relative;
+    z-index: 1;
+}
+.timeline-dot--done {
+    background: var(--accent-green);
+    opacity: 0.5;
+}
+.timeline-dot--active {
+    background: var(--accent-warm);
+    box-shadow: 0 0 0 3px rgba(201,125,78,0.15);
+}
+.timeline-dot--panic {
+    background: var(--accent-amber);
+    box-shadow: 0 0 0 3px rgba(212,168,67,0.2);
+}
+.timeline-content { flex: 1; }
+.timeline-content--done { opacity: 0.5; }
+.timeline-title {
+    display: block;
+    font-size: 0.9rem;
+    font-weight: 500;
+    margin-bottom: 0.2rem;
+}
+.timeline-context {
+    display: block;
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+    margin-bottom: 0.25rem;
+    line-height: 1.5;
+}
+.timeline-duration { font-size: 0.72rem; color: var(--text-muted); }
+
+/* Plan actions */
+.plan-actions { display: flex; gap: 0.75rem; flex-wrap: wrap; }
+
+/* Buddy skip message */
+.buddy-skip-msg {
+    font-size: 0.82rem;
+    color: var(--text-secondary);
+    font-style: italic;
+    margin-bottom: 0.75rem;
+    padding: 0.5rem 0.75rem;
+    background: #faf7f5;
+    border-radius: var(--radius-sm);
+    border-left: 2px solid var(--accent-soft);
+}

templates/base.html

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}Study Buddy{% endblock %}</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="/static/style.css">
+    <script src="https://unpkg.com/htmx.org@1.9.12"></script>
+</head>
+<body>
+    <div class="app-shell">
+        <header class="app-header">
+            <div class="header-inner">
+                <span class="logo">Study Buddy</span>
+                <span class="header-sub">Dein ADHS-Lernbegleiter</span>
+            </div>
+        </header>
+
+        <div id="buddy-area" class="buddy-area">
+            {% block buddy_message %}{% endblock %}
+        </div>
+
+        <main class="main-content">
+            {% block content %}{% endblock %}
+        </main>
+    </div>
+</body>
+</html>

templates/index.html

@@ -0,0 +1,107 @@
+{% extends "base.html" %}
+
+{% block title %}Dashboard — Study Buddy{% endblock %}
+
+{% block buddy_message %}
+<div class="buddy-message">
+    {% if active_subjects %}
+        Hey! Du bist wieder da. {{ active_subjects|length }} Fach{% if active_subjects|length > 1 %}er{% endif %} aktiv.
+        {% if next_step %}
+            Dein naechster Schritt wartet schon.
+        {% else %}
+            Keine offenen Steps — vielleicht eine neue Deadline eintragen?
+        {% endif %}
+    {% else %}
+        Willkommen! Trag dein erstes Fach ein und leg los. Keine Hektik.
+    {% endif %}
+</div>
+
+<div hx-get="/session/current" hx-trigger="load" hx-swap="outerHTML"></div>
+{% endblock %}
+
+{% block content %}
+
+<!-- WIP Warning placeholder -->
+<div id="wip-warning"></div>
+
+<!-- Active Subjects + Next Step -->
+<section class="section">
+    <h2 class="section-title">Aktive Faecher <span class="wip-badge">{{ active_subjects|length }}/2</span></h2>
+
+    <div id="subjects-list" class="subjects-grid">
+        {% for subject in active_subjects %}
+            {% include "partials/subject_card.html" %}
+        {% endfor %}
+    </div>
+
+    <!-- Add Subject Form -->
+    {% if active_subjects|length < 2 %}
+    <form hx-post="/subjects"
+          hx-target="#subjects-list"
+          hx-swap="beforeend"
+          class="inline-form">
+        <input type="text" name="name" placeholder="Fach (z.B. Mathe, OS, BWL)" required class="input-field">
+        <input type="text" name="semester" placeholder="Semester (optional)" class="input-field input-small">
+        <button type="submit" class="btn btn-primary">+ Fach hinzufuegen</button>
+    </form>
+    {% else %}
+    <div class="buddy-warning">
+        WIP-Limit erreicht (2/2). Parkiere ein Fach um ein neues hinzuzufuegen.
+    </div>
+    {% endif %}
+</section>
+
+<!-- Next Micro-Step -->
+{% if next_step %}
+<section class="section">
+    <h2 class="section-title">Jetzt anfangen</h2>
+    <div id="current-step">
+        {% include "partials/micro_step_card.html" with context %}
+    </div>
+</section>
+{% endif %}
+
+<!-- Plan Area (htmx target for elastic plan view) -->
+<div id="plan-area"></div>
+
+<!-- Upcoming Deadlines -->
+<section class="section">
+    <h2 class="section-title">Naechste Deadlines</h2>
+
+    <div id="deadlines-list" class="deadlines-list">
+        {% for deadline in upcoming_deadlines %}
+            {% set dl = deadline %}
+            {% include "partials/deadline_item.html" %}
+        {% endfor %}
+        {% if not upcoming_deadlines %}
+            <p class="empty-hint">Noch keine Deadlines — trag eine ein bevor der Stress kommt.</p>
+        {% endif %}
+    </div>
+
+    <!-- Add Deadline Form -->
+    {% if active_subjects %}
+    <form hx-post="/deadlines"
+          hx-target="#deadlines-list"
+          hx-swap="beforeend"
+          class="inline-form deadline-form">
+        <select name="subject_id" required class="input-field">
+            <option value="">Fach waehlen...</option>
+            {% for subject in active_subjects %}
+            <option value="{{ subject.id }}">{{ subject.name }}</option>
+            {% endfor %}
+        </select>
+        <input type="text" name="title" placeholder="Aufgabe (z.B. Klausur, Abgabe)" required class="input-field">
+        <input type="datetime-local" name="due_date" required class="input-field">
+        <textarea name="description" placeholder="Details (optional)" class="input-field input-textarea"></textarea>
+        <button type="submit" class="btn btn-secondary">Deadline eintragen</button>
+    </form>
+    {% endif %}
+</section>
+
+<!-- Session History / Progress Journey -->
+<section class="section">
+    <h2 class="section-title">Deine Lernreise</h2>
+    <div hx-get="/session/history" hx-trigger="load" hx-swap="innerHTML"></div>
+</section>
+
+{% endblock %}

templates/partials/deadline_item.html

@@ -0,0 +1,41 @@
+{% set deadline = dl if dl is defined else deadline %}
+{% set hours_left = ((deadline.due_date - now).total_seconds() / 3600) | int %}
+{% set is_overdue = hours_left < 0 %}
+{% set is_panic = hours_left < 48 %}
+{% set stats = deadline_stats[deadline.id] if deadline_stats is defined and deadline.id in deadline_stats else none %}
+<div class="deadline-item {% if is_overdue %}deadline-overdue{% elif is_panic %}deadline-panic{% endif %}" id="deadline-{{ deadline.id }}">
+    <div class="deadline-main">
+        <div class="deadline-title-row">
+            <span class="deadline-title">{{ deadline.title }}</span>
+            {% if is_overdue %}
+                <span class="deadline-badge badge-overdue">Ueberfaellig!</span>
+            {% elif is_panic %}
+                <span class="deadline-badge badge-endspurt">Endspurt!</span>
+            {% endif %}
+        </div>
+        <span class="deadline-subject">{{ deadline.subject.name }}</span>
+        {% if stats and stats.total > 0 %}
+        <div class="deadline-mini-progress">
+            <div class="mini-progress-track">
+                <div class="mini-progress-fill {% if is_panic %}mini-progress-fill--panic{% endif %}"
+                     style="width: {{ stats.pct }}%"></div>
+            </div>
+            <span class="mini-progress-label">{{ stats.completed }}/{{ stats.total }}</span>
+        </div>
+        {% endif %}
+    </div>
+    <div class="deadline-meta">
+        {% if is_overdue %}
+            <span class="deadline-date deadline-date--overdue">Seit {{ (hours_left * -1) }}h ueberfaellig</span>
+        {% elif is_panic %}
+            <span class="deadline-date deadline-date--panic">{{ hours_left }}h</span>
+        {% else %}
+            <span class="deadline-date">{{ deadline.due_date.strftime('%d.%m. %H:%M') }}</span>
+        {% endif %}
+        <a href="/deadlines/{{ deadline.id }}/plan"
+           hx-get="/deadlines/{{ deadline.id }}/plan"
+           hx-target="#plan-area"
+           hx-swap="innerHTML"
+           class="btn btn-ghost btn-small">Plan</a>
+    </div>
+</div>

templates/partials/elastic_plan.html

@@ -0,0 +1,104 @@
+{% set hours_left = ((deadline.due_date - now).total_seconds() / 3600) %}
+{% set overdue = hours_left < 0 %}
+{% set panic = hours_left < 48 %}
+{% set total = steps|length %}
+{% set completed_count = steps | selectattr('status', 'equalto', 'completed') | list | length %}
+{% set pending_steps = steps | selectattr('status', 'equalto', 'pending') | list %}
+{% set pending_count = pending_steps | length %}
+{% set progress_pct = ((completed_count / total * 100) | int) if total > 0 else 0 %}
+
+<div class="elastic-plan {% if panic %}elastic-plan--panic{% endif %}" id="plan-{{ deadline.id }}">
+
+    <!-- Header -->
+    <div class="plan-header">
+        <div class="plan-title-row">
+            <h2 class="plan-title">{{ deadline.title }}</h2>
+            <span class="plan-subject">{{ deadline.subject.name }}</span>
+        </div>
+
+        <!-- Time bar -->
+        <div class="plan-time-bar">
+            {% if overdue %}
+                <span class="time-badge time-badge--overdue">Ueberfaellig! Seit {{ (hours_left * -1) | int }}h</span>
+            {% elif panic %}
+                <span class="time-badge time-badge--panic">Endspurt! {{ hours_left | int }}h verbleibend</span>
+            {% elif hours_left < 168 %}
+                <span class="time-badge time-badge--soon">{{ hours_left | int }}h verbleibend</span>
+            {% else %}
+                <span class="time-badge">{{ deadline.due_date.strftime('%d.%m.%Y') }}</span>
+            {% endif %}
+        </div>
+
+        <!-- Buddy message -->
+        <div class="plan-buddy {% if panic %}plan-buddy--panic{% endif %}">
+            {% if buddy_message %}
+                {{ buddy_message }}
+            {% elif overdue %}
+                Die Deadline ist vorbei, aber offene Steps sind noch da. Abarbeiten oder Deadline loeschen?
+            {% elif panic %}
+                Du hast noch {{ hours_left | int }}h. Hier sind die wichtigsten Schritte — eins nach dem anderen. Du schaffst das.
+            {% elif completed_count > 0 %}
+                Super, du bist schon drin! {{ completed_count }} von {{ total }} Steps erledigt.
+            {% else %}
+                Hier ist dein Plan. Fang einfach mit dem ersten Schritt an.
+            {% endif %}
+        </div>
+    </div>
+
+    <!-- Progress bar -->
+    {% if total > 0 %}
+    <div class="plan-progress">
+        <div class="progress-track">
+            <div class="progress-fill" style="width: {{ progress_pct }}%"></div>
+        </div>
+        <span class="progress-label">{{ completed_count }}/{{ total }} erledigt</span>
+    </div>
+    {% endif %}
+
+    <!-- Timeline -->
+    <div class="plan-timeline">
+        {% for step in steps %}
+            {% if step.status.value == 'completed' %}
+            <div class="timeline-step timeline-step--done">
+                <div class="timeline-dot timeline-dot--done"></div>
+                <div class="timeline-content timeline-content--done">
+                    <span class="timeline-title">{{ step.title }}</span>
+                    <span class="timeline-duration">{{ step.duration_minutes }} Min</span>
+                </div>
+            </div>
+            {% elif step.status.value == 'pending' %}
+            <div class="timeline-step timeline-step--active">
+                <div class="timeline-dot timeline-dot--active {% if panic %}timeline-dot--panic{% endif %}"></div>
+                <div class="timeline-content">
+                    <span class="timeline-title">{{ step.title }}</span>
+                    {% if step.context %}
+                    <span class="timeline-context">{{ step.context }}</span>
+                    {% endif %}
+                    <span class="timeline-duration">{{ step.duration_minutes }} Min</span>
+                </div>
+            </div>
+            {% endif %}
+            {# skipped steps are intentionally omitted — no "Versagt" #}
+        {% endfor %}
+
+        {% if not steps %}
+        <p class="empty-hint">Noch keine Steps. Lass den Buddy einen Plan generieren!</p>
+        {% endif %}
+    </div>
+
+    <!-- Actions -->
+    <div class="plan-actions">
+        <button hx-post="/deadlines/{{ deadline.id }}/replan"
+                hx-target="#plan-{{ deadline.id }}"
+                hx-swap="outerHTML"
+                class="btn btn-secondary btn-small">
+            Plan anpassen
+        </button>
+        <button hx-post="/deadlines/{{ deadline.id }}/generate-steps"
+                hx-target="#plan-{{ deadline.id }}"
+                hx-swap="outerHTML"
+                class="btn btn-ghost btn-small">
+            Neu generieren
+        </button>
+    </div>
+</div>

templates/partials/micro_step_card.html

@@ -0,0 +1,28 @@
+{% set step = step if step is defined else next_step %}
+{% if step %}
+<div class="micro-step-card" id="step-{{ step.id }}">
+    <div class="step-fresh-tag">Frischer Start</div>
+    <h3 class="step-title">{{ step.title }}</h3>
+    {% if step.context %}
+    <p class="step-context">{{ step.context }}</p>
+    {% endif %}
+    <div class="step-meta">
+        <span class="step-duration">{{ step.duration_minutes }} Min</span>
+        <span class="step-subject">{{ step.deadline.subject.name }}</span>
+    </div>
+    <div class="step-actions">
+        <button hx-post="/steps/{{ step.id }}/complete"
+                hx-target="#current-step"
+                hx-swap="innerHTML"
+                class="btn btn-primary">
+            Geschafft!
+        </button>
+        <button hx-post="/steps/{{ step.id }}/skip"
+                hx-target="#current-step"
+                hx-swap="innerHTML"
+                class="btn btn-ghost">
+            Ueberspringen
+        </button>
+    </div>
+</div>
+{% endif %}

templates/partials/progress_journey.html

@@ -0,0 +1,30 @@
+{% if sessions %}
+<div class="progress-journey">
+    <h3 class="journey-title">Deine letzten Sessions</h3>
+    <div class="journey-timeline">
+        {% for session in sessions %}
+        <div class="journey-entry">
+            <div class="journey-dots">
+                {% for i in range(session.steps_completed) %}
+                    {% if loop.index <= 8 %}
+                    <span class="dot dot-done" title="Step {{ loop.index }} erledigt"></span>
+                    {% endif %}
+                {% endfor %}
+                {% if session.steps_completed > 8 %}
+                <span class="dot-overflow">+{{ session.steps_completed - 8 }}</span>
+                {% endif %}
+                {% if session.steps_completed == 0 %}
+                <span class="dot dot-empty"></span>
+                {% endif %}
+            </div>
+            <div class="journey-meta">
+                <span class="journey-subject">{{ session.subject.name if session.subject else "—" }}</span>
+                <span class="journey-date">{{ session.ended_at.strftime("%d.%m., %H:%M") if session.ended_at else "laufend" }}</span>
+            </div>
+        </div>
+        {% endfor %}
+    </div>
+</div>
+{% else %}
+<p class="empty-hint">Noch keine abgeschlossenen Sessions — fang einfach an.</p>
+{% endif %}

templates/partials/session_banner.html

@@ -0,0 +1,33 @@
+{% if last_session and last_session.subject %}
+<div class="session-banner" id="session-banner-card">
+    <div class="session-banner-inner">
+        <div class="session-banner-text">
+            <span class="session-banner-emoji">👋</span>
+            <div>
+                <strong>Schoen dass du wieder da bist!</strong>
+                <p class="session-banner-detail">
+                    Letzte Session: <em>{{ last_session.subject.name }}</em>
+                    {% if last_session.steps_completed > 0 %}
+                        — {{ last_session.steps_completed }} Step{% if last_session.steps_completed != 1 %}s{% endif %} geschafft
+                    {% endif %}
+                </p>
+            </div>
+        </div>
+        <div class="session-banner-actions">
+            {% if next_step %}
+            <button class="btn btn-primary btn-sm"
+                    hx-get="/steps/next"
+                    hx-target="#current-step"
+                    hx-swap="innerHTML"
+                    onclick="document.getElementById('session-banner-card').remove()">
+                Weitermachen
+            </button>
+            {% endif %}
+            <button class="btn btn-ghost btn-sm"
+                    onclick="document.getElementById('session-banner-card').remove()">
+                Neu starten
+            </button>
+        </div>
+    </div>
+</div>
+{% endif %}

templates/partials/subject_card.html

@@ -0,0 +1,17 @@
+<div class="subject-card" id="subject-{{ subject.id }}">
+    <div class="subject-card-header">
+        <span class="subject-name">{{ subject.name }}</span>
+        {% if subject.semester %}
+        <span class="subject-semester">{{ subject.semester }}</span>
+        {% endif %}
+    </div>
+    <div class="subject-card-actions">
+        <button hx-delete="/subjects/{{ subject.id }}"
+                hx-target="#subject-{{ subject.id }}"
+                hx-swap="outerHTML"
+                hx-confirm="'{{ subject.name }}' in die Parkzone?"
+                class="btn btn-ghost btn-small">
+            Pausieren
+        </button>
+    </div>
+</div>

tests/conftest.py

@@ -0,0 +1,14 @@
+"""Playwright E2E test configuration for StudyAgent."""
+import pytest
+
+BASE_URL = "http://localhost:8000"
+
+
+@pytest.fixture(scope="session")
+def base_url():
+    return BASE_URL
+
+
+@pytest.fixture(scope="session")
+def browser_context_args(browser_context_args):
+    return {**browser_context_args, "base_url": BASE_URL}

tests/test_e2e.py

@@ -0,0 +1,70 @@
+"""
+Playwright E2E tests for StudyAgent.
+
+Requires:
+  - Server running: cd ~/Projekte/StudyAgent && .venv/bin/uvicorn main:app --reload
+  - Browsers installed: playwright install chromium
+"""
+import pytest
+
+pw = pytest.importorskip("playwright")
+from playwright.sync_api import Page, expect
+
+
+def _add_subject(page: Page, name: str) -> None:
+    """Fill and submit the add-subject form via the visible input field."""
+    name_input = page.locator('input[name="name"]')
+    name_input.fill(name)
+    page.locator('button[type="submit"]:has-text("Fach hinzufuegen")').click()
+    # Wait for htmx to swap the new card into the DOM
+    page.wait_for_timeout(500)
+
+
+def test_dashboard_loads(page: Page, base_url: str) -> None:
+    """Dashboard returns 200 and renders the subjects section heading."""
+    response = page.goto(base_url)
+    assert response is not None and response.status == 200
+
+    # The section heading is always present on the page
+    expect(page.locator("text=Aktive Faecher")).to_be_visible()
+
+
+def test_add_subject_flow(page: Page, base_url: str) -> None:
+    """Adding a subject shows it on the page as a subject card."""
+    page.goto(base_url)
+
+    _add_subject(page, "Mathematik")
+
+    # The subject card renders the name inside .subject-name
+    expect(page.locator(".subject-name", has_text="Mathematik")).to_be_visible()
+
+
+def test_wip_limit_enforced(page: Page, base_url: str) -> None:
+    """A third subject is rejected with the WIP-limit buddy warning."""
+    page.goto(base_url)
+
+    # Add first two subjects — the form is rendered while < 2 active subjects
+    _add_subject(page, "Fach 1")
+
+    # After first add, reload so the template re-evaluates the condition and
+    # renders the form for the second subject
+    page.reload()
+    _add_subject(page, "Fach 2")
+
+    # Now the form is hidden by the template (WIP=2/2). Post the third subject
+    # directly via the API to trigger the server-side rejection message.
+    page.evaluate(
+        """async () => {
+            const body = new URLSearchParams({ name: 'Fach 3', semester: '' });
+            const resp = await fetch('/subjects', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: body.toString(),
+            });
+            const html = await resp.text();
+            document.getElementById('wip-warning').innerHTML = html;
+        }"""
+    )
+
+    # The rejection message contains "Parkiere"
+    expect(page.locator("#wip-warning")).to_contain_text("Parkiere")

tests/test_routes.py

@@ -0,0 +1,224 @@
+"""Basis-Tests fuer StudyAgent V1 — kritische Endpunkte."""
+
+import os
+import tempfile
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+# Ensure no API key so we get deterministic fallback steps
+os.environ.pop("MINIMAX_API_KEY", None)
+
+from database import Base, get_db  # noqa: E402
+from main import app, _utcnow, is_panic_mode, is_overdue, _should_auto_compress  # noqa: E402
+from models import Deadline, MicroStep, MicroStepStatus, Subject  # noqa: E402
+
+from datetime import timedelta  # noqa: E402
+
+
+@pytest.fixture()
+def db_session():
+    """In-memory SQLite DB per test."""
+    tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
+    tmp.close()
+    engine = create_engine(f"sqlite:///{tmp.name}", connect_args={"check_same_thread": False})
+    Base.metadata.create_all(bind=engine)
+    TestSession = sessionmaker(bind=engine)
+    session = TestSession()
+    try:
+        yield session
+    finally:
+        session.close()
+        os.unlink(tmp.name)
+
+
+@pytest.fixture()
+def client(db_session):
+    """TestClient with overridden DB dependency."""
+    def _override():
+        try:
+            yield db_session
+        finally:
+            pass
+    app.dependency_overrides[get_db] = _override
+    with TestClient(app) as c:
+        yield c
+    app.dependency_overrides.clear()
+
+
+@pytest.fixture()
+def seeded_db(db_session):
+    """DB with one subject, two deadlines (overdue + future), and steps."""
+    subj = Subject(name="Mathe", semester="3")
+    db_session.add(subj)
+    db_session.commit()
+    db_session.refresh(subj)
+
+    # Overdue deadline
+    dl_past = Deadline(
+        subject_id=subj.id,
+        title="Klausur Lineare Algebra",
+        due_date=_utcnow() - timedelta(hours=48),
+    )
+    # Future deadline (within 48h = panic)
+    dl_future = Deadline(
+        subject_id=subj.id,
+        title="Klausur Analysis",
+        due_date=_utcnow() + timedelta(hours=24),
+    )
+    db_session.add_all([dl_past, dl_future])
+    db_session.commit()
+    db_session.refresh(dl_past)
+    db_session.refresh(dl_future)
+
+    # Steps for both
+    for dl in [dl_past, dl_future]:
+        for i in range(3):
+            db_session.add(MicroStep(
+                deadline_id=dl.id,
+                title=f"Step {i+1} fuer {dl.title}",
+                order_num=i,
+                duration_minutes=5,
+            ))
+    db_session.commit()
+    return {"subject": subj, "dl_past": dl_past, "dl_future": dl_future}
+
+
+# ── Dashboard ──
+
+def test_dashboard_returns_200(client, seeded_db):
+    resp = client.get("/")
+    assert resp.status_code == 200
+    assert "Mathe" in resp.text
+
+
+def test_dashboard_shows_overdue_badge(client, seeded_db):
+    resp = client.get("/")
+    assert "Ueberfaellig" in resp.text
+
+
+# ── WIP-Limit ──
+
+def test_wip_limit_allows_second_subject(client, seeded_db):
+    resp = client.post("/subjects", data={"name": "Physik", "semester": "2"})
+    assert resp.status_code == 200
+    assert "Physik" in resp.text
+
+
+def test_wip_limit_rejects_third_subject(client, seeded_db):
+    client.post("/subjects", data={"name": "Physik", "semester": "2"})
+    resp = client.post("/subjects", data={"name": "Chemie", "semester": "1"})
+    assert resp.status_code == 200
+    assert "Parkiere" in resp.text
+    assert "Chemie" not in resp.text
+
+
+# ── Step Transitions ──
+
+def test_complete_step(client, seeded_db, db_session):
+    step = db_session.query(MicroStep).filter(MicroStep.status == MicroStepStatus.pending).first()
+    resp = client.post(f"/steps/{step.id}/complete")
+    assert resp.status_code == 200
+    db_session.refresh(step)
+    assert step.status == MicroStepStatus.completed
+
+
+def test_skip_step(client, seeded_db, db_session):
+    step = db_session.query(MicroStep).filter(MicroStep.status == MicroStepStatus.pending).first()
+    resp = client.post(f"/steps/{step.id}/skip")
+    assert resp.status_code == 200
+    db_session.refresh(step)
+    assert step.status == MicroStepStatus.skipped
+    assert "Kein Stress" in resp.text
+
+
+# ── Panic Mode / Overdue Detection ──
+
+def test_is_panic_mode_future_close(seeded_db):
+    assert is_panic_mode(seeded_db["dl_future"]) is True  # 24h < 48h
+
+
+def test_is_panic_mode_overdue(seeded_db):
+    assert is_panic_mode(seeded_db["dl_past"]) is True  # negative = still panic
+
+
+def test_is_overdue(seeded_db):
+    assert is_overdue(seeded_db["dl_past"]) is True
+    assert is_overdue(seeded_db["dl_future"]) is False
+
+
+# ── Auto-Compress ──
+
+def test_auto_compress_overdue_with_pending_steps(seeded_db):
+    """Overdue deadline with pending steps must trigger compression."""
+    assert _should_auto_compress(seeded_db["dl_past"], pending_count=3) is True
+
+
+def test_auto_compress_overdue_no_pending_steps(seeded_db):
+    """Overdue deadline with zero pending steps must NOT trigger compression."""
+    assert _should_auto_compress(seeded_db["dl_past"], pending_count=0) is False
+
+
+# ── Plan View ──
+
+def test_plan_view_overdue(client, seeded_db):
+    resp = client.get(f"/deadlines/{seeded_db['dl_past'].id}/plan")
+    assert resp.status_code == 200
+    assert "Ueberfaellig" in resp.text
+
+
+def test_plan_view_future(client, seeded_db):
+    resp = client.get(f"/deadlines/{seeded_db['dl_future'].id}/plan")
+    assert resp.status_code == 200
+    assert "Endspurt" in resp.text
+
+
+# ── Replan ──
+
+def test_replan_removes_pending_keeps_completed(client, seeded_db, db_session):
+    """Replan deletes pending+skipped steps, keeps completed, adds new ones."""
+    dl = seeded_db["dl_future"]
+
+    # Complete one step, skip another — only 1 pending should remain
+    steps = db_session.query(MicroStep).filter(
+        MicroStep.deadline_id == dl.id,
+    ).order_by(MicroStep.order_num).all()
+    steps[0].status = MicroStepStatus.completed
+    steps[1].status = MicroStepStatus.skipped
+    db_session.commit()
+
+    resp = client.post(f"/deadlines/{dl.id}/replan")
+    assert resp.status_code == 200
+    assert "Plan angepasst" in resp.text
+
+    # Reload steps from DB
+    db_session.expire_all()
+    remaining = db_session.query(MicroStep).filter(
+        MicroStep.deadline_id == dl.id,
+    ).order_by(MicroStep.order_num).all()
+
+    # 1 completed survives + new fallback steps (3 panic or 4 normal)
+    completed = [s for s in remaining if s.status == MicroStepStatus.completed]
+    pending = [s for s in remaining if s.status == MicroStepStatus.pending]
+    assert len(completed) == 1
+    assert len(pending) >= 3  # fallback generates 3-4 steps
+
+    # New steps order_num starts after completed count
+    assert pending[0].order_num == 1  # 1 completed = offset 1
+
+
+def test_replan_overdue_deadline(client, seeded_db, db_session):
+    """Replan works for overdue deadlines (negative hours_until_due)."""
+    dl = seeded_db["dl_past"]  # 48h in the past
+    resp = client.post(f"/deadlines/{dl.id}/replan")
+    assert resp.status_code == 200
+    assert "Plan angepasst" in resp.text
+
+
+def test_replan_nonexistent_deadline(client):
+    """Replan returns buddy warning for missing deadline."""
+    resp = client.post("/deadlines/99999/replan")
+    assert resp.status_code == 200
+    assert "nicht gefunden" in resp.text