From bd9df8ab8be44e3f52002c8230917bf31fd979112f3d3910b26ba0e1280e3628 Mon Sep 17 00:00:00 2001
From: wlfb <thomas.langer@destengs.com>
Date: Mon, 20 Jul 2026 11:13:21 +0200
Subject: [PATCH] docs: Implementierungsplan Ausbaustufe 5

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../plans/2026-07-20-ausbaustufe-5.md         | 1211 +++++++++++++++++
 1 file changed, 1211 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-07-20-ausbaustufe-5.md

diff --git a/docs/superpowers/plans/2026-07-20-ausbaustufe-5.md b/docs/superpowers/plans/2026-07-20-ausbaustufe-5.md
new file mode 100644
index 0000000..9d142da
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-20-ausbaustufe-5.md
@@ -0,0 +1,1211 @@
+# Ausbaustufe 5 Implementation Plan — Deutsche Formate, Posten-Bearbeitung, Szenario-Ende (v0.6.0)
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Deutsche Zahlenformate in der gesamten Web-GUI, Inline-Bearbeitung aller Planungs-Objekte inkl. Start/Ende bei Fixposten, Szenario-Modifikator-Art »Ende« plus szenario-eigene Einmalzahlungen; Release v0.6.0 mit Live-Demo-Szenario »Best Case«.
+
+**Architecture:** Anzeige-Formatierung als reine Funktionen in neuem Modul `app/formats.py` (Jinja-Filter `eur`/`de_label`, kein `locale`-Modul); Eingabe-Konvertierung clientseitig in der bestehenden json-form-htmx-Extension (`data-type="amount"`), API bleibt strikt Punkt-Dezimal. Szenario-Ende als neue Modifikator-Art `ende` (nullable `end_date`-Spalte) in der reinen Engine; szenario-eigene Einmalzahlungen als neue Tabelle `scenario_planned_items`, die `services/projection_service.py` unabhängig von `include_planned` einspeist. Eine Alembic-Migration.
+
+**Tech Stack:** FastAPI + Pydantic v2, SQLAlchemy 2 (Mapped), Alembic, Jinja2, htmx + eigene json-form-Extension, pytest (SQLite in-memory via `conftest.py`), Podman-Pod-Deployment via `create_pod_finance.sh`.
+
+**Spec:** `docs/superpowers/specs/2026-07-20-ausbaustufe-5-design.md`
+
+## Global Constraints
+
+- **Geldbeträge immer `decimal.Decimal`** (DB-Typ `MONEY = Numeric(12,2)`), niemals float-Arithmetik (CLAUDE.md).
+- **GUI-Texte, Fehlermeldungen, Commit-Messages auf Deutsch**; Datumsformat TT.MM.JJJJ.
+- **UX-Regel:** Bedienelemente sichtbar lassen (`hidden`/`disabled`, nie aus dem DOM entfernen); Fehler inline bzw. über den bestehenden `htmx:responseError`-Handler.
+- **API-Werte/DB-Werte bleiben englisch** (`monthly`, `annuity`, `percent`, `ende`, …) — nur Anzeige-Labels sind deutsch.
+- **Fable-Testagent-Gate:** Jeder Task braucht VOR dem Commit eine Abnahme durch den Fable-Testagenten (Faktencheck/Live-Test je nach Task). Kein Task ist ohne dieses Gate abgeschlossen.
+- **Ledger:** Nach jedem abgeschlossenen Task ein Eintrag in `.superpowers/sdd/progress.md` (Commit-Range + Fable-Befund).
+- **DATENSCHUTZ:** `tests/fixtures/*` = echte Kontodaten, nie committen/zitieren. Die konkreten Demo-Daten (Empfängernamen, Beträge, Termine des »Best Case«) stammen aus dem Nutzer-Chat und dürfen NUR in die Live-DB und den Chat — nicht in Commits, Ledger, Tests oder Doku.
+- **Testlauf immer:** `cd /home/wlfb/bin/finance && .venv/bin/python -m pytest -q` — Basis-Erwartung: alle grün (aktuell 154 passed).
+- **Arbeitsverzeichnis:** alle Pfade unten relativ zu `/home/wlfb/bin/finance` (Ausnahme: Ledger/Plan unter `/home/wlfb/bin`).
+
+---
+
+### Task 1: Anzeige-Formatierung — `app/formats.py` + Template-Umstellung
+
+**Files:**
+- Create: `app/formats.py`
+- Create: `tests/test_formats.py`
+- Modify: `app/routers/gui.py` (Filter-Registrierung, nach Zeile 30 `templates.env.globals[...]`)
+- Modify: `app/templates/index.html`, `app/templates/salden.html`, `app/templates/transactions.html`, `app/templates/planning.html`, `app/templates/_preview_table.html`
+- Modify: `tests/test_gui.py` (bestehende Punktformat-Assertions)
+
+**Interfaces:**
+- Produces: `app.formats.eur(value) -> str` (Decimal/str/int → `"−"`-lose deutsche Darstellung, z.B. `Decimal("-2474.5")` → `"-2.474,50"`, ohne €-Zeichen), `app.formats.de_label(value: str) -> str` (englischer API-Wert → deutsches Label, unbekannt → Rohwert), `app.formats.DE_LABELS: dict[str, str]`. Jinja-Filter `|eur` und `|de_label` in allen Templates verfügbar. Spätere Tasks (2, 4, 7) nutzen beide Filter.
+
+- [ ] **Step 1: Failing Tests schreiben** — `tests/test_formats.py`:
+
+```python
+from decimal import Decimal
+
+from app.formats import DE_LABELS, de_label, eur
+
+
+def test_eur_basisformat():
+    assert eur(Decimal("2474.00")) == "2.474,00"
+
+
+def test_eur_negativ_mit_mehreren_tausenderpunkten():
+    assert eur(Decimal("-1234567.5")) == "-1.234.567,50"
+
+
+def test_eur_null_und_kleinbetraege():
+    assert eur(Decimal("0")) == "0,00"
+    assert eur(Decimal("-0.5")) == "-0,50"
+    assert eur(Decimal("999.99")) == "999,99"
+
+
+def test_eur_rundung_half_up():
+    assert eur(Decimal("1.005")) == "1,01"
+    assert eur(Decimal("-1.005")) == "-1,01"
+
+
+def test_eur_akzeptiert_strings_und_int():
+    # Templates reichen teils DB-Werte als str/int durch (z.B. Suggestions).
+    assert eur("1234.5") == "1.234,50"
+    assert eur(7) == "7,00"
+
+
+def test_de_label_bekannte_und_unbekannte_werte():
+    assert de_label("monthly") == "monatlich"
+    assert de_label("quarterly") == "vierteljährlich"
+    assert de_label("yearly") == "jährlich"
+    assert de_label("annuity") == "Annuität"
+    assert de_label("bullet") == "endfällig"
+    assert de_label("percent") == "Prozent"
+    assert de_label("absolute") == "Absolut"
+    assert de_label("remove") == "Entfällt"
+    assert de_label("ende") == "Ende"
+    assert de_label("weirdvalue") == "weirdvalue"
+    assert set(DE_LABELS) == {"monthly", "quarterly", "yearly", "annuity",
+                              "bullet", "percent", "absolute", "remove", "ende"}
+```
+
+- [ ] **Step 2: Fehlschlag verifizieren**
+
+Run: `.venv/bin/python -m pytest tests/test_formats.py -q`
+Expected: FAIL/ERROR mit `ModuleNotFoundError: No module named 'app.formats'`
+
+- [ ] **Step 3: `app/formats.py` implementieren**
+
+```python
+"""Deutsche Anzeige-Formate fuer die GUI (Ausbaustufe 5).
+
+Bewusst ohne locale-Modul: Container-Locales sind nicht garantiert
+installiert, und die Ausgabe hinge sonst vom Host ab. Reine
+Decimal-Formatierung; die JSON-API bleibt Punkt-Dezimal.
+"""
+from decimal import Decimal, ROUND_HALF_UP
+
+DE_LABELS = {
+    "monthly": "monatlich",
+    "quarterly": "vierteljährlich",
+    "yearly": "jährlich",
+    "annuity": "Annuität",
+    "bullet": "endfällig",
+    "percent": "Prozent",
+    "absolute": "Absolut",
+    "remove": "Entfällt",
+    "ende": "Ende",
+}
+
+
+def eur(value) -> str:
+    """Decimal("-2474.5") -> "-2.474,50" (ohne Euro-Zeichen, das setzt das Template)."""
+    d = Decimal(str(value)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+    s = f"{d:,.2f}"  # US-Trenner: "-2,474.50"
+    return s.replace(",", "\x00").replace(".", ",").replace("\x00", ".")
+
+
+def de_label(value: str) -> str:
+    return DE_LABELS.get(value, value)
+```
+
+- [ ] **Step 4: Tests grün verifizieren**
+
+Run: `.venv/bin/python -m pytest tests/test_formats.py -q`
+Expected: alle Tests PASS
+
+- [ ] **Step 5: Filter registrieren** — `app/routers/gui.py`, direkt nach `templates.env.globals["app_version"] = get_version()`:
+
+```python
+from app.formats import de_label, eur  # (oben bei den Imports einsortieren)
+
+templates.env.filters["eur"] = eur
+templates.env.filters["de_label"] = de_label
+```
+
+- [ ] **Step 6: Failing GUI-Test für deutsche Anzeige** — in `tests/test_gui.py` ergänzen:
+
+```python
+def test_gui_zeigt_deutsche_betragsformate(client, db):
+    client.post("/login", data={"username": "admin", "password": "geheim"})
+    acc = Account(bank="dkb", iban="DE-FMT-1", name="Formatkonto", type="giro")
+    db.add(acc)
+    db.flush()
+    acc.anchor_date = date(2026, 6, 30)
+    acc.anchor_balance = Decimal("12345.60")
+    db.commit()
+    r = client.get("/")
+    assert "12.345,60" in r.text
+    assert "12345.60" not in r.text
+
+
+def test_planung_zeigt_deutsche_labels(client, db):
+    client.post("/login", data={"username": "admin", "password": "geheim"})
+    db.add(RecurringItem(name="Miete-Label-Test", amount=Decimal("-600.00"),
+                         rhythm="monthly", due_day=1))
+    db.commit()
+    r = client.get("/planung")
+    assert "monatlich" in r.text
+    assert "-600,00" in r.text
+```
+
+`RecurringItem` zum Import in `tests/test_gui.py` ergänzen: `from app.models.tables import Account, RecurringItem`.
+
+Run: `.venv/bin/python -m pytest tests/test_gui.py -q` → die zwei neuen Tests FAIL (Punktformat/englische Labels im HTML).
+
+- [ ] **Step 7: Templates umstellen** — alle `{{ '%.2f'|format(X) }}`-Vorkommen ersetzen durch `{{ X|eur }}` (Fundstellen: `index.html` Zeilen 14/29/32/71, `salden.html` 20/27/51/53, `transactions.html` 56, `_preview_table.html` 11/28/29, `planning.html` 16/67/101/146/147/231/284). In `planning.html` zusätzlich Labels:
+  - Zeile 17 `{{ r.rhythm }}` → `{{ r.rhythm|de_label }}`; Zeile 68 (Vorschläge) `{{ s.rhythm }}` → `{{ s.rhythm|de_label }}`; Zeile 148 `{{ l.repayment_type }}` → `{{ l.repayment_type|de_label }}`; Zeile 230 `{{ m.kind }}` → `{{ m.kind|de_label }}`.
+  - Dropdown-Optionen: `<option value="{{ rh }}">{{ rh|de_label }}</option>`, `<option value="{{ rt }}">{{ rt|de_label }}</option>`, `<option value="{{ k }}">{{ k|de_label }}</option>`.
+  - Kredit-Zins Zeile 147: `{{ l.annual_rate_pct|eur }} %`.
+  - Tilgungsplan-JS (`loadLoanSchedule`): Hilfsfunktion ergänzen und alle vier `Number(r.X).toFixed(2)` ersetzen:
+
+```javascript
+function fmtEur(n) {
+  return Number(n).toLocaleString('de-DE', {minimumFractionDigits: 2, maximumFractionDigits: 2});
+}
+// in loadLoanSchedule:
++ '<td>' + fmtEur(r.payment) + ' €</td>'
++ '<td>' + fmtEur(r.interest) + ' €</td>'
++ '<td>' + fmtEur(r.principal) + ' €</td>'
++ '<td>' + fmtEur(r.remaining) + ' €</td></tr>';
+```
+
+- [ ] **Step 8: Bestehende Punktformat-Assertions anpassen**
+
+Run: `grep -rn '\.00\|\.50\|\.99' tests/test_gui.py` und jede Assertion prüfen, die gerendertes HTML gegen Punktformat testet. Bekannt: `test_index_shows_account_anchor` erwartet `"Anker: 321.00"` → ändern in `"Anker: 321,00"`. Weitere Treffer analog auf Komma-Format umstellen (NUR Assertions gegen `r.text`/HTML — JSON-API-Assertions bleiben Punktformat!).
+
+- [ ] **Step 9: Gesamte Suite grün**
+
+Run: `.venv/bin/python -m pytest -q`
+Expected: alle Tests passed (154 alt + 8 neu)
+
+- [ ] **Step 10: Fable-Testagent-Abnahme einholen** (Faktencheck: Filter-Korrektheit inkl. Rundung/negativer Werte, Vollständigkeit der Template-Umstellung via grep `'%.2f'` → 0 Treffer in `app/templates/`, keine API-Format-Änderung). Erst nach VERIFIED weiter.
+
+- [ ] **Step 11: Commit**
+
+```bash
+cd /home/wlfb/bin && git add finance/app/formats.py finance/tests/test_formats.py finance/app/routers/gui.py finance/app/templates/ finance/tests/test_gui.py
+git commit -m "feat: deutsche Betragsanzeige (eur-Filter) und deutsche GUI-Labels"
+```
+
+---
+
+### Task 2: Deutsche Betrags-Eingabe — json-form `data-type="amount"`
+
+**Files:**
+- Modify: `app/templates/base.html` (json-form-Extension, `encodeParameters`)
+- Modify: `app/templates/planning.html` (alle Betrags-Inputs), `app/templates/index.html` (Anker-Saldo-Input)
+- Modify: `tests/test_gui.py`
+
+**Interfaces:**
+- Consumes: Filter `|eur` aus Task 1 (Vorbefüllung des Anker-Inputs).
+- Produces: json-form-Konvention `data-type="amount"`: Eingabewert wird vor dem JSON-Versand normalisiert (Leerzeichen/`€` entfernen; enthält der Wert ein Komma → Tausenderpunkte entfernen, Komma→Punkt; ohne Komma unverändert). Tasks 4 und 7 verwenden `data-type="amount"` in ihren Formularen.
+
+- [ ] **Step 1: Failing Test — Attribute im gerenderten HTML** (die JS-Konvertierung selbst ist serverseitig nicht testbar; sie wird im Fable-Live-Test geprüft). In `tests/test_gui.py`:
+
+```python
+def test_betragsfelder_haben_amount_typ_und_deutsche_platzhalter(client):
+    client.post("/login", data={"username": "admin", "password": "geheim"})
+    planung = client.get("/planung").text
+    # Fixposten-, Einmalposten-, Kredit-Formulare senden deutsche Eingaben:
+    assert planung.count('data-type="amount"') >= 4
+    assert '-49,99' in planung and '-2000,00' in planung
+    assert '-49.99' not in planung and '-2000.00' not in planung
+    index = client.get("/").text
+    assert 'placeholder="500,00"' in index
+```
+
+Run: `.venv/bin/python -m pytest tests/test_gui.py::test_betragsfelder_haben_amount_typ_und_deutsche_platzhalter -q` → FAIL
+
+- [ ] **Step 2: json-form-Extension erweitern** — `base.html`, in `encodeParameters` vor dem `else`-Zweig:
+
+```javascript
+          } else if (kind === 'int') {
+            out[k] = parseInt(v, 10);
+          } else if (kind === 'amount') {
+            // Deutsche Betragseingabe: "1.234,56" -> "1234.56". Ohne Komma
+            // bleibt der Wert unveraendert (Punkt-Eingaben funktionieren weiter).
+            var s = String(v).replace(/[\s€]/g, '');
+            if (s.indexOf(',') !== -1) {
+              s = s.replace(/\./g, '').replace(',', '.');
+            }
+            out[k] = s;
+          } else {
+```
+
+- [ ] **Step 3: Eingabefelder umstellen**
+  - `planning.html` Fixposten-Formular: `<input type="text" name="amount" data-type="amount" placeholder="-49,99" required>`
+  - `planning.html` Einmalposten-Formular: `placeholder="-2000,00"`, `data-type="amount"`
+  - `planning.html` Kredit-Formular: `principal` → `data-type="amount" placeholder="10000,00"`; `annual_rate_pct` → `data-type="amount" placeholder="4,5"`
+  - `planning.html` Modifikator-Formular: `<input type="text" name="value" data-type="amount" value="0">`
+  - `index.html` Anker-Formular: `<input type="text" name="anchor_balance" data-type="amount" placeholder="500,00" value="{{ account.anchor_balance|eur if account.anchor_balance is not none else '' }}" required>`
+  - Die versteckten Felder der Vorschlags-Übernahme (`<input type="hidden" name="amount" value="{{ s.amount }}">`) bekommen KEIN `data-type="amount"` — der Server liefert dort Punktformat, und die amount-Normalisierung ließe es unverändert; ohne Attribut bleibt die Semantik explizit.
+
+- [ ] **Step 4: Tests grün + Suite**
+
+Run: `.venv/bin/python -m pytest tests/test_gui.py -q && .venv/bin/python -m pytest -q`
+Expected: alles PASS
+
+- [ ] **Step 5: Fable-Testagent-Abnahme** — diesmal MIT Live-Anteil: gegen die laufende Instanz (oder lokal gestartete App) im Browser/per curl prüfen, dass ein Fixposten mit Eingabe `1.234,56` als `1234.56` gespeichert wird und `-49,99` korrekt ankommt. Erst nach VERIFIED weiter. (Hinweis: Wenn erst beim Release-Task deployt wird, den Live-Anteil per `uvicorn`-Teststart gegen SQLite erledigen: `cd finance && FB_DATABASE_URL=sqlite:///./demo.sqlite FB_GUI_PASSWORD_HASH=$(.venv/bin/python -c "from app.auth import hash_password; print(hash_password('demo'))") .venv/bin/uvicorn app.main:app --port 8123` — Wegwerf-DB danach löschen.)
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd /home/wlfb/bin && git add finance/app/templates/ finance/tests/test_gui.py
+git commit -m "feat: Betragseingabe mit Komma (data-type=amount in json-form)"
+```
+
+---
+
+### Task 3: Fixposten — Start/Ende in der GUI + Datumsvalidierung
+
+**Files:**
+- Modify: `app/routers/planning.py` (`RecurringIn`, `patch_recurring`)
+- Modify: `app/templates/planning.html` (Tabelle + Anlege-Formular)
+- Modify: `tests/test_planning_api.py`, `tests/test_gui.py`
+
+**Interfaces:**
+- Consumes: bestehende Felder `RecurringItem.start_date/end_date`, `RecurringIn/RecurringPatch.start_date/end_date` (existieren schon), Filter `|eur`/`|de_label`.
+- Produces: Validierungsregel »`end_date >= start_date`, sonst 422 mit Meldung „Ende darf nicht vor Start liegen"« bei POST und PATCH `/api/recurring`. GUI-Spalten »Start«/»Ende«. Task 4 baut das Bearbeiten-Formular auf dieselben Felder.
+
+- [ ] **Step 1: Failing API-Tests** — in `tests/test_planning_api.py`:
+
+```python
+def test_recurring_ende_vor_start_wird_abgelehnt(client):
+    r = client.post("/api/recurring", headers=H, json={
+        "name": "Falschrum", "amount": "-10.00", "rhythm": "monthly", "due_day": 1,
+        "start_date": "2026-10-01", "end_date": "2026-09-01"})
+    assert r.status_code == 422
+
+
+def test_recurring_start_ende_roundtrip_und_patch_validierung(client):
+    r = client.post("/api/recurring", headers=H, json={
+        "name": "Befristet", "amount": "-10.00", "rhythm": "monthly", "due_day": 1,
+        "start_date": "2026-01-01", "end_date": "2026-12-31"})
+    assert r.status_code == 201
+    item = r.json()
+    assert item["start_date"] == "2026-01-01" and item["end_date"] == "2026-12-31"
+    # PATCH, der Ende vor den (bestehenden) Start schieben will -> 422:
+    bad = client.patch(f"/api/recurring/{item['id']}", headers=H,
+                       json={"end_date": "2025-06-30"})
+    assert bad.status_code == 422
+    # Datum explizit loeschen (null) ist erlaubt:
+    ok = client.patch(f"/api/recurring/{item['id']}", headers=H,
+                      json={"end_date": None})
+    assert ok.status_code == 200 and ok.json()["end_date"] is None
+```
+
+Run: `.venv/bin/python -m pytest tests/test_planning_api.py -q` → die neuen Tests FAIL (POST liefert 201 statt 422 bzw. PATCH 200 statt 422)
+
+- [ ] **Step 2: Validierung implementieren** — `app/routers/planning.py`:
+
+Import ergänzen: `from pydantic import BaseModel, ConfigDict, Field, model_validator`
+
+In `RecurringIn` (gilt via Vererbung NICHT für `RecurringPatch` — dort prüft der Router den Merge-Zustand):
+
+```python
+class RecurringIn(BaseModel):
+    name: str
+    amount: Decimal
+    rhythm: Literal["monthly", "quarterly", "yearly"]
+    due_day: int = Field(ge=1, le=31)
+    start_date: date | None = None
+    end_date: date | None = None
+    category_id: int | None = None
+
+    @model_validator(mode="after")
+    def _ende_nicht_vor_start(self):
+        if (self.start_date is not None and self.end_date is not None
+                and self.end_date < self.start_date):
+            raise ValueError("Ende darf nicht vor Start liegen")
+        return self
+```
+
+In `patch_recurring` nach der `setattr`-Schleife, vor `session.commit()`:
+
+```python
+    if (item.start_date is not None and item.end_date is not None
+            and item.end_date < item.start_date):
+        session.rollback()
+        raise HTTPException(422, "Ende darf nicht vor Start liegen")
+```
+
+- [ ] **Step 3: API-Tests grün**
+
+Run: `.venv/bin/python -m pytest tests/test_planning_api.py -q` → PASS
+
+- [ ] **Step 4: Failing GUI-Test** — in `tests/test_gui.py`:
+
+```python
+def test_planung_fixposten_zeigt_start_und_ende(client, db):
+    client.post("/login", data={"username": "admin", "password": "geheim"})
+    db.add(RecurringItem(name="Befristet-GUI", amount=Decimal("-5.00"),
+                         rhythm="monthly", due_day=1,
+                         start_date=date(2026, 1, 1), end_date=date(2026, 12, 31)))
+    db.commit()
+    r = client.get("/planung").text
+    assert "<th>Start</th>" in r and "<th>Ende</th>" in r
+    assert "01.01.2026" in r and "31.12.2026" in r
+    assert 'name="start_date"' in r and 'name="end_date"' in r
+```
+
+Run: → FAIL
+
+- [ ] **Step 5: Template** — `planning.html`, Fixposten-Tabelle:
+
+Kopfzeile: `<tr><th>Name</th><th>Betrag</th><th>Rhythmus</th><th>Fälligkeitstag</th><th>Start</th><th>Ende</th><th>Kategorie</th><th></th></tr>`
+
+Datenzeile (nach der Fälligkeitstag-Zelle):
+
+```html
+<td>{{ r.start_date.strftime('%d.%m.%Y') if r.start_date else '–' }}</td>
+<td>{{ r.end_date.strftime('%d.%m.%Y') if r.end_date else '–' }}</td>
+```
+
+`colspan` der Leerzeile von 6 auf 8 erhöhen. Anlege-Formular (nach Fälligkeitstag):
+
+```html
+<label>Start (optional) <input type="date" name="start_date"></label>
+<label>Ende (optional) <input type="date" name="end_date"></label>
+```
+
+(Leere Datumsfelder sendet die json-form-Extension bereits als `null`.)
+
+- [ ] **Step 6: Suite grün**
+
+Run: `.venv/bin/python -m pytest -q` → PASS
+
+- [ ] **Step 7: Fable-Testagent-Abnahme** (Faktencheck: Validierung POST+PATCH inkl. Null-Löschen; GUI-Spalten; `occurrences` klammert Start/Ende korrekt — bestehende Engine-Tests referenzieren). Erst nach VERIFIED weiter.
+
+- [ ] **Step 8: Commit**
+
+```bash
+cd /home/wlfb/bin && git add finance/app/routers/planning.py finance/app/templates/planning.html finance/tests/
+git commit -m "feat: Start/Ende fuer Fixposten in der GUI + Datumsvalidierung"
+```
+
+---
+
+### Task 4: Inline-Bearbeiten — Fixposten, Einmalposten, Kredite, Szenario-Kopf
+
+**Files:**
+- Modify: `app/templates/planning.html`
+- Modify: `tests/test_gui.py`
+
+**Interfaces:**
+- Consumes: `PATCH /api/recurring/{id}`, `/api/planned/{id}`, `/api/loans/{id}`, `/api/scenarios/{id}` (existieren alle); json-form inkl. `data-type="amount"` (Task 2); Filter `|eur`/`|de_label` (Task 1); Start/Ende-Felder (Task 3).
+- Produces: JS-Helfer `toggleEdit(prefix, id, editing)` in `planning.html`; Formularzeilen-IDs `rec-edit-{id}`, `pln-edit-{id}`, `loan-edit-{id}`, `sc-edit-{id}` und Anzeige-IDs `rec-row-{id}`, `pln-row-{id}`, `loan-row-{id}`, `sc-head-{id}`. Task 7 folgt demselben Muster nicht (Szenario-Unterobjekte haben eigene Formulare), benötigt aber `toggleEdit` nicht.
+
+- [ ] **Step 1: Failing GUI-Test**
+
+```python
+def test_planung_hat_bearbeiten_formulare(client, db):
+    client.post("/login", data={"username": "admin", "password": "geheim"})
+    db.add(RecurringItem(name="EditR", amount=Decimal("-5.00"), rhythm="monthly", due_day=1))
+    db.add(PlannedItem(name="EditP", amount=Decimal("-7.00"), due=date(2026, 8, 1)))
+    db.add(Loan(name="EditL", principal=Decimal("1000.00"),
+                annual_rate_pct=Decimal("4.50"), term_months=12,
+                payout_date=date(2026, 8, 1), repayment_type="annuity"))
+    db.add(Scenario(name="EditS", description="d"))
+    db.commit()
+    r = client.get("/planung").text
+    assert r.count(">Bearbeiten</button>") >= 4
+    for fragment in ('hx-patch="/api/recurring/', 'hx-patch="/api/planned/',
+                     'hx-patch="/api/loans/', 'hx-patch="/api/scenarios/'):
+        assert fragment in r, fragment
+```
+
+Imports in `tests/test_gui.py` ergänzen: `from app.models.tables import Account, Loan, PlannedItem, RecurringItem, Scenario`
+
+Run: `.venv/bin/python -m pytest tests/test_gui.py::test_planung_hat_bearbeiten_formulare -q` → FAIL
+
+- [ ] **Step 2: JS-Helfer in `planning.html`** (in den bestehenden `<script>`-Block):
+
+```javascript
+function toggleEdit(prefix, id, editing) {
+  // UX-Regel: Zeilen werden versteckt (hidden), nie aus dem DOM entfernt.
+  document.getElementById(prefix + '-row-' + id).hidden = editing;
+  document.getElementById(prefix + '-edit-' + id).hidden = !editing;
+}
+```
+
+- [ ] **Step 3: Fixposten-Zeile umbauen** — Anzeige-`<tr>` bekommt `id="rec-row-{{ r.id }}"`, in der Aktions-Zelle vor dem Löschen-Formular:
+
+```html
+<button type="button" onclick="toggleEdit('rec', {{ r.id }}, true)">Bearbeiten</button>
+```
+
+Direkt nach der Anzeige-Zeile die Bearbeitungszeile:
+
+```html
+<tr id="rec-edit-{{ r.id }}" hidden>
+  <td colspan="8">
+    <form hx-ext="json-form" hx-patch="/api/recurring/{{ r.id }}" hx-swap="none"
+          hx-on::after-request="if(event.detail.successful){window.location.reload()}">
+      <label>Name <input type="text" name="name" value="{{ r.name }}" required></label>
+      <label>Betrag <input type="text" name="amount" data-type="amount" value="{{ r.amount|eur }}" required></label>
+      <label>Rhythmus
+        <select name="rhythm" data-type="str">
+          {% for rh in rhythms %}<option value="{{ rh }}" {% if rh == r.rhythm %}selected{% endif %}>{{ rh|de_label }}</option>{% endfor %}
+        </select>
+      </label>
+      <label>Fälligkeitstag <input type="number" name="due_day" data-type="int" min="1" max="31" value="{{ r.due_day }}" required></label>
+      <label>Start <input type="date" name="start_date" value="{{ r.start_date.isoformat() if r.start_date else '' }}"></label>
+      <label>Ende <input type="date" name="end_date" value="{{ r.end_date.isoformat() if r.end_date else '' }}"></label>
+      <label>Kategorie
+        <select name="category_id" data-type="int">
+          <option value="">–</option>
+          {% for c in categories %}<option value="{{ c.id }}" {% if c.id == r.category_id %}selected{% endif %}>{{ c.name }}</option>{% endfor %}
+        </select>
+      </label>
+      <button type="submit">Speichern</button>
+      <button type="button" onclick="toggleEdit('rec', {{ r.id }}, false)">Abbrechen</button>
+    </form>
+  </td>
+</tr>
+```
+
+- [ ] **Step 4: Einmalposten analog** — Anzeige-`<tr id="pln-row-{{ p.id }}">`, Button `toggleEdit('pln', {{ p.id }}, true)`, Bearbeitungszeile:
+
+```html
+<tr id="pln-edit-{{ p.id }}" hidden>
+  <td colspan="5">
+    <form hx-ext="json-form" hx-patch="/api/planned/{{ p.id }}" hx-swap="none"
+          hx-on::after-request="if(event.detail.successful){window.location.reload()}">
+      <label>Name <input type="text" name="name" value="{{ p.name }}" required></label>
+      <label>Betrag <input type="text" name="amount" data-type="amount" value="{{ p.amount|eur }}" required></label>
+      <label>Fällig am <input type="date" name="due" value="{{ p.due.isoformat() }}" required></label>
+      <label>Kategorie
+        <select name="category_id" data-type="int">
+          <option value="">–</option>
+          {% for c in categories %}<option value="{{ c.id }}" {% if c.id == p.category_id %}selected{% endif %}>{{ c.name }}</option>{% endfor %}
+        </select>
+      </label>
+      <button type="submit">Speichern</button>
+      <button type="button" onclick="toggleEdit('pln', {{ p.id }}, false)">Abbrechen</button>
+    </form>
+  </td>
+</tr>
+```
+
+- [ ] **Step 5: Kredite analog** — Anzeige-`<tr id="loan-row-{{ l.id }}">`, Button `toggleEdit('loan', {{ l.id }}, true)`, Bearbeitungszeile (`colspan="7"`):
+
+```html
+<tr id="loan-edit-{{ l.id }}" hidden>
+  <td colspan="7">
+    <form hx-ext="json-form" hx-patch="/api/loans/{{ l.id }}" hx-swap="none"
+          hx-on::after-request="if(event.detail.successful){window.location.reload()}">
+      <label>Name <input type="text" name="name" value="{{ l.name }}" required></label>
+      <label>Darlehenssumme <input type="text" name="principal" data-type="amount" value="{{ l.principal|eur }}" required></label>
+      <label>Zins p.a. (%) <input type="text" name="annual_rate_pct" data-type="amount" value="{{ l.annual_rate_pct|eur }}" required></label>
+      <label>Laufzeit (Monate) <input type="number" name="term_months" data-type="int" min="1" value="{{ l.term_months }}" required></label>
+      <label>Auszahlungsdatum <input type="date" name="payout_date" value="{{ l.payout_date.isoformat() }}" required></label>
+      <label>Tilgungsart
+        <select name="repayment_type" data-type="str">
+          {% for rt in repayment_types %}<option value="{{ rt }}" {% if rt == l.repayment_type %}selected{% endif %}>{{ rt|de_label }}</option>{% endfor %}
+        </select>
+      </label>
+      <button type="submit">Speichern</button>
+      <button type="button" onclick="toggleEdit('loan', {{ l.id }}, false)">Abbrechen</button>
+    </form>
+  </td>
+</tr>
+```
+
+Hinweis im Template als Kommentar: eine Kredit-Änderung ändert den Tilgungsplan; Szenarien müssen danach neu durchgerechnet werden.
+
+- [ ] **Step 6: Szenario-Kopf** — der beschreibende `<p>` im Szenario-Fieldset bekommt `id="sc-head-{{ sc.id }}"` und daneben einen Button `<button type="button" onclick="toggleEdit('sc', sc_id, true)">Bearbeiten</button>` (mit `{{ sc.id }}`); direkt danach ein verstecktes `<div id="sc-edit-{{ sc.id }}" hidden>`:
+
+```html
+<div id="sc-edit-{{ sc.id }}" hidden>
+  <form hx-ext="json-form" hx-patch="/api/scenarios/{{ sc.id }}" hx-swap="none"
+        hx-on::after-request="if(event.detail.successful){window.location.reload()}">
+    <label>Name <input type="text" name="name" value="{{ sc.name }}" required></label>
+    <label>Beschreibung <input type="text" name="description" value="{{ sc.description }}"></label>
+    <label><input type="checkbox" name="include_recurring" data-type="bool" {% if sc.include_recurring %}checked{% endif %}> Wiederkehrende Posten einschließen</label>
+    <label><input type="checkbox" name="include_planned" data-type="bool" {% if sc.include_planned %}checked{% endif %}> Einmalposten einschließen</label>
+    <button type="submit">Speichern</button>
+    <button type="button" onclick="toggleEdit('sc', {{ sc.id }}, false)">Abbrechen</button>
+  </form>
+</div>
+```
+
+Achtung `toggleEdit`-Prefix `sc` erwartet `sc-row-{id}` — hier heißt das Anzeige-Element `sc-head-{id}`. Deshalb `toggleEdit` generisch halten: die Anzeige-ID als `prefix + '-row-' + id` ODER Sonderfall vermeiden, indem der `<p>` die ID `sc-row-{{ sc.id }}` bekommt (einfachste Lösung — so umsetzen, `sc-head` nicht verwenden).
+
+- [ ] **Step 7: Tests + Suite grün**
+
+Run: `.venv/bin/python -m pytest -q` → PASS
+
+- [ ] **Step 8: Fable-Testagent-Abnahme** — Live-Test (uvicorn-Teststart wie in Task 2 oder deployte Instanz): je Bereich einmal Bearbeiten→Ändern→Speichern→Reload prüfen, inkl. deutscher Betragseingabe im Edit-Formular (vorbefüllt `1.234,56` muss nach Speichern unverändert bleiben) und Abbrechen. Erst nach VERIFIED weiter.
+
+- [ ] **Step 9: Commit**
+
+```bash
+cd /home/wlfb/bin && git add finance/app/templates/planning.html finance/tests/test_gui.py
+git commit -m "feat: Inline-Bearbeiten fuer Fixposten, Einmalposten, Kredite und Szenario-Kopf"
+```
+
+---
+
+### Task 5: Migration + Modelle + Engine — Modifikator-Art `ende`, Tabelle `scenario_planned_items`
+
+**Files:**
+- Modify: `app/models/tables.py` (`ScenarioModifier.end_date`, neue Klasse `ScenarioPlannedItem`)
+- Create: `alembic/versions/c4d7e2a91b53_szenario_ende.py`
+- Modify: `app/engine/scenario.py` (`PlainModifier.end_date`, effektives Ende in `build_cashflows`)
+- Modify: `tests/test_scenario_engine.py`, `tests/test_models.py`
+
+**Interfaces:**
+- Consumes: `engine.recurrence.occurrences(rhythm, due_day, window_start, window_end, item_start, item_end)` (unverändert).
+- Produces: `ScenarioModifier.end_date: date | None`; ORM-Klasse `ScenarioPlannedItem(id, scenario_id, name, amount, due)` (Tabelle `scenario_planned_items`); `PlainModifier(target_type, target_id, kind, value, end_date: date | None = None)` — Task 6 baut API/Service darauf. Modifikator-Art-String: `"ende"`.
+
+- [ ] **Step 1: Failing Engine-Tests** — in `tests/test_scenario_engine.py` (vorhandene Imports: `build_cashflows`, `PlainRecurring`, `PlainPlanned`, `PlainModifier`, `date`, `Decimal` — prüfen und ggf. ergänzen):
+
+```python
+def test_ende_modifier_beendet_posten_im_szenario():
+    r = PlainRecurring(1, "Miete", Decimal("-2000.00"), "monthly", 1, None, None, None)
+    m = PlainModifier("recurring", 1, "ende", Decimal("0"), date(2026, 8, 31))
+    flows = build_cashflows([r], [], [], [], [m], date(2026, 7, 1), date(2026, 12, 31))
+    assert [d for d, _ in flows] == [date(2026, 7, 1), date(2026, 8, 1)]
+    assert all(a == Decimal("-2000.00") for _, a in flows)
+
+
+def test_ende_modifier_minimum_mit_eigenem_ende():
+    # Posten endet selbst am 15.10.; Szenario-Ende 31.08. ist frueher -> gewinnt.
+    r = PlainRecurring(1, "Miete", Decimal("-100.00"), "monthly", 1,
+                       None, date(2026, 10, 15), None)
+    m = PlainModifier("recurring", 1, "ende", Decimal("0"), date(2026, 8, 31))
+    flows = build_cashflows([r], [], [], [], [m], date(2026, 7, 1), date(2026, 12, 31))
+    assert [d for d, _ in flows] == [date(2026, 7, 1), date(2026, 8, 1)]
+    # Umgekehrt: Szenario-Ende NACH eigenem Ende aendert nichts.
+    m_spaet = PlainModifier("recurring", 1, "ende", Decimal("0"), date(2026, 12, 31))
+    flows2 = build_cashflows([r], [], [], [], [m_spaet], date(2026, 7, 1), date(2026, 12, 31))
+    assert [d for d, _ in flows2][-1] == date(2026, 10, 1)
+
+
+def test_ende_modifier_auf_kategorie_trifft_alle_posten_der_kategorie():
+    r1 = PlainRecurring(1, "Miete A", Decimal("-10.00"), "monthly", 1, None, None, 7)
+    r2 = PlainRecurring(2, "Miete B", Decimal("-20.00"), "monthly", 1, None, None, 7)
+    r3 = PlainRecurring(3, "Strom", Decimal("-5.00"), "monthly", 1, None, None, 9)
+    m = PlainModifier("category", 7, "ende", Decimal("0"), date(2026, 7, 31))
+    flows = build_cashflows([r1, r2, r3], [], [], [], [m],
+                            date(2026, 7, 1), date(2026, 9, 30))
+    betraege = sorted(a for _, a in flows)
+    # Miete A/B nur je 1x (Juli), Strom 3x (Juli-Sept).
+    assert betraege == [Decimal("-20.00"), Decimal("-10.00"),
+                        Decimal("-5.00"), Decimal("-5.00"), Decimal("-5.00")]
+
+
+def test_ende_modifier_ohne_datum_wirkt_nicht():
+    r = PlainRecurring(1, "Miete", Decimal("-10.00"), "monthly", 1, None, None, None)
+    m = PlainModifier("recurring", 1, "ende", Decimal("0"), None)
+    flows = build_cashflows([r], [], [], [], [m], date(2026, 7, 1), date(2026, 9, 30))
+    assert len(flows) == 3
+
+
+def test_ende_modifier_aendert_betraege_nicht():
+    r = PlainRecurring(1, "Miete", Decimal("-2000.00"), "monthly", 1, None, None, None)
+    m = PlainModifier("recurring", 1, "ende", Decimal("50"), date(2026, 12, 31))
+    flows = build_cashflows([r], [], [], [], [m], date(2026, 7, 1), date(2026, 8, 31))
+    assert all(a == Decimal("-2000.00") for _, a in flows)
+```
+
+Run: `.venv/bin/python -m pytest tests/test_scenario_engine.py -q` → FAIL (`PlainModifier` nimmt kein 5. Argument)
+
+- [ ] **Step 2: Engine implementieren** — `app/engine/scenario.py`:
+
+`PlainModifier` erweitern:
+
+```python
+@dataclass(frozen=True)
+class PlainModifier:
+    target_type: str
+    target_id: int
+    kind: str
+    value: Decimal
+    end_date: date | None = None
+```
+
+Neue Hilfsfunktion + Nutzung in `build_cashflows` (die `for r in recurring:`-Schleife):
+
+```python
+def _effective_end(r: PlainRecurring, modifiers: list[PlainModifier]) -> date | None:
+    """Fruehestes Ende aus eigenem end_date und allen treffenden ende-Modifikatoren."""
+    end = r.end_date
+    for m in modifiers:
+        if m.kind != "ende" or m.end_date is None:
+            continue
+        hit = ((m.target_type == "category" and r.category_id == m.target_id)
+               or (m.target_type == "recurring" and r.id == m.target_id))
+        if hit:
+            end = m.end_date if end is None else min(end, m.end_date)
+    return end
+```
+
+In `build_cashflows`:
+
+```python
+    for r in recurring:
+        amount = _modified(r.amount, r.category_id, r.id, modifiers)
+        if amount is None:
+            continue
+        for d in occurrences(r.rhythm, r.due_day, window_start, window_end,
+                             r.start_date, _effective_end(r, modifiers)):
+            flows.append((d, amount))
+```
+
+`_modified` braucht KEINE Änderung (`ende` trifft keinen der kind-Zweige und lässt den Betrag unverändert) — der Test aus Step 1 sichert das ab.
+
+- [ ] **Step 3: Engine-Tests grün**
+
+Run: `.venv/bin/python -m pytest tests/test_scenario_engine.py -q` → PASS
+
+- [ ] **Step 4: Failing Modell-Test** — in `tests/test_models.py`:
+
+```python
+def test_scenario_planned_item_roundtrip(db):
+    from app.models.tables import Scenario, ScenarioPlannedItem
+    sc = Scenario(name="SPI-Test", description="")
+    db.add(sc)
+    db.flush()
+    db.add(ScenarioPlannedItem(scenario_id=sc.id, name="Einmalzahlung",
+                               amount=Decimal("5000.00"), due=date(2026, 7, 30)))
+    db.commit()
+    item = db.query(ScenarioPlannedItem).one()
+    assert item.amount == Decimal("5000.00") and item.scenario_id == sc.id
+```
+
+Run: → FAIL (`ImportError`)
+
+- [ ] **Step 5: Modelle** — `app/models/tables.py`:
+
+In `ScenarioModifier` ergänzen:
+
+```python
+    # Nur fuer kind="ende" gesetzt: Datum, an dem der Ziel-Posten innerhalb
+    # dieses Szenarios endet (Ausbaustufe 5).
+    end_date: Mapped[date | None] = mapped_column(Date, nullable=True)
+```
+
+Neue Klasse (nach `ScenarioModifier`):
+
+```python
+class ScenarioPlannedItem(Base):
+    """Einmalzahlung, die NUR in einem bestimmten Szenario zaehlt -
+    unabhaengig von Scenario.include_planned (das steuert nur die globalen
+    PlannedItems). Ausbaustufe 5."""
+    __tablename__ = "scenario_planned_items"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    scenario_id: Mapped[int] = mapped_column(ForeignKey("scenarios.id"), index=True)
+    name: Mapped[str] = mapped_column(String(200))
+    amount: Mapped[Decimal] = mapped_column(MONEY)
+    due: Mapped[date] = mapped_column(Date)
+```
+
+Run: `.venv/bin/python -m pytest tests/test_models.py -q` → PASS
+
+- [ ] **Step 6: Alembic-Migration** — Create `alembic/versions/c4d7e2a91b53_szenario_ende.py`:
+
+```python
+"""szenario ende + scenario_planned_items
+
+Revision ID: c4d7e2a91b53
+Revises: 1ef6a356f028
+Create Date: 2026-07-20
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+revision: str = 'c4d7e2a91b53'
+down_revision: Union[str, Sequence[str], None] = '1ef6a356f028'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column('scenario_modifiers', sa.Column('end_date', sa.Date(), nullable=True))
+    op.create_table(
+        'scenario_planned_items',
+        sa.Column('id', sa.Integer(), primary_key=True),
+        sa.Column('scenario_id', sa.Integer(), sa.ForeignKey('scenarios.id'), nullable=False),
+        sa.Column('name', sa.String(length=200), nullable=False),
+        sa.Column('amount', sa.Numeric(precision=12, scale=2), nullable=False),
+        sa.Column('due', sa.Date(), nullable=False),
+    )
+    op.create_index('ix_scenario_planned_items_scenario_id',
+                    'scenario_planned_items', ['scenario_id'])
+
+
+def downgrade() -> None:
+    op.drop_index('ix_scenario_planned_items_scenario_id', 'scenario_planned_items')
+    op.drop_table('scenario_planned_items')
+    op.drop_column('scenario_modifiers', 'end_date')
+```
+
+- [ ] **Step 7: Migration in Wegwerf-DB verifizieren** (env.py liest `FB_DATABASE_URL`):
+
+```bash
+cd /home/wlfb/bin/finance
+FB_DATABASE_URL=sqlite:////tmp/claude-1010/-home-wlfb-bin/42d50545-5cdd-41c9-9ade-aba54af164df/scratchpad/mig_check.sqlite .venv/bin/python -m alembic upgrade head
+FB_DATABASE_URL=sqlite:////tmp/claude-1010/-home-wlfb-bin/42d50545-5cdd-41c9-9ade-aba54af164df/scratchpad/mig_check.sqlite .venv/bin/python -c "
+import sqlalchemy as sa
+e = sa.create_engine('sqlite:////tmp/claude-1010/-home-wlfb-bin/42d50545-5cdd-41c9-9ade-aba54af164df/scratchpad/mig_check.sqlite')
+insp = sa.inspect(e)
+assert 'scenario_planned_items' in insp.get_table_names()
+assert any(c['name'] == 'end_date' for c in insp.get_columns('scenario_modifiers'))
+print('Migration OK')"
+```
+
+Expected: `Migration OK`. Danach Wegwerf-Datei löschen.
+
+- [ ] **Step 8: Suite grün**
+
+Run: `.venv/bin/python -m pytest -q` → PASS
+
+- [ ] **Step 9: Fable-Testagent-Abnahme** (Faktencheck: Minimum-Regel, Kategorie-Treffer, Migration up/down konsistent zu `tables.py`, `_modified` unangetastet für `ende`). Erst nach VERIFIED weiter.
+
+- [ ] **Step 10: Commit**
+
+```bash
+cd /home/wlfb/bin && git add finance/app/models/tables.py finance/app/engine/scenario.py finance/alembic/versions/c4d7e2a91b53_szenario_ende.py finance/tests/
+git commit -m "feat: Engine+Schema fuer Szenario-Ende und szenario-eigene Einmalzahlungen"
+```
+
+---
+
+### Task 6: API + Projektions-Service — `ende`-Validierung, Szenario-Einmalzahlungen-CRUD
+
+**Files:**
+- Modify: `app/routers/scenarios.py`
+- Modify: `app/services/projection_service.py`
+- Modify: `tests/test_crud_api.py`, `tests/test_planning_api.py` (Projektion)
+
+**Interfaces:**
+- Consumes: `ScenarioPlannedItem`, `ScenarioModifier.end_date`, `PlainModifier(..., end_date)` aus Task 5.
+- Produces: `ModifierIn`/`ModifierOut` mit `kind`-Literal `"ende"` und Feld `end_date: date | None`; Endpunkte `GET/POST /api/scenarios/{id}/planned` (`ScenarioPlannedOut(id, scenario_id, name, amount, due)`), `DELETE /api/scenarios/{id}/planned/{item_id}`. Task 7 (GUI) und Task 9 (Demo) rufen genau diese Endpunkte.
+
+- [ ] **Step 1: Failing API-Tests** — in `tests/test_crud_api.py`:
+
+```python
+def test_modifier_ende_validierung(client, db):
+    sc = client.post("/api/scenarios", headers=H, json={"name": "EndeVal"}).json()
+    # ende ohne Datum -> 422
+    r = client.post(f"/api/scenarios/{sc['id']}/modifiers", headers=H, json={
+        "target_type": "recurring", "target_id": 1, "kind": "ende"})
+    assert r.status_code == 422
+    # ende mit Datum -> 201, end_date in der Antwort
+    r = client.post(f"/api/scenarios/{sc['id']}/modifiers", headers=H, json={
+        "target_type": "recurring", "target_id": 1, "kind": "ende",
+        "end_date": "2026-08-31"})
+    assert r.status_code == 201
+    assert r.json()["end_date"] == "2026-08-31"
+    # andere Arten nullen end_date
+    r = client.post(f"/api/scenarios/{sc['id']}/modifiers", headers=H, json={
+        "target_type": "recurring", "target_id": 1, "kind": "remove",
+        "end_date": "2026-08-31"})
+    assert r.status_code == 201 and r.json()["end_date"] is None
+
+
+def test_scenario_planned_crud_und_cleanup(client, db):
+    sc = client.post("/api/scenarios", headers=H, json={"name": "SPI-CRUD"}).json()
+    r = client.post(f"/api/scenarios/{sc['id']}/planned", headers=H, json={
+        "name": "Sonderzahlung", "amount": "5000.00", "due": "2026-07-30"})
+    assert r.status_code == 201
+    item = r.json()
+    assert item["scenario_id"] == sc["id"] and item["amount"] == "5000.00"
+    assert client.get(f"/api/scenarios/{sc['id']}/planned", headers=H).json()[0]["name"] == "Sonderzahlung"
+    # DELETE mit fremder scenario_id -> 404
+    other = client.post("/api/scenarios", headers=H, json={"name": "SPI-Other"}).json()
+    assert client.delete(f"/api/scenarios/{other['id']}/planned/{item['id']}",
+                         headers=H).status_code == 404
+    # Szenario loeschen raeumt Einmalzahlungen mit ab (kein FK-Fehler):
+    assert client.delete(f"/api/scenarios/{sc['id']}", headers=H).status_code == 204
+    from app.models.tables import ScenarioPlannedItem
+    assert db.query(ScenarioPlannedItem).count() == 0
+```
+
+Und in `tests/test_planning_api.py` (Projektion nutzt `_seed_balance`-Muster der Datei):
+
+```python
+def test_projektion_mit_ende_modifier_und_szenario_einmalzahlung(client, db):
+    _seed_balance(db)
+    rec = client.post("/api/recurring", headers=H, json={
+        "name": "Miete-Proj", "amount": "-1000.00", "rhythm": "monthly",
+        "due_day": 1}).json()
+    sc = client.post("/api/scenarios", headers=H,
+                     json={"name": "BestCase-Test", "include_planned": False}).json()
+    client.post(f"/api/scenarios/{sc['id']}/modifiers", headers=H, json={
+        "target_type": "recurring", "target_id": rec["id"], "kind": "ende",
+        "end_date": "2026-08-31"})
+    client.post(f"/api/scenarios/{sc['id']}/planned", headers=H, json={
+        "name": "Zufluss", "amount": "5000.00", "due": "2026-07-30"})
+    r = client.post(f"/api/scenarios/{sc['id']}/project", headers=H,
+                    params={"horizon_days": 150, "start_date": "2026-07-15"})
+    assert r.status_code == 200
+    series = {p["day"]: Decimal(p["balance"]) for p in r.json()["series"]}
+    # Start 1000; +5000 am 30.07.; Miete nur noch am 01.08. (ende 31.08.);
+    # include_planned=False, aber die SZENARIO-Zahlung zaehlt trotzdem.
+    assert series["2026-07-30"] == Decimal("6000.00")
+    assert series["2026-08-01"] == Decimal("5000.00")
+    assert series["2026-12-01"] == Decimal("5000.00")  # keine Miete mehr ab Sept.
+```
+
+Run: `.venv/bin/python -m pytest tests/test_crud_api.py tests/test_planning_api.py -q` → neue Tests FAIL
+
+- [ ] **Step 2: `ModifierIn` erweitern** — `app/routers/scenarios.py`:
+
+Imports: `from pydantic import BaseModel, ConfigDict, model_validator` und `ScenarioPlannedItem` in den `app.models.tables`-Import aufnehmen.
+
+```python
+class ModifierIn(BaseModel):
+    target_type: Literal["category", "recurring"]
+    target_id: int
+    kind: Literal["percent", "absolute", "remove", "ende"]
+    value: Decimal = Decimal("0")
+    end_date: date | None = None
+
+    @model_validator(mode="after")
+    def _ende_braucht_datum(self):
+        if self.kind == "ende" and self.end_date is None:
+            raise ValueError("Art »Ende« erfordert ein Datum")
+        if self.kind != "ende":
+            self.end_date = None
+        return self
+```
+
+(`ModifierOut` erbt `end_date` automatisch; `add_modifier` übergibt es via `**data.model_dump()` bereits.)
+
+- [ ] **Step 3: Szenario-Einmalzahlungen-Endpunkte** — `app/routers/scenarios.py` (vor `project_scenario` einfügen):
+
+```python
+class ScenarioPlannedIn(BaseModel):
+    name: str
+    amount: Decimal
+    due: date
+
+
+class ScenarioPlannedOut(ScenarioPlannedIn):
+    model_config = ConfigDict(from_attributes=True)
+    id: int
+    scenario_id: int
+
+
+@router.get("/{scenario_id}/planned", response_model=list[ScenarioPlannedOut])
+def list_scenario_planned(scenario_id: int, session: Session = Depends(get_session)):
+    _get_scenario(session, scenario_id)
+    return [ScenarioPlannedOut.model_validate(p) for p in session.execute(
+        select(ScenarioPlannedItem)
+        .where(ScenarioPlannedItem.scenario_id == scenario_id)
+        .order_by(ScenarioPlannedItem.due)).scalars()]
+
+
+@router.post("/{scenario_id}/planned", response_model=ScenarioPlannedOut,
+             status_code=201)
+def add_scenario_planned(scenario_id: int, data: ScenarioPlannedIn,
+                         session: Session = Depends(get_session)):
+    _get_scenario(session, scenario_id)
+    item = ScenarioPlannedItem(scenario_id=scenario_id, **data.model_dump())
+    session.add(item)
+    session.commit()
+    session.refresh(item)
+    return ScenarioPlannedOut.model_validate(item)
+
+
+@router.delete("/{scenario_id}/planned/{item_id}", status_code=204)
+def delete_scenario_planned(scenario_id: int, item_id: int,
+                            session: Session = Depends(get_session)):
+    _get_scenario(session, scenario_id)
+    item = session.get(ScenarioPlannedItem, item_id)
+    if item is None or item.scenario_id != scenario_id:
+        raise HTTPException(404, "Einmalzahlung nicht gefunden")
+    session.delete(item)
+    session.commit()
+```
+
+In `delete_scenario` zusätzlich (bei den bestehenden Cleanup-Deletes):
+
+```python
+    session.execute(delete(ScenarioPlannedItem).where(
+        ScenarioPlannedItem.scenario_id == scenario_id))
+```
+
+- [ ] **Step 4: Projektions-Service** — `app/services/projection_service.py`:
+
+`ScenarioPlannedItem` in den `app.models.tables`-Import aufnehmen. Nach dem `planned`-Block:
+
+```python
+    # Szenario-eigene Einmalzahlungen zaehlen IMMER fuer dieses Szenario -
+    # include_planned steuert nur die globalen PlannedItems.
+    planned += [PlainPlanned(p.name, Decimal(p.amount), p.due, None)
+                for p in session.execute(select(ScenarioPlannedItem).where(
+                    ScenarioPlannedItem.scenario_id == scenario.id)).scalars()]
+```
+
+Modifier-Konstruktion um `end_date` ergänzen:
+
+```python
+    modifiers = [PlainModifier(m.target_type, m.target_id, m.kind,
+                               Decimal(m.value), m.end_date)
+                 for m in session.execute(select(ScenarioModifier).where(
+                     ScenarioModifier.scenario_id == scenario.id)).scalars()]
+```
+
+- [ ] **Step 5: Tests + Suite grün**
+
+Run: `.venv/bin/python -m pytest -q` → PASS
+
+- [ ] **Step 6: Fable-Testagent-Abnahme** (Faktencheck + Handrechnung der Projektions-Zahlen aus Step 1; 404-Pfade; Cleanup bei delete_scenario). Erst nach VERIFIED weiter.
+
+- [ ] **Step 7: Commit**
+
+```bash
+cd /home/wlfb/bin && git add finance/app/routers/scenarios.py finance/app/services/projection_service.py finance/tests/
+git commit -m "feat: API fuer Szenario-Ende-Modifikator und szenario-eigene Einmalzahlungen"
+```
+
+---
+
+### Task 7: Szenario-GUI — Art »Ende«, Einmalzahlungen-Fieldset, Hilfe
+
+**Files:**
+- Modify: `app/routers/gui.py` (`_scenario_rows`, `planung_page`)
+- Modify: `app/templates/planning.html` (Modifikator-Formular/-Tabelle, neues Fieldset)
+- Modify: `app/templates/hilfe.html`
+- Modify: `tests/test_gui.py`
+
+**Interfaces:**
+- Consumes: Endpunkte und Schemata aus Task 6; Filter `|eur`/`|de_label`; `ScenarioPlannedItem`.
+- Produces: Template-Kontext `row.planned_items` je Szenario; `modifier_kinds = ["percent", "absolute", "remove", "ende"]`; JS `onModKindChange(select)`.
+
+- [ ] **Step 1: Failing GUI-Test**
+
+```python
+def test_szenario_gui_ende_und_einmalzahlungen(client, db):
+    client.post("/login", data={"username": "admin", "password": "geheim"})
+    sc = Scenario(name="GUI-Ende", description="")
+    db.add(sc)
+    db.flush()
+    db.add(ScenarioModifier(scenario_id=sc.id, target_type="recurring",
+                            target_id=1, kind="ende", value=Decimal("0"),
+                            end_date=date(2026, 8, 31)))
+    db.add(ScenarioPlannedItem(scenario_id=sc.id, name="Zufluss-GUI",
+                               amount=Decimal("5000.00"), due=date(2026, 7, 30)))
+    db.commit()
+    r = client.get("/planung").text
+    assert 'value="ende"' in r                     # neue Art im Dropdown
+    assert 'name="end_date"' in r                  # Datumsfeld im Modifikator-Formular
+    assert "31.08.2026" in r                       # ende-Modifikator zeigt Datum
+    assert "Einmalzahlungen in diesem Szenario" in r
+    assert "Zufluss-GUI" in r and "5.000,00" in r and "30.07.2026" in r
+    assert f'hx-post="/api/scenarios/{sc.id}/planned"' in r
+```
+
+Imports ergänzen: `ScenarioModifier, ScenarioPlannedItem` aus `app.models.tables`.
+
+Run: → FAIL
+
+- [ ] **Step 2: GUI-Router** — `app/routers/gui.py`: `ScenarioPlannedItem` importieren. In `planung_page`: `"modifier_kinds": ["percent", "absolute", "remove", "ende"],`. In `_scenario_rows` je Szenario ergänzen:
+
+```python
+        planned_items = session.execute(
+            select(ScenarioPlannedItem)
+            .where(ScenarioPlannedItem.scenario_id == sc.id)
+            .order_by(ScenarioPlannedItem.due)).scalars().all()
+```
+
+und `"planned_items": planned_items,` ins `rows.append`-Dict.
+
+- [ ] **Step 3: Modifikator-Formular + -Tabelle** — `planning.html`:
+
+Tabelle: Wert-Zelle ersetzen durch
+
+```html
+<td>
+  {% if m.kind == 'ende' %}{{ m.end_date.strftime('%d.%m.%Y') if m.end_date else '–' }}
+  {% else %}{{ m.value|eur }}{% endif %}
+</td>
+```
+
+Formular: Art-Select bekommt `onchange="onModKindChange(this)"`; nach dem Wert-Label:
+
+```html
+<label>Wert <input type="text" name="value" data-type="amount" value="0"></label>
+<label>Endet am <input type="date" name="end_date" disabled></label>
+```
+
+JS (in den `<script>`-Block):
+
+```javascript
+function onModKindChange(select) {
+  var form = select.closest('form');
+  var isEnde = select.value === 'ende';
+  form.querySelector('[name="end_date"]').disabled = !isEnde;
+  form.querySelector('[name="value"]').disabled = isEnde;
+}
+```
+
+(disabled-Felder fehlen in der Serialisierung → `value` fällt auf Default 0, `end_date` auf null — passt zur Validierung aus Task 6. UX-Regel eingehalten: Felder bleiben sichtbar, nur `disabled`.)
+
+- [ ] **Step 4: Einmalzahlungen-Fieldset** — in `planning.html` im Szenario-Loop nach dem Modifikatoren-`</details>`:
+
+```html
+<details>
+  <summary>Einmalzahlungen in diesem Szenario</summary>
+  <table>
+    <thead><tr><th>Name</th><th>Betrag</th><th>Fällig am</th><th></th></tr></thead>
+    <tbody>
+      {% for sp in row.planned_items %}
+      <tr>
+        <td>{{ sp.name }}</td>
+        <td class="{{ 'neg' if sp.amount < 0 else '' }}">{{ sp.amount|eur }} €</td>
+        <td>{{ sp.due.strftime('%d.%m.%Y') }}</td>
+        <td>
+          <form class="inline-form" hx-delete="/api/scenarios/{{ sc.id }}/planned/{{ sp.id }}" hx-swap="none"
+                hx-confirm="„{{ sp.name }}“ wirklich löschen?"
+                hx-on::after-request="if(event.detail.successful){window.location.reload()}">
+            <button type="submit">Löschen</button>
+          </form>
+        </td>
+      </tr>
+      {% else %}
+      <tr><td colspan="4">Keine szenario-eigenen Einmalzahlungen.</td></tr>
+      {% endfor %}
+    </tbody>
+  </table>
+  <form hx-ext="json-form" hx-post="/api/scenarios/{{ sc.id }}/planned" hx-swap="none"
+        hx-on::after-request="if(event.detail.successful){window.location.reload()}">
+    <label>Name <input type="text" name="name" required></label>
+    <label>Betrag <input type="text" name="amount" data-type="amount" placeholder="5000,00" required></label>
+    <label>Fällig am <input type="date" name="due" required></label>
+    <button type="submit">Einmalzahlung hinzufügen</button>
+  </form>
+  <p class="hint">Zählt nur in diesem Szenario — unabhängig von „Einmalposten einschließen“.</p>
+</details>
+```
+
+- [ ] **Step 5: Hilfe-Abschnitt** — `hilfe.html`, im Szenarien-`<li>` (Zeile ~68) ergänzen (generisch, KEINE echten Daten):
+
+```html
+Varianten wie „Best Case“ entstehen über Modifikatoren: Art „Ende“ lässt
+einen wiederkehrenden Posten (z. B. eine auslaufende Miete) innerhalb des
+Szenarios zu einem Datum enden, ohne den Posten selbst zu ändern; „Prozent“/
+„Absolut“ kürzen Beträge; „Entfällt“ blendet sie ganz aus. Szenario-eigene
+Einmalzahlungen (z. B. ein erwarteter Zufluss) zählen nur in ihrem Szenario.
+```
+
+- [ ] **Step 6: Suite grün**
+
+Run: `.venv/bin/python -m pytest -q` → PASS
+
+- [ ] **Step 7: Fable-Testagent-Abnahme** — Live-Test (uvicorn-Teststart, Muster Task 2): Modifikator »Ende« mit Datumsfeld-Umschaltung anlegen, Einmalzahlung anlegen/löschen, Szenario durchrechnen, Ergebnis plausibel. Erst nach VERIFIED weiter.
+
+- [ ] **Step 8: Commit**
+
+```bash
+cd /home/wlfb/bin && git add finance/app/routers/gui.py finance/app/templates/ finance/tests/test_gui.py
+git commit -m "feat: Szenario-GUI mit Ende-Modifikator und Einmalzahlungen je Szenario"
+```
+
+---
+
+### Task 8: Release v0.6.0 — Version, Redeploy, Live-Smoke
+
+**Files:**
+- Modify: `finance/VERSION` (`0.5.0` → `0.6.0`)
+- Modify: `.superpowers/sdd/progress.md` (Ledger, unter `/home/wlfb/bin`)
+
+**Interfaces:**
+- Consumes: alle Tasks 1–7 committet, Suite grün.
+- Produces: laufender Pod v0.6.0 mit angewendeter Migration `c4d7e2a91b53` — Voraussetzung für Task 9.
+
+- [ ] **Step 1: Gesamte Suite final**
+
+Run: `cd /home/wlfb/bin/finance && .venv/bin/python -m pytest -q`
+Expected: alle Tests passed, 0 failed
+
+- [ ] **Step 2: Version hochzählen**
+
+```bash
+echo "0.6.0" > /home/wlfb/bin/finance/VERSION
+cd /home/wlfb/bin && git add finance/VERSION && git commit -m "chore: Version 0.6.0"
+```
+
+- [ ] **Step 3: Redeploy** (baut Image mit Tag 0.6.0, Entrypoint führt `alembic upgrade head` aus):
+
+```bash
+cd /home/wlfb/bin && ./create_pod_finance.sh
+```
+
+Expected: Skript endet erfolgreich, Service aktiv.
+
+- [ ] **Step 4: Live-Smoke**
+
+```bash
+systemctl --user is-active pod-finance_pod.service        # -> active
+curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8096/login   # -> 200
+curl -s http://127.0.0.1:8096/api/version                 # -> {"version":"0.6.0"}
+podman exec finance-db_ctr psql -U finance -d finance -c "\d scenario_planned_items" | head -5
+podman exec finance-db_ctr psql -U finance -d finance -c "SELECT column_name FROM information_schema.columns WHERE table_name='scenario_modifiers' AND column_name='end_date';"
+```
+
+Expected: Tabelle existiert, Spalte `end_date` vorhanden. (DB-Name/User ggf. aus `~/.local/share/finance_pod/.env` ablesen, falls abweichend.)
+
+- [ ] **Step 5: Fable-Testagent-Abnahme** — Live: Login in die GUI, `/planung` rendert deutsche Formate, ein Test-Fixposten mit Komma-Eingabe anlegen und wieder löschen, Migration-Status wie Step 4. Erst nach VERIFIED weiter.
+
+- [ ] **Step 6: Ledger + Push**
+
+`.superpowers/sdd/progress.md`: je Task 1–8 eine Zeile (Commit-Range, Fable-Befund) im Stil der bestehenden Einträge. Dann:
+
+```bash
+cd /home/wlfb/bin && git add .superpowers/sdd/progress.md docs/superpowers/plans/2026-07-20-ausbaustufe-5.md && git commit -m "docs: Ledger Ausbaustufe 5 + Plan-Haekchen" && git push
+```
+
+---
+
+### Task 9: Demo »Best Case« live anlegen + Nutzer-Erklärung (kein Code)
+
+**Files:** keine Repo-Änderungen (nur Live-DB + Chat). **DATENSCHUTZ:** Die konkreten Empfänger/Beträge/Termine stammen aus dem Nutzer-Chat vom 2026-07-20 — sie dürfen in Live-DB und Chat-Antwort auftauchen, aber NICHT in Commits/Ledger/Doku (Ledger-Eintrag nur generisch: »Demo-Szenario live angelegt und durchgerechnet«).
+
+**Interfaces:**
+- Consumes: deployte v0.6.0 (Task 8); `POST /api/scenarios`, `POST /api/scenarios/{id}/modifiers` (kind `ende`), `POST /api/scenarios/{id}/planned`, `POST /api/scenarios/{id}/project`; GUI-Login via `FB_PASSWORD` aus `~/.local/share/finance_pod/.env`.
+
+- [ ] **Step 1: Bestehende Fixposten prüfen** — per API (`FB_API_KEY` aus der `.env`; Header `Authorization: Bearer <key>`): `GET http://127.0.0.1:8096/api/recurring` und mit den zwei im Chat genannten Mietposten abgleichen (Empfänger + Betrag). Fehlen sie: über `GET /api/recurring/suggestions` prüfen, ob sie als Vorschlag erkannt sind, und mit den Chat-Daten als monatliche Fixposten anlegen (`POST /api/recurring`, negativer Betrag, `due_day` aus den echten Buchungen der Vorschläge).
+
+- [ ] **Step 2: Szenario »Best Case« anlegen** — `POST /api/scenarios` mit `{"name": "Best Case", "description": "<kurze deutsche Beschreibung>"}` (Standard-Flags belassen).
+
+- [ ] **Step 3: Die zwei »Ende«-Modifikatoren setzen** — je Mietposten `POST /api/scenarios/{id}/modifiers` mit `{"target_type": "recurring", "target_id": <fixposten-id>, "kind": "ende", "end_date": "<termin aus dem Chat>"}`.
+
+- [ ] **Step 4: Szenario-Einmalzahlung anlegen** — `POST /api/scenarios/{id}/planned` mit Name/Betrag/Datum aus dem Chat (positiver Betrag = Zufluss).
+
+- [ ] **Step 5: Durchrechnen + Plausibilisierung** — `POST /api/scenarios/{id}/project`; prüfen, dass die Serie die Einmalzahlung am Stichtag springt und die beiden Mietabflüsse nach ihren Endterminen fehlen (Vergleich mit einem Basis-Szenario ohne Modifikatoren, falls vorhanden).
+
+- [ ] **Step 6: Fable-Testagent-Abnahme** — Live-Faktencheck der Szenario-Einträge und der Projektion (Handrechnung der Sprünge). Erst nach VERIFIED weiter.
+
+- [ ] **Step 7: Nutzer-Erklärung im Chat** — Schritt-für-Schritt beschreiben, wie man die Eingabe in der GUI macht (Planung → Szenario anlegen → Modifikatoren-Details → Art »Ende« wählen → Datum; Einmalzahlungen-Details → Betrag mit Komma eingeben), plus Ergebnis-Zusammenfassung (Tiefpunkt, Verlauf) und Grafana-Hinweis. Ledger-Eintrag (generisch) ergänzen und committen.
+
+---
+
+## Self-Review (durchgeführt beim Planschreiben)
+
+- **Spec-Abdeckung:** Teil 1 → Tasks 1–2; Teil 2 → Tasks 3–4; Teil 3 → Tasks 5–7; Teil 4 (Demo/Release/Hilfe) → Tasks 7 (Hilfe), 8, 9. Migration-Test (Spec) → Task 5 Step 7. Keine Lücken gefunden.
+- **Platzhalter:** keine; alle Steps enthalten konkreten Code/Kommandos.
+- **Typ-Konsistenz:** `PlainModifier(..., end_date=None)` (Task 5) = Nutzung in Task 6; `ScenarioPlannedOut(id, scenario_id, name, amount, due)` (Task 6) = GUI-Kontext `row.planned_items` (Task 7); Modifikator-Art-String überall `"ende"`; `toggleEdit`-IDs `*-row-`/`*-edit-` konsistent (Szenario-Kopf nutzt `sc-row-{id}`, siehe Task 4 Step 6).