Merge #55: Anleitung zum Jahresabschluss und zu Genossenschaftsanteilen

Zwei Fragen aus der Praxis, die die Anleitung nicht beantwortete.

## Der Jahresabschluss

Sie beschrieb, was in jedem Bericht steht, aber nicht die Reihenfolge und
nicht, was man vorher besorgen muss. Der neue Abschnitt beginnt deshalb
sechs Wochen vor dem Stichtag: Rueckkaufswerte und Bescheinigungen
brauchen Wochen, und wer erst am Stichtag daran denkt, geraet in Verzug.
Danach die Staende mit Quellenangabe, dann die Berichte in der
Reihenfolge, in der sie aufeinander aufbauen.

## Genossenschaftsanteile

Das Gericht fragt einen "Kontoauszug" an, den es nicht gibt: Ein
Geschaeftsguthaben ist kein Zahlungskonto, sondern eine Forderung gegen
die Genossenschaft. Es laufen keine Buchungen darueber, und ausgezahlt
wird erst nach Kuendigung der Mitgliedschaft.

Der Fall fuehrt zu einem stillen Fehler: Wer die Anteile als Konto
anlegt, kann die Bescheinigung nicht am Wert hinterlegen - genau das
Blatt, das das Gericht sehen will. Ein Saldostand traegt eine
Quellenangabe, aber kein Dokument; ein Wertstand am Vermoegensposten
schon. Deshalb steht im Text nicht nur, was zu tun ist, sondern warum -
sonst legt der naechste Leser es wieder als Konto an.

Dazu der Hinweis, dass "der Wert bleibt doch gleich" nicht traegt: Wird
eine Dividende dem Geschaeftsguthaben gutgeschrieben statt ausgezahlt,
waechst es. Genau deshalb fragt man jaehrlich nach, statt den
Vorjahreswert fortzuschreiben.

Eine Uebersicht behandelt die verwandten Faelle mit - Bausparvertrag,
Depot, Verbindlichkeit. Das Depot ist die Ausnahme: Dort laufen Umsaetze,
es gibt einen Auszug, es ist ein Konto. Versicherungen gehoeren an den
Vertrag, nicht ins Vermoegen.

Zehn Pruefungen in tests/anleitung.test.ts, gegen vier Mutationen
geprueft: als Konto geraten, Dividendenhinweis entfernt, Vorlauf
entfernt, Abschnitt entfernt - jede wird rot.

Refs #55

.env.example

@@ -15,9 +15,49 @@ DATABASE_URL="postgresql://cockpit:bitte-aendern@localhost:5432/betreuungs_cockp
 # 32 zufaellige Bytes, base64. Erzeugen: npm run schluessel
 AUTH_SECRET=
 # Oeffentliche Basis-URL der Anwendung (ohne abschliessenden Slash).
+# Hinter einem Proxy die Adresse, die im Browser in der Adresszeile steht -
+# nicht die interne. Passkeys pruefen dagegen.
 AUTH_URL=http://localhost:3000
-# Hinter einem Reverse Proxy (Caddy) auf true setzen.
-AUTH_TRUST_HOST=true
+
+# Darf der Host-Kopf der Anfrage die Adresse bestimmen?
+#
+# Solange AUTH_URL gesetzt ist: nein, und die Zeile bleibt weg. Die Adresse
+# ist dann bekannt und muss nicht aus einer Kopfzeile abgeleitet werden, die
+# von aussen kommt. Ein "X-Forwarded-Host: fremde.example" schlaegt sonst in
+# erzeugte Adressen durch.
+# AUTH_TRUST_HOST=true
+
+# --- Erreichbarkeit: HIER MUSST DU DICH ENTSCHEIDEN -------------------------
+#
+# Auf welcher Adresse soll die Anwendung erreichbar sein? Das haengt davon
+# ab, WO dein Reverse Proxy laeuft. Waehl genau eine Zeile aus:
+#
+#   Proxy auf DEMSELBEN Server
+#       APP_BIND=127.0.0.1
+#       Von aussen kommt niemand heran, nur der Proxy nebenan. Sicherste
+#       Variante - aber ein Proxy auf einem anderen Rechner erreicht die
+#       Anwendung damit NICHT.
+#
+#   Proxy auf einem ANDEREN Server, privates Netz oder WireGuard vorhanden
+#       APP_BIND=10.0.0.5        <- die Adresse DIESES Servers in dem Netz
+#       Erste Wahl, wenn der Proxy woanders steht.
+#
+#   Proxy auf einem ANDEREN Server, kein privates Netz
+#       APP_BIND=0.0.0.0
+#       Nur zusammen mit einer Firewallregel, die den Port ausschliesslich
+#       fuer die IP des Proxy-Servers oeffnet:
+#           ufw allow from <IP-des-Proxys> to any port 3000 proto tcp
+#           ufw deny 3000/tcp
+#
+# Zwischen Proxy und Anwendung laeuft unverschluesseltes HTTP - die
+# Anwendung beendet kein TLS. Dieser Weg darf nie durchs offene Netz gehen.
+# Einzelheiten: docs/INSTALLATION.md, Schritt 7.
+APP_BIND=127.0.0.1
+APP_PORT=3000
+
+# Die Konsole des mitgelieferten Objektspeichers. Nur noetig, wenn auf dem
+# Server schon etwas auf 9001 laeuft.
+MINIO_KONSOLE_PORT=9001
 
 # --- Anwendungsseitige Feldverschluesselung ---------------------------------
 # AES-256-GCM. 32 Bytes, base64. OHNE DIESEN SCHLUESSEL SIND DIE VERSCHLUESSELTEN
@@ -41,15 +81,57 @@ LOGIN_MAX_VERSUCHE=5
 LOGIN_FENSTER_SEKUNDEN=900
 LOGIN_SPERRE_SEKUNDEN=900
 
+# Geheimnis fuer die Ersteinrichtung. OHNE DIESEN WERT LAESST SICH DER ERSTE
+# ZUGANG NICHT ANLEGEN - das ist Absicht.
+#
+# Zwischen dem ersten Start und dem Anlegen des Zugangs stand die
+# Einrichtungsseite sonst offen: Wer sie in diesem Fenster findet, wird
+# Administrator. Erzeugen: npm run schluessel
+ERSTEINRICHTUNG_GEHEIMNIS=
+
+# Steht ein Reverse Proxy davor?
+#
+# Nur mit "true" wird "X-Forwarded-For" geglaubt - und dann von HINTEN
+# gelesen, weil der vordere Teil der Liste vom Aufrufer selbst kommt.
+# Ohne diese Zeile zaehlt die Anmeldesperre nur nach E-Mail-Adresse.
+#
+# Der dokumentierte Betrieb (Reverse Proxy davor) braucht sie also:
+VERTRAUE_PROXY=true
+# Bei mehreren gestaffelten Proxys deren Anzahl. Sonst weglassen.
+# VERTRAUE_PROXY_STUFEN=1
+
 # --- Objektspeicher (S3-kompatibel, EU!) ------------------------------------
 # Wird ab Etappe 3 verwendet. Beispiel: Hetzner Object Storage, Falkenstein.
 # ACHTUNG: Mit dem Anbieter muss ein AV-Vertrag nach Art. 28 DSGVO bestehen.
-S3_ENDPOINT=https://fsn1.your-objectstorage.com
+# Bleibt AUSKOMMENTIERT, solange das mitgelieferte MinIO benutzt wird.
+#
+# Die docker-compose.yml setzt dann von selbst http://minio:9000 - aber
+# nur, wenn die Variable leer ist. Steht hier ein Wert, gewinnt er, und
+# die Anwendung spricht mit einem fremden Host statt mit dem Speicher
+# nebenan. Genau das ist am 31.08.2026 passiert: Jede Ablage scheiterte
+# monatelang mit "NoSuchBucket", und die Zugangs-ID ging bei jedem Versuch
+# nach draussen.
+#
+# Nur setzen, wenn ein EXTERNER Objektspeicher benutzt wird, z.B.:
+# S3_ENDPOINT=https://fsn1.your-objectstorage.com
 S3_REGION=eu-central
 S3_BUCKET=betreuungs-cockpit
 S3_ACCESS_KEY_ID=
 S3_SECRET_ACCESS_KEY=
 
+# Serverseitige Verschluesselung durch den Anbieter.
+#
+# Bleibt leer, und das ist die richtige Voreinstellung: Die Anwendung
+# verschluesselt jede Datei selbst, bevor sie den Server verlaesst. Eine
+# zweite Lage durch den Anbieter schuetzt vor nichts, was der eigene
+# Umschlag nicht schon abdeckt.
+#
+# Das mitgelieferte MinIO kann sie ohnehin nicht - es laeuft ohne KMS und
+# lehnt jede Ablage mit "NotImplemented" ab, sobald hier etwas steht.
+#
+# Nur setzen, wenn ein externer Anbieter sie ausdruecklich verlangt:
+# S3_SSE=AES256
+
 # --- E-Mail-Erinnerungen (optional, ab Etappe 2) ----------------------------
 SMTP_HOST=
 SMTP_PORT=587
@@ -59,5 +141,5 @@ SMTP_FROM="Betreuungs-Cockpit <cockpit@example.de>"
 
 # --- Erstanmeldung ----------------------------------------------------------
 # Wird nur vom Seed benutzt, um den ersten Betreuer-Zugang anzulegen.
-SEED_ADMIN_EMAIL=fw@wildeflorian.de
-SEED_ADMIN_PASSWORT=bitte-beim-ersten-login-aendern
+SEED_ADMIN_EMAIL=
+SEED_ADMIN_PASSWORT=

.gitattributes

@@ -0,0 +1,32 @@
+# Zeilenenden
+#
+# Im Repository steht ueberall LF, unabhaengig davon, auf welchem System
+# gearbeitet wird. Der Grund ist nicht Geschmack, sondern eine Falle:
+#
+# Solange Dateien gemischt vorliegen, schreibt jedes zeilenweise
+# arbeitende Werkzeug - sed, ein Formatierer, ein Skript - die Datei mit
+# LF zurueck. Der Diff zeigt dann nicht die drei geaenderten Zeilen,
+# sondern die ganze Datei. Genau das ist passiert: 578 Diff-Zeilen statt
+# 8, kurz vor einem Push bemerkt.
+#
+# Nebenwirkung derselben Mischung: "git diff --check" meldet bei
+# CRLF-Dateien jede hinzugefuegte Zeile als "trailing whitespace", weil
+# es das CR so wertet. Damit ist die Pruefung fuer diese Dateien wertlos.
+* text=auto eol=lf
+
+# Shell-Skripte laufen auf dem Server. Ein CRLF im Shebang macht sie
+# unbrauchbar ("bad interpreter"), und der Fehler ist von aussen nicht
+# anzusehen. Deshalb hier ausdruecklich, nicht nur ueber die Regel oben.
+*.sh text eol=lf
+
+# Binaerdateien nie anfassen.
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.pdf binary
+*.woff binary
+*.woff2 binary
+*.ttf binary
+*.zip binary

.gitignore

@@ -11,6 +11,14 @@ dist/
 next-env.d.ts
 *.tsbuildinfo
 
+# Eigene Anpassungen der Installation.
+#
+# Docker Compose liest diese Datei automatisch zusaetzlich zur
+# docker-compose.yml. Sie ist der vorgesehene Ort fuer Aenderungen, die ein
+# Update ueberleben sollen: update.sh prueft nur versionierte Dateien
+# (git status --untracked-files=no) und laesst sie deshalb in Ruhe.
+docker-compose.override.yml
+
 # Umgebung - enthaelt Schluessel, gehoert NIE ins Repo
 .env
 .env.local
@@ -43,3 +51,7 @@ npm-debug.log*
 # Bildschirmfotos entstehen beim Entwickeln neu
 screenshots/
 daten/dokumente/
+
+# Arbeitsbereiche paralleler Agenten (git worktrees). Enthalten einen
+# vollstaendigen zweiten Checkout - der gehoert nicht ins Repository.
+.claude/

Dockerfile

@@ -95,6 +95,17 @@ COPY --from=bau --chown=cockpit:cockpit /app/node_modules/.prisma ./node_modules
 COPY --from=bau --chown=cockpit:cockpit /app/node_modules/@prisma ./node_modules/@prisma
 COPY --from=bau --chown=cockpit:cockpit /app/node_modules/prisma ./node_modules/prisma
 
+# Betriebsskripte, die im laufenden Behaelter gebraucht werden:
+#   totp-geheimnis.mjs      zweites Geraet fuer den Zweitfaktor einrichten
+#   wartungsschluessel.mjs  Schluessel fuer /api/wartung ausrechnen
+#   schluessel-erzeugen.mjs neue Schluessel fuer die Rotation
+#
+# Das ganze Verzeichnis, nicht einzelne Dateien: sonst faellt beim
+# naechsten Betriebsskript wieder auf, dass es fehlt - und zwar erst dann,
+# wenn man es braucht. Die Entwicklungsskripte darin laufen hier mangels
+# Werkzeugen nicht, kosten aber auch nur ein paar Kilobyte.
+COPY --from=bau --chown=cockpit:cockpit /app/scripts ./scripts
+
 # Ablage fuer den Dateitreiber, falls kein Objektspeicher benutzt wird.
 RUN mkdir -p /app/daten/dokumente && chown -R cockpit:cockpit /app/daten
 

README.md

@@ -15,6 +15,7 @@ eines Angehörigen: Fristen, Vorgänge, Belege, Vermögen, Sozialhilfe, Berichte
 ## Inhalt
 
 - [Was die Anwendung kann](#was-die-anwendung-kann)
+- [Die drei Dokumente, die du wirklich brauchst](#die-drei-dokumente-die-du-wirklich-brauchst)
 - [Schnellstart zum Ausprobieren](#schnellstart-zum-ausprobieren)
 - [Produktivbetrieb mit Docker Compose](#produktivbetrieb-mit-docker-compose)
 - [Reverse Proxy](#reverse-proxy)
@@ -46,6 +47,23 @@ eines Angehörigen: Fristen, Vorgänge, Belege, Vermögen, Sozialhilfe, Berichte
 
 ---
 
+## Die drei Dokumente, die du wirklich brauchst
+
+| Wofür | Wo |
+|---|---|
+| **Die Anwendung aufsetzen** — auf einem Server, der Docker und einen Proxy schon hat, mit Kontrolle nach jedem Schritt | [`docs/INSTALLATION.md`](docs/INSTALLATION.md) |
+| **Täglich damit arbeiten** — die zwölf Handgriffe, der Jahresrhythmus, was tun wenn etwas schiefgeht | [`docs/ANLEITUNG.md`](docs/ANLEITUNG.md), in der Anwendung unter `/anleitung` |
+| **Wissen, was sich ändert** — was neu ist, was du vor einem Update beachten musst | [`CHANGELOG.md`](CHANGELOG.md) |
+
+Dazu: [`docs/ROADMAP.md`](docs/ROADMAP.md) für das, was als Nächstes
+kommt, und [`docs/BAUPROTOKOLL.md`](docs/BAUPROTOKOLL.md) für die Frage,
+wie das hier entstanden ist.
+
+Der Rest dieser Datei ist die Kurzfassung für alle, die schon wissen, was
+sie tun.
+
+---
+
 ## Schnellstart zum Ausprobieren
 
 Voraussetzungen: **Node.js ≥ 20.11**, **Docker** und **Git**.
@@ -79,11 +97,12 @@ DATABASE_URL="postgresql://cockpit:entwicklung@localhost:5433/betreuungs_cockpit
 **3. Datenbank einrichten:**
 
 ```bash
-npx prisma migrate dev --name fundament
-npm run db:sql            # Volltextsuche und Audit-Schutz
-npm run db:seed
+npm run setup             # Migrationen, Volltextsuche, Audit-Schutz, Beispieldaten
 ```
 
+Das ist die Kurzform für `db:deploy`, `db:sql` und `db:seed` — die drei
+Schritte laufen ohne Rückfrage durch.
+
 **4. Starten:**
 
 ```bash
@@ -113,6 +132,10 @@ laufender Antrag beim Bezirk Oberfranken mit acht Nachforderungen.
 
 ## Produktivbetrieb mit Docker Compose
 
+> **Zum ersten Mal?** Nimm die [Schritt-für-Schritt-Anleitung](docs/INSTALLATION.md).
+> Sie fängt beim leeren Server an, hat nach jedem Abschnitt eine Kontrolle
+> und endet mit einer Abnahmeliste. Was hier steht, ist die Kurzfassung.
+
 Das Compose-Setup bringt drei Dienste mit: die Anwendung, PostgreSQL und
 MinIO als S3-kompatiblen Objektspeicher, dazu einen Sicherungsdienst.
 
@@ -155,72 +178,72 @@ existiert.
 ### Aktualisieren
 
 ```bash
-git pull
-docker compose up -d --build
+./scripts/update.sh
 ```
 
-Die Migrationen laufen beim Start des Anwendungsbehälters mit. **Vorher ein
-Backup anstoßen** (siehe unten) — eine Migration lässt sich nicht zurückrollen.
+> **Kommst du von 1.1.0 oder älter?** Dort lag `update.sh` ohne
+> Ausführungsrecht im Repository — `./scripts/update.sh` endet dann in
+> „Permission denied". Einmalig hilft:
+>
+> ```bash
+> bash scripts/update.sh
+> ```
+>
+> Ab 1.1.1 ist das Recht gesetzt und der Punktschrägstrich funktioniert.
+
+Das Skript sichert zuerst, zeigt den Changelog zwischen altem und neuem
+Stand, fragt nach, schaltet um, baut neu und führt danach die beiden
+SQL-Skripte aus. Schlägt die Sicherung fehl, wird nicht aktualisiert.
+
+`--pruefen` sieht nur nach, ohne etwas zu ändern. Eigene Änderungen an
+versionierten Dateien werden vor dem Umschalten beiseite gelegt
+(`git stash`), die `.env` bleibt unangetastet.
+
+Einzelheiten und der Weg von Hand: [`docs/INSTALLATION.md`](docs/INSTALLATION.md).
 
 ---
 
 ## Reverse Proxy
 
-Die Anwendung erwartet, dass der Proxy TLS beendet und die echte Client-IP
-weiterreicht. Sie liest `X-Forwarded-For` bzw. `X-Real-IP` für das
-Rate-Limiting am Login und für das Audit-Log (dort nur als Hash).
+Die Anwendung **beendet selbst kein TLS** und bringt keinen Proxy mit. Sie
+horcht standardmäßig auf `127.0.0.1:3000`.
 
-**Caddy**
+**Läuft der Proxy auf demselben Server**, ist damit alles gesagt: Er zeigt
+auf `127.0.0.1:3000`, fertig.
 
-```caddyfile
-cockpit.example.de {
-    encode zstd gzip
-    reverse_proxy 127.0.0.1:3000
+**Läuft er auf einem anderen Server**, setz in der `.env` die Adresse, über
+die er herankommt — am besten die eines privaten Netzes oder eines
+WireGuard-Tunnels:
 
-    # Uploads: Fotos von Behördenschreiben können groß sein.
-    request_body {
-        max_size 30MB
-    }
-}
+```bash
+APP_BIND=10.0.0.5
+APP_PORT=3000
 ```
 
-**nginx**
+`0.0.0.0` nur, wenn eine Firewall den Port ausschließlich für die IP des
+Proxy-Servers öffnet. Zwischen Proxy und Anwendung läuft unverschlüsseltes
+HTTP — dieser Weg darf nie durchs offene Netz gehen.
 
-```nginx
-server {
-    listen 443 ssl http2;
-    server_name cockpit.example.de;
+### Was der Proxy leisten muss
 
-    ssl_certificate     /etc/letsencrypt/live/cockpit.example.de/fullchain.pem;
-    ssl_certificate_key /etc/letsencrypt/live/cockpit.example.de/privkey.pem;
+| Anforderung | Was ohne sie passiert |
+|---|---|
+| TLS beenden | Der Browser lehnt Cookies mit `Secure`-Kennzeichen ab, die Anmeldung schlägt stumm fehl |
+| `Host` durchreichen | Auth.js vergleicht ihn mit `AUTH_URL` und weist die Anmeldung ab |
+| `X-Forwarded-Proto: https` | Die Anwendung baut Adressen mit `http` |
+| `X-Forwarded-For` | Die Login-Sperre zählt alle Zugriffe als denselben Anschluss |
+| Uploads ≥ 30 MB | Fotos mehrseitiger Bescheide werden abgeschnitten |
+| Zeitgrenze ≥ 10 Minuten | Belegmappe, Rechnungslegung und Vollexport brechen ab |
+| Antwort nicht puffern | Der Vollexport kommt als Strom |
 
-    client_max_body_size 30M;
+**Keine eigenen Sicherheitskopfzeilen setzen.** CSP, `X-Frame-Options`,
+`nosniff` und HSTS kommen aus der Anwendung. Die CSP enthält eine Nonce,
+die pro Anfrage neu ist — eine feste CSP aus dem Proxy blockiert die
+eigenen Skripte.
 
-    location / {
-        proxy_pass         http://127.0.0.1:3000;
-        proxy_http_version 1.1;
-        proxy_set_header   Host              $host;
-        proxy_set_header   X-Real-IP         $remote_addr;
-        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
-        proxy_set_header   X-Forwarded-Proto $scheme;
-        proxy_set_header   Upgrade           $http_upgrade;
-        proxy_set_header   Connection        "upgrade";
-    }
-}
-```
-
-**Traefik** (Labels am `app`-Dienst)
-
-```yaml
-labels:
-  - traefik.enable=true
-  - traefik.http.routers.cockpit.rule=Host(`cockpit.example.de`)
-  - traefik.http.routers.cockpit.tls.certresolver=letsencrypt
-  - traefik.http.services.cockpit.loadbalancer.server.port=3000
-```
-
-In allen Fällen muss `AUTH_URL` in der `.env` auf die öffentliche Adresse
-zeigen (`https://cockpit.example.de`), sonst schlägt die Anmeldung fehl.
+**Fertige Konfigurationen** für Caddy, nginx und Traefik, mit Zeitgrenzen
+und den Gegenproben, stehen in
+[`docs/INSTALLATION.md`](docs/INSTALLATION.md), Schritt 7.
 
 ---
 
@@ -281,6 +304,15 @@ entscheiden kann. Was dafür umgesetzt ist:
 - Passwörter mit **Argon2id** (19 MiB, t=2, p=1 — OWASP-Empfehlung).
 - **Zweiter Faktor ist Pflicht** und lässt sich nicht abschalten. TOTP nach
   RFC 6238, kompatibel mit Aegis, 2FAS, Bitwarden, 1Password.
+- **Passkeys** (WebAuthn/FIDO2) als zweiter Anmeldeweg — auch für die
+  erneute Bestätigung vor sensiblen Aktionen. Sie *ersetzen* den zweiten
+  Faktor, statt zu ihm hinzuzukommen: Nutzerverifikation wird verlangt
+  (`userVerification: 'required'`) und serverseitig nachgeprüft, ein
+  Schlüssel ohne sie wird abgewiesen. Damit sind es dieselben zwei
+  Faktoren — Besitz des Geräts und dessen Entsperrung —, nur an die Domain
+  gebunden und deshalb nicht abphishbar. TOTP muss trotzdem eingerichtet
+  sein, bevor sich ein Passkey anlegen lässt: Er hängt an einem Gerät und
+  darf nicht der einzige Weg hinein sein.
 - **Rate-Limiting** am Login, nach E-Mail *und* nach Anschluss. Die Sperre
   wird geprüft, bevor Argon2 überhaupt rechnet.
 - Die Antwortzeit ist auf eine Mindestdauer gestreckt, damit sie nicht
@@ -479,8 +511,38 @@ npm test                 # Vitest: Fachlogik
 npm run test:e2e         # Playwright: kritische Abläufe
 npm run db:studio        # Prisma Studio
 npm run protokoll        # Bauprotokoll aus der Git-Historie
+npm run version -- patch # Version anheben, Changelog vorbereiten
 ```
 
+### Die Datenbankbefehle
+
+Welcher Befehl wofür — und welcher am Terminal Rückfragen stellt. Nur
+`db:migrate` ist interaktiv; alle anderen laufen in Skripten, in der CI
+und im Container durch.
+
+| Befehl | Wofür | Rückfragen? |
+|---|---|---|
+| `npm run setup` | Ersteinrichtung: Migrationen, SQL-Skripte, Beispieldaten | nein |
+| `npm run db:migration -- <name>` | Schemaänderung während der Entwicklung — erzeugt die Migration und nimmt die `DROP INDEX`-Zeilen zur Volltextsuche heraus | nein |
+| `npm run db:deploy` | Vorhandene Migrationen anwenden (Server, CI, Container) | nein |
+| `npm run db:migrate` | `prisma migrate dev` — fragt nach dem Namen und bietet an, die Datenbank zurückzusetzen | **ja** |
+| `npm run db:sql` | Volltextsuche und Audit-Schutz; läuft nicht mit den Migrationen mit | nein |
+| `npm run db:pruefen` | Nachsehen, ob die Trigramm-Indizes noch stehen | nein |
+| `npm run db:seed` | Beispieldaten einspielen | nein |
+
+Der übliche Weg für eine Schemaänderung:
+
+```bash
+# Schema in prisma/schema.prisma ändern, dann
+npm run db:migration -- ansprechpartner   # erzeugen und lesen
+npm run db:deploy                          # anwenden
+npm run db:pruefen                         # Indizes nachsehen
+```
+
+`db:migrate` braucht man dafür nicht mehr. Es bleibt für die Fälle, in
+denen man wirklich den interaktiven Prisma-Ablauf will — etwa um eine
+verkorkste Entwicklungsdatenbank zurückzusetzen.
+
 Konventionen — verbindlich für alle Beiträge:
 [`docs/KONVENTIONEN.md`](docs/KONVENTIONEN.md).
 Schnittstellen zwischen den Modulen:
@@ -513,7 +575,8 @@ Produktion.
   über den Abschnitt `environment:`.
 - Beim ersten Start eines Containers laufen die Migrationen automatisch
   mit. Die beiden SQL-Skripte (Volltextsuche, Audit-Schutz) sind
-  **einmalig von Hand** anzustoßen, siehe oben.
+  **einmalig von Hand** anzustoßen, siehe oben. Beim Aktualisieren
+  erledigt das `scripts/update.sh` mit — beide Skripte sind idempotent.
 
 ### Technische Grundlage
 
@@ -546,14 +609,17 @@ Fehler, die während des Baus aufgefallen sind.
 
 ## Stand
 
-| | |
-|---|---:|
-| Zeilen TypeScript/TSX | 71.051 |
-| Prisma-Modelle | 24 |
-| Seiten | 46 |
-| Unit-Tests (Vitest) | 458 |
-| End-to-End-Tests (Playwright) | 34 |
-| TypeScript-Fehler | 0 |
+| | | nachzuzählen mit |
+|---|---:|---|
+| Zeilen TypeScript/TSX | 79.102 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
+| Prisma-Modelle | 34 | `grep -c '^model ' prisma/schema.prisma` |
+| Seiten | 82 | `find src/app -name page.tsx \| wc -l` |
+| Unit-Tests (Vitest) | 602 | `npm test` |
+| End-to-End-Tests (Playwright) | 87 | `npm run test:e2e` — 47 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
+| TypeScript-Fehler | 0 | `npm run typecheck` |
+
+Die Befehle stehen dabei, weil die Zahlen sonst altern, ohne dass es
+jemandem auffällt — bei den Modellen und Seiten war genau das passiert.
 
 Alle acht Etappen sind umgesetzt. Der Produktionsbuild ist gegen den
 fertigen Standalone-Server geprüft: strenge CSP aktiv, keine

docker-compose.yml

@@ -4,10 +4,13 @@
 #
 #   docker compose up -d --build
 #
-# Kein Reverse Proxy in dieser Datei: der ist auf dem Server bereits
-# vorhanden. Die Anwendung horcht nur auf 127.0.0.1:3000 - von aussen
-# erreichbar wird sie ausschliesslich ueber den vorhandenen Proxy, der
-# auch TLS beendet. Siehe README, Abschnitt "Reverse Proxy".
+# Kein Reverse Proxy in dieser Datei: der ist bereits vorhanden. Die
+# Anwendung beendet selbst kein TLS und horcht standardmaessig nur auf
+# 127.0.0.1:3000.
+#
+# Liegt der Proxy auf einem anderen Server, setze APP_BIND in der .env auf
+# die Adresse, ueber die er herankommt - siehe docs/INSTALLATION.md,
+# Schritt 7.
 #
 # Die Datenbank hat bewusst KEINE Portfreigabe. Sie ist nur ueber das
 # interne Docker-Netz erreichbar. Wer mit psql heran muss, geht ueber
@@ -63,7 +66,10 @@ services:
     ports:
       # Nur an die Loopback-Adresse gebunden. Die Konsole erreichst du
       # ueber einen SSH-Tunnel oder ueber deinen vorhandenen Proxy.
-      - '127.0.0.1:9001:9001'
+      #
+      # Laeuft auf dem Server schon etwas auf 9001, weich in der .env aus:
+      #     MINIO_KONSOLE_PORT=9011
+      - '${MINIO_KONSOLE_BIND:-127.0.0.1}:${MINIO_KONSOLE_PORT:-9001}:9001'
     networks: [intern]
 
   app:
@@ -87,8 +93,19 @@ services:
       AUTH_SECRET: ${AUTH_SECRET:?AUTH_SECRET fehlt in der .env}
       AUTH_URL: ${AUTH_URL:?AUTH_URL fehlt in der .env}
       AUTH_TRUST_HOST: 'true'
+      # Ohne diesen Wert laesst sich der erste Zugang nicht anlegen - siehe
+      # src/server/actions/ersteinrichtung.ts. Leer heisst: gesperrt.
+      ERSTEINRICHTUNG_GEHEIMNIS: ${ERSTEINRICHTUNG_GEHEIMNIS:-}
+      # Bewusst OHNE Vorgabe "true": Die strengere Einstellung bleibt die
+      # Voreinstellung. Wer einen Reverse Proxy davorstellt - der
+      # dokumentierte Betrieb tut das -, sagt es in der .env ausdruecklich.
+      # Ohne den Wert zaehlt die Anmeldesperre nur nach E-Mail-Adresse.
+      VERTRAUE_PROXY: ${VERTRAUE_PROXY:-}
+      VERTRAUE_PROXY_STUFEN: ${VERTRAUE_PROXY_STUFEN:-}
       ENC_KEY_V1: ${ENC_KEY_V1:?ENC_KEY_V1 fehlt in der .env - ohne ihn sind die verschluesselten Felder nicht lesbar}
-      ENC_KEY_V2: ${ENC_KEY_V2:-}
+      # Bleibt leer, solange nicht rotiert wird. Die Anwendung ueberspringt
+      # leere Schluesselvariablen - siehe src/lib/env.ts.
+      # ENC_KEY_V2: ${ENC_KEY_V2:-}
       ENC_KEY_AKTIV: ${ENC_KEY_AKTIV:-1}
       INDEX_KEY: ${INDEX_KEY:?INDEX_KEY fehlt in der .env}
       SESSION_MAX_AGE: ${SESSION_MAX_AGE:-1800}
@@ -102,6 +119,9 @@ services:
       S3_BUCKET: ${S3_BUCKET:-betreuungs-cockpit}
       S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID}
       S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY}
+      # Leer lassen. Das mitgelieferte MinIO laeuft ohne KMS und lehnt jede
+      # Ablage ab, sobald hier etwas steht - siehe .env.example.
+      S3_SSE: ${S3_SSE:-}
       UPLOAD_MAX_BYTES: ${UPLOAD_MAX_BYTES:-26214400}
       OCR_AKTIV: ${OCR_AKTIV:-true}
       SMTP_HOST: ${SMTP_HOST:-}
@@ -111,9 +131,19 @@ services:
       SMTP_FROM: ${SMTP_FROM:-}
       TZ: Europe/Berlin
     ports:
-      # Nur Loopback. Der vorhandene Reverse Proxy auf dem Host reicht
-      # von aussen hierher durch und beendet TLS.
-      - '127.0.0.1:${APP_PORT:-3000}:3000'
+      # Standard ist die Loopback-Adresse: dann erreicht die Anwendung nur
+      # ein Proxy, der auf demselben Rechner laeuft.
+      #
+      # Liegt der Reverse Proxy auf einem ANDEREN Server, muss hier die
+      # Adresse stehen, ueber die er herankommt - am besten die eines
+      # privaten Netzes oder eines WireGuard-Tunnels:
+      #
+      #     APP_BIND=10.0.0.5
+      #
+      # 0.0.0.0 nur setzen, wenn eine Firewall den Port ausschliesslich
+      # fuer die IP des Proxy-Servers oeffnet. Die Anwendung beendet kein
+      # TLS und gehoert nie unverschluesselt ins offene Netz.
+      - '${APP_BIND:-127.0.0.1}:${APP_PORT:-3000}:3000'
     networks: [intern]
     healthcheck:
       test: ['CMD', 'node', '-e', "fetch('http://127.0.0.1:3000/api/gesundheit').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"]
@@ -137,9 +167,20 @@ services:
       PGDATABASE: ${POSTGRES_DB:-betreuungs_cockpit}
       SICHERUNG_PASSWORT: ${SICHERUNG_PASSWORT:?SICHERUNG_PASSWORT fehlt in der .env}
       SICHERUNG_AUFBEWAHRUNG_TAGE: ${SICHERUNG_AUFBEWAHRUNG_TAGE:-30}
+      SICHERUNG_DOKUMENTE_QUELLE: /dokumente
       TZ: Europe/Berlin
     volumes:
       - ./backups:/backups
+      # Die Dokumente, ausdruecklich NUR LESEND.
+      #
+      # Der Sicherungsdienst laeuft unbeaufsichtigt per cron. Ein Dienst,
+      # der die Daten zerstoeren kann, die er sichern soll, ist ein Risiko
+      # ohne Gegenwert - ein Fehler im Skript oder ein kompromittierter
+      # Behaelter wuerde beides auf einmal treffen.
+      #
+      # Zurueckspielen geschieht deshalb nicht hierher, sondern in ein
+      # Verzeichnis unter ./backups; siehe scripts/wiederherstellung.sh.
+      - minio-daten:/dokumente:ro
       - ./scripts/sicherung.sh:/sicherung.sh:ro
       - ./scripts/wiederherstellung.sh:/wiederherstellung.sh:ro
     entrypoint: ['/bin/sh', '-c']

docs/ANLEITUNG.md

@@ -0,0 +1,665 @@
+# Bedienungsanleitung
+
+Für dich als ehrenamtlichen Betreuer. Kein Handbuch zum Durchlesen —
+sondern eine Sammlung der Handgriffe, die du tatsächlich brauchst, in der
+Reihenfolge, in der sie im Alltag vorkommen.
+
+> Diese Anwendung ist ein **Arbeits- und Dokumentationswerkzeug**. Sie
+> rechnet Fristen aus und sortiert Unterlagen. Sie erteilt **keine
+> Rechtsberatung** und kennt deinen Einzelfall nicht. Wo ein Paragraph
+> steht, steht daneben der Hinweis, dass er die Rückfrage bei Gericht,
+> Bezirk oder Anwalt nicht ersetzt. Nimm den ernst.
+
+---
+
+## Der Grundgedanke in drei Sätzen
+
+Du trägst einmal ein, was passiert ist — ein Schreiben, ein Besuch, eine
+Überweisung. Die Anwendung merkt sich, wann daraus etwas folgt, und
+erinnert dich rechtzeitig. Am Ende des Betreuungsjahres erzeugt sie aus
+demselben Bestand die Berichte, die Gericht und Bezirk von dir wollen.
+
+Das heißt umgekehrt: **Was du nicht einträgst, steht später nicht im
+Bericht.** Der Aufwand liegt vorn, der Gewinn hinten.
+
+---
+
+## Der erste Tag
+
+Beim allerersten Aufruf führt dich ein Assistent durch drei Schritte.
+
+**Schritt 1 — Dein Zugang.** Name, E-Mail, Passwort. Nimm vier zufällige
+Wörter statt eines kurzen Kunstworts: *Kastanie-Waschbär-Turm-Grün* ist
+leichter zu merken und deutlich schwerer zu knacken. Noch besser ist ein
+Passwortmanager.
+
+**Schritt 2 — Der zweite Faktor.** Installiere eine Authenticator-App —
+**Aegis** (Android) oder **2FAS** (iOS) sind quelloffen und brauchen kein
+Konto. Scanne den Code, tippe die sechs Ziffern ein.
+
+Danach bekommst du **acht Wiederherstellungscodes**. Die sind der einzige
+Weg zurück, wenn dein Handy verloren geht. Druck sie aus und leg sie zu
+deinen Betreuungsunterlagen — **nicht** auf dasselbe Gerät wie die App.
+Sie werden dir nie wieder angezeigt.
+
+**Schritt 3 — Die betreute Person.** Nur das Nötigste. Ein Feld ist dabei
+wichtiger als alle anderen:
+
+> **Das Bestellungsdatum.** Es steht in deiner Bestellungsurkunde. Daraus
+> berechnet die Anwendung dein Betreuungsjahr — und damit, wann
+> Anfangsbericht, Vermögensverzeichnis, Jahresbericht und die
+> Aufwandspauschale fällig sind. Ist es falsch, ist alles falsch.
+
+Alles Weitere trägst du später unter **Stammdaten → Bearbeiten** in Ruhe
+nach. Das lohnt sich: Was dort steht, taucht in jedem Bericht und in jedem
+Anschreiben wieder auf.
+
+**Zum Schluss:** Geh auf **Fristen** und klicke einmal auf
+*Pflichtfristen ableiten*. Danach stehen deine gesetzlichen Termine drin.
+
+Und wenn du magst: Richte unter **Mein Konto → Passkeys** einen Passkey
+ein. Dann meldest du dich künftig mit dem Finger an, statt drei Felder
+auszufüllen. Wie das geht, steht gleich im nächsten Abschnitt.
+
+---
+
+## Der Morgen: die Seite „Heute"
+
+Diese eine Seite beantwortet die Frage, was ansteht. Von oben nach unten:
+
+| Kachel | Was sie dir sagt |
+|---|---|
+| **Fristen** | Was überfällig ist (rot), was diese Woche fällig wird (orange), was diesen Monat (gelb) |
+| **Wartet auf andere** | Vorgänge, bei denen die Gegenstelle am Zug ist — mit Tagen seit dem letzten Kontakt |
+| **Nachforderungen des Trägers** | Was der Bezirk noch von dir will, mit Fortschrittsbalken |
+| **Ungeprüfter Posteingang** | Neu hochgeladene Schreiben, die noch niemand zugeordnet hat |
+| **Unverbuchte Belege** | Rechnungen ohne Buchung und Buchungen ohne Beleg |
+| **Wo stehen wir?** | Vermögen zum letzten Stichtag, Heimkosten gegen Deckung, Tage bis zum Jahresbericht |
+
+Jede Kachel endet in einer Handlung. Wenn irgendwo nichts steht, ist dort
+auch nichts zu tun.
+
+**Ist eine Kachel leer, obwohl du Daten erwartest?** Dann fehlt meist ein
+Eintrag: keine Fristen ohne Bestellungsdatum, keine Deckungslücke ohne
+erfassten Heimkostenmonat.
+
+---
+
+## Die zwölf häufigsten Handgriffe
+
+### 1. Ein Behördenschreiben aufnehmen
+
+**Dokumente → Aufnehmen**, oder unterwegs über den runden Knopf unten
+rechts → *Beleg fotografieren*.
+
+1. Foto machen oder PDF wählen — mehrere auf einmal sind ausdrücklich
+   erwünscht.
+2. Warten, bis die Datei angenommen ist. Geprüft wird der **Inhalt**, nicht
+   die Endung: eine Datei, die sich nur als PDF ausgibt, wird abgelehnt.
+3. Titel eintragen (oder leer lassen — die Erkennung schlägt einen vor).
+4. **Eingangsdatum** setzen. Das ist wichtiger, als es aussieht: Bei
+   Bescheiden läuft die Widerspruchsfrist ab dem Zugang, nicht ab dem
+   Datum auf dem Brief.
+5. Vorgang auswählen.
+6. *In die Akte übernehmen*.
+
+Danach liest der Server den Text (Texterkennung auf Deutsch) und schlägt
+dir **Absender, Datum, Aktenzeichen, Dokumentart und eine im Text genannte
+Frist** vor. Die Textstelle steht daneben — prüf sie, bevor du übernimmst.
+Nichts davon wird automatisch angelegt.
+
+**Trag ein, wo das Papier liegt.** Es gibt ein Feld für Ordner und
+Register. Wenn der Rechtspfleger das Original sehen will, findest du es
+dann in zehn Sekunden.
+
+### 2. Aus einem Schreiben eine Frist machen
+
+Öffne das Dokument. Steht unter den Vorschlägen eine erkannte Frist,
+genügt ein Klick auf *Als Frist übernehmen*. Sonst: **Fristen → Neu**,
+Datum eintragen, Vorgang zuordnen.
+
+Setz bei behördlichen Fristen die Vorwarnung großzügig. Der Standard ist
+60/30/7/1 Tage vorher.
+
+### 3. Einen Besuch festhalten — in zwanzig Sekunden
+
+Runder Knopf unten rechts → *Notiz / Kontakt festhalten*.
+
+Datum ist auf heute vorbelegt, die Art wählst du aus einer Knopfreihe, die
+Dauer per Schnellwahl. Ein Freitextfeld, fertig.
+
+Zwei Felder lohnen die zusätzlichen Sekunden:
+
+- **„Persönlicher Kontakt zur betreuten Person"** — dieses Häkchen zählt
+  direkt in den Jahresbericht. Es ist bewusst **nicht** vorbelegt: ein
+  versehentlich gesetztes Häkchen wäre eine falsche Angabe gegenüber dem
+  Gericht.
+- **Geäußerte Wünsche** — seit der Reform 2023 ist der Wille der betreuten
+  Person die Leitschnur deines Handelns (§ 1821 BGB). Was du hier
+  festhältst, landet im Jahresbericht und trägt deine Entscheidungen.
+
+Das ist der Handgriff, der sich am meisten auszahlt. Ein Jahresbericht aus
+vierzig kurzen Notizen schreibt sich fast von selbst; einer aus der
+Erinnerung ist eine Qual.
+
+### 4. Eine Buchung erfassen
+
+**Vermögen & Kasse → Buchungen → Neu**, oder über den runden Knopf.
+
+Wichtig ist die Trennung: **Betrifft die Buchung die betreute Person oder
+ist es deine eigene Auslage?** Läuft eine Buchung auf ein als privat
+markiertes Konto und ist trotzdem als „betrifft die Betreute"
+gekennzeichnet, warnt die Anwendung. Das ist der Fehler, der einem in der
+Rechnungslegung um die Ohren fliegt.
+
+**Belege.** Eine Buchung ohne Beleg wird in der Liste markiert. Das ist
+kein Verbot — manchmal gibt es keinen. Dann trag eine Begründung ein, dann
+ist die Zeile sauber und du weißt später noch, warum.
+
+### 5. Einen Vorgang anlegen
+
+**Vorgänge → Neuer Vorgang.** Nimm eine Vorlage, wenn eine passt:
+
+Heimeinzug · Antrag Hilfe zur Pflege · Wohnungsauflösung · Hausverkauf ·
+Darlehen § 91 SGB XII · Versicherungsverwertung · Pflegegrad-Höherstufung ·
+Steuererklärung · Widerspruch gegen Bescheid
+
+Jede bringt eine durchdachte Aufgabenliste in der richtigen Reihenfolge
+mit. Bei den genehmigungspflichtigen erzwingt sie die Reihenfolge
+**Mitteilung → Genehmigung → Rechtsgeschäft**.
+
+Ein Feld solltest du immer pflegen: **Nächster Schritt.** Es steht auf dem
+Dashboard und beantwortet dir in vier Wochen die Frage, was du dir dabei
+gedacht hast.
+
+### 6. Ein genehmigungspflichtiges Geschäft
+
+Hausverkauf, Wohnungskündigung, Kreditaufnahme, Verwertung einer
+Lebensversicherung — dafür brauchst du das Betreuungsgericht.
+
+Markiere den Vorgang als genehmigungspflichtig und wähle die
+Rechtsgrundlage. Die Anwendung zeigt dann eine feste Stufenfolge:
+
+**Mitteilung ans Gericht → Antrag gestellt → Anhörung → Beschluss →
+Rechtskraft → Vollzug**
+
+> Die Stufe **Vollzug lässt sich erst setzen, wenn ein Beschlussdokument
+> hinterlegt ist.** Das ist Absicht: Nach § 1858 BGB muss die Genehmigung
+> **vor** dem Rechtsgeschäft vorliegen. Ein Vertrag, den du vorher
+> unterschreibst, ist schwebend unwirksam.
+
+Sprich vorher mit dem Rechtspfleger. Die Anwendung ersetzt das Gespräch
+nicht, sie erinnert dich nur daran.
+
+### 7. Eine Nachforderung des Bezirks abarbeiten
+
+**Sozialhilfe → Akte öffnen.** Jede angeforderte Unterlage steht als
+eigene Zeile mit Status und Frist. Der Fortschrittsbalken zeigt „x von y
+Unterlagen geliefert".
+
+Beim Anlegen des Antrags kannst du die **Checkliste der Standardunterlagen**
+übernehmen — Rentenbescheide, Kontoauszüge, Versicherungsunterlagen,
+notarielle Übertragungsverträge, Pflegegradbescheid, Heimvertrag,
+Grundbuchauszug. Zu jeder steht dabei, **warum** der Träger sie will. Das
+erspart Rückfragen.
+
+Gibt es eine Unterlage nicht, setz den Status auf *nicht vorhanden* und
+schreib eine Begründung dazu. Die geht später mit ins Unterlagenpaket —
+besser als kommentarloses Schweigen.
+
+Wenn alles beisammen ist: **Berichte → Unterlagenpaket**. Das macht aus
+den markierten Dokumenten **eine** PDF mit Anschreiben, laufender Nummer
+und Inhaltsverzeichnis.
+
+### 8. Einen Bescheid prüfen
+
+**Sozialhilfe → Akte → Bescheide → Neu.**
+
+Trag das **Zugangsdatum** ein, nicht das Datum auf dem Bescheid. Die
+Widerspruchsfrist läuft ab Bekanntgabe.
+
+Die Anwendung rechnet die Frist aus — mit Wochenende, bayerischen
+Feiertagen und dem Sonderfall, dass bei fehlender oder falscher
+Rechtsbehelfsbelehrung ein Jahr statt eines Monats gilt (§ 66 SGG). Der
+Rechenweg wird ausgegeben, damit du ihn nachvollziehen kannst. Aus dem
+Ergebnis entsteht automatisch die Frist *Widerspruch möglich bis*.
+
+**Rechne im Zweifel nach oder frag beim Bezirk.** Eine verstrichene
+Widerspruchsfrist bekommst du nicht zurück.
+
+### 9. Einen Rückkaufswert anfordern
+
+**Verträge → Vertrag öffnen → Rückkaufswert anfordern.** Es entsteht ein
+Anschreiben zum Kopieren, und die Anwendung legt eine **Wiedervorlage in
+vier Wochen** an. Versicherer antworten selten von selbst.
+
+### 10. Einen Vertrag kündigen
+
+**Verträge → Vertrag öffnen → Kündigen.**
+
+Der Rechner nennt dir den **spätesten Absendetag**, nicht den Fristablauf —
+eine Kündigung wirkt mit dem Zugang, nicht mit dem Abschicken. Drei Tage
+Postlauf sind eingerechnet.
+
+Der Assistent fragt dich nach der Genehmigung. Er beantwortet die Frage
+nicht, und das soll er auch nicht: Ob die Verwertung einer
+Lebensversicherung genehmigungspflichtig ist, entscheidet der
+Rechtspfleger. Der **Versandnachweis** (Einschreiben, Faxprotokoll) ist
+Pflichtfeld — ohne ihn geht die Kündigung nicht durch.
+
+### 11. Einen Wertstand nachtragen
+
+**Vermögen & Kasse → Vermögen → Posten öffnen → Wert eintragen.**
+
+Stichtag, Betrag und **Wertquelle** — letztere ist Pflicht. „Eigene
+Schätzung" ist eine zulässige Antwort, „keine Angabe" nicht: Im
+Vermögensverzeichnis steht die Quelle mit dabei, und das Gericht darf
+wissen, woher die Zahl kommt.
+
+Alte Werte werden **nie überschrieben**. Jede Vermögensübersicht bleibt
+später reproduzierbar.
+
+### 12. Etwas versehentlich Gelöschtes zurückholen
+
+**Einstellungen → Papierkorb.** Gelöschtes bleibt 30 Tage liegen und lässt
+sich mit einem Klick zurückholen. Erst danach ist es wirklich weg.
+
+Endgültiges Löschen verlangt eine erneute Anmeldung.
+
+---
+
+## Das Betreuungsjahr
+
+Dein Jahr läuft **ab dem Tag der Bestellung**, nicht ab dem 1. Januar. Wer
+am 14. Februar bestellt wurde, hat sein erstes Betreuungsjahr bis zum
+13. Februar des Folgejahres.
+
+| Wann | Was | Grundlage |
+|---|---|---|
+| 3 Monate nach Bestellung | Vermögensverzeichnis und Anfangsbericht | §§ 1835, 1863 BGB |
+| Zum Ende jedes Betreuungsjahres | Jahresbericht und Vermögensübersicht | §§ 1859, 1863 BGB |
+| Bis 6 Monate danach | **Aufwandspauschale beantragen** | § 1878 BGB |
+| Jährlich bis 31.12. | Bayerisches Landespflegegeld | BayLPflGG |
+| Jährlich | Zuzahlungsbefreiung der Krankenkasse | § 62 SGB V |
+| Jährlich | Rückkaufswerte aller Versicherungen aktualisieren | — |
+
+> **Die Aufwandspauschale ist eine Ausschlussfrist.** Läuft sie ab, ist
+> der Anspruch ersatzlos weg — keine Nachsicht, keine Wiedereinsetzung.
+> Die Anwendung warnt deshalb schon 90 Tage vorher und markiert sie rot.
+
+---
+
+## Die Berichte
+
+Alle unter **Berichte**, die beiden Finanzberichte unter **Vermögen &
+Kasse → Berichte**. Jeder trägt Kopf mit Aktenzeichen, Fußzeile mit
+Seitenzahl und ein Unterschriftenfeld.
+
+**Vermögensverzeichnis (§ 1835 BGB).** Stichtag wählen, Knopf drücken.
+Aktiva nach Gruppen, Passiva, laufende Einnahmen und Ausgaben,
+Belegverweise. Hat ein Posten zum Stichtag keinen Wert, erscheint er als
+**Lücke** — nicht als 0,00 €. Das ist ehrlicher und fällt dir auf.
+
+**Vermögensübersicht / Rechnungslegung (§§ 1859, 1865 BGB).**
+Betreuungsjahr wählen. Anfangsbestand, geordnete Einnahmen und Ausgaben,
+Endbestand, Belegliste.
+
+Zwei Varianten: die knappe Übersicht für **befreite Betreuer** (§ 1859 BGB
+— als Angehöriger bist du das in der Regel) und die vollständige
+Rechnungslegung.
+
+> Geht die Rechenprobe nicht auf, wird die **Differenz im Bericht
+> ausgewiesen** und jeder fehlende Saldostand benannt. Das ist Absicht.
+> Eine still geglättete Rechnungslegung ist gegenüber dem Gericht wertlos —
+> und meistens fehlt einfach ein Kontoauszug.
+
+**Jahresbericht (§ 1863 BGB).** Die Anwendung erzeugt einen **Entwurf** aus
+deinen Kontaktprotokollen, Gesundheitsereignissen und Vorgängen, gegliedert
+nach dem, was das Gericht sehen will. Du überarbeitest ihn im Browser
+(wird automatisch zwischengespeichert) und gibst ihn dann als PDF oder DOCX
+aus.
+
+> Es ist ein Entwurf, kein fertiger Bericht. Lies ihn durch, bevor du ihn
+> abgibst. Was dort steht, verantwortest du.
+
+**Belegmappe.** Alle Dokumente eines Vorgangs oder Zeitraums als eine
+chronologisch sortierte, paginierte PDF mit Deckblatt und
+Inhaltsverzeichnis. Genau das, was Gericht und Bezirk haben wollen.
+
+**Vollexport.** Ein ZIP mit allen Originaldateien, allen Daten als
+lesbarem JSON, den Berichten und Prüfsummen. Damit kannst du diese
+Anwendung jederzeit verlassen. Verlangt eine erneute Anmeldung.
+
+---
+
+## Der Jahresabschluss, Schritt für Schritt
+
+Einmal im Jahr will das Gericht zwei Dinge: einen **Bericht über die
+Person** und eine **Rechnung über das Vermögen**. Beides bezieht sich auf
+dein Betreuungsjahr, nicht auf das Kalenderjahr.
+
+Die Reihenfolge unten ist keine Formalie. Der erste Schritt liegt sechs
+Wochen vor dem Stichtag, weil manche Auskünfte so lange brauchen — wer erst
+am Stichtag daran denkt, wartet und gerät in Verzug.
+
+### Sechs Wochen vorher: anfordern, was du nicht selbst hast
+
+Manche Werte kannst du nicht nachsehen, sondern nur erfragen:
+
+- **Rückkaufswerte** aller Lebens-, Renten- und Sterbegeldversicherungen
+- **Bescheinigungen** über Geschäftsguthaben, Bausparguthaben, Depotwerte
+- **Jahresabrechnungen**, die noch ausstehen
+
+Die Anwendung legt dir dafür rechtzeitig eine Frist an. Schreib die Briefe
+gleich, wenn sie fällig wird — unter **Vorgänge** oder direkt am Vertrag.
+Jedes Schreiben bekommt eine **Wiedervorlage**: Kommt in drei Wochen keine
+Antwort, fasst du nach. Ohne Wiedervorlage geht eine unbeantwortete Anfrage
+unter, und das merkst du am Stichtag.
+
+### Am Stichtag: Stände eintragen
+
+**Konten** — *Vermögen & Kasse → Konten → Konto öffnen → „Neuen Kontostand
+festhalten"*. Für jedes Konto einzeln: Stichtag, Betrag, **Quelle**.
+
+Die Quelle ist kein Beiwerk. Sie steht später neben der Zahl im Bericht,
+und ein Betrag ohne Herkunft ist gegenüber dem Gericht wenig wert. Schreib
+hinein, woher du die Zahl hast: „Kontoauszug 11/2026", „Online-Banking,
+abgerufen am 07.11.".
+
+Vergiss die kleinen nicht: **Verwahrgeld im Heim** und die **Barkasse**
+sind Konten wie jedes andere.
+
+**Vermögen** — *Vermögen & Kasse → Vermögen*. Immobilie, Fahrzeug,
+Wertgegenstände, Forderungen, Schulden. Jeder Posten bekommt einen
+**Wertstand** zum Stichtag, ebenfalls mit Quelle — und hier kannst du das
+**Nachweisdokument gleich anhängen**.
+
+> **Du musst nicht auf den Tag genau treffen.** Die Anwendung nimmt je
+> Konto den letzten Stand am oder vor dem Stichtag. Weicht er ab, schreibt
+> sie es in den Bericht: „Der Stand von ‚Sparbuch' stammt vom 31.10.2026,
+> nicht vom Stichtag." Fehlt ein Stand ganz, steht das Konto ohne Betrag
+> drin — mit Hinweis, nicht mit einer erfundenen Null.
+
+### Dann die Berichte
+
+1. **Vermögensübersicht oder Rechnungslegung** — *Vermögen & Kasse →
+   Berichte*, Betreuungsjahr wählen.
+2. **Belegmappe** — *Berichte → Belegmappe*, derselbe Zeitraum. Das ist die
+   Anlage.
+3. **Jahresbericht** — *Berichte → Jahresbericht*. Entwurf überarbeiten,
+   dann ausgeben.
+
+Vorher lohnt ein Blick ins **Kassenbuch**: Buchungen ohne Beleg und ohne
+Begründung fallen dem Gericht auf. Entweder den Beleg nachreichen oder in
+einem Satz begründen, warum es keinen gibt.
+
+---
+
+## Was aussieht wie ein Konto, aber keines ist
+
+**Genossenschaftsanteile** sind der Leitfall. Im Alltag redet man von einem
+Konto, das Gericht fragt einen „Kontoauszug" an — nur gibt es keinen. Am
+Automaten schon gar nicht.
+
+Der Grund: Ein Geschäftsguthaben bei einer Genossenschaft ist **kein
+Zahlungskonto**, sondern eine **Forderung gegen die Genossenschaft**. Es
+laufen keine Buchungen darüber, es gibt keine Umsätze, und ausgezahlt wird
+erst nach Kündigung der Mitgliedschaft — mit Frist.
+
+### Deshalb: als Vermögensposten anlegen, nicht als Konto
+
+*Vermögen & Kasse → Vermögen → Posten anlegen*, Art **Forderung**.
+
+Das ist kein Formalismus, sondern hat zwei handfeste Gründe:
+
+1. **Nur am Vermögensposten kannst du den Nachweis anhängen.** Ein
+   Kontostand trägt eine Quellenangabe, aber kein Dokument. Die
+   Bescheinigung der Genossenschaft — genau das Blatt, das das Gericht
+   sehen will — hätte am Konto keinen Platz.
+2. **Als Konto stünde es in der Kontenliste** und würde dort einen Auszug
+   und Buchungen erwarten, die es nie geben wird.
+
+Trag dann einen **Wertstand** zum Stichtag ein, mit der Bescheinigung als
+Nachweisdokument.
+
+### Den „Kontoauszug" bekommst du schriftlich
+
+Die Genossenschaft stellt dir auf Anfrage eine **Bescheinigung über das
+Geschäftsguthaben** zum Stichtag aus. Viele verschicken ohnehin einmal
+jährlich eine Abrechnung nach der Generalversammlung — dann genügt es,
+diese abzuwarten und einzuscannen.
+
+Fehlt sie, schreib hin. Unter **Vorlagen** liegt das *Auskunftsersuchen*
+als Kopiervorlage; darin änderst du die Bitte auf „Bescheinigung über das
+Geschäftsguthaben zum <Stichtag>". Und setz eine Wiedervorlage.
+
+> **„Der Wert bleibt doch immer gleich."** Meistens ja — aber nicht
+> zwangsläufig. Wird eine **Dividende dem Geschäftsguthaben
+> gutgeschrieben** statt ausgezahlt, wächst es. Ebenso, wenn weitere
+> Anteile gezeichnet wurden. Genau deshalb fragt man einmal im Jahr nach,
+> statt den Vorjahreswert fortzuschreiben.
+
+### Dieselbe Bauform, andere Namen
+
+Nach demselben Muster behandelst du alles, was „Konto" heißt und keinen
+Auszug kennt:
+
+| Was | Als was anlegen | Nachweis |
+|---|---|---|
+| Genossenschaftsanteile | Vermögensposten, *Forderung* | Bescheinigung der Genossenschaft |
+| Bausparvertrag | Vermögensposten, *Forderung* | Jahreskontoauszug der Bausparkasse |
+| Sterbegeld-, Lebensversicherung | **Vertrag**, Rückkaufswert am Vertrag | Rückkaufswertmitteilung |
+| Wertpapierdepot | Konto, Art *Depot* | Depotauszug zum Stichtag |
+| Darlehen, das die Person schuldet | Vermögensposten, *Verbindlichkeit* | Saldenbestätigung der Bank |
+
+Das Depot ist die Ausnahme: Dort laufen Umsätze, es gibt einen Auszug, und
+es verhält sich wie ein Konto.
+
+Bei Versicherungen nimmst du **nicht** den Vermögensbereich, sondern den
+Vertrag selbst — dort gehört der Rückkaufswert hin, samt Historie über die
+Jahre.
+
+---
+
+
+## Anmelden mit dem Finger: Passkeys
+
+Drei Felder auszufüllen, nur um kurz eine Frist nachzusehen, ist lästig —
+und lästige Sicherheit wird umgangen. Ein Passkey macht daraus einen
+Handgriff.
+
+### Einrichten
+
+**Mein Konto → Passkeys.** Gib dem Gerät einen Namen, an dem du es später
+wiedererkennst („iPhone", „Laptop Büro"), und klicke auf *Passkey
+einrichten*. Dein Gerät fragt nach Fingerabdruck, Gesicht oder PIN —
+fertig.
+
+Mach das auf **jedem Gerät**, mit dem du arbeitest. Sie stören sich nicht
+gegenseitig.
+
+### Anmelden
+
+Auf der Anmeldeseite steht unter dem Formular *Mit Passkey anmelden*. Ein
+Klick, ein Finger, drin. Keine E-Mail, kein Passwort, kein Code.
+
+### Warum das nicht unsicherer ist
+
+Es sieht nach weniger aus, ist aber dasselbe — zweimal:
+
+| | Bisher | Mit Passkey |
+|---|---|---|
+| Erster Faktor | Passwort (Wissen) | Das Gerät selbst (Besitz) |
+| Zweiter Faktor | Code aus der App (Besitz) | Fingerabdruck, Gesicht oder PIN |
+
+Der entscheidende Zusatz: **Ein Passkey ist an die Adresse gebunden**,
+unter der du ihn eingerichtet hast. Landest du auf einer nachgebauten
+Anmeldeseite, funktioniert er dort schlicht nicht — er lässt sich nicht
+abtippen und nicht weitergeben. Genau das ist der übliche Weg, an einen
+Code aus der Authenticator-App zu kommen.
+
+Ein Gerät, das den Passkey ohne Fingerabdruck oder PIN freigibt, wird
+abgewiesen. Das wäre nur ein Faktor, und dafür ist hier zu viel zu
+verlieren.
+
+### Die Authenticator-App bleibt
+
+Du kannst sie nicht abschaffen, und das ist Absicht. **Ein Passkey hängt
+an einem Gerät.** Geht das Handy in der Donau baden und wäre der Passkey
+der einzige Weg hinein, käme niemand mehr an die Akte — auch der Bezirk
+nicht, auch das Gericht nicht.
+
+Deshalb: erst Authenticator-App und Wiederherstellungscodes, dann Passkeys.
+Die Anmeldung mit E-Mail, Passwort und Code bleibt daneben immer offen.
+
+### Was in der Liste steht
+
+Unter **Mein Konto → Passkeys** siehst du zu jedem Gerät, wann es
+eingerichtet und wann es zuletzt benutzt wurde. **Sieh da gelegentlich
+hinein.** Ein Eintrag, den du nicht zuordnen kannst, gehört sofort
+entfernt — und danach das Passwort gewechselt.
+
+Steht bei einem Eintrag *gesichert*, wird der Schlüssel vom Anbieter
+mitgesichert (iCloud-Schlüsselbund, Google, Bitwarden) und taucht auf
+einem neuen Gerät von selbst wieder auf. Ohne diesen Vermerk liegt er nur
+auf diesem einen Gerät.
+
+### Wenn ein Gerät verloren geht
+
+1. Auf einem anderen Gerät mit E-Mail, Passwort und Code anmelden.
+2. **Mein Konto → Passkeys**, den Eintrag des verlorenen Geräts entfernen.
+3. Fertig — der Schlüssel auf dem Gerät ist damit wertlos.
+
+Ein Passkey allein reicht ohnehin niemandem, der das Gerät findet: Ohne
+Fingerabdruck oder PIN gibt das Gerät ihn nicht heraus.
+
+### Wenn der Knopf gar nicht erscheint
+
+Dann bietet der Server Passkeys nicht an — das Verfahren verlangt eine
+verschlüsselte Verbindung (`https`). Oder der Browser ist zu alt. Melde
+dich mit E-Mail, Passwort und Code an; alles andere funktioniert
+unverändert.
+
+---
+
+## Am Handy
+
+Die Anwendung ist am Telefon vollwertig bedienbar — sie ist dafür gebaut,
+nicht dafür angepasst.
+
+- Menü über das Symbol links oben, schließt mit Wischen oder Escape.
+- Der **runde Knopf unten rechts** ist immer erreichbar: Beleg
+  fotografieren, Notiz festhalten, Frist anlegen, Buchung erfassen.
+- Tabellen scrollen in ihrem eigenen Rahmen, nie die ganze Seite.
+- Zoomen ist erlaubt und abgeschaltet wird es nie.
+
+Der typische Fall: Du sitzt im Heim, fotografierst die Heimrechnung,
+ordnest sie dem Vorgang zu, hältst den Besuch fest — drei Minuten, und
+abends musst du nichts nacharbeiten.
+
+---
+
+## Wenn etwas schiefgeht
+
+**Ich will den Zugang auf ein zweites Gerät legen.**
+Das Geheimnis wird nur einmal angezeigt, beim Einrichten. Wer es später
+noch einmal braucht — Handy und Tablet, oder ein Ersatzgerät im Schrank —
+liest es auf dem Server aus:
+
+```bash
+docker compose exec app node scripts/totp-geheimnis.mjs deine@adresse.de
+```
+
+Läuft der Behälter noch mit einer Fassung vor 1.0.1, fehlt das Skript im
+Abbild (`Cannot find module`). Dann entweder aktualisieren, oder einmalig:
+
+```bash
+docker compose cp scripts/totp-geheimnis.mjs app:/app/totp-geheimnis.mjs
+docker compose exec app node totp-geheimnis.mjs deine@adresse.de
+```
+
+Das ist keine Hintertür: Es läuft nur mit Zugriff auf die Datenbank **und**
+auf `ENC_KEY_V1`. Wer beides hat, kommt ohnehin an alles. Die Ausgabe
+gehört trotzdem in kein Protokoll und in keine E-Mail.
+
+**Ich habe mein Handy mit der Authenticator-App verloren.**
+Melde dich mit einem deiner Wiederherstellungscodes an — statt der sechs
+Ziffern gibst du den Code im Format `XXXX-XXXX-XXXX` ein. Jeder
+funktioniert einmal. Danach unter **Konto → Zweiter Faktor** neu
+einrichten und **neue Codes erzeugen**.
+
+**Ich habe auch die Wiederherstellungscodes verloren.**
+Dann kommt nur noch jemand mit Zugriff auf den Server weiter, indem er den
+zweiten Faktor in der Datenbank zurücksetzt. Genau deshalb: Codes
+ausdrucken.
+
+**Der Code wird nicht angenommen.**
+Fast immer geht die Uhr des Telefons falsch. TOTP-Codes hängen an der
+Uhrzeit. Stell die automatische Zeitsynchronisierung ein.
+
+**„Zu viele Fehlversuche."**
+Nach fünf Fehlversuchen wird für eine Viertelstunde gesperrt. Warte ab —
+das gilt auch dann, wenn du selbst es warst.
+
+**Ich habe mein Passwort geändert und bin überall abgemeldet.**
+So gewollt. Ein Passwortwechsel beendet alle Sitzungen, auch auf Geräten,
+an denen du gerade nicht sitzt.
+
+**Eine Frist stimmt nicht.**
+Prüf zuerst das Bestellungsdatum unter **Stammdaten**. Änderst du es,
+werden die Pflichtfristen neu berechnet. Erledigte Fristen bleiben dabei
+unangetastet.
+
+**Ein Bericht zeigt eine Differenz.**
+Meistens fehlt ein Saldostand. Der Bericht sagt dir, welcher. Trag ihn
+unter **Vermögen & Kasse → Konten** nach und erzeuge neu.
+
+**Die Texterkennung findet nichts.**
+Sie braucht Tesseract auf dem Server. Fehlt es, funktioniert der Upload
+trotzdem — nur ohne Volltextsuche. Titel und Absender kannst du von Hand
+eintragen.
+
+---
+
+## Was diese Anwendung nicht tut
+
+Damit du dich nicht darauf verlässt:
+
+- **Sie berät dich nicht.** Sie rechnet Fristen und schlägt Einordnungen
+  vor. Ob dein Fall eine Ausnahme ist, weiß sie nicht.
+- **Sie entscheidet nicht, was Schonvermögen ist.** Sie gibt dir
+  Argumentationshilfen zu § 90 SGB XII zum Übernehmen. Entscheiden tun der
+  Träger und notfalls das Sozialgericht.
+- **Sie schätzt keine Bewilligungschancen.**
+- **Sie holt keine Kontoauszüge ab.** Kontobewegungen kommen per
+  CSV-Import oder von Hand.
+- **Sie verschickt nichts.** Anschreiben entstehen als Text zum Kopieren,
+  Berichte als PDF. Absenden musst du selbst — und den Versandnachweis
+  hochladen.
+- **Sie ersetzt deine Papierablage nicht.** Originale bleiben Originale.
+  Deshalb gibt es das Feld für den Ablageort.
+
+---
+
+## Zwei Gewohnheiten, die sich lohnen
+
+**Jeden Kontakt festhalten, sofort.** Auch das kurze Telefonat. Zwanzig
+Sekunden jetzt sparen dir im Januar einen halben Tag.
+
+**Einmal im Jahr die Wiederherstellung üben.** Ein Backup, das nie
+zurückgespielt wurde, ist kein Backup. Die Anleitung steht in der README
+unter *Sicherung und Wiederherstellung*. Zwanzig Minuten, einmal im Jahr.
+
+---
+
+## Wo du weiterkommst
+
+- **Hinweise** in der Anwendung — 37 Karten zu den häufigen Fallstricken,
+  jede mit Rechtsgrundlage und Link zum Gesetzestext.
+- **Protokoll** — jede Änderung, lückenlos und unveränderlich. Dein
+  Nachweis gegenüber Gericht und möglichen Miterben.
+- Dein **Rechtspfleger** beim Betreuungsgericht. Er ist zuständig und
+  antwortet. Bei allem, was genehmigungspflichtig sein könnte: vorher
+  fragen, nicht nachher.
+- Die örtliche **Betreuungsbehörde** und die Betreuungsvereine beraten
+  ehrenamtliche Betreuer kostenlos.

docs/ROADMAP.md

@@ -0,0 +1,397 @@
+# Roadmap
+
+Was als Nächstes drankommt, und warum in dieser Reihenfolge.
+
+**Maßstab ist der Alltag, nicht die Vollständigkeit.** Ein Punkt steht
+weit oben, wenn er entweder etwas Falsches richtigstellt oder jeden Monat
+Zeit spart. Er steht weit unten, wenn er nur schön wäre.
+
+Diese Datei ist eine Absichtserklärung, kein Vertrag. Was sich im Betrieb
+als wichtiger herausstellt, rutscht nach oben.
+
+Stand: 23.08.2026 · Aktuelle Fassung: **1.10.2** ([CHANGELOG](../CHANGELOG.md))
+
+---
+
+## Woher die Punkte kommen
+
+Beim Bauen sind **44 Schema-Wünsche** aufgelaufen — Stellen, an denen das
+Datenmodell etwas nicht abbildet, was die Fachlogik gebraucht hätte. Sie
+liegen einzeln und begründet in [`schema-wuensche/`](schema-wuensche/),
+nach Modul getrennt. Diese Roadmap sortiert sie nach Dringlichkeit und
+bündelt sie zu Releases, die sich in einem Rutsch migrieren lassen.
+
+Dazu kommen die bekannten Einschränkungen aus dem Changelog und das, was
+sich im Betrieb noch zeigen wird.
+
+---
+
+## 1.1 — Was heute noch falsch sein kann
+
+**Ziel:** Kein Wert in der Anwendung soll unter ungünstigen Umständen
+falsch sein, ohne dass man es merkt. Das ist die einzige Art von Fehler,
+die man einem Betreuungsgericht nicht erklären kann.
+
+### Kostenkonto der Immobilie richtigstellen
+
+`Buchung` hat kein `immobilieId`. Das Kostenkonto wertet deshalb über
+Buchungskategorien aus — bei **einem** Grundstück richtig, bei einem
+zweiten still falsch. Die Oberfläche sagt das derzeit an der Auswertung
+dazu; das ist ein Pflaster, keine Lösung.
+
+*Aufwand: klein. Migration: ein Feld, ein Index.*
+
+### Umbuchungen kennen ihr Gegenkonto
+
+Eine Umbuchung zwischen zwei Konten erscheint heute als zwei unverbundene
+Buchungen. In der Rechnungslegung sieht das aus wie eine Ausgabe und eine
+Einnahme — und wer nachrechnet, fragt zu Recht nach.
+
+*Aufwand: klein. Migration: ein selbstbezüglicher Fremdschlüssel.*
+
+### Dublettenschutz beim Import ohne Konto
+
+Der Schutz vor Doppelbuchungen greift über `(kontoId, importReferenz)`.
+Ist kein Konto zugeordnet, greift er nicht — ein zweimal eingelesener
+Auszug erzeugt dann doppelte Buchungen.
+
+*Aufwand: klein. Migration: partieller eindeutiger Index.*
+
+### Rückkaufswert am Vertrag
+
+Der Wert hängt heute am Vermögensposten. In der Vertragsübersicht steht
+deshalb kein Betrag — ausgerechnet dort, wo man ihn beim Telefonat mit dem
+Versicherer braucht. Es ist derselbe Wert, um den es im Anschreiben an den
+Versicherer geht — siehe 1.2a.
+
+*Aufwand: klein. Issue: [#8](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/8).*
+
+### Genau eine Zielspalte je Dokumentverknüpfung
+
+`DokumentVerknuepfung` hat zwölf mögliche Zielspalten; dass genau eine
+gesetzt ist, erzwingt bisher nur die Anwendung. Ein CHECK-Constraint macht
+daraus eine Zusage, die auch bei direktem Datenbankzugriff hält.
+
+*Aufwand: klein. Migration: ein Constraint.*
+
+### Papierkorb für Saldo- und Wertstände
+
+Beide Modelle haben kein `geloeschtAm`. Ein versehentlich eingetragener
+Kontostand lässt sich nur endgültig löschen — was der Zusage widerspricht,
+dass Löschen 30 Tage rückgängig zu machen ist.
+
+*Aufwand: klein.*
+
+### Aufgaben aus Vorlagen entfernen können
+
+Passt eine Aufgabe aus einer Vorgangs-Vorlage im Einzelfall nicht, bleibt
+sie dauerhaft offen stehen und verfälscht jede Fortschrittsanzeige.
+
+*Aufwand: klein.*
+
+---
+
+## 1.2 — Weniger tippen
+
+**Ziel:** Die Handgriffe, die sich jeden Monat wiederholen, kürzer machen.
+
+### Nachforderungen mit stabilem Schlüssel
+
+Der Dublettenschutz beim Übernehmen der Standardcheckliste läuft über die
+Bezeichnung. Wer eine Zeile umbenennt, bekommt sie beim nächsten Mal
+doppelt.
+
+### Bescheid und Frist verbinden
+
+Aus einem Bescheid entsteht die Widerspruchsfrist heute über einen
+Textschlüssel statt über einen Fremdschlüssel. Ändert sich das
+Zugangsdatum, wandert die Frist nicht mit.
+
+### Statuswechsel eines Vorgangs als eigene Tabelle
+
+Der Zeitstrahl liest Statuswechsel aus dem entschlüsselten Audit-Log. Das
+funktioniert, ist aber langsam und hängt an einem Format, das eigentlich
+nur Nachweis sein soll.
+
+### Wer hat was erfasst
+
+Fristen, Saldo- und Wertstände tragen kein Feld für den erfassenden
+Benutzer. Bei einer Betreuung zu zweit ist das die erste Frage.
+
+### Ansprechpartner am Vorgang
+
+Die Sachstandsanfrage kann namentlich anreden, bekommt den Ansprechpartner
+mangels Feld aber nicht übergeben. Gehört zum Schriftverkehr in 1.2a: dort
+entsteht das Schreiben, hier fehlt ihm die Anrede.
+
+*Issue: [#9](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/9).*
+
+### Inventarliste als eigenes Modell
+
+Wertgegenstände hängen heute an Freitext und Fotos. Für die
+Wohnungsauflösung wäre eine Liste mit Bezeichnung, Raum, geschätztem Wert
+und Verbleib das richtige Werkzeug.
+
+### Pflegegrad-Historie
+
+Der Pflegegrad steht als einzelnes Feld in den Stammdaten. Frühere Grade
+mit ihren Zeiträumen gehören in eine Historie — sie werden im
+Jahresbericht und bei einer Höherstufung gebraucht.
+
+---
+
+## 1.2a — Schriftverkehr, der sich nicht wiederholt
+
+**Ziel:** Ein Schreiben wird einmal geschrieben, einmal ausgegeben und
+einmal abgelegt — statt viermal angefasst.
+
+Die Anschreiben an Versicherer und Behörden gibt es heute nur als Text zum
+Markieren und Kopieren. Was danach kommt, macht man von Hand: in Word
+nachbauen, ausdrucken, abschicken und anschließend noch einmal als Dokument
+in die Akte legen. Vergessen wird regelmäßig der letzte Schritt — und dann
+fehlt der Nachweis genau dort, wo er später gebraucht wird.
+
+Nach der Priorisierungsregel am Ende dieser Datei ist das Kriterium 2: Es
+kostet jeden Monat Zeit, und einmal im Jahr — vor Vermögensverzeichnis und
+Jahresbericht — besonders viel. Bisher stand das Thema als einzelne Zeile
+unter „Später, ohne Datum", also unter „wäre schön, und ehrlich gesagt
+vielleicht nie". Das war zu tief gehängt.
+
+Die Punkte bauen aufeinander auf und stehen deshalb in dieser Reihenfolge.
+
+### Verträge überhaupt erst finden
+
+Am Anfang einer Betreuung weiß niemand, welche Verträge es gibt; es liegt
+kein Ordner bereit, und die betreute Person kann es oft selbst nicht mehr
+sagen. Die Antwort steht aber schon im System: **Wer regelmäßig abbucht,
+hat einen Vertrag.** Eine Auswertung der Gegenstellen nach wiederkehrenden
+Zahlungen macht aus hunderten Buchungszeilen eine Liste von Gesellschaften,
+an die zu schreiben ist. Solange die fehlt, nützt die beste Briefvorlage
+nichts — deshalb steht dieser Punkt vor allen anderen.
+
+*Issue: [#3](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/3).*
+
+### Schreiben erzeugen, ablegen, nachhalten
+
+Das Kernstück: eine Word-Datei statt Text zum Kopieren, Ablage als
+Ausgangsdokument mit Empfänger und Versanddatum, Wiedervorlage mit
+vorbelegter Frist. Dazu Empfänger, zu denen es noch keinen Datensatz gibt —
+am Anfang schreibt man ja gerade an Stellen, von denen man erst erfahren
+will, ob dort etwas besteht. Der Text bleibt vor der Ausgabe änderbar, weil
+jeder Fall eine Besonderheit hat, die in den Brief gehört. Die Bausteine
+liegen bereits im Code; was fehlt, ist der durchgehende Weg. Alles Weitere
+in diesem Abschnitt setzt darauf auf.
+
+*Issue: [#4](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/4).*
+
+### Dasselbe Schreiben als E-Mail
+
+Vieles geht per Mail raus, nicht per Brief. Dafür müssen Betreff und Text
+getrennt vorliegen und Absenderblock, Anschrift und Datumszeile
+verschwinden. Auseinandergebaut wird das heute von Hand, und dabei fällt
+regelmäßig etwas heraus, das drinbleiben sollte.
+
+*Issue: [#5](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/5).*
+
+### Rückkaufswerte in einem Zug anfragen
+
+Vor Vermögensverzeichnis und Jahresbericht sind es jedes Mal dieselben fünf
+bis zehn Briefe an dieselben Gesellschaften — einzeln erzeugt, einzeln
+nachgehalten, und bei zwei Dritteln muss nachgefasst werden. Das ist der
+Handgriff, der im Jahr am meisten Zeit kostet, und derjenige, der sich am
+einfachsten bündeln lässt, sobald ein Schreiben ohnehin auf Knopfdruck
+entsteht.
+
+*Issue: [#6](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/6).*
+
+### Eigene Vorlagen
+
+Die Brieftexte stehen fest im Programmcode. Formulierungen, die sich bei
+einer bestimmten Stelle bewährt haben, lassen sich nicht hinterlegen, und
+für Schreiben ohne mitgelieferte Vorlage — Auskunftsersuchen,
+Vollmachtsnachweis, Adressänderung — fängt man bei null an. Wer eine
+Vorlage selbst schreibt, vergisst als Erstes den Bestellungsabsatz; ohne
+den antwortet keine Versicherung, und dann ist ein Monat vergangen. Die
+Vorlagenverwaltung muss ihn deshalb einfordern, statt ihn nur anzubieten.
+
+*Issue: [#7](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/7).*
+
+### Dauerzahlungen gelten als belegt
+
+Ist ein Vertrag erst erfasst, ist er auch der Beleg für die Zahlungen
+daraus. Für zwölf gleiche Lastschriften will niemand zwölf Quittungen
+sehen, sondern die Police. Heute bleibt dafür nur ein Freitextfeld je
+Buchung — stumpfe Arbeit mit einem Ergebnis, das schwächer aussieht als
+die Aktenlage tatsächlich ist. Das Feld gehört in dieselbe Migration wie
+`Buchung.immobilieId` aus 1.1; zwei Wanderungen an derselben Tabelle wären
+Verschwendung.
+
+*Issue: [#11](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/11). Migration: ein Feld, ein Index — gebündelt mit 1.1.*
+
+### Was in 1.1 und 1.2 dazugehört
+
+Zwei Punkte weiter oben sind Teil derselben Sache und bleiben trotzdem
+stehen, wo sie stehen: „Rückkaufswert am Vertrag" ist ein möglicher
+Fehler und deshalb 1.1, „Ansprechpartner am Vorgang" ein Handgriff und
+deshalb 1.2. Gelesen gehören sie hierher — der eine liefert den Wert, um
+den das Anschreiben bittet, der andere die namentliche Anrede.
+
+*Issues: [#8](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/8) und [#9](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/9).*
+
+---
+
+## 1.2b — Passkeys abrunden
+
+Der Grundstock steht seit 1.1.0. Was noch fehlt, ist Bequemlichkeit, nicht
+Sicherheit.
+
+### Passkey direkt im Anmeldefeld anbieten
+
+Browser können einen Passkey im Ausfüllvorschlag des E-Mail-Feldes
+anbieten (*conditional UI*), statt hinter einem eigenen Knopf. Ein Schritt
+weniger. Braucht einen zweiten Challenge-Weg und sorgfältiges Abbrechen,
+wenn stattdessen doch das Passwort getippt wird.
+
+### Passkey umbenennen
+
+Heute geht nur anlegen und entfernen. Wer sein Gerät „Handy" genannt hat
+und inzwischen zwei hat, muss den Passkey neu einrichten.
+
+### Warnen, wenn der letzte Passkey nur auf einem Gerät liegt
+
+Die Liste sagt bereits, ob ein Schlüssel gesichert ist. Wer ausschließlich
+ungesicherte Passkeys hat und dazu keine Wiederherstellungscodes mehr,
+sollte das deutlicher zu sehen bekommen als in einer Zeile Kleingedrucktem.
+
+---
+
+## 1.3 — Belastbarkeit
+
+**Ziel:** Die Stellen absichern, die bisher nur unter Laborbedingungen
+geprüft sind.
+
+### Texterkennung gegen echtes Tesseract
+
+Bisher ist nur der Weg „nicht verfügbar, Upload funktioniert trotzdem"
+getestet. Ein Test im Container gegen echte Schreiben — auch schlechte
+Handyfotos, auch mehrseitige Bescheide — fehlt.
+
+### CAMT.053 gegen einen echten Bankauszug
+
+Der Leser ist gegen selbst gebaute Beispiele geprüft. Ein echter Auszug
+der Sparkasse ist der eigentliche Test.
+
+### Suche und Belegmappe gegen Postgres
+
+Beide sind nur in Einzelteilen geprüft, nicht end-to-end gegen die
+Datenbank mit einigen hundert Dokumenten.
+
+### Wiederherstellung als Test
+
+Die Anleitung dafür steht in der README. Ein Skript, das sie einmal im
+Monat automatisch durchspielt — Sicherung zurückspielen, Diagnosen im
+Klartext prüfen, Testdatenbank verwerfen — wäre der Beweis statt der
+Absichtserklärung.
+
+### Passkey-Ablehnung ohne Browser nachstellen
+
+Die Prüfung „Passkey ohne Nutzerverifikation wird abgewiesen" ist im Code
+doppelt abgesichert und im Browsertest belegt — dort weist allerdings
+schon der Browser ab, der Server kommt gar nicht dran. Ein Test, der die
+Antwort von Hand baut und den Browser umgeht, würde den serverseitigen
+Rückhalt tatsächlich beweisen.
+
+### Barrierefreiheits-Durchgang mit einem Screenreader
+
+Semantik, Fokusreihenfolge und Kontraste sind beim Bauen beachtet und in
+Teilen getestet. Ein Durchgang mit NVDA oder VoiceOver ist etwas anderes
+als eine Testzusicherung.
+
+### `@react-pdf/renderer` ohne Krücke
+
+`src/lib/pdf/standardschrift.ts` gleicht aus, dass die Unterabhängigkeiten
+für Standardschriften kein Schriftobjekt mehr liefern. Ein `overrides`-
+Eintrag in der `package.json` oder eine neuere Fassung macht die Datei
+überflüssig — sie baut sich dann selbst ab.
+
+---
+
+## 2.0 — Mehr als eine Betreuung
+
+**Ziel:** Was sich nur mit einem Bruch lösen lässt. Deshalb eine eigene
+Hauptversion — und deshalb nicht vorher.
+
+### Zweite betreute Person im Alltag erprobt
+
+Das Datenmodell trägt es von Anfang an: Alles hängt an einer `betreuteId`,
+der Zugriff wird gegen sie geprüft, die Auswahl steht in der Seitenleiste.
+**Gelaufen ist es bisher nur mit einer.** Was fehlt, ist Erfahrung — und
+vermutlich ein Dashboard, das über beide hinwegsieht.
+
+### Heimkostenmodell entwirren
+
+Der einrichtungseinheitliche Eigenanteil auf der Heimrechnung ist bereits
+um die Leistung der Pflegekasse gekürzt. Das Modul rechnet deshalb
+ausdrücklich nach der Lesart `EIGENANTEIL_NETTO` und warnt, wenn die
+Pflegekassenleistung zusätzlich erfasst wird.
+
+Sauberer wäre, die beiden Lesarten im Modell zu trennen, statt sie im Kopf
+auseinanderzuhalten. Das ändert bestehende Datensätze — also 2.0.
+
+### Mehrere Fassungen je Bericht
+
+Heute verdrängt die DOCX-Ausgabe die abgegebene PDF-Fassung. Was einmal
+beim Gericht lag, sollte unverändert nachweisbar bleiben.
+
+### Verschlüsselte Ablage auch bei S3
+
+Beim Dateitreiber liegen Dokumente zusätzlich AES-256-GCM-verschlüsselt.
+Bei S3 geht das nicht, weil signierte URLs am Server vorbei ausgeliefert
+werden. Der Ausweg wäre, Dateien durch die Anwendung zu reichen — das
+kostet Durchsatz und ist eine bewusste Abwägung, keine Selbstverständlichkeit.
+
+---
+
+## Später, ohne Datum
+
+Sinnvoll, aber nicht dringend:
+
+- **Kalendarische Wiedervorlage per E-Mail als Wochenübersicht** statt
+  einzelner Erinnerungen.
+- **Import eines Grundbuchauszugs** als strukturierte Daten statt als PDF.
+- **Mehrere Betreuungsgerichte** je betreuter Person (bei Umzug).
+- **Zwei-Personen-Prinzip** für besonders sensible Aktionen — technisch
+  vorbereitet durch die erneute Anmeldung, fachlich noch nicht gebraucht.
+- **Statistik über mehrere Betreuungsjahre** für den eigenen Überblick.
+
+---
+
+## Bewusst nicht geplant
+
+Damit klar ist, worauf niemand warten muss:
+
+| Was | Warum nicht |
+|---|---|
+| **Automatische Rechtsberatung** | Die Anwendung kennt den Einzelfall nicht. Sie rechnet und dokumentiert; entscheiden tun Gericht, Träger und im Zweifel das Sozialgericht. |
+| **Prognosen zu Bewilligungschancen** | Eine Zahl, die niemand belegen kann, wird trotzdem geglaubt. Das ist schlimmer als keine Zahl. |
+| **Direkte Bankanbindung** | Ein dauerhafter Kontozugriff ist ein Risiko, das der Bequemlichkeit nicht wert ist. CSV und CAMT reichen. |
+| **Mehrmandantenfähigkeit für fremde Betreuungen** | Sobald mehrere Betreuer mit fremden Fällen auf derselben Installation arbeiten, ändert sich die datenschutzrechtliche Lage grundlegend. Mehrere Betreute **einer** Person bleiben möglich. |
+| **Native App für Handy und Tablet** | Die Web-Anwendung ist am Telefon vollwertig bedienbar. Eine zweite Oberfläche wäre eine zweite Oberfläche, die veraltet. |
+| **Cloud-Angebot für andere Betreuer** | Dann wäre ich Auftragsverarbeiter für fremde Gesundheitsdaten. Eine andere Aufgabe als die, für die das hier gebaut wurde. |
+| **KI-Auswertung der Akte** | Gesundheitsdaten einer nicht entscheidungsfähigen Person verlassen diesen Server nicht. Die Texterkennung läuft lokal, und dabei bleibt es. |
+
+---
+
+## Wie hier priorisiert wird
+
+Drei Fragen, in dieser Reihenfolge:
+
+1. **Kann daraus ein falscher Wert in einem Bericht ans Gericht werden?**
+   Dann sofort — auch wenn es unbequem ist.
+2. **Kostet es jeden Monat Zeit?** Dann bald.
+3. **Wäre es schön?** Dann irgendwann, und ehrlich gesagt vielleicht nie.
+
+Fällt ein Punkt in Kategorie 1 und wird trotzdem nicht sofort behoben,
+steht der Grund dabei — und die Oberfläche sagt an der betroffenen Stelle,
+worauf man achten muss. Ein stillschweigend falscher Wert ist das
+Schlimmste, was diese Anwendung produzieren kann.

docs/SICHERHEIT.md

@@ -0,0 +1,168 @@
+# Sicherheit
+
+Was in dieser Anwendung gegen welche Bedrohung steht — und was
+ausdrücklich **nicht**. Der zweite Teil ist der wichtigere: Eine Zusage,
+die nicht gilt, ist gefährlicher als eine fehlende, weil man sich auf sie
+verlässt.
+
+Stand: v1.11.0. Die Fassung entstand beim Abarbeiten von Issue #38
+(Sicherheitsprüfung durch ein zweites Modell) und dem eigenen Durchgang
+entlang der OWASP Top 10 (2021).
+
+---
+
+## Das Bedrohungsmodell
+
+Eine ehrenamtliche rechtliche Betreuung. Ein Benutzer, eine betreute
+Person, ein kleiner Server hinter einem Reverse Proxy. In der Datenbank
+liegen Gesundheitsdaten (Art. 9 DSGVO), Kontobewegungen und
+Vermögensverzeichnisse.
+
+Nach Wahrscheinlichkeit geordnet:
+
+| Was | Wie wahrscheinlich | Was dagegen steht |
+|---|---|---|
+| Offene Sitzung an einem unbeaufsichtigten Rechner | hoch | Abmeldung nach 30 min Leerlauf; erneute Bestätigung vor Export, Löschen, Benutzer- und Passkey-Verwaltung |
+| Verlorenes oder gestohlenes Gerät | mittel | Zweiter Faktor ist Pflicht; Passkeys verlangen Nutzerverifikation |
+| Kopiertes Backup, falsch gerechtetes Verzeichnis | mittel | Feldverschlüsselung (AES-256-GCM), Dateien im Umschlag, Schlüssel nur in der Umgebung |
+| Zugangsdaten zum Objektspeicher abhandengekommen | mittel | Objekte liegen verschlüsselt, an ihren Ablageort gebunden |
+| Raten von Passwörtern über das Formular | mittel | Anmeldesperre nach E-Mail **und** Anschluss, Argon2id |
+| Einbruch in den Server selbst | gering | Kaum etwas — wer dort Wurzelrechte hat, hat die Schlüssel |
+
+Der letzte Punkt ist keine Nachlässigkeit, sondern eine Grenze: Die
+Anwendung braucht die Schlüssel zur Laufzeit. Wer den Prozess kontrolliert,
+kommt an sie heran. Dagegen hilft Betriebssicherheit, kein Anwendungscode.
+
+---
+
+## Was ausdrücklich nicht geschützt ist
+
+- **Der Server selbst.** Siehe oben.
+- **Metadaten in der Datenbank.** Verschlüsselt sind einzelne Felder —
+  Diagnosen, IBANs, Verwendungszwecke, Notizen. Dass es einen Vorgang
+  „Betreuungsgericht" gibt und wann er angelegt wurde, steht im Klartext.
+  Sonst ließe sich nichts mehr sortieren oder filtern.
+- **Symlinks im Ablageverzeichnis.** `resolve()` folgt keinen Links. Wer
+  dort einen anlegen kann, hat bereits Schreibrechte im Datenverzeichnis —
+  dann ist der Umweg über einen Link die geringste Sorge. Bis v1.10.2 stand
+  im Code das Gegenteil; der Satz ist entfernt.
+- **Die Middleware prüft keine Anmeldung.** Sie setzt Kopfzeilen, mehr
+  nicht. Der Zugriffsschutz sitzt in `src/lib/auth/sitzung.ts`, und nur
+  dort. Bis v1.10.2 behauptete ein Kommentar das Gegenteil.
+- **Verfügbarkeit.** Es gibt keinen Schutz gegen jemanden, der den Server
+  mit Anfragen überzieht. Bei einem Nutzer hinter einem Proxy ist das die
+  Aufgabe des Proxys.
+
+---
+
+## Der Durchgang entlang der OWASP Top 10 (2021)
+
+### A01 Broken Access Control
+
+Jede Server Action und jede Seite geht durch `erfordereZugang()`, das
+zeilenweise gegen die `betreuteId` prüft — nie nur im UI ausgeblendet.
+Fremdschlüssel aus Formularen werden über `src/lib/auth/verweise.ts`
+geprüft; ein verändertes Auswahlfeld kann keine fremde Akte verknüpfen
+(e2e-Test `fremdakte.spec.ts`).
+
+Weiterleitungsziele laufen durch `sicheresZiel()` — kein offener Redirect.
+
+**Behoben in dieser Runde:** Die MFA-Pflicht galt nur für Seiten, nicht
+für Server Actions und Route Handler. Sie steckt jetzt in
+`erfordereBenutzer()` selbst. `tests/mfa-grenze.test.ts` liest den
+Quelltext und schlägt an, sobald eine weitere Umgehung dazukommt.
+
+### A02 Cryptographic Failures
+
+- Felder: AES-256-GCM, Umschlag `bc1.<version>.<iv>.<tag>.<ct>`, Feldname
+  als Zusatzdaten — ein Geheimtext lässt sich nicht von einem Feld in ein
+  anderes kopieren.
+- Dateien: AES-256-GCM, Umschlag `BCD1`, seit v1.11.0 **beide** Treiber,
+  mit dem Ablageschlüssel als Zusatzdaten.
+- Passwörter: Argon2id, Parameter im Hash, Nachziehen beim Anmelden.
+- Schlüsselrotation über `ENC_KEY_V<n>` / `ENC_KEY_AKTIV`; alte Schlüssel
+  bleiben zum Entschlüsseln stehen.
+- Alle Geheimnisvergleiche laufen über `timingSafeEqual` — geprüft für
+  Reauth-Cookie, Zugriffstoken, ICS-Signatur, Wartungsschlüssel und das
+  Einrichtungsgeheimnis.
+
+**Behoben in dieser Runde:** Der Objektspeicher verließ sich auf
+`ServerSideEncryption: 'AES256'` — den Schlüssel des Anbieters.
+
+### A03 Injection
+
+Prisma parametrisiert. Die fünf Rohabfragen benutzen ausnahmslos
+`Prisma.sql`-Templates; `Prisma.join()` in `suche.ts` fügt nur bereits
+parametrisierte Fragmente zusammen und ist damit unbedenklich.
+
+Zu XSS: `ts_headline` liefert `<mark>`-Marker im Suchausschnitt, und die
+Quelle ist der OCR-Text hochgeladener Dokumente. Gerendert wird er in
+`dokument-liste.tsx` aber nicht als HTML, sondern zerlegt und als React-
+Kinder ausgegeben — also escaped. Das einzige
+`dangerouslySetInnerHTML` der Anwendung setzt eine feste Konstante für die
+Themenumschaltung. **Kein Fund.**
+
+### A04 Insecure Design
+
+Erneute Bestätigung vor den folgenschweren Handlungen. Anmeldesperre nach
+zwei Dimensionen. Löschen ist ein Papierkorb mit 30 Tagen Frist.
+
+**Behoben in dieser Runde:** Passkeys ließen sich ohne erneute
+Bestätigung anlegen und entfernen — ein Passkey ist ein vollwertiger
+Zugang, der einen Passwortwechsel überlebt.
+
+### A05 Security Misconfiguration
+
+CSP mit Nonce pro Anfrage und `strict-dynamic` im Produktivbetrieb; dazu
+`X-Content-Type-Options`, `X-Frame-Options: DENY`, `Referrer-Policy:
+no-referrer`, `Permissions-Policy`, HSTS mit zwei Jahren.
+`poweredByHeader` aus.
+
+**Behoben in dieser Runde:** `trustHost` stand fest auf `true`, obwohl
+`AUTH_URL` gesetzt ist. `X-Forwarded-For` wurde ohne Proxy geglaubt und
+aus dem falschen Ende gelesen.
+
+### A06 Vulnerable and Outdated Components
+
+`npm audit`: 0 Schwachstellen (vorher 32, davon 5 kritisch).
+
+### A07 Identification and Authentication Failures
+
+Passwort + TOTP in einem Schritt, kein Zwischenzustand. Passkeys mit
+erzwungener Nutzerverifikation zählen als zwei Faktoren.
+`sitzungsGeneration` macht alle Sitzungen auf einen Schlag ungültig.
+Antwortzeiten sind angeglichen, damit sich keine E-Mail-Adressen abfragen
+lassen.
+
+**Behoben in dieser Runde:** TOTP-Codes galten mehrfach; die Anmeldesperre
+verlängerte sich selbst; die Ersteinrichtung stand offen und war nicht
+atomar.
+
+### A08 Software and Data Integrity Failures
+
+Zu jedem abgelegten Dokument steht eine SHA-256-Prüfsumme über den
+Klartext in der Datenbank — der Nachweis der Unverändertheit gegenüber dem
+Gericht. Der Umschlag ist authentifiziert (GCM), Veränderungen fallen beim
+Lesen auf.
+
+### A09 Security Logging and Monitoring Failures
+
+`AuditLog` hält Anmeldungen, Fehlversuche, Exporte, Löschungen und
+Passkey-Änderungen fest. Anmeldeversuche stehen zusätzlich in
+`login_versuch` und werden nach 30 Tagen aufgeräumt.
+
+**Behoben in dieser Runde:** Während einer Sperre entstand pro Anfrage
+eine Zeile — die Tabelle ließ sich vollschreiben. Jetzt eine je Sperre.
+
+### A10 Server-Side Request Forgery
+
+Die Anwendung ruft nichts von außen ab: kein `fetch`, keine
+HTTP-Bibliothek, keine Webhooks, keine URL-Vorschauen. Ausgehend geht nur
+SMTP an den konfigurierten Server. **Keine Angriffsfläche.**
+
+---
+
+## Wenn etwas gefunden wird
+
+Kein öffentliches Issue. Der Weg führt über das Dashboard; dort wird
+entschieden, ob und wie es hier landet.

e2e/absenderanschrift.spec.ts

@@ -0,0 +1,97 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Die eigene Anschrift im Schreiben — gegen die echte Anwendung.
+ *
+ * Der Weg, um den es geht: einmal unter „Mein Konto" hinterlegen, und
+ * ab da steht sie im Absenderblock und der Ort in der Datumszeile —
+ * ohne dass man beim Schreiben daran denken muss.
+ */
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+/** Zurück auf „nichts hinterlegt", damit der Fall auch prüfbar bleibt. */
+async function anschriftLeeren(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.user.updateMany({ data: { strasse: null, plz: null, ort: null } })
+  })
+}
+
+test.describe('Absenderanschrift', () => {
+  test.beforeAll(async () => {
+    await anschriftLeeren()
+  })
+
+  test.afterAll(async () => {
+    await anschriftLeeren()
+  })
+
+  test('ohne hinterlegte Anschrift steht nur der Name im Brief', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    const text = await page.locator('textarea#text').inputValue()
+    const zeilen = text.split('\n')
+
+    // Erste Zeile ist der Absender, danach kommt gleich die Leerzeile.
+    expect(zeilen[0]).toBe('Florian Wilde')
+    expect(zeilen[1]).toBe('')
+    // Kein Ort in der Datumszeile, also auch kein Komma davor.
+    expect(text).not.toContain(', den ')
+  })
+
+  test('speichert die Anschrift unter Mein Konto', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/konto')
+
+    await page.locator('input#strasse').fill('Cottenbacher Str. 23')
+    await page.locator('input#plz').fill('95445')
+    await page.locator('input#ort').fill('Bayreuth')
+    await page.getByRole('button', { name: 'Anschrift speichern' }).click()
+
+    await expect(page.getByText('Deine Anschrift ist gespeichert.')).toBeVisible()
+
+    await page.reload()
+    await expect(page.locator('input#strasse')).toHaveValue('Cottenbacher Str. 23')
+  })
+
+  test('trägt sie in Absenderblock und Datumszeile des Schreibens', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    const text = await page.locator('textarea#text').inputValue()
+    const zeilen = text.split('\n')
+
+    expect(zeilen[0]).toBe('Florian Wilde')
+    expect(zeilen[1]).toBe('Cottenbacher Str. 23')
+    expect(zeilen[2]).toBe('95445 Bayreuth')
+    expect(text).toContain('Bayreuth, den ')
+  })
+
+  test('steht auch im Rückkaufswert-Schreiben zum Vertrag', async ({ page }) => {
+    const vertragId = await mitDb(async (db) => {
+      const vertrag = await db.vertrag.findFirst({
+        where: { art: 'LEBENSVERSICHERUNG', geloeschtAm: null },
+        select: { id: true },
+      })
+      return vertrag?.id ?? ''
+    })
+    test.skip(vertragId === '', 'Kein Lebensversicherungsvertrag im Bestand.')
+
+    await anmelden(page)
+    await page.goto(`/schreiben/neu?art=RUECKKAUFSWERT&vertragId=${vertragId}`)
+
+    const text = await page.locator('textarea#text').inputValue()
+    expect(text).toContain('Cottenbacher Str. 23')
+    expect(text).toContain('Bayreuth, den ')
+  })
+})

e2e/ansprechpartner.spec.ts

@@ -0,0 +1,164 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Ansprechpartner am Vorgang — gegen die echte Anwendung.
+ *
+ * Geprüft wird die Zusage, um die es geht: Ein Schreiben zum Vorgang
+ * redet die Sachbearbeiterin namentlich an und trägt ihren Namen über
+ * der Behörde — ohne benannten Ansprechpartner bleibt alles beim Alten.
+ */
+
+const KENNUNG = 'Prüfhausen Partner'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.vorgang.deleteMany({ where: { titel: { contains: KENNUNG } } })
+    await db.kontakt.deleteMany({ where: { name: { contains: KENNUNG } } })
+  })
+}
+
+test.describe('Ansprechpartner am Vorgang', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+    await mitDb(async (db) => {
+      const betreute = await db.betreute.findMany({
+        where: { geloeschtAm: null },
+        select: { id: true },
+      })
+      for (const person of betreute) {
+        await db.kontakt.create({
+          data: {
+            betreuteId: person.id,
+            name: `${KENNUNG} Petra Sachs`,
+            organisation: `${KENNUNG} Bezirk`,
+            rolle: 'SACHBEARBEITER_BEZIRK',
+            anrede: 'FRAU',
+            telefon: '0921 604-1234',
+            strasse: 'Cottenbacher Str. 23',
+            plz: '95445',
+            ort: 'Bayreuth',
+          },
+        })
+        await db.vorgang.create({
+          data: {
+            betreuteId: person.id,
+            titel: `${KENNUNG} Antrag auf Hilfe zur Pflege`,
+            kategorie: 'SOZIALHILFE',
+            status: 'WARTET_AUF_DRITTE',
+            gegenstelle: `${KENNUNG} Bezirk`,
+            aktenzeichen: 'HzP 2026/4711',
+          },
+        })
+      }
+    })
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('bleibt ohne benannten Ansprechpartner bei der allgemeinen Anrede', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vorgaenge')
+    await page.getByRole('link', { name: new RegExp(`${KENNUNG} Antrag`) }).first().click()
+    await page.waitForURL(/\/vorgaenge\/[a-z0-9]+$/)
+
+    await expect(page.getByText('Keiner benannt', { exact: false }).first()).toBeVisible()
+
+    await page.getByRole('button', { name: 'Sachstandsanfrage erzeugen' }).click()
+    const text = await page.locator('textarea#sachstand-text').inputValue()
+    expect(text).toContain('Sehr geehrte Damen und Herren,')
+  })
+
+  test('lässt einen Kontakt als Ansprechpartner wählen und zeigt ihn an', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vorgaenge')
+    await page.getByRole('link', { name: new RegExp(`${KENNUNG} Antrag`) }).first().click()
+    await page.waitForURL(/\/vorgaenge\/[a-z0-9]+$/)
+
+    await page
+      .locator('select[name="ansprechpartnerId"]')
+      .selectOption({ label: `${KENNUNG} Petra Sachs · ${KENNUNG} Bezirk` })
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText('Der Vorgang ist gespeichert.')).toBeVisible()
+
+    await page.reload()
+    const inhalt = await page.locator('body').innerText()
+    // Vor dem Anruf weiß man, wen man fragt — samt Durchwahl.
+    expect(inhalt).toContain(`${KENNUNG} Petra Sachs`)
+    expect(inhalt).toContain('0921 604-1234')
+  })
+
+  test('redet die Sachstandsanfrage namentlich an', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vorgaenge')
+    await page.getByRole('link', { name: new RegExp(`${KENNUNG} Antrag`) }).first().click()
+    await page.waitForURL(/\/vorgaenge\/[a-z0-9]+$/)
+
+    await page.getByRole('button', { name: 'Sachstandsanfrage erzeugen' }).click()
+    const text = await page.locator('textarea#sachstand-text').inputValue()
+    expect(text).toContain('Sehr geehrte Frau Sachs,')
+    expect(text).not.toContain('Sehr geehrte Damen und Herren,')
+    // Der Name steht über der Behörde.
+    const zeilen = text.split('\n')
+    expect(zeilen[0]).toContain('Petra Sachs')
+  })
+
+  test('übernimmt Name und Anschrift in das Schreiben zum Vorgang', async ({ page }) => {
+    const vorgangId = await mitDb(async (db) => {
+      const vorgang = await db.vorgang.findFirst({
+        where: { titel: { contains: KENNUNG }, ansprechpartnerId: { not: null } },
+        select: { id: true },
+      })
+      return vorgang?.id ?? ''
+    })
+    expect(vorgangId).not.toBe('')
+
+    await anmelden(page)
+    await page.goto(`/schreiben/neu?art=SACHSTAND&vorgangId=${vorgangId}`)
+
+    await expect(page.locator('textarea#text')).toBeVisible()
+    const text = await page.locator('textarea#text').inputValue()
+    expect(text).toContain('Sehr geehrte Frau Sachs,')
+
+    // Empfänger und Anschrift sind vorbelegt, nichts abzutippen.
+    await expect(page.locator('input[name="empfaengerName"]').first()).toHaveValue(
+      `${KENNUNG} Petra Sachs`,
+    )
+    expect(await page.locator('textarea#empfaengerAnschrift').first().inputValue()).toContain(
+      '95445 Bayreuth',
+    )
+  })
+
+  test('hält den Wechsel des Ansprechpartners mit Namen im Protokoll fest', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vorgaenge')
+    await page.getByRole('link', { name: new RegExp(`${KENNUNG} Antrag`) }).first().click()
+    await page.waitForURL(/\/vorgaenge\/[a-z0-9]+$/)
+
+    // Zurück auf „keiner benannt" — der Wechsel muss nachvollziehbar sein.
+    await page.locator('select[name="ansprechpartnerId"]').selectOption('')
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText('Der Vorgang ist gespeichert.')).toBeVisible()
+
+    // Im Protokoll steht der Name, nicht die Id: Zwei cuids nebeneinander
+    // sind protokolliert, aber nicht nachvollziehbar.
+    await page.goto('/protokoll')
+    // textContent statt innerText: Die Felderliste steckt in einem
+    // zugeklappten <details>.
+    const protokoll = (await page.locator('body').textContent()) ?? ''
+    expect(protokoll).toContain('ansprechpartner')
+    expect(protokoll).toContain(`${KENNUNG} Petra Sachs`)
+  })
+})

e2e/benutzermenue.spec.ts

@@ -0,0 +1,117 @@
+import { expect, test } from '@playwright/test'
+import type { Page } from '@playwright/test'
+import { anmelden } from './hilfen'
+
+/**
+ * Das Benutzermenü muss erreichbar sein, ohne danach zu suchen.
+ *
+ * Anlass ist Issue #1: Am Schreibtisch war „Mein Konto" praktisch nicht
+ * zu finden — und damit auch nicht der Passwortwechsel, der zweite Faktor
+ * und die Passkey-Verwaltung. Die Seitenleiste hatte keine feste Höhe und
+ * wuchs mit der Seite mit; ihr Fuß landete deshalb am Ende der Seite statt
+ * am unteren Bildschirmrand. Auf `/heute` waren das 1632 Pixel bei 900
+ * Pixel Fensterhöhe.
+ *
+ * Der Fehler sah nach nichts aus: Kein Element fehlte, nichts war kaputt,
+ * die Seite sah richtig aus. Man musste nur ans Seitenende scrollen — und
+ * darauf kommt niemand, der eine Seitenleiste vor sich hat.
+ *
+ * Geprüft wird deshalb nicht „ist das Element im DOM", sondern „steht es
+ * im sichtbaren Bereich".
+ */
+
+/** Der Auslöser des Benutzermenüs in der Seitenleiste am Schreibtisch. */
+function ausloeserInSeitenleiste(seite: Page) {
+  return seite.locator('aside button[aria-haspopup="menu"]')
+}
+
+/** Steht das Element vollständig im Fenster, ohne zu scrollen? */
+async function imSichtbarenBereich(seite: Page, auswahl: string): Promise<boolean> {
+  return seite.evaluate((sel) => {
+    const el = document.querySelector(sel)
+    if (!el) return false
+    const k = el.getBoundingClientRect()
+    return k.top >= 0 && k.bottom <= window.innerHeight && k.height > 0
+  }, auswahl)
+}
+
+test.describe('Benutzermenü am Schreibtisch', () => {
+  test.skip(({ isMobile }) => Boolean(isMobile), 'Am Handy sitzt es in der Kopfzeile.')
+
+  test('steht auch auf langen Seiten im Bild, ohne zu scrollen', async ({ page }) => {
+    await anmelden(page)
+
+    // Seiten, die laenger sind als das Fenster - genau dort trat der
+    // Fehler auf. /fristen ist als Gegenprobe kurz.
+    for (const ziel of ['/heute', '/vorgaenge', '/dokumente', '/finanzen', '/fristen']) {
+      await page.goto(ziel)
+      await page.waitForLoadState('networkidle')
+
+      const sichtbar = await imSichtbarenBereich(page, 'aside button[aria-haspopup="menu"]')
+      expect(sichtbar, `Benutzermenü nicht im Bild auf ${ziel}`).toBe(true)
+    }
+  })
+
+  test('bleibt an jeder Scrollposition stehen', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/heute')
+    await page.waitForLoadState('networkidle')
+
+    // Bewusst auch die Mitte pruefen. Nur oben und unten zu messen genuegt
+    // nicht: Eine mitwachsende Leiste ist am Seitenende zufaellig doch
+    // sichtbar - der Test waere dann gruen und der Fehler trotzdem da.
+    for (const anteil of [0, 0.5, 1]) {
+      await page.evaluate((a) => {
+        const hoehe = document.documentElement.scrollHeight - window.innerHeight
+        window.scrollTo(0, hoehe * a)
+      }, anteil)
+      await page.waitForTimeout(250)
+
+      const sichtbar = await imSichtbarenBereich(page, 'aside button[aria-haspopup="menu"]')
+      expect(sichtbar, `Benutzermenü nicht im Bild bei ${anteil * 100}% Scrollposition`).toBe(true)
+    }
+  })
+
+  test('führt in zwei Klicks nach „Mein Konto"', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/heute')
+
+    await ausloeserInSeitenleiste(page).click()
+    await page.getByRole('menuitem', { name: 'Mein Konto' }).click()
+
+    await page.waitForURL('**/konto')
+    // Und dort steht auch, worum es im Issue ging.
+    await expect(page.getByRole('heading', { name: 'Mein Konto' })).toBeVisible()
+    await expect(page.getByRole('heading', { name: 'Passwort ändern' })).toBeVisible()
+    await expect(page.getByRole('heading', { name: 'Passkeys' })).toBeVisible()
+  })
+
+  test('bleibt auf einem flachen Fenster erreichbar', async ({ page }) => {
+    // Ein Laptop mit 1280x620 ist knapp: Kopf, Betreutenauswahl,
+    // Navigation und Fuss muessen zusammen hineinpassen. Die Navigation
+    // dazwischen darf scrollen, der Fuss nicht verschwinden.
+    await anmelden(page)
+    await page.setViewportSize({ width: 1280, height: 620 })
+    await page.goto('/heute')
+    await page.waitForLoadState('networkidle')
+
+    expect(await imSichtbarenBereich(page, 'aside button[aria-haspopup="menu"]')).toBe(true)
+  })
+})
+
+test.describe('Benutzermenü am Handy', () => {
+  test.skip(({ isMobile }) => !isMobile, 'Am Schreibtisch sitzt es in der Seitenleiste.')
+
+  test('steht in der Kopfzeile und bleibt beim Scrollen stehen', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/heute')
+    await page.waitForLoadState('networkidle')
+
+    expect(await imSichtbarenBereich(page, 'header button[aria-haspopup="menu"]')).toBe(true)
+
+    await page.evaluate(() => window.scrollTo(0, document.documentElement.scrollHeight))
+    await page.waitForTimeout(300)
+
+    expect(await imSichtbarenBereich(page, 'header button[aria-haspopup="menu"]')).toBe(true)
+  })
+})

e2e/dauerzahlung.spec.ts

@@ -0,0 +1,176 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Dauerzahlungen zu einem Vertrag — gegen die echte Anwendung.
+ *
+ * Die Einheitstests nageln die Belegzustände fest. Hier geht es um das, was
+ * sie nicht sehen: Kommt die Zuordnung in der Datenbank an, verschwindet die
+ * Buchung wirklich aus „Beleg fehlt", und trägt die abweichende Zahlung
+ * sichtbar die Warnung?
+ *
+ * Der Test legt Vertrag und Buchungen selbst an und räumt sie weg.
+ */
+
+const GESELLSCHAFT = 'Prüfhausen Rentenversicherung'
+const VERTRAG = 'Prüfhausen Rente (Test)'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.buchung.deleteMany({ where: { gegenstelle: GESELLSCHAFT } })
+    await db.vertrag.deleteMany({ where: { bezeichnung: VERTRAG } })
+  })
+}
+
+/**
+ * Sechs passende Monatsraten plus eine, die zehnmal so hoch ist.
+ * Die letzte ist der eigentliche Prüffall.
+ */
+async function testdatenAnlegen(): Promise<void> {
+  await mitDb(async (db) => {
+    const betreute = await db.betreute.findMany({
+      where: { geloeschtAm: null },
+      select: { id: true },
+    })
+
+    for (const person of betreute) {
+      const vertrag = await db.vertrag.create({
+        data: {
+          betreuteId: person.id,
+          bezeichnung: VERTRAG,
+          gesellschaft: GESELLSCHAFT,
+          art: 'RENTENVERSICHERUNG_PRIVAT',
+          beitragCent: 4250n,
+          rhythmus: 'MONATLICH',
+        },
+        select: { id: true },
+      })
+
+      const konto = await db.konto.findFirst({
+        where: { betreuteId: person.id, geloeschtAm: null },
+        select: { id: true },
+      })
+
+      const gemeinsam = {
+        betreuteId: person.id,
+        kontoId: konto?.id ?? null,
+        richtung: 'AUSGABE' as const,
+        kategorie: 'VERSICHERUNG' as const,
+        betrifftBetreute: true,
+        gegenstelle: GESELLSCHAFT,
+      }
+
+      for (let monat = 1; monat <= 6; monat++) {
+        await db.buchung.create({
+          data: {
+            ...gemeinsam,
+            datum: new Date(Date.UTC(2026, monat - 1, 1)),
+            betragCent: 4250n,
+          },
+        })
+      }
+
+      // Die Ausreißerin: schon zugeordnet, aber zehnmal so hoch.
+      await db.buchung.create({
+        data: {
+          ...gemeinsam,
+          datum: new Date(Date.UTC(2026, 6, 1)),
+          betragCent: 42_500n,
+          vertragId: vertrag.id,
+        },
+      })
+    }
+  })
+}
+
+test.describe('Dauerzahlungen', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+    await testdatenAnlegen()
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('ordnet alle Zahlungen einer Gruppe in einem Schritt zu', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    // Der Vertrag liegt vor, also steht die Gruppe unter „schon zugeordnet".
+    const eintrag = page.locator('li', { hasText: VERTRAG }).first()
+    await expect(eintrag).toBeVisible()
+
+    // Sechs offene Zahlungen — die siebte hängt schon am Vertrag.
+    const knopf = eintrag.getByRole('button', { name: /6 Zahlungen als belegt zuordnen/ })
+    await expect(knopf).toBeVisible()
+    await knopf.click()
+
+    // Die Rückmeldung ist der neue Zustand, nicht eine Meldung: Sind alle
+    // Zahlungen zugeordnet, verschwindet der Knopf und die Gruppe meldet
+    // sich als vollständig.
+    await expect(eintrag).toContainText('Alle 7 Zahlungen sind dem Vertrag zugeordnet')
+    await expect(eintrag.getByRole('button', { name: /als belegt zuordnen/ })).toHaveCount(0)
+  })
+
+  test('zeigt die Zahlungen danach als durch Vertrag belegt', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const zeilen = page.locator('tr', { hasText: GESELLSCHAFT })
+    await expect(zeilen.first()).toBeVisible()
+
+    // Die passenden Raten gelten als belegt …
+    await expect(page.getByText('durch Vertrag belegt').first()).toBeVisible()
+    // … und keine davon steht mehr als „Beleg fehlt".
+    const zeileMitFehlt = page.locator('tr', { hasText: GESELLSCHAFT }).filter({
+      hasText: 'Beleg fehlt',
+    })
+    await expect(zeileMitFehlt).toHaveCount(0)
+  })
+
+  test('markiert die abweichende Zahlung zur Prüfung, statt sie durchzuwinken', async ({
+    page,
+  }) => {
+    // Die Zusage, auf der alles steht: Die Zuordnung darf keine Hintertür
+    // sein, durch die eine verzehnfachte Prämie unbemerkt als belegt gilt.
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const ausreisser = page.locator('tr', { hasText: '425,00' })
+    await expect(ausreisser).toContainText('Betrag prüfen')
+  })
+
+  test('nimmt die Zuordnung aus der Kachel auf „Heute“ heraus', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/heute')
+
+    // Die sechs zugeordneten Zahlungen dürfen dort nicht mehr auftauchen.
+    const kachel = page.locator('section, div').filter({ hasText: 'Unverbuchte Belege' }).last()
+    await expect(kachel).not.toContainText(GESELLSCHAFT)
+  })
+
+  test('fällt zurück in „Beleg fehlt“, wenn der Vertrag verschwindet', async ({ page }) => {
+    // Ein Nachweis, der auf etwas zeigt, das es nicht mehr gibt, wäre
+    // schlimmer als gar keiner.
+    await mitDb(async (db) => {
+      await db.vertrag.deleteMany({ where: { bezeichnung: VERTRAG } })
+    })
+
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const zeilen = page.locator('tr', { hasText: GESELLSCHAFT })
+    await expect(zeilen.first()).toContainText('Beleg fehlt')
+  })
+})

e2e/demofall.spec.ts

@@ -0,0 +1,138 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Der Demo-Fall mit Kontobewegungen — gegen die echte Anwendung.
+ *
+ * Was hier geprüft wird, ist kein Verhalten der Anwendung, sondern die
+ * Brauchbarkeit der Beispieldaten: Wer die Anwendung zum ersten Mal
+ * ansieht, soll auf den Finanzseiten etwas vorfinden und nicht erst
+ * eine CSV importieren müssen.
+ *
+ * Die Prüfungen sind bewusst grob gehalten — sie sollen anschlagen, wenn
+ * der Demo-Fall leer läuft, und nicht bei jeder geänderten Zahl.
+ */
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+test.describe('Demo-Fall', () => {
+  test('bringt ein Jahr Kontobewegungen mit', async () => {
+    const zahlen = await mitDb(async (db) => {
+      const betreute = await db.betreute.findFirst({
+        where: { vorname: 'Erika', nachname: 'Musterfrau' },
+        select: { id: true },
+      })
+      if (!betreute) return null
+
+      const buchungen = await db.buchung.findMany({
+        where: { betreuteId: betreute.id, geloeschtAm: null },
+        select: { datum: true },
+        orderBy: { datum: 'asc' },
+      })
+      const ohneNachweis = await db.buchung.count({
+        where: { betreuteId: betreute.id, belegId: null, belegFehltBegruendung: null },
+      })
+      return { buchungen, ohneNachweis }
+    })
+
+    test.skip(zahlen === null, 'Kein Demo-Fall in dieser Datenbank.')
+    if (!zahlen) return
+
+    expect(zahlen.buchungen.length).toBeGreaterThan(50)
+
+    // Über mindestens zwölf Monate verteilt, nicht alle an einem Tag.
+    const erste = zahlen.buchungen[0]!.datum
+    const letzte = zahlen.buchungen[zahlen.buchungen.length - 1]!.datum
+    const monate =
+      (letzte.getUTCFullYear() - erste.getUTCFullYear()) * 12 +
+      (letzte.getUTCMonth() - erste.getUTCMonth())
+    expect(monate).toBeGreaterThanOrEqual(11)
+
+    // Genau ein Fall ohne Beleg und ohne Begründung — sonst hätte die
+    // Belegpflicht nichts zu zeigen, oder zu viel.
+    expect(zahlen.ohneNachweis).toBe(1)
+  })
+
+  test('der Kontostand stimmt mit der Summe der Buchungen überein', async () => {
+    const ergebnis = await mitDb(async (db) => {
+      const konto = await db.konto.findFirst({
+        where: { art: 'GIRO', betreute: { vorname: 'Erika', nachname: 'Musterfrau' } },
+        select: { id: true },
+      })
+      if (!konto) return null
+
+      const staende = await db.saldostand.findMany({
+        where: { kontoId: konto.id },
+        orderBy: { stichtag: 'asc' },
+      })
+      if (staende.length < 2) return null
+
+      const [anfang, ende] = [staende[0]!, staende[staende.length - 1]!]
+      const bewegungen = await db.buchung.findMany({
+        where: {
+          kontoId: konto.id,
+          geloeschtAm: null,
+          datum: { gt: anfang.stichtag, lte: ende.stichtag },
+        },
+        select: { betragCent: true, richtung: true },
+      })
+
+      const summe = bewegungen.reduce(
+        (wert, b) => (b.richtung === 'EINNAHME' ? wert + b.betragCent : wert - b.betragCent),
+        0n,
+      )
+      return { erwartet: anfang.betragCent + summe, tatsaechlich: ende.betragCent }
+    })
+
+    test.skip(ergebnis === null, 'Kein Demo-Fall mit zwei Kontoständen.')
+    if (!ergebnis) return
+
+    // Ein Demo-Fall, der sich selbst widerspricht, ist schlimmer als
+    // einer ohne Buchungen: Man rechnet nach und verliert das Vertrauen.
+    expect(ergebnis.tatsaechlich).toBe(ergebnis.erwartet)
+  })
+
+  test('die Erkennung wiederkehrender Zahlungen findet mehrere Gruppen', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    const inhalt = await page.locator('body').innerText()
+
+    // Monatliches und Vierteljährliches, beides erkannt.
+    expect(inhalt).toContain('Seniorenzentrum')
+    expect(inhalt).toContain('TeleCare')
+    expect(inhalt).toContain('Beitragsservice')
+    expect(inhalt).toContain('monatlich')
+    expect(inhalt).toContain('vierteljährlich')
+
+    // Der eigentliche Vorführeffekt: Das Heim steht in drei Schreibweisen
+    // auf dem Auszug und wird trotzdem als eine Zahlung geführt.
+    expect(inhalt).toContain('3 Schreibweisen zusammengefasst')
+
+    // Die Sterbekasse steht im zweiten Abschnitt: Zu ihr gibt es einen
+    // Vertrag, die Zahlungen sind ihm aber noch nicht zugeordnet. Damit
+    // lässt sich der Handgriff aus der Dauerzahlungs-Zuordnung am
+    // Demo-Fall ausprobieren, statt ihn nur zu beschreiben.
+    expect(inhalt).toContain('Schon einem Vertrag zugeordnet')
+    expect(inhalt).toContain('Nordheim Sterbekasse')
+    expect(inhalt).toContain('als belegt zuordnen')
+  })
+
+  test('das Kassenbuch zeigt die Buchungen und die fehlende Quittung', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const inhalt = await page.locator('body').innerText()
+    expect(inhalt).toContain('Heimentgelt')
+    // Die eine Buchung ohne Quittung und ohne Begründung.
+    expect(inhalt).toContain('Modehaus Lindner')
+  })
+})

e2e/email.spec.ts

@@ -0,0 +1,123 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Schreiben als E-Mail — gegen die echte Anwendung.
+ *
+ * Geprüft wird der Weg, den die Einheitstests nicht sehen: Umschalten auf
+ * E-Mail, die abgeleitete Fassung ohne Briefkopf, der .eml-Download und
+ * die Ablage, die das Schreiben als E-Mail kennzeichnet.
+ */
+
+const KONTAKT = 'Prüfhausen Versicherung (E-Mail-Test)'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.dokument.deleteMany({ where: { empfaenger: { contains: 'Prüfhausen' } } })
+    await db.frist.deleteMany({ where: { titel: { contains: 'Antwort abwarten' } } })
+    await db.kontakt.deleteMany({ where: { name: { contains: 'Prüfhausen' } } })
+  })
+}
+
+test.describe('Schreiben als E-Mail', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+    await mitDb(async (db) => {
+      const betreute = await db.betreute.findMany({
+        where: { geloeschtAm: null },
+        select: { id: true },
+      })
+      for (const person of betreute) {
+        await db.kontakt.create({
+          data: {
+            betreuteId: person.id,
+            name: KONTAKT,
+            organisation: KONTAKT,
+            rolle: 'SONSTIGES',
+            email: 'service@pruefhausen.example',
+          },
+        })
+      }
+    })
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('leitet die E-Mail-Fassung ohne Briefkopf ab, mit Bestellungsabsatz', async ({
+    page,
+  }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    // Kontakt wählen - bringt die E-Mail-Adresse mit.
+    await page.locator('select#kontaktAuswahl').selectOption({ label: `${KONTAKT}` })
+    await expect(page.locator('input#empfaengerEmail')).toHaveValue(
+      'service@pruefhausen.example',
+    )
+
+    await page.getByRole('button', { name: 'Als E-Mail' }).click()
+
+    const mailtext = await page.locator('textarea#emailText').inputValue()
+    // Beginnt mit der Anrede - kein Absenderblock, keine Datumszeile.
+    expect(mailtext.startsWith('Sehr geehrte')).toBe(true)
+    expect(mailtext).not.toMatch(/^\d{1,2}\.\d{1,2}\.\d{4}$/m)
+    // Der Nachweis der Bestellung bleibt drin.
+    expect(mailtext).toMatch(/Betreuungsgericht|bestellt/i)
+  })
+
+  test('lädt den .eml-Entwurf herunter', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+    await page.locator('select#kontaktAuswahl').selectOption({ label: `${KONTAKT}` })
+    await page.getByRole('button', { name: 'Als E-Mail' }).click()
+
+    const [download] = await Promise.all([
+      page.waitForEvent('download'),
+      page.getByRole('button', { name: 'Als E-Mail-Entwurf (.eml)' }).click(),
+    ])
+
+    expect(download.suggestedFilename()).toMatch(/^\d{4}-\d{2}-\d{2}_.*\.eml$/)
+  })
+
+  test('zeigt ohne Adresse keine Mailprogramm-Knöpfe', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+    await page.getByRole('button', { name: 'Als E-Mail' }).click()
+
+    // Kopieren geht immer, die Programm-Knöpfe nicht.
+    await expect(page.getByRole('button', { name: 'Text kopieren' }).last()).toBeVisible()
+    await expect(page.getByRole('button', { name: 'Als E-Mail-Entwurf (.eml)' })).toHaveCount(0)
+    await expect(page.getByRole('link', { name: 'Im Mailprogramm öffnen' })).toHaveCount(0)
+    await expect(page.getByText(/Trag oben eine E-Mail-Adresse ein/)).toBeVisible()
+  })
+
+  test('legt die E-Mail als solche gekennzeichnet in die Akte', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+    await page.locator('select#kontaktAuswahl').selectOption({ label: `${KONTAKT}` })
+
+    await page.locator('input#betreff').fill('Prüfhausen Testanfrage')
+    await page.getByRole('button', { name: 'Als E-Mail' }).click()
+    await page.getByRole('button', { name: 'In die Akte legen' }).click()
+
+    await expect(page.getByText('Das Schreiben liegt in der Akte.')).toBeVisible({
+      timeout: 30_000,
+    })
+
+    // In der Akte als E-Mail erkennbar, nicht als Brief.
+    await page.goto('/dokumente?richtung=AUSGANG')
+    await expect(page.locator('body')).toContainText('E-Mail: Prüfhausen Testanfrage')
+  })
+})

e2e/fremdakte.spec.ts

@@ -0,0 +1,116 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Verweise über Aktengrenzen hinweg — gegen die echte Anwendung.
+ *
+ * Die Auswahllisten im Browser zeigen nur die eigene Akte. Darauf darf
+ * sich der Server nicht verlassen: Wer das Formular verändert, schickt
+ * jede beliebige Id.
+ *
+ * Genau das wird hier nachgestellt — nicht als nachgebauter Aufruf,
+ * sondern indem dem echten Auswahlfeld ein Eintrag mit einer fremden Id
+ * untergeschoben und das Formular ganz normal abgeschickt wird. Nur so
+ * beweist der Test etwas: Er liefe rot, wenn die Prüfung fehlte.
+ *
+ * Solange nur eine betreute Person angelegt ist, wäre der Fehler
+ * folgenlos. Er bliebe es nicht — ein fremder Name stünde im Briefkopf.
+ */
+
+const KENNUNG = 'Prüfhausen Fremdakte'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.betreute.deleteMany({ where: { nachname: { contains: 'Fremdakte' } } })
+  })
+}
+
+test.describe('Verweise auf eine fremde Akte', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('weist einen Kontakt aus einer anderen Akte ab', async ({ page }) => {
+    // Zweite Akte mit einem Kontakt darin — der angemeldete Benutzer hat
+    // auf sie keinen Zugriff.
+    const fremderKontakt = await mitDb(async (db) => {
+      const fremde = await db.betreute.create({
+        data: {
+          vorname: 'Otto',
+          nachname: `${KENNUNG} Fremdakte`,
+          geburtsdatum: new Date(Date.UTC(1940, 0, 1)),
+        },
+      })
+      const kontakt = await db.kontakt.create({
+        data: {
+          betreuteId: fremde.id,
+          name: `${KENNUNG} Fremder Sachbearbeiter`,
+          rolle: 'SACHBEARBEITER_BEZIRK',
+        },
+      })
+      return kontakt.id
+    })
+
+    await anmelden(page)
+    // Irgendeinen Vorgang der eigenen Akte öffnen.
+    const vorgangId = await mitDb(async (db) => {
+      const vorgang = await db.vorgang.findFirst({
+        where: { geloeschtAm: null, betreute: { vorname: 'Erika' } },
+        select: { id: true },
+      })
+      return vorgang?.id ?? ''
+    })
+    test.skip(vorgangId === '', 'Kein Vorgang in der eigenen Akte.')
+
+    await page.goto(`/vorgaenge/${vorgangId}`)
+    const auswahl = page.locator('select[name="ansprechpartnerId"]')
+    await auswahl.waitFor()
+
+    // Dem echten Auswahlfeld die fremde Id unterschieben und ganz normal
+    // abschicken — so, wie es ein verändertes Formular täte.
+    await auswahl.evaluate((feld, id) => {
+      const eintrag = document.createElement('option')
+      eintrag.value = id
+      eintrag.textContent = 'untergeschoben'
+      ;(feld as HTMLSelectElement).append(eintrag)
+      ;(feld as HTMLSelectElement).value = id
+    }, fremderKontakt)
+
+    await page.getByRole('button', { name: 'Speichern' }).click()
+
+    // Der Server lehnt ab, mit einer Meldung, die den Grund nennt.
+    // Grosszuegige Frist: Im Entwicklungsmodus wird die Server Action beim
+    // ersten Aufruf uebersetzt, und das dauert laenger als die Vorgabe.
+    await expect(page.getByText(/gehört nicht zu dieser betreuten Person/).first()).toBeVisible({
+      timeout: 45_000,
+    })
+
+    // Und vor allem: Die Verknüpfung ist nicht entstanden.
+    const verknuepft = await mitDb((db) =>
+      db.vorgang.count({ where: { ansprechpartnerId: fremderKontakt } }),
+    )
+    expect(verknuepft).toBe(0)
+  })
+
+  test('die Auswahlliste zeigt den fremden Kontakt gar nicht erst', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vorgaenge')
+
+    const inhalt = await page.locator('body').innerText()
+    expect(inhalt).not.toContain('Fremder Sachbearbeiter')
+  })
+})

e2e/hilfen.ts

@@ -117,3 +117,46 @@ export function beispielPdf(text = 'Bescheid'): Buffer {
 
   return Buffer.from(pdf, 'latin1')
 }
+
+/**
+ * Doppelt gerenderte Listen — was beim Suchen schiefgeht.
+ *
+ * Die Dokumentenliste (und moeglicherweise kuenftig weitere) rendert
+ * denselben Inhalt ZWEIMAL: als Karten fuers Handy, als Tabelle ab
+ * Tablet. Eine der beiden Fassungen ist per Breakpoint versteckt, steht
+ * aber im DOM.
+ *
+ * Die Folge im Test:
+ *
+ *   await expect(page.getByText('Bescheid').first()).toBeVisible()
+ *   // -> "element is not visible", obwohl die Seite richtig aussieht
+ *
+ * `.first()` nimmt, was zuerst im Baum steht - und das ist die Karte,
+ * also am Schreibtisch die unsichtbare Fassung. Es liegt NICHT an der
+ * Anwendung.
+ *
+ * Nachgemessen an /dokumente mit acht Dokumenten: Ein Titel liefert 16
+ * Treffer, davon 8 sichtbar - und `.first()` ist unsichtbar.
+ *
+ * Drei Wege, die tragen:
+ *
+ *   1. Ueber den Seitentext pruefen, wenn es nur um "steht das da?" geht:
+ *
+ *        const inhalt = await page.locator('body').innerText()
+ *        expect(inhalt).toContain('Bescheid')
+ *
+ *      innerText liefert nur sichtbaren Text - die versteckte Fassung
+ *      faellt von selbst weg. (Fuer Inhalt in einem zugeklappten
+ *      <details> braucht es dagegen textContent.)
+ *
+ *   2. Auf die sichtbare Fassung einschraenken, wenn geklickt wird:
+ *
+ *        page.getByRole('link', { name: 'Bescheid' }).locator('visible=true')
+ *
+ *   3. Die Zusammenfassungszeile pruefen ("12 Dokumente"), wenn es um
+ *      Anzahlen geht - die steht nur einmal.
+ *
+ * Was nicht traegt: eine feste Anzahl erwarten. `getByText(...)` findet
+ * jeden Eintrag zweimal, und wer das mit toHaveCount(1) prueft, schreibt
+ * einen Test, der bei jeder Layoutaenderung umfaellt.
+ */

e2e/passkey.spec.ts

@@ -0,0 +1,188 @@
+import { expect, test } from '@playwright/test'
+import type { BrowserContext, CDPSession, Page } from '@playwright/test'
+import { anmelden, fehlversucheLoeschen } from './hilfen'
+
+/**
+ * Passkeys gegen einen echten Browser.
+ *
+ * WebAuthn laesst sich nicht sinnvoll mit Einheitstests pruefen: Was zaehlt,
+ * passiert zwischen Browser und Authenticator. Chromium bringt dafuer einen
+ * virtuellen Authenticator mit, der ueber das Debugprotokoll gesteuert wird -
+ * er signiert echt, nur ohne Fingerabdrucksensor.
+ *
+ * Damit laesst sich der Ablauf vollstaendig durchspielen: einrichten,
+ * abmelden, mit Passkey anmelden, entfernen. Und, wichtiger, der Fall, den
+ * die Zusage dieser Anwendung traegt - ein Geraet OHNE Nutzerverifikation
+ * darf nicht hereinkommen.
+ */
+
+type VirtuellerAuthenticator = {
+  cdp: CDPSession
+  id: string
+}
+
+async function authenticatorAnlegen(
+  kontext: BrowserContext,
+  seite: Page,
+  verifiziert = true,
+): Promise<VirtuellerAuthenticator> {
+  const cdp = await kontext.newCDPSession(seite)
+  await cdp.send('WebAuthn.enable')
+
+  const { authenticatorId } = await cdp.send('WebAuthn.addVirtualAuthenticator', {
+    options: {
+      protocol: 'ctap2',
+      // "internal" = im Geraet verbaut, wie Face ID oder Windows Hello.
+      transport: 'internal',
+      // Auffindbarer Schluessel - Voraussetzung fuer die Anmeldung ohne
+      // vorherige Eingabe der E-Mail-Adresse.
+      hasResidentKey: true,
+      hasUserVerification: true,
+      isUserVerified: verifiziert,
+      automaticPresenceSimulation: true,
+    },
+  })
+
+  return { cdp, id: authenticatorId }
+}
+
+async function passkeyEinrichten(seite: Page, name: string): Promise<void> {
+  await seite.goto('/konto')
+  await seite.getByLabel('Neues Gerät').fill(name)
+  await seite.getByRole('button', { name: 'Passkey einrichten' }).click()
+  await expect(seite.getByText(`„${name}“ ist eingerichtet.`)).toBeVisible()
+}
+
+test.describe('Passkey', () => {
+  test.beforeEach(async () => {
+    await fehlversucheLoeschen()
+  })
+
+  test('richtet einen Passkey ein und meldet sich anschliessend damit an', async ({
+    page,
+    context,
+  }) => {
+    const authenticator = await authenticatorAnlegen(context, page)
+
+    // --- 1. Auf dem gewoehnlichen Weg herein --------------------------------
+    await anmelden(page)
+
+    // --- 2. Passkey einrichten ---------------------------------------------
+    await passkeyEinrichten(page, 'Testgerät')
+
+    // Er steht in der Liste, mit Datum und dem Hinweis "noch nicht benutzt".
+    const eintrag = page.locator('li', { hasText: 'Testgerät' })
+    await expect(eintrag).toBeVisible()
+    await expect(eintrag).toContainText('noch nicht benutzt')
+
+    // --- 3. Abmelden --------------------------------------------------------
+    await context.clearCookies()
+    await page.goto('/anmelden')
+    await expect(page.getByRole('button', { name: 'Mit Passkey anmelden' })).toBeVisible()
+
+    // --- 4. Mit Passkey anmelden -------------------------------------------
+    await Promise.all([
+      page.waitForURL((url) => !url.pathname.startsWith('/anmelden'), { timeout: 45_000 }),
+      page.getByRole('button', { name: 'Mit Passkey anmelden' }).click(),
+    ])
+
+    // Kein zweiter Schritt: Der Passkey IST der zweite Faktor. Wer hier auf
+    // der Einrichtungsseite fuer TOTP landet, hat einen Fehler im Ablauf.
+    expect(new URL(page.url()).pathname).not.toContain('/zwei-faktor')
+
+    // --- 5. Die Benutzung ist vermerkt -------------------------------------
+    await page.goto('/konto')
+    await expect(page.locator('li', { hasText: 'Testgerät' })).toContainText('zuletzt benutzt')
+
+    // --- 6. Wieder entfernen, damit der naechste Lauf sauber startet -------
+    await page.locator('li', { hasText: 'Testgerät' }).getByRole('button').click()
+    await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
+    await expect(page.getByText('„Testgerät“ wurde entfernt.')).toBeVisible()
+
+    await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
+      authenticatorId: authenticator.id,
+    })
+  })
+
+  test('laesst ein Geraet ohne Nutzerverifikation nicht herein', async ({ page, context }) => {
+    // Das ist die Zusage, auf der alles steht: Ein Passkey darf den zweiten
+    // Faktor nur ersetzen, wenn das Geraet den Benutzer wirklich verifiziert
+    // hat - Fingerabdruck, Gesicht oder PIN. Ein Schluessel, der auf blosses
+    // Antippen hin signiert, ist ein Faktor, kein zweiter.
+    //
+    // Was dieser Test belegt: Die Anforderung erreicht das Geraet, und ein
+    // Geraet ohne Verifikation kommt nicht herein. Abgewiesen wird dabei
+    // schon vom Browser - im Protokoll steht deshalb kein fehlgeschlagener
+    // Versuch. Die Pruefung auf dem Server (requireUserVerification und die
+    // ausdrueckliche Abfrage von userVerified in anmeldungPruefen) ist der
+    // Rueckhalt fuer den Fall, dass jemand die Antwort von Hand baut und den
+    // Browser umgeht. Der laesst sich hier nicht nachstellen.
+    const authenticator = await authenticatorAnlegen(context, page, true)
+
+    await anmelden(page)
+    await passkeyEinrichten(page, 'Ungesichertes Gerät')
+
+    // Jetzt die Verifikation abschalten - so verhaelt sich ein Geraet ohne
+    // eingerichtete Bildschirmsperre.
+    await authenticator.cdp.send('WebAuthn.setUserVerified', {
+      authenticatorId: authenticator.id,
+      isUserVerified: false,
+    })
+
+    await context.clearCookies()
+    await page.goto('/anmelden')
+    await page.getByRole('button', { name: 'Mit Passkey anmelden' }).click()
+
+    // Entscheidend ist nicht der Wortlaut, sondern: Es geht nicht herein.
+    await expect(page.getByRole('alert')).toBeVisible({ timeout: 30_000 })
+    await page.waitForTimeout(1000)
+    expect(new URL(page.url()).pathname).toBe('/anmelden')
+
+    // Aufraeumen: wieder verifizieren, anmelden, Passkey entfernen.
+    await authenticator.cdp.send('WebAuthn.setUserVerified', {
+      authenticatorId: authenticator.id,
+      isUserVerified: true,
+    })
+    await fehlversucheLoeschen()
+    await anmelden(page)
+    await page.goto('/konto')
+    await page.locator('li', { hasText: 'Ungesichertes Gerät' }).getByRole('button').click()
+    await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
+    await expect(page.getByText('„Ungesichertes Gerät“ wurde entfernt.')).toBeVisible()
+
+    await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
+      authenticatorId: authenticator.id,
+    })
+  })
+
+  test('bestaetigt eine sensible Aktion mit dem Passkey statt mit Passwort und Code', async ({
+    page,
+    context,
+  }) => {
+    const authenticator = await authenticatorAnlegen(context, page)
+
+    await anmelden(page)
+    await passkeyEinrichten(page, 'Bestätigungsgerät')
+
+    // Der Vollexport verlangt eine frische Anmeldung.
+    await page.goto('/berichte/export')
+    await page.waitForURL(/\/(bestaetigen|berichte)/)
+
+    if (new URL(page.url()).pathname === '/bestaetigen') {
+      await Promise.all([
+        page.waitForURL((url) => url.pathname !== '/bestaetigen', { timeout: 45_000 }),
+        page.getByRole('button', { name: 'Mit Passkey bestätigen' }).click(),
+      ])
+      expect(new URL(page.url()).pathname).toContain('/berichte/export')
+    }
+
+    await page.goto('/konto')
+    await page.locator('li', { hasText: 'Bestätigungsgerät' }).getByRole('button').click()
+    await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
+    await expect(page.getByText('„Bestätigungsgerät“ wurde entfernt.')).toBeVisible()
+
+    await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
+      authenticatorId: authenticator.id,
+    })
+  })
+})

e2e/rueckkaufswert-vertrag.spec.ts

@@ -0,0 +1,176 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Der Rückkaufswert am Vertrag — gegen die echte Anwendung.
+ *
+ * Die Zusage, die hier geprüft wird: Der Wert steht dort, wo man ihn
+ * braucht, sein Stichtag steht daneben, ein alter Wert ist als alt
+ * erkennbar — und es ist derselbe Wert, den das Vermögensverzeichnis
+ * ausweist, nicht ein zweiter danebengelegter.
+ */
+
+const KENNUNG = 'Prüfhausen Wert'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.vermoegensposten.deleteMany({ where: { bezeichnung: { contains: KENNUNG } } })
+    await db.vertrag.deleteMany({ where: { bezeichnung: { contains: KENNUNG } } })
+  })
+}
+
+/** Tag vor N Tagen, als reines Datum. */
+function vorTagen(tage: number): Date {
+  const heute = new Date()
+  const ziel = new Date(Date.UTC(heute.getFullYear(), heute.getMonth(), heute.getDate()))
+  ziel.setUTCDate(ziel.getUTCDate() - tage)
+  return ziel
+}
+
+test.describe('Rückkaufswert am Vertrag', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+    await mitDb(async (db) => {
+      const betreute = await db.betreute.findMany({
+        where: { geloeschtAm: null },
+        select: { id: true },
+      })
+      for (const person of betreute) {
+        // Ein Vertrag mit frischem Wert, einer mit einem zwei Jahre alten,
+        // einer ohne jeden Wert.
+        const frisch = await db.vertrag.create({
+          data: {
+            betreuteId: person.id,
+            bezeichnung: `${KENNUNG} Frisch`,
+            gesellschaft: `${KENNUNG} Leben AG`,
+            art: 'LEBENSVERSICHERUNG',
+            status: 'AKTIV',
+          },
+        })
+        const alt = await db.vertrag.create({
+          data: {
+            betreuteId: person.id,
+            bezeichnung: `${KENNUNG} Alt`,
+            gesellschaft: `${KENNUNG} Sterbekasse`,
+            art: 'STERBEGELDVERSICHERUNG',
+            status: 'AKTIV',
+          },
+        })
+        await db.vertrag.create({
+          data: {
+            betreuteId: person.id,
+            bezeichnung: `${KENNUNG} Ohne`,
+            gesellschaft: `${KENNUNG} Renten AG`,
+            art: 'RENTENVERSICHERUNG_PRIVAT',
+            status: 'AKTIV',
+          },
+        })
+
+        await db.vermoegensposten.create({
+          data: {
+            betreuteId: person.id,
+            vertragId: frisch.id,
+            art: 'VERSICHERUNG',
+            bezeichnung: `${KENNUNG} Frisch`,
+            wertstaende: {
+              create: [
+                {
+                  stichtag: vorTagen(30),
+                  wertCent: 521055n,
+                  wertquelle: 'Rückkaufswertmitteilung',
+                },
+                { stichtag: vorTagen(400), wertCent: 480000n, wertquelle: 'Jahresmitteilung' },
+              ],
+            },
+          },
+        })
+
+        // Bewusst als „Sonstiges" verknüpft: Die Zuordnung zum Vertrag
+        // hängt an der Verknüpfung, nicht an der Art des Postens.
+        await db.vermoegensposten.create({
+          data: {
+            betreuteId: person.id,
+            vertragId: alt.id,
+            art: 'SONSTIGES',
+            bezeichnung: `${KENNUNG} Alt`,
+            wertstaende: {
+              create: [
+                { stichtag: vorTagen(800), wertCent: 310000n, wertquelle: 'Jahresmitteilung' },
+              ],
+            },
+          },
+        })
+      }
+    })
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('zeigt Wert und Stichtag in der Vertragsübersicht', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vertraege')
+
+    const inhalt = await page.locator('body').innerText()
+    expect(inhalt).toContain('5.210,55')
+    // Ohne Wert bleibt die Zelle nicht leer, sondern sagt es.
+    expect(inhalt).toContain('noch nicht erfasst')
+  })
+
+  test('kennzeichnet einen über ein Jahr alten Wert', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vertraege')
+
+    // Der 800 Tage alte Wert des „Alt"-Vertrags trägt das Abzeichen …
+    await expect(page.getByText('über ein Jahr alt').first()).toBeVisible()
+
+    // … und er wird trotz Posten-Art „Sonstiges" überhaupt gefunden.
+    expect(await page.locator('body').innerText()).toContain('3.100,00')
+  })
+
+  test('zeigt am Vertrag den letzten Wert und die Historie', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vertraege')
+    await page.getByRole('link', { name: `${KENNUNG} Frisch` }).click()
+    await page.waitForURL(/\/vertraege\/[a-z0-9]+$/)
+    await expect(page.getByText('Zuletzt mitgeteilt')).toBeVisible()
+
+    const inhalt = await page.locator('body').innerText()
+    expect(inhalt).toContain('Zuletzt mitgeteilt')
+    expect(inhalt).toContain('5.210,55')
+    // Der frühere Wert bleibt abrufbar — die Entwicklung ist die Aussage.
+    expect(inhalt).toContain('4.800,00')
+  })
+
+  test('trägt einen neuen Wert am Vertrag ein — sichtbar auch im Vermögensverzeichnis', async ({
+    page,
+  }) => {
+    await anmelden(page)
+    await page.goto('/vertraege')
+    await page.getByRole('link', { name: `${KENNUNG} Ohne` }).click()
+    await page.waitForURL(/\/vertraege\/[a-z0-9]+$/)
+
+    await page.getByRole('button', { name: 'Mitgeteilten Wert eintragen' }).click()
+    await page.locator('input[name="stichtag"]').last().fill('2026-08-01')
+    await page.locator('input[name="wert"]').fill('1.234,56')
+    await page.getByRole('button', { name: 'Wert aufnehmen' }).click()
+
+    await expect(page.getByText('Rückkaufswert in die Historie aufgenommen.')).toBeVisible()
+    expect(await page.locator('body').innerText()).toContain('1.234,56')
+
+    // Dieselbe Zahl, eine Quelle: Das Vermögensverzeichnis kennt sie auch.
+    await page.goto('/finanzen/vermoegen?stichtag=2026-08-31')
+    expect(await page.locator('body').innerText()).toContain('1.234,56')
+  })
+})

e2e/schreiben.spec.ts

@@ -0,0 +1,179 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Schreiben erzeugen — gegen die echte Anwendung.
+ *
+ * Der eigentliche Gewinn dieses Issues ist nicht der Brieftext (den gab es
+ * schon), sondern was danach passiert: Word-Datei, Ablage als
+ * Ausgangsdokument, Wiedervorlage. Genau dieser Teil lässt sich mit
+ * Einheitstests nicht prüfen — er berührt Objektspeicher, Datenbank und
+ * Download.
+ */
+
+const VERTRAG = 'Prüfhausen Police (Test Schreiben)'
+const GESELLSCHAFT = 'Prüfhausen Lebensversicherung'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.dokument.deleteMany({ where: { titel: { contains: 'Rückkaufswert' } } })
+    await db.dokument.deleteMany({ where: { empfaenger: { contains: 'Prüfhausen' } } })
+    await db.frist.deleteMany({ where: { titel: { contains: 'Antwort abwarten' } } })
+    await db.kontakt.deleteMany({ where: { name: { contains: 'Prüfhausen' } } })
+    await db.vertrag.deleteMany({ where: { bezeichnung: VERTRAG } })
+  })
+}
+
+async function vertragAnlegen(): Promise<void> {
+  await mitDb(async (db) => {
+    const betreute = await db.betreute.findMany({
+      where: { geloeschtAm: null },
+      select: { id: true },
+    })
+    for (const person of betreute) {
+      await db.vertrag.create({
+        data: {
+          betreuteId: person.id,
+          bezeichnung: VERTRAG,
+          gesellschaft: GESELLSCHAFT,
+          art: 'LEBENSVERSICHERUNG',
+          beitragCent: 4250n,
+          rhythmus: 'MONATLICH',
+          beginnAm: new Date(Date.UTC(2015, 0, 1)),
+        },
+      })
+    }
+  })
+}
+
+/**
+ * Findet die Vertrags-ID der AKTIVEN betreuten Person.
+ *
+ * Welche Person aktiv ist, haengt an einem Cookie — die Datenbank allein
+ * weiss es nicht. Der Weg ueber die Vertragsliste ist zugleich der Weg,
+ * den ein Mensch nimmt.
+ */
+async function vertragIdAusOberflaeche(page: import('@playwright/test').Page): Promise<string> {
+  await page.goto('/vertraege')
+  const link = page.getByRole('link', { name: new RegExp(VERTRAG.replace(/[()]/g, '.')) }).first()
+  await expect(link).toBeVisible()
+  const ziel = await link.getAttribute('href')
+  return (ziel ?? '').split('/').pop() ?? ''
+}
+
+test.describe('Schreiben erzeugen', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+    await vertragAnlegen()
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('baut den Entwurf mit Bestellungsabsatz und lässt ihn bearbeiten', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    const brief = page.locator('textarea#text')
+    await expect(brief).toBeVisible()
+
+    const text = await brief.inputValue()
+    // Ohne den Nachweis der Vertretungsmacht antwortet keine Stelle —
+    // deshalb steht er auch im freien Entwurf drin.
+    expect(text).toMatch(/Betreuungsgericht|bestellt/i)
+    // Und die Lücken sind sichtbar, nicht stillschweigend leer.
+    expect(text).toContain('[')
+
+    await brief.fill(`${text}\n\nZusatz aus dem Test.`)
+    expect(await brief.inputValue()).toContain('Zusatz aus dem Test.')
+  })
+
+  test('erzeugt aus dem Vertrag heraus einen Rückkaufswert-Entwurf', async ({ page }) => {
+    await anmelden(page)
+
+    const vertragId = await vertragIdAusOberflaeche(page)
+    expect(vertragId).not.toBe('')
+
+    await page.goto(`/schreiben/neu?art=RUECKKAUFSWERT&vertragId=${vertragId}`)
+
+    await expect(page.locator('input#empfaengerName')).toHaveValue(GESELLSCHAFT)
+    await expect(page.locator('input#betreff')).not.toHaveValue('')
+    // Die Wiedervorlage ist vorbelegt — 28 Tage.
+    await expect(page.locator('input#wiedervorlageAm')).not.toHaveValue('')
+
+    const text = await page.locator('textarea#text').inputValue()
+    expect(text).toContain('Rückkaufswert')
+  })
+
+  test('liefert die Word-Datei aus', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+    await page.locator('input#empfaengerName').fill('Prüfhausen Amt')
+
+    const [download] = await Promise.all([
+      page.waitForEvent('download'),
+      page.getByRole('button', { name: 'Als Word-Datei' }).click(),
+    ])
+
+    // Sprechender, sortierbarer Name mit Datum vorn.
+    expect(download.suggestedFilename()).toMatch(/^\d{4}-\d{2}-\d{2}_.*\.docx$/)
+    expect(download.suggestedFilename()).toContain('Pruefhausen')
+  })
+
+  test('legt das Schreiben in die Akte und setzt die Wiedervorlage', async ({ page }) => {
+    await anmelden(page)
+
+    const vertragId = await vertragIdAusOberflaeche(page)
+
+    await page.goto(`/schreiben/neu?art=RUECKKAUFSWERT&vertragId=${vertragId}`)
+    await page.getByRole('button', { name: 'In die Akte legen' }).click()
+
+    await expect(page.getByText('Das Schreiben liegt in der Akte.')).toBeVisible({
+      timeout: 30_000,
+    })
+    await expect(page.getByText(/Wiedervorlage zum/)).toBeVisible()
+
+    // Und es steht wirklich in der Dokumentenliste, als Ausgang.
+    //
+    // Bewusst ohne tr/li: Die Liste rendert Tabelle UND Karten, je nach
+    // Bildschirmbreite ist eine davon versteckt. Ein Treffer auf die
+    // unsichtbare Fassung sähe wie ein Fehler aus.
+    await page.goto('/dokumente?richtung=AUSGANG')
+
+    // Die Zusammenfassungszeile gibt es nur einmal — anders als den Titel,
+    // der in Tabelle UND Kartenliste steht.
+    await expect(page.getByText('1 Dokument passen zu den Filtern')).toBeVisible()
+    await expect(page.locator('body')).toContainText('Auskunft über Rückkaufswert')
+    await expect(page.locator('body')).toContainText('Ausgang')
+
+    // Die Wiedervorlage steht in der Fristenliste.
+    await page.goto('/fristen')
+    await expect(page.getByText(/Antwort abwarten/).first()).toBeVisible()
+  })
+
+  test('legt aus einer freien Anschrift einen Kontakt an', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    await page.locator('input#empfaengerName').fill('Prüfhausen Sozialamt')
+    await page.locator('textarea#empfaengerAnschrift').fill('Musterweg 3\n96450 Coburg')
+
+    await page.getByRole('button', { name: 'Als Kontakt merken' }).click()
+    await expect(page.getByText(/steht jetzt in den Kontakten/)).toBeVisible()
+
+    // Beim nächsten Mal steht er zur Auswahl.
+    await page.goto('/schreiben/neu?art=FREI')
+    await expect(page.locator('select#kontaktAuswahl')).toContainText('Prüfhausen Sozialamt')
+  })
+})

e2e/serienabfrage.spec.ts

@@ -0,0 +1,185 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Serienabfrage der Rückkaufswerte — gegen die echte Anwendung.
+ *
+ * Geprüft wird der ganze Lauf: Vorauswahl, ZIP-Download, die
+ * Nebenwirkungen (Anfragedatum, Wiedervorlage, Ausgangsdokumente) und der
+ * Dublettenschutz beim zweiten Lauf am selben Tag.
+ */
+
+const KENNUNG = 'Prüfhausen Serie'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.dokument.deleteMany({ where: { empfaenger: { contains: KENNUNG } } })
+    await db.frist.deleteMany({ where: { titel: { contains: KENNUNG } } })
+    await db.vertrag.deleteMany({ where: { bezeichnung: { contains: KENNUNG } } })
+  })
+}
+
+test.describe('Serienabfrage', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+    await mitDb(async (db) => {
+      const betreute = await db.betreute.findMany({
+        where: { geloeschtAm: null },
+        select: { id: true },
+      })
+      for (const person of betreute) {
+        // Zwei anfragbare, eine ohne Rueckkaufswert, eine ohne Gesellschaft.
+        await db.vertrag.createMany({
+          data: [
+            {
+              betreuteId: person.id,
+              bezeichnung: `${KENNUNG} Leben`,
+              gesellschaft: `${KENNUNG} Lebensversicherung`,
+              art: 'LEBENSVERSICHERUNG',
+              status: 'AKTIV',
+            },
+            {
+              betreuteId: person.id,
+              bezeichnung: `${KENNUNG} Sterbegeld`,
+              gesellschaft: `${KENNUNG} Sterbekasse`,
+              art: 'STERBEGELDVERSICHERUNG',
+              status: 'AKTIV',
+            },
+            {
+              betreuteId: person.id,
+              bezeichnung: `${KENNUNG} Haftpflicht`,
+              gesellschaft: `${KENNUNG} Allgemeine`,
+              art: 'HAFTPFLICHT',
+              status: 'AKTIV',
+            },
+            {
+              betreuteId: person.id,
+              bezeichnung: `${KENNUNG} Ohne Gesellschaft`,
+              gesellschaft: null,
+              art: 'LEBENSVERSICHERUNG',
+              status: 'AKTIV',
+            },
+          ],
+        })
+      }
+    })
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('wählt richtig vor und benennt die Hindernisse', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vertraege/serienabfrage/seite')
+
+    // Die beiden anfragbaren sind vorausgewählt …
+    await expect(
+      page.locator('li', { hasText: `${KENNUNG} Leben` }).locator('input[type="checkbox"]'),
+    ).toBeChecked()
+    await expect(
+      page.locator('li', { hasText: `${KENNUNG} Sterbegeld` }).locator('input[type="checkbox"]'),
+    ).toBeChecked()
+
+    // … die ohne Gesellschaft steht mit Begründung da, ohne Haken …
+    const ohne = page.locator('li', { hasText: `${KENNUNG} Ohne Gesellschaft` })
+    await expect(ohne).toContainText('nachtragen')
+    await expect(ohne.locator('input[type="checkbox"]')).toHaveCount(0)
+
+    // … und die Haftpflicht taucht gar nicht erst auf.
+    await expect(page.locator('li', { hasText: `${KENNUNG} Haftpflicht` })).toHaveCount(0)
+
+    // Die Zusammenfassung steht auf dem Knopf, BEVOR etwas entsteht -
+    // und sie stimmt mit der Zahl der gesetzten Haken ueberein. Auf die
+    // absolute Zahl laesst sich nicht bauen: Der Demofall bringt eigene
+    // Vertraege mit.
+    const haken = await page.locator('input[type="checkbox"]:checked').count()
+    expect(haken).toBeGreaterThanOrEqual(2)
+    await expect(
+      page.getByRole('button', { name: new RegExp(`${haken} Schreiben erzeugen`) }),
+    ).toBeVisible()
+  })
+
+  test('führt den Lauf durch: ZIP, Akte, Wiedervorlagen, Anfragedatum', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vertraege/serienabfrage/seite')
+
+    const [download] = await Promise.all([
+      page.waitForEvent('download'),
+      page.getByRole('button', { name: /Schreiben erzeugen und herunterladen/ }).click(),
+    ])
+    expect(download.suggestedFilename()).toMatch(/^\d{4}-\d{2}-\d{2}_Rueckkaufswert-Anfragen\.zip$/)
+
+    // Nebenwirkungen in der Datenbank: Anfragedatum, Dokumente, Fristen.
+    const stand = await mitDb(async (db) => {
+      const angefragt = await db.vertrag.count({
+        where: {
+          bezeichnung: { in: [`${KENNUNG} Leben`, `${KENNUNG} Sterbegeld`] },
+          rueckkaufswertAngefragtAm: { not: null },
+        },
+      })
+      const dokumente = await db.dokument.count({
+        where: { empfaenger: { contains: KENNUNG }, richtung: 'AUSGANG' },
+      })
+      const fristen = await db.frist.count({
+        where: { titel: { contains: KENNUNG }, typ: 'WIEDERVORLAGE' },
+      })
+      return { angefragt, dokumente, fristen }
+    })
+
+    // Beide betreute Personen haben die Verträge - angefragt wird aber nur
+    // bei der aktiven. Deshalb: genau 2 von 4.
+    expect(stand.angefragt).toBe(2)
+    expect(stand.dokumente).toBe(2)
+    expect(stand.fristen).toBe(2)
+
+    // Auf der Seite stehen die beiden jetzt als frisch angefragt.
+    await page.goto('/vertraege/serienabfrage/seite')
+    await expect(page.getByText(/bereits angefragt/).first()).toBeVisible()
+  })
+
+  test('erzeugt beim zweiten Lauf am selben Tag keine Dubletten', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vertraege/serienabfrage/seite')
+
+    // Alles abwaehlen, dann NUR den frisch angefragten Vertrag anwaehlen.
+    // So prueft der Lauf genau den Dublettenschutz und fasst die uebrigen
+    // Vertraege nicht an.
+    const angehakte = page.locator('input[type="checkbox"]:checked')
+    while ((await angehakte.count()) > 0) {
+      await angehakte.first().uncheck()
+    }
+    const leben = page.locator('li', { hasText: `${KENNUNG} Leben` })
+    await leben.locator('input[type="checkbox"]').check()
+
+    const [download] = await Promise.all([
+      page.waitForEvent('download'),
+      page.getByRole('button', { name: /Schreiben erzeugen und herunterladen/ }).click(),
+    ])
+    expect(download.suggestedFilename()).toContain('.zip')
+
+    // Der Dublettenschutz greift: weiterhin genau ein Dokument und eine
+    // Frist für diesen Vertrag.
+    const stand = await mitDb(async (db) => {
+      const dokumente = await db.dokument.count({
+        where: { empfaenger: `${KENNUNG} Lebensversicherung` },
+      })
+      const fristen = await db.frist.count({
+        where: { titel: { contains: `${KENNUNG} Leben` }, typ: 'WIEDERVORLAGE' },
+      })
+      return { dokumente, fristen }
+    })
+    expect(stand.dokumente).toBe(1)
+    expect(stand.fristen).toBe(1)
+  })
+})

e2e/vorlagen.spec.ts

@@ -0,0 +1,157 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Eigene Schreibvorlagen — gegen die echte Anwendung.
+ *
+ * Der Weg über die Oberfläche: Vorlage anlegen (mit der zweistufigen
+ * Bestellungsabsatz-Warnung), aus einer mitgelieferten kopieren, beim
+ * Schreiben auswählen und die Platzhalter-Auflösung sehen.
+ */
+
+const VORLAGE = 'Prüfhausen Testvorlage'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.schreibvorlage.deleteMany({ where: { name: { contains: 'Prüfhausen' } } })
+    await db.schreibvorlage.deleteMany({ where: { name: { contains: '(eigene Fassung)' } } })
+  })
+}
+
+test.describe('Schreibvorlagen', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('warnt ohne Bestellungsabsatz und speichert erst nach Bestätigung', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    await page.getByRole('button', { name: 'Neue Vorlage' }).click()
+    await page.locator('input[name="name"]').fill(VORLAGE)
+    await page
+      .locator('textarea[name="text"]')
+      .fill('Sehr geehrte Damen und Herren,\n\nbitte um Auskunft zu {{betreute_name}}.\n\nMfG')
+
+    // Erster Versuch: Warnung, nicht gespeichert.
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(/fehlt der Bestellungsabsatz/)).toBeVisible()
+
+    // Bestätigen und erneut speichern.
+    await page.getByText('Bewusst ohne Bestellungsabsatz speichern').click()
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(`„${VORLAGE}“ ist gespeichert.`)).toBeVisible()
+  })
+
+  test('speichert mit Platzhalter ohne Warnung', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    await page.getByRole('button', { name: 'Neue Vorlage' }).click()
+    await page.locator('input[name="name"]').fill(`${VORLAGE} mit Absatz`)
+    await page
+      .locator('textarea[name="text"]')
+      .fill('Sehr geehrte Damen und Herren,\n\n{{bestellungsabsatz}}\n\nbitte um Auskunft.\n\nMfG')
+
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(`„${VORLAGE} mit Absatz“ ist gespeichert.`)).toBeVisible()
+  })
+
+  test('übernimmt eine mitgelieferte Vorlage als Kopie', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    await page
+      .locator('li', { hasText: 'Auskunftsersuchen' })
+      .getByRole('button', { name: 'Als Kopie übernehmen' })
+      .click()
+
+    // Der Editor öffnet mit den kopierten Inhalten.
+    await expect(page.locator('input[name="name"]')).toHaveValue(/eigene Fassung/)
+    const text = await page.locator('textarea[name="text"]').inputValue()
+    expect(text).toContain('{{bestellungsabsatz}}')
+
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(/ist gespeichert/)).toBeVisible()
+  })
+
+  test('löst die Platzhalter beim Erzeugen auf — mit sichtbaren Lücken', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    // Die gespeicherte Vorlage steht zur Wahl.
+    const wahl = page.locator('select#vorlageWahl')
+    await expect(wahl).toBeVisible()
+    await wahl.selectOption({ label: `${VORLAGE} mit Absatz` })
+
+    await page.waitForURL(/vorlageId=/)
+    const text = await page.locator('textarea#text').inputValue()
+
+    // Der Bestellungsabsatz ist aufgelöst (kein Platzhalter mehr) …
+    expect(text).not.toContain('{{bestellungsabsatz}}')
+    expect(text).toMatch(/Beschluss|bestellt/)
+    // … und der Rest des Textes steht drin.
+    expect(text).toContain('bitte um Auskunft.')
+  })
+
+  test('markiert unbekannte Platzhalter im Text und warnt', async ({ page }) => {
+    await mitDb(async (db) => {
+      const betreute = await db.betreute.findMany({
+        where: { geloeschtAm: null },
+        select: { id: true },
+      })
+      for (const person of betreute) {
+        await db.schreibvorlage.create({
+          data: {
+            betreuteId: person.id,
+            name: `${VORLAGE} kaputt`,
+            text: 'Sehr geehrte Damen und Herren,\n\n{{bestellungsabsatz}}\n\nHallo {{gibt_es_nicht}}.',
+          },
+        })
+      }
+    })
+
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+    await page.locator('select#vorlageWahl').selectOption({ label: `${VORLAGE} kaputt` })
+    await page.waitForURL(/vorlageId=/)
+
+    // Markiert im Text, benannt in der Warnung — kein Abbruch.
+    const text = await page.locator('textarea#text').inputValue()
+    expect(text).toContain('[Unbekannter Platzhalter: {{gibt_es_nicht}}]')
+    await expect(page.getByText(/unbekannte Platzhalter/)).toBeVisible()
+  })
+
+  test('gelöschte Vorlage liegt im Papierkorb und kommt zurück', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    // Zweistufig - Loeschen fragt erst nach.
+    const eintrag = page.locator('li', { hasText: `${VORLAGE} mit Absatz` })
+    await eintrag.getByRole('button', { name: 'Löschen' }).click()
+    await eintrag.getByRole('button', { name: 'In den Papierkorb' }).click()
+    await expect(page.getByText(`${VORLAGE} mit Absatz`)).toHaveCount(0)
+
+    await page.goto('/einstellungen/papierkorb')
+    const zeile = page.locator('li', { hasText: `${VORLAGE} mit Absatz` })
+    await expect(zeile).toBeVisible()
+
+    await zeile.getByRole('button', { name: 'Wiederherstellen' }).click()
+    await page.goto('/einstellungen/vorlagen')
+    await expect(page.getByText(`${VORLAGE} mit Absatz`)).toBeVisible()
+  })
+})

e2e/wiederkehrend.spec.ts

@@ -0,0 +1,181 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Wiederkehrende Zahlungen gegen die echte Anwendung.
+ *
+ * Die Einheitstests nageln die Erkennung fest (tests/wiederkehrend.test.ts).
+ * Hier geht es um das, was sie nicht sehen können: Kommt die Auswertung mit
+ * Daten aus der Datenbank überein, führt die Zeile wirklich ins
+ * Vertragsformular, und überlebt ein Abhaken das Neuladen?
+ *
+ * Der Test legt sich seine Buchungen selbst an und räumt sie hinterher weg.
+ * Er hängt damit nicht am Demofall — der hat heute gar keine Buchungen, und
+ * ein Test, der auf fremde Daten hofft, wird irgendwann grundlos rot.
+ */
+
+/** Eigener Name, damit das Aufräumen nichts Fremdes trifft. */
+const EMPFAENGER = 'Prüfhausen Lebensversicherung AG'
+const EMPFAENGER_ZWEITE_SCHREIBWEISE = 'PRUEFHAUSEN LEBENSVERSICHERUNG AG'
+const EINZELNE = 'Prüfhausen Feuersozietät'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+/**
+ * Legt für JEDE betreute Person dieselben Buchungen an.
+ *
+ * Welche Person nach dem Anmelden aktiv ist, hängt an einem Cookie. Statt
+ * das im Test nachzubauen, bekommen alle dieselben Daten — es sind ein paar
+ * Zeilen, und der Test wird dadurch unabhängig von der Reihenfolge.
+ */
+async function testdatenAnlegen(): Promise<void> {
+  await mitDb(async (db) => {
+    const betreute = await db.betreute.findMany({
+      where: { geloeschtAm: null },
+      select: { id: true },
+    })
+
+    for (const person of betreute) {
+      const konto = await db.konto.findFirst({
+        where: { betreuteId: person.id, geloeschtAm: null },
+        select: { id: true },
+      })
+
+      const gemeinsam = {
+        betreuteId: person.id,
+        kontoId: konto?.id ?? null,
+        richtung: 'AUSGABE' as const,
+        kategorie: 'VERSICHERUNG' as const,
+        betrifftBetreute: true,
+      }
+
+      // Sechs monatliche Abbuchungen, zwei davon in anderer Schreibweise.
+      for (let monat = 1; monat <= 6; monat++) {
+        await db.buchung.create({
+          data: {
+            ...gemeinsam,
+            datum: new Date(Date.UTC(2026, monat - 1, 1)),
+            betragCent: 4250n,
+            gegenstelle: monat > 4 ? EMPFAENGER_ZWEITE_SCHREIBWEISE : EMPFAENGER,
+          },
+        })
+      }
+
+      // Eine einzelne größere Zahlung - der Fall "Jahresbeitrag".
+      await db.buchung.create({
+        data: {
+          ...gemeinsam,
+          datum: new Date(Date.UTC(2026, 2, 15)),
+          betragCent: 48_000n,
+          gegenstelle: EINZELNE,
+        },
+      })
+    }
+  })
+}
+
+async function testdatenEntfernen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.buchung.deleteMany({
+      where: { gegenstelle: { in: [EMPFAENGER, EMPFAENGER_ZWEITE_SCHREIBWEISE, EINZELNE] } },
+    })
+    await db.zahlungsgruppeGeklaert.deleteMany({
+      where: { anzeigename: { contains: 'Prüfhausen' } },
+    })
+  })
+}
+
+test.describe('Wiederkehrende Zahlungen', () => {
+  test.beforeAll(async () => {
+    await testdatenEntfernen()
+    await testdatenAnlegen()
+  })
+
+  test.afterAll(async () => {
+    await testdatenEntfernen()
+  })
+
+  test('findet die monatliche Abbuchung und fasst die Schreibweisen zusammen', async ({
+    page,
+  }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    const zeile = page.locator('tr', { hasText: 'Prüfhausen Lebensversicherung' }).first()
+    await expect(zeile).toBeVisible()
+
+    // Erkannter Rhythmus samt Begründung - nicht nur das Ergebnis.
+    await expect(zeile).toContainText('monatlich')
+    await expect(zeile).toContainText('6 Zahlungen')
+    // 42,50 EUR mal zwölf.
+    await expect(zeile).toContainText('510,00')
+    // Zwei Schreibweisen desselben Empfängers, in einer Zeile.
+    await expect(zeile).toContainText('Schreibweisen zusammengefasst')
+    // Und angezeigt wird die lesbare, nicht die geschriene aus dem Auszug.
+    await expect(zeile).toContainText(EMPFAENGER)
+  })
+
+  test('listet die einzelne größere Zahlung getrennt', async ({ page }) => {
+    // Die Lücke der Gruppierung: Ein Jahresbeitrag erscheint nur einmal.
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    // Die Überschrift steht, und die Zahlung dazu in einer eigenen Zeile.
+    await expect(page.getByText('Einzelne größere Zahlungen')).toBeVisible()
+
+    const zeile = page.locator('tr', { hasText: EINZELNE })
+    await expect(zeile).toContainText('480,00')
+    // Ohne Vertrag - genau deshalb steht sie hier.
+    await expect(zeile).toContainText('keiner')
+  })
+
+  test('übernimmt Gesellschaft und Beitrag ins Vertragsformular', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    const zeile = page.locator('tr', { hasText: 'Prüfhausen Lebensversicherung' }).first()
+    await zeile.getByRole('link', { name: 'Vertrag anlegen' }).click()
+
+    await page.waitForURL('**/vertraege/neu**')
+    await expect(page.getByText('aus den wiederkehrenden Zahlungen')).toBeVisible()
+
+    // Was aus dem Auszug ablesbar ist, steht drin.
+    await expect(page.locator('input[name="gesellschaft"]')).toHaveValue(
+      /Prüfhausen Lebensversicherung/,
+    )
+    await expect(page.locator('input[name="beitrag"]')).toHaveValue('42,50')
+
+    // Was NICHT ablesbar ist, bleibt leer - eine geratene Vorbelegung
+    // würde übersehen statt korrigiert.
+    await expect(page.locator('input[name="bezeichnung"]')).toHaveValue('')
+  })
+
+  test('hakt eine Gruppe ab und holt sie wieder zurück', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    const zeile = page.locator('tr', { hasText: 'Prüfhausen Lebensversicherung' }).first()
+    await zeile.getByRole('button', { name: 'Kein Vertrag' }).click()
+    await zeile.getByPlaceholder('Warum kein Vertrag?').fill('Nur zum Prüfen')
+    await zeile.getByRole('button', { name: 'Abhaken', exact: true }).click()
+
+    // Aus der Kandidatenliste verschwunden, unter „abgehakt" wieder da.
+    await expect(page.getByRole('cell', { name: /Prüfhausen Lebensversicherung/ })).toHaveCount(0)
+    await expect(page.getByText('Nur zum Prüfen')).toBeVisible()
+
+    // Und die Entscheidung überlebt das Neuladen.
+    await page.reload()
+    await expect(page.getByText('Nur zum Prüfen')).toBeVisible()
+
+    await page.getByRole('button', { name: 'Zurückholen' }).first().click()
+    await expect(page.getByRole('cell', { name: /Prüfhausen Lebensversicherung/ })).toHaveCount(1)
+  })
+})

next.config.mjs

@@ -6,6 +6,16 @@ const nextConfig = {
   poweredByHeader: false,
   // Argon2 ist eine native Bibliothek und darf nicht gebundelt werden.
   serverExternalPackages: ['@node-rs/argon2'],
+
+  // Zwei Seiten lesen zur Laufzeit eine Markdown-Datei aus docs/:
+  // die Datenschutzhinweise und die Bedienungsanleitung. Der Pfad wird
+  // erst zur Laufzeit gebaut, die Dateiverfolgung von Next.js kann ihn
+  // also nicht erkennen - ohne diesen Eintrag fehlten beide Dateien im
+  // Standalone-Build, und im Behaelter waeren die Seiten leer.
+  outputFileTracingIncludes: {
+    '/datenschutz': ['./docs/datenschutzhinweise.md'],
+    '/anleitung': ['./docs/ANLEITUNG.md'],
+  },
   eslint: {
     ignoreDuringBuilds: false,
   },

package.json

@@ -1,6 +1,6 @@
 {
   "name": "betreuungs-cockpit",
-  "version": "1.0.0",
+  "version": "1.12.0",
   "private": true,
   "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
   "engines": {
@@ -17,6 +17,9 @@
     "db:generate": "prisma generate",
     "db:migrate": "prisma migrate dev",
     "db:deploy": "prisma migrate deploy",
+    "db:migration": "node scripts/migration-erzeugen.mjs",
+    "speicher:verschluesseln": "tsx --env-file=.env scripts/speicher-verschluesseln.mts",
+    "db:pruefen": "node -e \"import('./scripts/migration-erzeugen.mjs').then(m => m.indizesPruefen())\"",
     "db:volltext": "prisma db execute --schema prisma/schema.prisma --file prisma/sql/volltextsuche.sql",
     "db:seed": "prisma db seed",
     "db:studio": "prisma studio",
@@ -35,8 +38,8 @@
     "seed": "tsx prisma/seed.ts"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.735.0",
-    "@aws-sdk/s3-request-presigner": "3.735.0",
+    "@aws-sdk/client-s3": "3.1116.0",
+    "@aws-sdk/s3-request-presigner": "3.1116.0",
     "@node-rs/argon2": "2.0.2",
     "@prisma/client": "6.3.1",
     "@radix-ui/react-dialog": "1.1.4",
@@ -44,15 +47,17 @@
     "@radix-ui/react-label": "2.1.1",
     "@radix-ui/react-slot": "1.1.1",
     "@react-pdf/renderer": "4.1.6",
+    "@simplewebauthn/browser": "13.3.0",
+    "@simplewebauthn/server": "13.3.2",
     "archiver": "7.0.1",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "date-fns": "4.1.0",
     "docx": "9.1.1",
     "lucide-react": "0.474.0",
-    "next": "15.1.6",
-    "next-auth": "5.0.0-beta.25",
-    "nodemailer": "6.10.0",
+    "next": "15.5.23",
+    "next-auth": "5.0.0-beta.32",
+    "nodemailer": "9.0.5",
     "otpauth": "9.3.6",
     "pdf-lib": "1.17.1",
     "qrcode": "1.5.4",
@@ -65,22 +70,22 @@
     "zod": "3.24.1"
   },
   "devDependencies": {
-    "@playwright/test": "1.50.1",
+    "@playwright/test": "1.62.1",
     "@types/archiver": "6.0.3",
     "@types/node": "22.13.1",
-    "@types/nodemailer": "6.4.17",
+    "@types/nodemailer": "7.0.4",
     "@types/qrcode": "1.5.5",
     "@types/react": "19.0.8",
     "@types/react-dom": "19.0.3",
     "autoprefixer": "10.4.20",
-    "eslint": "9.19.0",
-    "eslint-config-next": "15.1.6",
-    "postcss": "8.5.1",
+    "eslint": "9.39.1",
+    "eslint-config-next": "15.5.23",
+    "postcss": "8.5.26",
     "prisma": "6.3.1",
     "tailwindcss": "3.4.17",
-    "tsx": "4.19.2",
+    "tsx": "4.20.6",
     "typescript": "5.7.3",
-    "vitest": "3.0.5"
+    "vitest": "3.2.6"
   },
   "allowScripts": {
     "@prisma/client@6.3.1": true,
@@ -90,5 +95,14 @@
     "prisma@6.3.1": true,
     "sharp@0.33.5": true,
     "unrs-resolver@1.12.2": true
+  },
+  "overrides": {
+    "next-auth": {
+      "@simplewebauthn/server": "$@simplewebauthn/server",
+      "@simplewebauthn/browser": "$@simplewebauthn/browser"
+    },
+    "nodemailer": "9.0.5",
+    "postcss": "8.5.26",
+    "sharp": "0.35.3"
   }
 }

prisma/migrations/20260822160000_passkey_anmeldung/migration.sql

@@ -0,0 +1,68 @@
+-- Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg.
+--
+-- ACHTUNG beim Erzeugen weiterer Migrationen: "prisma migrate diff" wollte
+-- hier zusaetzlich die Trigramm-Indizes "dokument_absender_trgm" und
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/volltextsuche.sql und
+-- sind Prisma unbekannt - ein DROP haette die unscharfe Suche stillgelegt,
+-- ohne dass irgendetwas fehlgeschlagen waere. Solche Zeilen gehoeren aus
+-- jeder erzeugten Migration entfernt.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
+
+-- CreateEnum
+CREATE TYPE "PasskeyAnfrageArt" AS ENUM ('REGISTRIERUNG', 'ANMELDUNG');
+
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_REGISTRIERT';
+ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_ENTFERNT';
+
+-- CreateTable
+CREATE TABLE "passkey" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "credentialId" TEXT NOT NULL,
+    "publicKey" BYTEA NOT NULL,
+    "counter" BIGINT NOT NULL DEFAULT 0,
+    "transports" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "name" TEXT NOT NULL,
+    "geraeteArt" TEXT,
+    "gesichert" BOOLEAN NOT NULL DEFAULT false,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "zuletztBenutztAm" TIMESTAMP(3),
+
+    CONSTRAINT "passkey_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "passkey_anfrage" (
+    "id" TEXT NOT NULL,
+    "challenge" TEXT NOT NULL,
+    "art" "PasskeyAnfrageArt" NOT NULL,
+    "userId" TEXT,
+    "ablaufAm" TIMESTAMP(3) NOT NULL,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "passkey_anfrage_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "passkey_credentialId_key" ON "passkey"("credentialId");
+
+-- CreateIndex
+CREATE INDEX "passkey_userId_idx" ON "passkey"("userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "passkey_anfrage_challenge_key" ON "passkey_anfrage"("challenge");
+
+-- CreateIndex
+CREATE INDEX "passkey_anfrage_ablaufAm_idx" ON "passkey_anfrage"("ablaufAm");
+
+-- AddForeignKey
+ALTER TABLE "passkey" ADD CONSTRAINT "passkey_userId_fkey" FOREIGN KEY ("userId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

prisma/migrations/20260823000500_zahlungsgruppe_geklaert/migration.sql

@@ -0,0 +1,31 @@
+-- Abgehakte Zahlungsgruppen: "das ist kein Vertrag".
+--
+-- ACHTUNG, zum zweiten Mal in diesem Projekt: "prisma migrate diff" wollte
+-- hier wieder die Trigramm-Indizes "dokument_absender_trgm" und
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/volltextsuche.sql und
+-- sind Prisma unbekannt; ein DROP haette die unscharfe Suche stillgelegt,
+-- ohne dass irgendetwas fehlgeschlagen waere. Die Zeilen sind entfernt.
+-- Wer die naechste Migration erzeugt: nachsehen und wieder herausnehmen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
+
+-- CreateTable
+CREATE TABLE "zahlungsgruppe_geklaert" (
+    "id" TEXT NOT NULL,
+    "betreuteId" TEXT NOT NULL,
+    "schluessel" TEXT NOT NULL,
+    "anzeigename" TEXT NOT NULL,
+    "begruendung" TEXT,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "zahlungsgruppe_geklaert_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "zahlungsgruppe_geklaert_betreuteId_idx" ON "zahlungsgruppe_geklaert"("betreuteId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "zahlungsgruppe_geklaert_betreuteId_schluessel_key" ON "zahlungsgruppe_geklaert"("betreuteId", "schluessel");
+
+-- AddForeignKey
+ALTER TABLE "zahlungsgruppe_geklaert" ADD CONSTRAINT "zahlungsgruppe_geklaert_betreuteId_fkey" FOREIGN KEY ("betreuteId") REFERENCES "betreute"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

prisma/migrations/20260823062000_buchung_vertragszahlung/migration.sql

@@ -0,0 +1,20 @@
+-- Dauerzahlungen: Buchung.vertragId.
+--
+-- ACHTUNG, zum dritten Mal: "prisma migrate diff" wollte wieder die
+-- Trigramm-Indizes "dokument_absender_trgm" und "vorgang_titel_trgm"
+-- loeschen. Sie stammen aus prisma/sql/volltextsuche.sql und sind Prisma
+-- unbekannt; ein DROP legt die unscharfe Suche stumm, ohne dass etwas
+-- fehlschlaegt. Zeilen entfernt. Wer die naechste Migration erzeugt:
+-- nachsehen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
+
+-- AlterTable
+ALTER TABLE "buchung" ADD COLUMN     "vertragAutomatisch" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "vertragId" TEXT;
+
+-- CreateIndex
+CREATE INDEX "buchung_vertragId_idx" ON "buchung"("vertragId");
+
+-- AddForeignKey
+ALTER TABLE "buchung" ADD CONSTRAINT "buchung_vertragId_fkey" FOREIGN KEY ("vertragId") REFERENCES "vertrag"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+

prisma/migrations/20260823102500_schreibvorlage/migration.sql

@@ -0,0 +1,28 @@
+-- Eigene Schreibvorlagen.
+--
+-- ACHTUNG, zum vierten Mal: "prisma migrate diff" wollte wieder die
+-- Trigramm-Indizes aus prisma/sql/volltextsuche.sql loeschen. Zeilen entfernt.
+-- Wer die naechste Migration erzeugt: nachsehen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
+
+-- CreateTable
+CREATE TABLE "schreibvorlage" (
+    "id" TEXT NOT NULL,
+    "betreuteId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "betreff" TEXT NOT NULL DEFAULT '',
+    "text" TEXT NOT NULL,
+    "ohneBestellungsabsatz" BOOLEAN NOT NULL DEFAULT false,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+    "geloeschtAm" TIMESTAMP(3),
+
+    CONSTRAINT "schreibvorlage_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "schreibvorlage_betreuteId_idx" ON "schreibvorlage"("betreuteId");
+
+-- AddForeignKey
+ALTER TABLE "schreibvorlage" ADD CONSTRAINT "schreibvorlage_betreuteId_fkey" FOREIGN KEY ("betreuteId") REFERENCES "betreute"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

prisma/migrations/20260823153000_ansprechpartner/migration.sql

@@ -0,0 +1,18 @@
+-- Ansprechpartner am Vorgang, Anrede am Kontakt.
+--
+-- ACHTUNG, zum fuenften Mal: "prisma migrate diff" wollte wieder die
+-- Trigramm-Indizes aus prisma/sql/volltextsuche.sql loeschen. Zeilen entfernt.
+-- Wer die naechste Migration erzeugt: nachsehen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
+
+-- CreateEnum
+CREATE TYPE "KontaktAnrede" AS ENUM ('OHNE', 'FRAU', 'HERR');
+
+-- AlterTable
+ALTER TABLE "kontakt" ADD COLUMN     "anrede" "KontaktAnrede" NOT NULL DEFAULT 'OHNE';
+
+-- AlterTable
+ALTER TABLE "vorgang" ADD COLUMN     "ansprechpartnerId" TEXT;
+
+-- AddForeignKey
+ALTER TABLE "vorgang" ADD CONSTRAINT "vorgang_ansprechpartnerId_fkey" FOREIGN KEY ("ansprechpartnerId") REFERENCES "kontakt"("id") ON DELETE SET NULL ON UPDATE CASCADE;

prisma/migrations/20260823193832_betreuer_anschrift/migration.sql

@@ -0,0 +1,14 @@
+-- betreuer_anschrift
+--
+-- Erzeugt mit "npm run db:migration". Entfernt wurden die
+-- DROP-INDEX-Anweisungen zu diesen Indizes:
+--   dokument_absender_trgm
+--   vorgang_titel_trgm
+--
+-- Sie stammen aus prisma/sql/volltextsuche.sql und sind Prisma unbekannt;
+-- ohne sie waere die Volltextsuche still langsam geworden.
+
+-- AlterTable
+ALTER TABLE "benutzer" ADD COLUMN     "ort" TEXT,
+ADD COLUMN     "plz" TEXT,
+ADD COLUMN     "strasse" TEXT;

prisma/migrations/20260824074643_sicherheitsaudit/migration.sql

@@ -0,0 +1,31 @@
+-- sicherheitsaudit
+--
+-- Erzeugt mit "npm run db:migration". Entfernt wurden die
+-- DROP-INDEX-Anweisungen zu diesen Indizes:
+--   dokument_absender_trgm
+--   vorgang_titel_trgm
+--
+-- Sie stammen aus prisma/sql/volltextsuche.sql und sind Prisma unbekannt;
+-- ohne sie waere die Volltextsuche still langsam geworden.
+
+-- AlterTable
+ALTER TABLE "benutzer" ADD COLUMN     "totpLetzterSchritt" INTEGER;
+
+-- CreateTable
+CREATE TABLE "ersteinrichtung" (
+    "id" TEXT NOT NULL,
+    "abgeschlossenAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "userId" TEXT,
+
+    CONSTRAINT "ersteinrichtung_pkey" PRIMARY KEY ("id")
+);
+
+-- Bestehende Installationen nachziehen.
+--
+-- Die Tabelle oben ist die Sperre fuer die Ersteinrichtung. Auf einem
+-- System, das schon laeuft, ist die Einrichtung laengst erledigt - ohne
+-- diese Zeile stuende die Sperre nach dem Update offen, und der Weg zum
+-- Anlegen eines Administrators waere wieder frei.
+INSERT INTO "ersteinrichtung" ("id", "userId")
+SELECT 'einmalig', (SELECT "id" FROM "benutzer" ORDER BY "erstelltAm" ASC LIMIT 1)
+WHERE EXISTS (SELECT 1 FROM "benutzer");

prisma/schema.prisma

@@ -70,6 +70,13 @@ model User {
   // TOTP ist Pflicht. Das Secret liegt verschluesselt, nicht im Klartext.
   totpSecretVerschluesselt String?
   totpAktiviertAm          DateTime?
+  /// Der zuletzt akzeptierte TOTP-Zeitschritt (Unixzeit / 30).
+  ///
+  /// Ein TOTP-Code gilt 30 Sekunden, mit Toleranz bis zu 90. In dieser Zeit
+  /// liesse sich derselbe Code ein zweites Mal einloesen - abgelesen ueber
+  /// die Schulter oder abgefangen. Deshalb wird der Schritt festgehalten
+  /// und nur noch ein groesserer akzeptiert.
+  totpLetzterSchritt       Int?
   // Einmal-Wiederherstellungscodes, einzeln Argon2id-gehasht.
   wiederherstellungscodes  String[]  @default([])
 
@@ -81,6 +88,13 @@ model User {
   // (Passwortwechsel, Rollenaenderung, Verdacht auf Kompromittierung).
   sitzungsGeneration Int @default(0)
 
+  /// Die eigene Anschrift - Absenderblock und Ort in der Datumszeile
+  /// jedes erzeugten Schreibens. Sie gehoert zum Betreuer und nicht zur
+  /// betreuten Person: Sie gilt fuer alle Akten.
+  strasse String?
+  plz     String?
+  ort     String?
+
   // Oberflaechen-Einstellungen
   theme String @default("system") // "system" | "hell" | "dunkel"
 
@@ -89,6 +103,7 @@ model User {
   geloeschtAm    DateTime?
 
   zugaenge           BetreuungsZugang[]
+  passkeys           Passkey[]
   auditEintraege     AuditLog[]
   angelegteVorgaenge Vorgang[]          @relation("VorgangAngelegtVon")
   berichte           Bericht[]
@@ -120,6 +135,25 @@ model BetreuungsZugang {
   @@map("betreuungs_zugang")
 }
 
+/// Haelt fest, dass die Ersteinrichtung stattgefunden hat.
+///
+/// Die Tabelle hat genau eine Zeile mit fester Id. Das ist kein Protokoll,
+/// sondern eine Sperre: Vorher stand im Code "wenn es noch keinen Benutzer
+/// gibt, lege einen an" - zwei Anfragen gleichzeitig kamen beide durch die
+/// Pruefung und legten beide einen Administrator an. Ueber den
+/// Primaerschluessel entscheidet das jetzt die Datenbank, und zwar fuer
+/// genau einen Gewinner.
+model Ersteinrichtung {
+  /// Immer "einmalig". Der feste Wert ist die Sperre.
+  id String @id
+
+  abgeschlossenAm DateTime @default(now())
+  /// Wer den Zugang angelegt hat - nur zum Nachvollziehen.
+  userId          String?
+
+  @@map("ersteinrichtung")
+}
+
 /// Fehlgeschlagene und erfolgreiche Anmeldeversuche - Grundlage fuer das
 /// Rate-Limiting am Login. Wird nach 30 Tagen aufgeraeumt.
 model LoginVersuch {
@@ -135,6 +169,91 @@ model LoginVersuch {
   @@map("login_versuch")
 }
 
+/// Ein registrierter Passkey (WebAuthn/FIDO2).
+///
+/// Der private Schluessel verlaesst das Geraet nie - hier liegt nur der
+/// oeffentliche Teil. Ein gestohlener Datenbankabzug erlaubt deshalb keine
+/// Anmeldung, anders als bei einem Passworthash, den man offline angreifen
+/// kann.
+///
+/// Ein Passkey zaehlt bei uns als ZWEI Faktoren: Besitz des Geraets plus
+/// die Nutzerverifikation darauf (Fingerabdruck, Gesicht oder Geraete-PIN).
+/// Deshalb wird bei der Anmeldung "userVerified" erzwungen - siehe
+/// src/lib/auth/passkey.ts. Ohne diese Pruefung waere es nur ein Faktor.
+model Passkey {
+  id String @id @default(cuid())
+
+  userId String
+  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  /// Kennung des Authenticators, base64url. Eindeutig ueber alle Benutzer -
+  /// derselbe Schluessel darf nicht an zwei Zugaengen haengen.
+  credentialId String @unique
+
+  /// Oeffentlicher Schluessel im COSE-Format. Kein Geheimnis.
+  publicKey Bytes
+
+  /// Signaturzaehler des Authenticators. Zaehlt er nicht hoch, obwohl er
+  /// es vorher tat, ist der Schluessel womoeglich geklont worden.
+  /// BigInt, weil der Zaehler bis 2^32-1 geht.
+  counter BigInt @default(0)
+
+  /// "usb", "nfc", "ble", "internal", "hybrid" - hilft dem Browser beim
+  /// naechsten Mal, das richtige Geraet vorzuschlagen.
+  transports String[] @default([])
+
+  /// Vom Benutzer vergeben ("iPhone von Florian"). Bei mehreren Geraeten
+  /// ist das die einzige Moeglichkeit, sie auseinanderzuhalten.
+  name String
+
+  /// "singleDevice" = liegt nur auf diesem Geraet, "multiDevice" = wird vom
+  /// Schluesselbund synchronisiert. Steht in der Uebersicht, weil es den
+  /// Unterschied macht, ob ein verlorenes Geraet den Zugang mitnimmt.
+  geraeteArt String?
+
+  /// Ob der Anbieter den Schluessel gesichert hat (iCloud, Google, Bitwarden).
+  gesichert Boolean @default(false)
+
+  erstelltAm       DateTime  @default(now())
+  zuletztBenutztAm DateTime?
+
+  @@index([userId])
+  @@map("passkey")
+}
+
+enum PasskeyAnfrageArt {
+  REGISTRIERUNG
+  ANMELDUNG
+}
+
+/// Kurzlebiger Speicher fuer die Challenge einer laufenden Passkey-Aktion.
+///
+/// Die Challenge muss serverseitig liegen und genau einmal gelten, sonst
+/// liesse sich eine mitgeschnittene Antwort erneut einspielen. Verbraucht
+/// wird sie durch DELETE - dass genau eine Zeile geloescht wurde, ist der
+/// Beweis, dass sie noch nicht benutzt war.
+///
+/// Bewusst ohne Fremdschluessel auf User: die Zeile lebt fuenf Minuten und
+/// ist kein Fachdatum. Der Wartungslauf raeumt Liegengebliebenes weg.
+model PasskeyAnfrage {
+  id String @id @default(cuid())
+
+  /// base64url, zufaellig. Eindeutig, damit das Verbrauchen atomar ist.
+  challenge String @unique
+
+  art PasskeyAnfrageArt
+
+  /// Bei der Registrierung bekannt. Bei der Anmeldung nicht - dort weiss
+  /// der Server erst nach der Antwort, wer sich anmeldet.
+  userId String?
+
+  ablaufAm   DateTime
+  erstelltAm DateTime @default(now())
+
+  @@index([ablaufAm])
+  @@map("passkey_anfrage")
+}
+
 // =============================================================================
 // Betreute Person
 // =============================================================================
@@ -226,6 +345,8 @@ model Betreute {
   dokumente             Dokument[]
   konten                Konto[]
   buchungen             Buchung[]
+  zahlungsgruppen       ZahlungsgruppeGeklaert[]
+  schreibvorlagen       Schreibvorlage[]
   vermoegensposten      Vermoegensposten[]
   immobilien            Immobilie[]
   vertraege             Vertrag[]
@@ -285,6 +406,14 @@ model Vorgang {
   gegenstelle  String?
   aktenzeichen String?
 
+  /// Die Person bei der Gegenstelle, die den Vorgang bearbeitet. Ein
+  /// namentlich adressiertes Schreiben landet bei ihr statt in der
+  /// Poststelle - beim Bezirk ist das der Unterschied zwischen zwei
+  /// Wochen und zwei Monaten. SetNull: Ein Vorgang darf nicht daran
+  /// haengen, dass es den Kontakt noch gibt.
+  ansprechpartnerId String?
+  ansprechpartner   Kontakt? @relation("VorgangAnsprechpartner", fields: [ansprechpartnerId], references: [id], onDelete: SetNull)
+
   verantwortlich String?
   angelegtVonId  String?
   angelegtVon    User?   @relation("VorgangAngelegtVon", fields: [angelegtVonId], references: [id], onDelete: SetNull)
@@ -742,6 +871,75 @@ enum BuchungKategorie {
   UMBUCHUNG
 }
 
+/// Eine Gruppe wiederkehrender Zahlungen, zu der bewusst KEIN Vertrag
+/// gefuehrt wird - Miete, Strom, Rundfunkbeitrag, Finanzamt.
+///
+/// Die Entscheidung haengt am normalisierten Namen der Gegenstelle, nicht
+/// an den Buchungen. Nur so ueberlebt sie den naechsten Kontoauszug: Beim
+/// Import entstehen neue Buchungszeilen, der Empfaenger bleibt derselbe.
+///
+/// ACHTUNG: Der Schluessel wird von normalisieren() in
+/// src/lib/finanzen/wiederkehrend.ts gebildet. Aendert sich diese Funktion,
+/// passen bestehende Schluessel nicht mehr und abgehakte Gruppen tauchen
+/// wieder auf. Das ist unangenehm, aber ungefaehrlich - schlimmer waere,
+/// eine Gruppe stillschweigend weiter zu verbergen, die inzwischen anders
+/// zugeschnitten ist.
+/// Eine eigene Schreibvorlage.
+///
+/// Die mitgelieferten Vorlagen (Rueckkaufswert, Kuendigung,
+/// Sachstandsanfrage) stehen bewusst NICHT in dieser Tabelle - sie sind
+/// Code, getestet und unveraenderlich. "Wiederherstellen" heisst: die
+/// mitgelieferte Fassung als neue Kopie hierher holen.
+///
+/// Der Text traegt Platzhalter im Format {{name}} - aufgeloest in
+/// src/lib/schreiben/platzhalter.ts. Er ist bewusst NICHT verschluesselt:
+/// Eine Vorlage ist ein Textbaustein ohne Fallbezug; die Fachdaten kommen
+/// erst beim Erzeugen hinein.
+model Schreibvorlage {
+  id String @id @default(cuid())
+
+  betreuteId String
+  betreute   Betreute @relation(fields: [betreuteId], references: [id], onDelete: Cascade)
+
+  name    String
+  betreff String @default("")
+  text    String
+
+  /// Beim Speichern bestaetigt, dass der fehlende Bestellungsabsatz
+  /// Absicht ist - dann wird nicht bei jedem Bearbeiten erneut gewarnt.
+  ohneBestellungsabsatz Boolean @default(false)
+
+  erstelltAm     DateTime  @default(now())
+  aktualisiertAm DateTime  @updatedAt
+  geloeschtAm    DateTime?
+
+  @@index([betreuteId])
+  @@map("schreibvorlage")
+}
+
+model ZahlungsgruppeGeklaert {
+  id String @id @default(cuid())
+
+  betreuteId String
+  betreute   Betreute @relation(fields: [betreuteId], references: [id], onDelete: Cascade)
+
+  /// Normalisierter Name der Gegenstelle.
+  schluessel String
+
+  /// Die Schreibweise, wie sie beim Abhaken auf dem Bildschirm stand -
+  /// damit spaeter noch erkennbar ist, worum es ging.
+  anzeigename String
+
+  /// Warum kein Vertrag? Freiwillig, aber in einem Jahr Gold wert.
+  begruendung String?
+
+  erstelltAm DateTime @default(now())
+
+  @@unique([betreuteId, schluessel])
+  @@index([betreuteId])
+  @@map("zahlungsgruppe_geklaert")
+}
+
 model Buchung {
   id String @id @default(cuid())
 
@@ -767,6 +965,21 @@ model Buchung {
   /// Buchung ohne Beleg wird in der Liste markiert - Belegzwang.
   belegFehltBegruendung String?
 
+  /// Dauerzahlung zu einem Vertrag. Bei einem Dauerschuldverhaeltnis IST
+  /// der Vertrag der Beleg - fuer zwoelf gleiche Lastschriften gibt es
+  /// keine zwoelf Quittungen, sondern eine Police.
+  ///
+  /// onDelete: SetNull ist Absicht und Teil der Zusage: Verschwindet der
+  /// Vertrag, faellt die Buchung zurueck in "Beleg fehlt". Ein Nachweis,
+  /// der auf etwas zeigt, das es nicht mehr gibt, waere schlimmer als
+  /// gar keiner.
+  vertragId String?
+  vertrag   Vertrag? @relation("Vertragszahlung", fields: [vertragId], references: [id], onDelete: SetNull)
+
+  /// Wurde die Zuordnung beim Import automatisch gesetzt? Dann ist sie
+  /// eine Vermutung der Maschine und in der Liste als solche erkennbar.
+  vertragAutomatisch Boolean @default(false)
+
   /// false = Auslage des Betreuers, die erstattet werden muss.
   betrifftBetreute  Boolean @default(true)
   /// Verschiebt das Vermoegen (z.B. Verkaufserloes), nicht nur laufende
@@ -785,6 +998,7 @@ model Buchung {
   @@unique([kontoId, importReferenz])
   @@index([betreuteId, datum])
   @@index([betreuteId, kategorie])
+  @@index([vertragId])
   @@map("buchung")
 }
 
@@ -1050,6 +1264,7 @@ model Vertrag {
 
   vermoegensposten Vermoegensposten[]
   verknuepfungen   DokumentVerknuepfung[]
+  zahlungen        Buchung[]              @relation("Vertragszahlung")
 
   @@index([betreuteId, status])
   @@map("vertrag")
@@ -1059,6 +1274,13 @@ model Vertrag {
 // Kontakte und Kontaktprotokoll
 // =============================================================================
 
+/// Anrede fuer die Briefanrede eines Kontakts.
+enum KontaktAnrede {
+  OHNE
+  FRAU
+  HERR
+}
+
 enum KontaktRolle {
   RECHTSPFLEGER
   RICHTER
@@ -1094,6 +1316,9 @@ model Kontakt {
   name         String
   organisation String?
   rolle        KontaktRolle  @default(SONSTIGES)
+  /// Fuer die Briefanrede. Ohne Angabe wird mit vollem Namen angeredet -
+  /// nie geraten, das faellt dem Empfaenger sofort auf.
+  anrede       KontaktAnrede @default(OHNE)
 
   telefon      String?
   mobil        String?
@@ -1113,6 +1338,7 @@ model Kontakt {
 
   protokolle        Kontaktprotokoll[]
   vorgaenge         Vorgang[]              @relation("VorgangKontakte")
+  betreuteVorgaenge Vorgang[]              @relation("VorgangAnsprechpartner")
   verknuepfungen    DokumentVerknuepfung[]
 
   @@index([betreuteId, rolle])
@@ -1527,6 +1753,8 @@ enum AuditAktion {
   ANMELDUNG_FEHLGESCHLAGEN
   ABMELDUNG
   ZWEITER_FAKTOR_EINGERICHTET
+  PASSKEY_REGISTRIERT
+  PASSKEY_ENTFERNT
   PASSWORT_GEAENDERT
   ROLLE_GEAENDERT
   FREIGABE_GEAENDERT

prisma/seed.ts

@@ -22,7 +22,7 @@
  *
  * Der Seed ist idempotent: mehrfaches Ausfuehren aendert nichts.
  */
-import { PrismaClient } from '@prisma/client'
+import { PrismaClient, type BuchungKategorie, type Prisma } from '@prisma/client'
 import { hash } from '@node-rs/argon2'
 import { createCipheriv, randomBytes } from 'node:crypto'
 
@@ -112,6 +112,14 @@ async function ersterZugang() {
     },
   })
 
+  // Die Ersteinrichtung ist damit erledigt. Ohne diese Zeile stuende die
+  // Einrichtungsseite nach dem Seed weiter offen.
+  await db.ersteinrichtung.upsert({
+    where: { id: 'einmalig' },
+    update: {},
+    create: { id: 'einmalig', userId: benutzer.id },
+  })
+
   console.log(`Zugang ${email} angelegt.`)
   if (devSecret) {
     console.log('  Zweiter Faktor mit dem Entwicklungs-Geheimnis vorbelegt.')
@@ -263,9 +271,11 @@ async function demofall(userId: string) {
       art: 'GIRO',
       ibanVerschluesselt: verschluesseln('DE02773501100123456789', 'ibanVerschluesselt'),
       saldostaende: {
+        // Nur der Anfangsstand. Der spaetere wird weiter unten aus den
+        // Buchungen gerechnet - ein Demofall, der sich selbst
+        // widerspricht, waere schlimmer als einer ohne Buchungen.
         create: [
           { stichtag: datum('2026-02-14'), betragCent: cent(4218.36), quelle: 'Kontoauszug 02/2026' },
-          { stichtag: datum('2026-07-31'), betragCent: cent(2967.11), quelle: 'Kontoauszug 07/2026' },
         ],
       },
     },
@@ -523,6 +533,309 @@ async function demofall(userId: string) {
     })
   }
 
+
+  // --- Kontobewegungen ----------------------------------------------------
+  // Zwoelf Monate auf dem Girokonto. Erzeugt aus einem Muster und nicht
+  // einzeln abgetippt: So bleibt der Fall aenderbar, und die Betraege
+  // widersprechen sich nicht.
+  //
+  // Die Gegenstellen sind absichtlich uneinheitlich geschrieben. Genau
+  // damit muss die Zusammenfassung wiederkehrender Zahlungen umgehen - auf
+  // einem Kontoauszug steht dieselbe Stelle auch mal in Grossbuchstaben.
+  type Buchungsvorlage = {
+    tag: number
+    betrag: number
+    richtung: 'EINNAHME' | 'AUSGABE'
+    kategorie: BuchungKategorie
+    gegenstellen: string[]
+    zweck: string
+  }
+
+  const MONATLICH: Buchungsvorlage[] = [
+    {
+      tag: 1,
+      betrag: 1284.17,
+      richtung: 'EINNAHME',
+      kategorie: 'RENTE',
+      gegenstellen: [
+        'Deutsche Rentenversicherung Bund',
+        'DRV BUND',
+        'Deutsche Rentenversich. Bund',
+      ],
+      zweck: 'Altersrente',
+    },
+    {
+      tag: 1,
+      betrag: 96.4,
+      richtung: 'EINNAHME',
+      kategorie: 'RENTE',
+      gegenstellen: ['Zusatzversorgungskasse Bayern', 'ZVK Bayern'],
+      zweck: 'Betriebsrente',
+    },
+    {
+      tag: 3,
+      betrag: 1262,
+      richtung: 'EINNAHME',
+      kategorie: 'PFLEGEKASSE',
+      gegenstellen: ['Pflegekasse bei der AOK Bayern', 'AOK Bayern - Pflegekasse'],
+      zweck: 'Leistung vollstationaere Pflege, Pflegegrad 3',
+    },
+    {
+      tag: 5,
+      betrag: 2489,
+      richtung: 'AUSGABE',
+      kategorie: 'HEIMKOSTEN',
+      gegenstellen: [
+        'Seniorenzentrum St. Katharina',
+        'SENIORENZENTRUM ST KATHARINA',
+        'Seniorenzentrum St. Katharina gGmbH',
+      ],
+      zweck: 'Heimentgelt',
+    },
+    {
+      tag: 5,
+      betrag: 135,
+      richtung: 'AUSGABE',
+      kategorie: 'BARBETRAG',
+      // Eigene Gegenstelle, nicht das Heim: Sonst faellt der Barbetrag
+      // mit dem Heimentgelt in eine Gruppe, und aus zwei sauberen
+      // monatlichen Zahlungen wird eine "schwankende".
+      gegenstellen: ['Barauszahlung Verwahrgeldkonto'],
+      zweck: 'Barbetrag zur persoenlichen Verfuegung',
+    },
+    {
+      tag: 15,
+      betrag: 18.4,
+      richtung: 'AUSGABE',
+      kategorie: 'VERSICHERUNG',
+      gegenstellen: ['Nordheim Sterbekasse VVaG', 'NORDHEIM STERBEKASSE', 'Nordheim Sterbekasse'],
+      zweck: 'Beitrag Sterbegeldversicherung SG-220417',
+    },
+    {
+      tag: 20,
+      betrag: 24.9,
+      richtung: 'AUSGABE',
+      kategorie: 'TELEFON_INTERNET',
+      gegenstellen: ['TeleCare Kommunikation GmbH', 'TELECARE KOMMUNIKATION'],
+      zweck: 'Telefon und Fernsehen im Zimmer',
+    },
+    {
+      tag: 28,
+      betrag: 4.9,
+      richtung: 'AUSGABE',
+      kategorie: 'BANKGEBUEHREN',
+      gegenstellen: ['Sparkasse Bayreuth'],
+      zweck: 'Kontofuehrung',
+    },
+  ]
+
+  /** Zwoelf Monate bis einschliesslich Juli 2026. */
+  const MONATE = [
+    '2025-08',
+    '2025-09',
+    '2025-10',
+    '2025-11',
+    '2025-12',
+    '2026-01',
+    '2026-02',
+    '2026-03',
+    '2026-04',
+    '2026-05',
+    '2026-06',
+    '2026-07',
+  ]
+
+  const buchungen: Prisma.BuchungCreateManyInput[] = []
+
+  MONATE.forEach((monat, lauf) => {
+    MONATLICH.forEach((vorlage, stelle) => {
+      // Die Sterbegeld-Lastschrift steigt im Mai 2026. Daran wird die
+      // Pruefung beim Zuordnen einer Dauerzahlung sichtbar: Der Betrag
+      // weicht vom hinterlegten Beitrag ab.
+      const betrag =
+        vorlage.kategorie === 'VERSICHERUNG' && monat >= '2026-05' ? 19.8 : vorlage.betrag
+
+      buchungen.push({
+        betreuteId: betreute.id,
+        kontoId: giro.id,
+        datum: datum(`${monat}-${String(vorlage.tag).padStart(2, '0')}`),
+        betragCent: cent(betrag),
+        richtung: vorlage.richtung,
+        kategorie: vorlage.kategorie,
+        gegenstelle: vorlage.gegenstellen[lauf % vorlage.gegenstellen.length],
+        verwendungszweckVerschluesselt: verschluesseln(
+          vorlage.zweck,
+          'verwendungszweckVerschluesselt',
+        ),
+        // Wiederkehrende Zahlungen brauchen keinen Einzelbeleg - der
+        // Bescheid bzw. der Vertrag dahinter ist der Nachweis.
+        belegFehltBegruendung:
+          vorlage.richtung === 'EINNAHME'
+            ? 'Laufender Bezug, Nachweis ist der Bescheid.'
+            : 'Wiederkehrende Zahlung aus laufendem Vertrag.',
+        // Die Stelle in der Vorlagenliste gehoert in die Referenz: Zwei
+        // Renten am Monatsersten haetten sonst dieselbe, und der
+        // Unique-Index gegen Doppelbuchungen schlaegt zu Recht zu.
+        importReferenz: `demo-${monat}-${stelle}-${vorlage.kategorie}`,
+      })
+    })
+  })
+
+  // Vierteljaehrliches und Einmaliges - damit nicht alles im Monatsraster
+  // liegt und die Belegpflicht etwas zu zeigen hat.
+  const EINZELN: {
+    datum: string
+    betrag: number
+    richtung: 'EINNAHME' | 'AUSGABE'
+    kategorie: BuchungKategorie
+    gegenstelle: string
+    zweck: string
+    begruendung?: string
+  }[] = [
+    {
+      datum: '2025-08-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 3. Quartal 2025',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2025-11-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 4. Quartal 2025',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2026-02-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 1. Quartal 2026',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2026-05-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 2. Quartal 2026',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2026-02-16',
+      betrag: 187.5,
+      richtung: 'AUSGABE',
+      kategorie: 'GRUNDSTEUER',
+      gegenstelle: 'Gemeinde Bindlach',
+      zweck: 'Grundsteuer B, 1. Rate 2026',
+      begruendung: 'Bescheid der Gemeinde liegt in der Akte.',
+    },
+    {
+      datum: '2026-05-16',
+      betrag: 187.5,
+      richtung: 'AUSGABE',
+      kategorie: 'GRUNDSTEUER',
+      gegenstelle: 'Gemeinde Bindlach',
+      zweck: 'Grundsteuer B, 2. Rate 2026',
+      begruendung: 'Bescheid der Gemeinde liegt in der Akte.',
+    },
+    {
+      datum: '2026-01-19',
+      betrag: 240,
+      richtung: 'AUSGABE',
+      kategorie: 'IMMOBILIE_BETRIEBSKOSTEN',
+      gegenstelle: 'Stadtwerke Bayreuth',
+      zweck: 'Abschlag Strom und Wasser, Haus Bindlach',
+      begruendung: 'Jahresabrechnung steht noch aus.',
+    },
+    {
+      datum: '2026-03-11',
+      betrag: 10,
+      richtung: 'AUSGABE',
+      kategorie: 'ZUZAHLUNG',
+      gegenstelle: 'Apotheke am Markt',
+      zweck: 'Zuzahlung Rezept',
+      begruendung: 'Quittung liegt in der Akte.',
+    },
+    // Der Fall fuer die Belegpflicht: keine Quittung und keine Begruendung.
+    // Genau so sieht eine Buchung aus, die noch Arbeit macht.
+    {
+      datum: '2026-04-08',
+      betrag: 89.95,
+      richtung: 'AUSGABE',
+      kategorie: 'BEKLEIDUNG',
+      gegenstelle: 'Modehaus Lindner',
+      zweck: 'Winterjacke und zwei Nachthemden',
+    },
+    {
+      datum: '2026-06-17',
+      betrag: 23,
+      richtung: 'AUSGABE',
+      kategorie: 'SONSTIGE_AUSGABE',
+      gegenstelle: 'Friseur im Haus',
+      zweck: 'Friseur',
+      begruendung: 'Bar aus dem Barbetrag bezahlt, keine Quittung ausgestellt.',
+    },
+    {
+      datum: '2026-07-02',
+      betrag: 62.4,
+      richtung: 'EINNAHME',
+      kategorie: 'ZINSEN',
+      gegenstelle: 'Sparkasse Bayreuth',
+      zweck: 'Zinsgutschrift',
+      begruendung: 'Der Kontoauszug ist der Nachweis.',
+    },
+  ]
+
+  for (const eintrag of EINZELN) {
+    buchungen.push({
+      betreuteId: betreute.id,
+      kontoId: giro.id,
+      datum: datum(eintrag.datum),
+      betragCent: cent(eintrag.betrag),
+      richtung: eintrag.richtung,
+      kategorie: eintrag.kategorie,
+      gegenstelle: eintrag.gegenstelle,
+      verwendungszweckVerschluesselt: verschluesseln(
+        eintrag.zweck,
+        'verwendungszweckVerschluesselt',
+      ),
+      belegFehltBegruendung: eintrag.begruendung ?? null,
+      importReferenz: `demo-${eintrag.datum}-${eintrag.kategorie}`,
+    })
+  }
+
+  await db.buchung.createMany({ data: buchungen })
+
+  // Der Kontostand zum 31.07.2026 wird gerechnet, nicht behauptet: Anfangs-
+  // stand plus alles, was seither ueber das Konto gelaufen ist. Sonst
+  // widerspraeche der Demofall sich selbst, sobald jemand nachrechnet.
+  const bewegungCent = buchungen
+    .filter((eintrag) => {
+      const tag = eintrag.datum as Date
+      return tag > datum('2026-02-14') && tag <= datum('2026-07-31')
+    })
+    .reduce((summe, eintrag) => {
+      const betrag = eintrag.betragCent as bigint
+      return eintrag.richtung === 'EINNAHME' ? summe + betrag : summe - betrag
+    }, 0n)
+
+  await db.saldostand.create({
+    data: {
+      kontoId: giro.id,
+      stichtag: datum('2026-07-31'),
+      betragCent: cent(4218.36) + bewegungCent,
+      quelle: 'Kontoauszug 07/2026',
+    },
+  })
+
   console.log('Demofall "Erika Musterfrau" angelegt.')
 }
 

prisma/sql/audit-schutz.sql

@@ -25,6 +25,42 @@ BEGIN
     RETURN OLD;
   END IF;
 
+  /*
+   * Eine einzige Ausnahme beim UPDATE: das Nullen der beiden
+   * Fremdschluessel.
+   *
+   * Wird eine betreute Person oder ein Benutzer endgueltig geloescht
+   * (Papierkorb nach 30 Tagen), setzt Postgres wegen ON DELETE SET NULL
+   * die Spalten betreuteId bzw. userId auf NULL. Ohne diese Ausnahme
+   * scheitert das Loeschen - und der Papierkorb liesse sich nie leeren.
+   *
+   * Der Nachweis bleibt dabei vollstaendig: Zeitpunkt, Aktion, Entitaet,
+   * Bezeichnung und die verschluesselte Aenderung sind unberuehrt, ebenso
+   * die Momentaufnahmen userEmail und userName. Es verschwindet nur der
+   * Verweis auf einen Datensatz, den es nicht mehr gibt.
+   *
+   * Jede andere Aenderung wird abgewiesen - auch das Zurueckschreiben
+   * eines Fremdschluessels auf einen anderen Wert.
+   */
+  IF TG_OP = 'UPDATE'
+     AND NEW.id                        =                OLD.id
+     AND NEW.zeitpunkt                 =                OLD.zeitpunkt
+     AND NEW.aktion                    =                OLD.aktion
+     AND NEW.entitaet                  =                OLD.entitaet
+     AND NEW."entitaetId"              IS NOT DISTINCT FROM OLD."entitaetId"
+     AND NEW.bezeichnung               IS NOT DISTINCT FROM OLD.bezeichnung
+     AND NEW."userEmail"               IS NOT DISTINCT FROM OLD."userEmail"
+     AND NEW."userName"                IS NOT DISTINCT FROM OLD."userName"
+     AND NEW."aenderungVerschluesselt" IS NOT DISTINCT FROM OLD."aenderungVerschluesselt"
+     AND NEW."ipHash"                  IS NOT DISTINCT FROM OLD."ipHash"
+     AND NEW."userAgent"               IS NOT DISTINCT FROM OLD."userAgent"
+     -- Die beiden Fremdschluessel duerfen sich aendern, aber NUR nach NULL.
+     AND (NEW."betreuteId" IS NULL OR NEW."betreuteId" IS NOT DISTINCT FROM OLD."betreuteId")
+     AND (NEW."userId"     IS NULL OR NEW."userId"     IS NOT DISTINCT FROM OLD."userId")
+  THEN
+    RETURN NEW;
+  END IF;
+
   RAISE EXCEPTION
     'Das Audit-Log ist unveraenderlich. % auf audit_log ist nicht zulaessig.',
     TG_OP

scripts/anmeldung-pruefen.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Warum klappt die Anmeldung nicht?
+ *
+ *   node --env-file=.env scripts/anmeldung-pruefen.mjs <e-mail>
+ *   docker compose exec app node scripts/anmeldung-pruefen.mjs <e-mail>
+ *
+ * Die Anwendung sagt am Anmeldeformular bewusst nicht, woran es lag - sonst
+ * liesse sich daran ablesen, welche Adressen es gibt. Auf dem Server darf
+ * man es wissen: Jeder Versuch wird mit Grund protokolliert, und dieses
+ * Skript liest ihn vor.
+ *
+ * Es aendert nichts. Es liest nur.
+ */
+import { PrismaClient } from '@prisma/client'
+
+const email = (process.argv[2] ?? '').trim().toLowerCase()
+
+if (!email) {
+  console.error('Aufruf: node scripts/anmeldung-pruefen.mjs <e-mail>')
+  process.exit(1)
+}
+
+const db = new PrismaClient()
+
+function zeit(d) {
+  return d ? new Date(d).toLocaleString('de-DE') : '—'
+}
+
+/** Klartext zu den Gruenden, die src/auth.ts protokolliert. */
+const GRUND = {
+  unbekannt: 'Diese E-Mail-Adresse gibt es nicht (Tippfehler? andere Adresse?)',
+  'passwort-falsch': 'Das Passwort stimmt nicht',
+  'code-falsch': 'Der Code aus der Authenticator-App stimmt nicht',
+  gesperrt: 'Abgewiesen, weil zu diesem Zeitpunkt bereits gesperrt war',
+  'konto-inaktiv': 'Der Zugang ist deaktiviert oder im Papierkorb',
+}
+
+try {
+  const benutzer = await db.user.findUnique({ where: { email } })
+
+  console.log('\n══ Zugang ' + '═'.repeat(50))
+
+  if (!benutzer) {
+    console.log(`  Es gibt KEINEN Zugang mit der Adresse ${email}.`)
+    const alle = await db.user.findMany({
+      select: { email: true, aktiv: true, geloeschtAm: true },
+      orderBy: { erstelltAm: 'asc' },
+    })
+    console.log(
+      alle.length
+        ? '\n  Vorhandene Adressen:\n' +
+            alle.map((u) => `    ${u.email}${u.geloeschtAm ? '  (im Papierkorb)' : u.aktiv ? '' : '  (deaktiviert)'}`).join('\n')
+        : '\n  Es gibt ueberhaupt keinen Zugang. Leg ihn im Browser unter /ersteinrichtung an.',
+    )
+  } else {
+    const zweiterFaktor = benutzer.totpAktiviertAm
+      ? `eingerichtet am ${zeit(benutzer.totpAktiviertAm)}`
+      : benutzer.totpSecretVerschluesselt
+        ? 'vorbereitet, aber NICHT bestaetigt - beim Anmelden wird noch kein Code verlangt'
+        : 'noch nicht eingerichtet - beim Anmelden wird noch kein Code verlangt'
+
+    console.log(`  Name:              ${benutzer.name}`)
+    console.log(`  Rolle:             ${benutzer.rolle}`)
+    console.log(`  Aktiv:             ${benutzer.aktiv ? 'ja' : 'NEIN - Anmeldung nicht moeglich'}`)
+    console.log(`  Papierkorb:        ${benutzer.geloeschtAm ? 'JA seit ' + zeit(benutzer.geloeschtAm) : 'nein'}`)
+    console.log(`  Zweiter Faktor:    ${zweiterFaktor}`)
+    console.log(`  Wiederherstellung: ${benutzer.wiederherstellungscodes.length} Codes uebrig`)
+    console.log(`  Passwort gesetzt:  ${zeit(benutzer.passwortGeaendertAm)}`)
+    console.log(`  Letzte Anmeldung:  ${zeit(benutzer.letzteAnmeldung)}`)
+
+    const zugaenge = await db.betreuungsZugang.count({ where: { userId: benutzer.id } })
+    const betreute = await db.betreute.count({ where: { geloeschtAm: null } })
+    console.log(`  Betreute Personen: ${zugaenge} zugeordnet, ${betreute} insgesamt angelegt`)
+
+    if (zugaenge === 0 && betreute === 0) {
+      console.log(
+        '\n  Hinweis: Nach dem Anmelden landest du zuerst bei der\n' +
+          '  Ersteinrichtung - erst zweiter Faktor, dann betreute Person.',
+      )
+    }
+  }
+
+  // --- Versuche der letzten Tage -------------------------------------------
+  const versuche = await db.loginVersuch.findMany({
+    where: { email },
+    orderBy: { zeitpunkt: 'desc' },
+    take: 15,
+  })
+
+  console.log('\n══ Letzte Anmeldeversuche ' + '═'.repeat(35))
+
+  if (versuche.length === 0) {
+    console.log(
+      '  Keine. Es ist also NIE ein Versuch beim Server angekommen.\n\n' +
+        '  Das heisst: Das Formular hat gar nicht abgeschickt, oder es lief\n' +
+        '  auf eine andere Adresse. Pruef AUTH_URL - siehe unten.',
+    )
+  } else {
+    for (const v of versuche) {
+      const kennzeichen = v.erfolg ? 'OK    ' : 'FEHLER'
+      const grund = v.erfolg ? 'angemeldet' : (GRUND[v.grund] ?? v.grund ?? 'unbekannter Grund')
+      console.log(`  ${zeit(v.zeitpunkt).padEnd(20)} ${kennzeichen}  ${grund}`)
+    }
+  }
+
+  // --- Sperre ---------------------------------------------------------------
+  const fenster = Number.parseInt(process.env.LOGIN_FENSTER_SEKUNDEN ?? '900', 10)
+  const grenze = Number.parseInt(process.env.LOGIN_MAX_VERSUCHE ?? '5', 10)
+  const seit = new Date(Date.now() - fenster * 1000)
+
+  const offen = await db.loginVersuch.count({
+    where: { email, erfolg: false, zeitpunkt: { gte: seit } },
+  })
+
+  console.log('\n══ Sperre ' + '═'.repeat(51))
+  console.log(`  ${offen} von ${grenze} Fehlversuchen im laufenden Fenster (${fenster / 60} Minuten)`)
+
+  if (offen >= grenze) {
+    console.log(
+      '\n  GESPERRT. Warte das Fenster ab, oder setz die Zaehler zurueck:\n' +
+        '    docker compose exec db psql -U cockpit betreuungs_cockpit \\\n' +
+        '      -c "DELETE FROM login_versuch WHERE erfolg = false;"',
+    )
+  }
+
+  // --- Umgebung -------------------------------------------------------------
+  console.log('\n══ Umgebung ' + '═'.repeat(49))
+  console.log(`  AUTH_URL:  ${process.env.AUTH_URL ?? 'NICHT GESETZT'}`)
+  console.log(
+    '\n  Diese Adresse muss EXAKT die sein, die du im Browser aufrufst -\n' +
+      '  gleiches Schema (https), gleicher Hostname, kein Schraegstrich am\n' +
+      '  Ende. Weicht sie ab, wird das Sitzungs-Cookie fuer die falsche\n' +
+      '  Herkunft gesetzt: Die Anmeldung landet ohne Fehlermeldung wieder\n' +
+      '  auf dem Formular, und oben steht kein einziger Fehlversuch.\n',
+  )
+} catch (fehler) {
+  // Ein Prisma-Stacktrace hilft hier niemandem weiter.
+  const meldung = fehler instanceof Error ? fehler.message : String(fehler)
+
+  if (/Can't reach database server|ECONNREFUSED/i.test(meldung)) {
+    // Das Passwort in der Verbindungszeichenkette gehoert nicht auf den Schirm.
+    const url = (process.env.DATABASE_URL ?? 'NICHT GESETZT').replace(/:[^:@/]+@/, ':***@')
+    console.error(
+      [
+        '',
+        'Die Datenbank ist nicht erreichbar.',
+        '',
+        `  DATABASE_URL: ${url}`,
+        '',
+        '  Im Docker-Betrieb gehoert dieses Skript IN den Behaelter:',
+        '    docker compose exec app node scripts/anmeldung-pruefen.mjs <e-mail>',
+        '',
+        '  Laeuft die Datenbank ueberhaupt?',
+        '    docker compose ps',
+        '',
+      ].join('\n'),
+    )
+  } else {
+    console.error(`\nFehler: ${meldung}\n`)
+  }
+  process.exitCode = 1
+} finally {
+  await db.$disconnect()
+}

scripts/migration-erzeugen.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Typen fuer das Werkzeugskript.
+ *
+ * Das Skript selbst bleibt .mjs - es laeuft ohne Bauschritt, auch auf
+ * einem Rechner, auf dem nur Node steht. Die Typen daneben sorgen dafuer,
+ * dass die Tests trotzdem geprueft werden und nicht stillschweigend
+ * gegen "any" laufen.
+ */
+
+export type GeschuetzterIndex = {
+  name: string
+  quelle: string
+}
+
+export declare const GESCHUETZTE_INDIZES: GeschuetzterIndex[]
+
+export declare function dropZeilenEntfernen(
+  sql: string,
+  geschuetzt?: GeschuetzterIndex[],
+): { sql: string; entfernt: string[] }
+
+export declare function hatAnweisungen(sql: string): boolean
+
+export declare function kopfBauen(
+  name: string,
+  entfernt: string[],
+  geschuetzt?: GeschuetzterIndex[],
+): string
+
+export declare function ordnernameBauen(name: string, jetzt?: Date): string
+
+export declare function indizesPruefen(): void

scripts/migration-erzeugen.mjs

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+/**
+ * Eine Migration erzeugen, ohne die Volltextsuche kaputtzumachen.
+ *
+ *   npm run db:migration -- ansprechpartner
+ *   npm run db:migration -- ansprechpartner --anwenden
+ *
+ * Das Problem, das dieses Skript loest: "prisma migrate diff" kennt nur
+ * das, was im Prisma-Schema steht. Die Trigramm-Indizes der Suche stehen
+ * aber in prisma/sql/volltextsuche.sql und sind Prisma unbekannt - also
+ * haelt es sie fuer ueberfluessig und schreibt in JEDE erzeugte Migration:
+ *
+ *   DROP INDEX "dokument_absender_trgm";
+ *   DROP INDEX "vorgang_titel_trgm";
+ *
+ * Fuenfmal ist das passiert, fuenfmal mussten die Zeilen von Hand raus.
+ * Auf dem Server waere es nicht aufgefallen, weil update.sh die Indizes
+ * hinterher ohnehin neu anlegt - in der Entwicklung dagegen waere die
+ * Suche still langsam geworden, ohne dass etwas fehlschlaegt.
+ *
+ * Was das Skript macht:
+ *   1. Migration mit "migrate diff" erzeugen.
+ *   2. DROP-Zeilen zu geschuetzten Indizes entfernen und im Kopf
+ *      vermerken, welche das waren.
+ *   3. Auf Wunsch (--anwenden) "migrate deploy" laufen lassen und danach
+ *      pruefen, dass die geschuetzten Indizes wirklich noch stehen.
+ *
+ * Nicht automatisch angewendet wird die Migration ohne --anwenden: Erst
+ * liest man, was da erzeugt wurde.
+ */
+import { execFileSync } from 'node:child_process'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const WURZEL = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+/**
+ * Indizes, die es nur in prisma/sql/ gibt und die Prisma deshalb nicht
+ * kennt. Wer dort einen hinzufuegt, traegt ihn hier ein - sonst faellt er
+ * der naechsten Migration zum Opfer.
+ */
+export const GESCHUETZTE_INDIZES = [
+  { name: 'dokument_absender_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+  { name: 'vorgang_titel_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+]
+
+/**
+ * Entfernt DROP-INDEX-Anweisungen zu geschuetzten Indizes.
+ *
+ * Bewusst eng gefasst: Nur eine Anweisung, die genau einen geschuetzten
+ * Index nennt, faellt weg. Ein DROP INDEX auf einen Prisma-eigenen Index
+ * bleibt stehen - der soll ja weg. Der Kommentar "-- DropIndex", den
+ * Prisma darueber setzt, wird mitgenommen, damit keine verwaisten
+ * Ueberschriften zurueckbleiben.
+ *
+ * @param {string} sql
+ * @param {{name: string}[]} geschuetzt
+ * @returns {{sql: string, entfernt: string[]}}
+ */
+export function dropZeilenEntfernen(sql, geschuetzt = GESCHUETZTE_INDIZES) {
+  const namen = geschuetzt.map((eintrag) => eintrag.name)
+  const zeilen = sql.split('\n')
+  const behalten = []
+  const entfernt = []
+
+  for (let i = 0; i < zeilen.length; i++) {
+    const zeile = zeilen[i]
+    const treffer = namen.find(
+      (name) => /^\s*DROP\s+INDEX\b/i.test(zeile) && zeile.includes(name),
+    )
+
+    if (!treffer) {
+      behalten.push(zeile)
+      continue
+    }
+
+    entfernt.push(treffer)
+
+    // Die "-- DropIndex"-Ueberschrift darueber mitnehmen, samt der
+    // Leerzeile davor - sonst bleiben Luecken im Text stehen.
+    while (behalten.length > 0 && /^\s*--\s*DropIndex\s*$/i.test(behalten[behalten.length - 1])) {
+      behalten.pop()
+      while (behalten.length > 0 && behalten[behalten.length - 1].trim() === '') behalten.pop()
+    }
+
+    // Leerzeilen, die der entfernten Anweisung folgen, ebenfalls.
+    while (i + 1 < zeilen.length && zeilen[i + 1].trim() === '') i++
+  }
+
+  return { sql: behalten.join('\n').replace(/\n{3,}/g, '\n\n').trimStart(), entfernt }
+}
+
+/**
+ * Steht in dem SQL ueberhaupt noch eine Anweisung?
+ *
+ * Wichtig fuer den Normalfall: Wenn Schema und Datenbank uebereinstimmen,
+ * besteht der ganze Diff aus den beiden bekannten DROP-INDEX-Zeilen. Nach
+ * dem Entfernen bleibt nichts uebrig - und eine leere Migration anzulegen
+ * waere schlimmer als gar keine, weil sie als angewendet in der Historie
+ * steht und niemand mehr weiss, wofuer sie gut war.
+ *
+ * @param {string} sql
+ * @returns {boolean}
+ */
+export function hatAnweisungen(sql) {
+  return sql
+    .split('\n')
+    .some((zeile) => zeile.trim() !== '' && !zeile.trim().startsWith('--'))
+}
+
+/** Der Kopfkommentar der erzeugten Datei. */
+export function kopfBauen(name, entfernt, geschuetzt = GESCHUETZTE_INDIZES) {
+  const zeilen = [`-- ${name}`, '--']
+
+  if (entfernt.length === 0) {
+    zeilen.push('-- Erzeugt mit "npm run db:migration". Nichts zu entfernen.')
+  } else {
+    const quellen = [
+      ...new Set(
+        entfernt.map(
+          (eintrag) => geschuetzt.find((g) => g.name === eintrag)?.quelle ?? 'prisma/sql/',
+        ),
+      ),
+    ]
+    zeilen.push(
+      '-- Erzeugt mit "npm run db:migration". Entfernt wurden die',
+      '-- DROP-INDEX-Anweisungen zu diesen Indizes:',
+      ...entfernt.map((eintrag) => `--   ${eintrag}`),
+      '--',
+      `-- Sie stammen aus ${quellen.join(', ')} und sind Prisma unbekannt;`,
+      '-- ohne sie waere die Volltextsuche still langsam geworden.',
+    )
+  }
+
+  zeilen.push('')
+  return zeilen.join('\n')
+}
+
+/** Zeitstempel im Prisma-Format, aus der lokalen Uhr. */
+export function ordnernameBauen(name, jetzt = new Date()) {
+  const zwei = (zahl) => String(zahl).padStart(2, '0')
+  const stempel = [
+    jetzt.getFullYear(),
+    zwei(jetzt.getMonth() + 1),
+    zwei(jetzt.getDate()),
+    zwei(jetzt.getHours()),
+    zwei(jetzt.getMinutes()),
+    zwei(jetzt.getSeconds()),
+  ].join('')
+  return `${stempel}_${name}`
+}
+
+// --- Ab hier: Ausfuehrung ----------------------------------------------------
+
+/**
+ * Prisma direkt ueber sein Eintrittsskript aufrufen, nicht ueber npx.
+ *
+ * Mit "shell: true" wuerde Node warnen (Argumente werden dann nur
+ * aneinandergehaengt statt maskiert), und ohne Shell findet Windows das
+ * npx-Skript nicht. Der Weg ueber node loest beides und ist derselbe,
+ * den scripts/update.sh schon nimmt.
+ */
+function prisma(argumente, optionen = {}) {
+  const eintritt = join(WURZEL, 'node_modules', 'prisma', 'build', 'index.js')
+  return execFileSync(process.execPath, [eintritt, ...argumente], {
+    cwd: WURZEL,
+    encoding: 'utf8',
+    ...optionen,
+  })
+}
+
+function abbruch(meldung) {
+  console.error(`\n  Abbruch: ${meldung}\n`)
+  process.exit(1)
+}
+
+function hauptlauf() {
+  const argumente = process.argv.slice(2)
+  const anwenden = argumente.includes('--anwenden')
+  const name = argumente.find((eintrag) => !eintrag.startsWith('--'))
+
+  if (!name) {
+    abbruch(
+      'Bitte einen Namen angeben:  npm run db:migration -- <name> [--anwenden]\n' +
+        '           Beispiel:              npm run db:migration -- ansprechpartner',
+    )
+  }
+  if (!/^[a-z0-9_]+$/.test(name)) {
+    abbruch(`"${name}" taugt nicht als Ordnername. Erlaubt: a-z, 0-9 und _`)
+  }
+
+  console.log(`\n  Migration "${name}" erzeugen\n`)
+
+  let roh
+  try {
+    roh = prisma([
+      'migrate',
+      'diff',
+      '--from-schema-datasource',
+      'prisma/schema.prisma',
+      '--to-schema-datamodel',
+      'prisma/schema.prisma',
+      '--script',
+    ])
+  } catch (fehler) {
+    abbruch(`"prisma migrate diff" ist fehlgeschlagen:\n${fehler.message}`)
+  }
+
+  if (roh.trim() === '' || /^--\s*This is an empty migration/im.test(roh)) {
+    abbruch('Schema und Datenbank stimmen bereits ueberein - es gibt nichts zu migrieren.')
+  }
+
+  const { sql, entfernt } = dropZeilenEntfernen(roh)
+
+  if (!hatAnweisungen(sql)) {
+    const grund =
+      entfernt.length > 0
+        ? `Uebrig blieben nur die bekannten DROP-INDEX-Zeilen (${entfernt.join(', ')}).`
+        : 'Der Vergleich hat keine Anweisungen ergeben.'
+    abbruch(
+      `Es gibt nichts zu migrieren. ${grund}\n` +
+        '           Es wurde keine Migration angelegt.',
+    )
+  }
+
+  const ordner = join(WURZEL, 'prisma', 'migrations', ordnernameBauen(name))
+  mkdirSync(ordner, { recursive: true })
+  const datei = join(ordner, 'migration.sql')
+  writeFileSync(datei, `${kopfBauen(name, entfernt)}\n${sql.trimEnd()}\n`, 'utf8')
+
+  console.log(`  Geschrieben: ${datei.replace(WURZEL, '.')}`)
+  if (entfernt.length > 0) {
+    console.log('\n  Entfernte DROP-INDEX-Anweisungen:')
+    for (const eintrag of entfernt) console.log(`    - ${eintrag}`)
+  } else {
+    console.log('  Keine DROP-INDEX-Anweisung zu schuetzenden Indizes gefunden.')
+  }
+
+  if (!anwenden) {
+    console.log('\n  Jetzt: die Datei lesen, dann anwenden mit')
+    console.log('    npm run db:deploy && npm run db:pruefen\n')
+    return
+  }
+
+  console.log('\n  Anwenden ...')
+  try {
+    prisma(['migrate', 'deploy'], { stdio: 'inherit' })
+  } catch {
+    abbruch('"prisma migrate deploy" ist fehlgeschlagen. Die Datei bleibt liegen.')
+  }
+
+  indizesPruefen()
+}
+
+/**
+ * Stehen die geschuetzten Indizes noch?
+ *
+ * Der Sinn des ganzen Skripts haengt an dieser Pruefung: Sie ist der
+ * Unterschied zwischen "sollte gutgegangen sein" und "nachgesehen".
+ */
+export function indizesPruefen() {
+  const bedingung = GESCHUETZTE_INDIZES.map((eintrag) => `'${eintrag.name}'`).join(', ')
+  const sql = `DO $$
+BEGIN
+  IF (SELECT count(*) FROM pg_indexes WHERE indexname IN (${bedingung})) <> ${GESCHUETZTE_INDIZES.length} THEN
+    RAISE EXCEPTION 'Es fehlen geschuetzte Indizes';
+  END IF;
+END $$;`
+
+  // In den Temp-Ordner, nicht ins Repository: Die Datei ist Werkzeug,
+  // kein Bestandteil des Projekts.
+  const datei = join(tmpdir(), `indizes-pruefung-${process.pid}.sql`)
+  writeFileSync(datei, sql, 'utf8')
+
+  try {
+    prisma(['db', 'execute', '--schema', 'prisma/schema.prisma', '--file', datei], {
+      stdio: 'pipe',
+    })
+    console.log('\n  Geschuetzte Indizes stehen:')
+    for (const eintrag of GESCHUETZTE_INDIZES) console.log(`    - ${eintrag.name}`)
+    console.log('')
+  } catch {
+    abbruch(
+      'Nach der Migration fehlen geschuetzte Indizes.\n' +
+        '           Wiederherstellen mit:  npm run db:sql',
+    )
+  } finally {
+    rmSync(datei, { force: true })
+  }
+}
+
+if (process.argv[1] && process.argv[1].endsWith('migration-erzeugen.mjs')) {
+  hauptlauf()
+}

scripts/schluessel-erzeugen.mjs

@@ -18,6 +18,7 @@ AUTH_SECRET=${b64(32)}
 ENC_KEY_V1=${b64(32)}
 ENC_KEY_AKTIV=1
 INDEX_KEY=${b64(32)}
+ERSTEINRICHTUNG_GEHEIMNIS=${b64(24)}
 POSTGRES_PASSWORD=${b64(24).replace(/[+/=]/g, 'x')}
 
 # WICHTIG: ENC_KEY_V1 geht NICHT verloren gehen duerfen.

scripts/sicherung.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 # =============================================================================
-# Taegliche Sicherung der Datenbank
+# Taegliche Sicherung: Datenbank UND Dokumente
 # =============================================================================
 #
 # Laeuft im Behaelter "sicherung" per cron um 03:15 Uhr. Von Hand:
@@ -10,17 +10,44 @@
 # Was passiert:
 #   1. pg_dump im eigenen Format (-Fc), damit einzelne Tabellen
 #      wiederherstellbar bleiben.
-#   2. Verschluesselung mit AES-256 und PBKDF2 aus SICHERUNG_PASSWORT.
+#   2. Die abgelegten Dokumente als Archiv.
+#   3. Beides verschluesselt mit AES-256 und PBKDF2 aus SICHERUNG_PASSWORT.
 #      Das Backup liegt oft auf fremdem Speicher - unverschluesselt waere
 #      es ein Datenleck mit Ansage.
-#   3. SHA-256-Pruefsumme daneben.
-#   4. Staende, die aelter sind als SICHERUNG_AUFBEWAHRUNG_TAGE, entfernen.
+#   4. SHA-256-Pruefsumme je Datei.
+#   5. Staende, die aelter sind als SICHERUNG_AUFBEWAHRUNG_TAGE, entfernen.
 #      Der jeweils erste Stand eines Monats bleibt stehen.
 #
-# WICHTIG: Dieses Backup enthaelt die verschluesselten Felder, aber NICHT
-# den Schluessel ENC_KEY_V1. Ohne ihn sind Diagnosen, IBANs und Notizen
-# auch aus einer wiederhergestellten Datenbank nicht lesbar. Den Schluessel
-# getrennt sichern - Passwortmanager oder ausgedruckt im Ordner.
+# ## Warum die Dokumente dazugehoeren
+#
+# Bis v1.11.0 sicherte dieses Skript nur die Datenbank. Nach einem
+# Plattenschaden waere die Akte vollstaendig wiederhergestellt worden -
+# mit allen Eintraegen, Verweisen und Pruefsummen, aber ohne eine einzige
+# Datei dahinter. Die Pruefsumme in der Akte haette dann ein Dokument
+# belegt, das es nicht mehr gibt. Gegenueber dem Betreuungsgericht ist das
+# der schlechteste denkbare Zustand.
+#
+# ## Warum das Ablageverzeichnis roh eingepackt wird
+#
+# Der naheliegende Weg waere "mc mirror" aus dem MinIO-Client. Der ist in
+# diesem Behaelter aber nicht vorhanden und muesste bei jedem Lauf aus dem
+# Netz geholt werden - eine Internetabhaengigkeit im Sicherungspfad ist
+# genau das, was man dort nicht will.
+#
+# Stattdessen wird das Datenverzeichnis direkt eingepackt. Das ist
+# vertretbar, weil MinIO ein Objekt erst vollstaendig unter .minio.sys/tmp
+# schreibt und dann an seinen Platz umbenennt: Ein laufender Upload liegt
+# also nie halbfertig im Archiv, er fehlt hoechstens. Bei einem Lauf um
+# 03:15 Uhr auf einem Einzelplatzsystem ist auch das unwahrscheinlich.
+#
+# Derselbe Weg deckt den Dateitreiber mit ab - dort liegen die Dateien
+# ebenfalls einfach im Verzeichnis.
+#
+# WICHTIG: Dieses Backup enthaelt die verschluesselten Felder und die
+# verschluesselten Dateien, aber NICHT den Schluessel ENC_KEY_V1. Ohne ihn
+# sind Diagnosen, IBANs, Notizen und Dokumente auch aus einer
+# wiederhergestellten Sicherung nicht lesbar. Den Schluessel getrennt
+# sichern - Passwortmanager oder ausgedruckt im Ordner.
 # =============================================================================
 
 set -eu
@@ -30,6 +57,11 @@ AUFBEWAHRUNG="${SICHERUNG_AUFBEWAHRUNG_TAGE:-30}"
 ZEITSTEMPEL="$(date +%Y-%m-%d_%H%M)"
 TAG_IM_MONAT="$(date +%d)"
 DATEI="$ZIEL/cockpit_${ZEITSTEMPEL}.dump.enc"
+DOKUMENTE_DATEI="$ZIEL/dokumente_${ZEITSTEMPEL}.tar.gz.enc"
+
+# Wo die Dokumente liegen. Der Behaelter bekommt das Ablageverzeichnis
+# eingehaengt - siehe docker-compose.yml, Dienst "sicherung".
+DOKUMENTE_QUELLE="${SICHERUNG_DOKUMENTE_QUELLE:-/dokumente}"
 
 if [ -z "${SICHERUNG_PASSWORT:-}" ]; then
   echo "$(date -Iseconds) FEHLER: SICHERUNG_PASSWORT ist nicht gesetzt. Abbruch." >&2
@@ -50,17 +82,39 @@ pg_dump --format=custom --compress=6 --no-owner --no-privileges \
 GROESSE="$(du -h "$DATEI" | cut -f1)"
 sha256sum "$DATEI" > "$DATEI.sha256"
 
-# Der jeweils erste Stand eines Monats bekommt eine Markierung und bleibt
-# beim Aufraeumen verschont.
-if [ "$TAG_IM_MONAT" = "01" ]; then
-  touch "$DATEI.monatsstand"
+echo "$(date -Iseconds) Datenbank gesichert ($GROESSE)"
+
+# --- Dokumente ---------------------------------------------------------------
+# Schlaegt dieser Teil fehl, bricht der ganze Lauf ab (set -e). Das ist
+# Absicht: Eine Sicherung, die nur die halbe Wahrheit enthaelt, aber
+# vollstaendig aussieht, ist schlimmer als gar keine - man verlaesst sich
+# darauf und merkt es erst im Ernstfall.
+if [ ! -d "$DOKUMENTE_QUELLE" ]; then
+  echo "$(date -Iseconds) FEHLER: Das Ablageverzeichnis $DOKUMENTE_QUELLE ist nicht eingehaengt." >&2
+  echo "                        Ohne die Dokumente ist die Sicherung unvollstaendig." >&2
+  echo "                        Siehe docker-compose.yml, Dienst \"sicherung\"." >&2
+  rm -f "$DATEI" "$DATEI.sha256"
+  exit 1
 fi
 
-echo "$(date -Iseconds) Sicherung fertig ($GROESSE)"
+# "tar" ohne Leitung an einen Verbraucher, der frueh schliesst - sonst
+# SIGPIPE, siehe die Anmerkung zur Selbstpruefung weiter unten.
+tar -czf - -C "$DOKUMENTE_QUELLE" .   | openssl enc -aes-256-cbc -pbkdf2 -iter 200000 -salt       -pass env:SICHERUNG_PASSWORT       -out "$DOKUMENTE_DATEI"
+
+DOK_GROESSE="$(du -h "$DOKUMENTE_DATEI" | cut -f1)"
+sha256sum "$DOKUMENTE_DATEI" > "$DOKUMENTE_DATEI.sha256"
+
+echo "$(date -Iseconds) Dokumente gesichert ($DOK_GROESSE)"
+
+# Der jeweils erste Stand eines Monats bekommt eine Markierung und bleibt
+# beim Aufraeumen verschont. Beide Teile, sonst faellt die Haelfte weg.
+if [ "$TAG_IM_MONAT" = "01" ]; then
+  touch "$DATEI.monatsstand" "$DOKUMENTE_DATEI.monatsstand"
+fi
 
 # --- Aufraeumen --------------------------------------------------------------
 ENTFERNT=0
-for alt in "$ZIEL"/cockpit_*.dump.enc; do
+for alt in "$ZIEL"/cockpit_*.dump.enc "$ZIEL"/dokumente_*.tar.gz.enc; do
   [ -e "$alt" ] || continue
   [ -e "$alt.monatsstand" ] && continue
 
@@ -75,11 +129,30 @@ done
 # --- Selbstpruefung ----------------------------------------------------------
 # Ein Backup, das sich nicht entschluesseln laesst, ist kein Backup.
 # Deshalb wird sofort geprueft, ob die Datei wieder lesbar ist.
-if openssl enc -d -aes-256-cbc -pbkdf2 -iter 200000 \
+# Kein "| head -c 5 | grep -q": Beide schliessen die Leitung, sobald sie
+# genug haben. openssl schreibt dann in ein geschlossenes Rohr, bekommt
+# SIGPIPE - und mit "set -o pipefail" gilt die ganze Kette als
+# gescheitert. Bei einer kleinen Datenbank faellt das nicht auf, weil
+# alles schon im Puffer steht; mit wachsender Datenbank kippt es, und
+# dann meldet die Selbstpruefung eine INTAKTE Sicherung als kaputt.
+#
+# "dd" liest eine feste Menge und beendet sich regulaer.
+KOPF="$(openssl enc -d -aes-256-cbc -pbkdf2 -iter 200000 \
           -pass env:SICHERUNG_PASSWORT -in "$DATEI" 2>/dev/null \
-   | head -c 5 | grep -q "PGDMP"; then
-  echo "$(date -Iseconds) Selbstpruefung bestanden."
-else
-  echo "$(date -Iseconds) FEHLER: Die Sicherung laesst sich nicht entschluesseln!" >&2
+        | dd bs=1 count=5 2>/dev/null || true)"
+
+if [ "$KOPF" != "PGDMP" ]; then
+  echo "$(date -Iseconds) FEHLER: Der Datenbankstand laesst sich nicht entschluesseln!" >&2
   exit 1
 fi
+
+# Dasselbe fuer die Dokumente: entschluesseln und das Archiv auflisten
+# lassen. "tar -tzf" liest die ganze Datei und meldet jeden Schaden - das
+# ist bei den Groessenordnungen hier bezahlbar und sagt mehr aus als ein
+# Blick auf die ersten Bytes.
+if ! openssl enc -d -aes-256-cbc -pbkdf2 -iter 200000        -pass env:SICHERUNG_PASSWORT -in "$DOKUMENTE_DATEI" 2>/dev/null      | tar -tzf - >/dev/null 2>&1; then
+  echo "$(date -Iseconds) FEHLER: Das Dokumentenarchiv laesst sich nicht lesen!" >&2
+  exit 1
+fi
+
+echo "$(date -Iseconds) Selbstpruefung bestanden - Datenbank und Dokumente."

scripts/speicher-verschluesseln.mts

@@ -0,0 +1,184 @@
+/**
+ * Bestehende Dateien nachtraeglich in den Umschlag stecken.
+ *
+ *   npm run speicher:verschluesseln            # nur schauen
+ *   npm run speicher:verschluesseln -- --anwenden
+ *
+ * Warum es diesen Lauf gibt: Der Objektspeicher-Treiber hat bis v1.10.2
+ * unverschluesselt abgelegt - es stand nur ServerSideEncryption: 'AES256'
+ * darauf, also Verschluesselung mit dem Schluessel des Anbieters. Seit
+ * v1.11.0 liegt derselbe Umschlag darum wie beim Dateitreiber. Neue Dateien
+ * bekommen ihn beim Ablegen; die alten liegen weiter im Klartext, bis sie
+ * hier einmal umgeschrieben werden.
+ *
+ * Lesen funktioniert waehrenddessen durchgehend: Der Treiber erkennt am
+ * Kopf, ob ein Umschlag da ist, und reicht alles andere unveraendert durch.
+ * Der Lauf laesst sich also jederzeit starten, abbrechen und wiederholen.
+ *
+ * Er ist absichtlich langsam und einfach: ein Objekt nach dem anderen,
+ * lesen, pruefen, zurueckschreiben. Bei ein paar hundert Dokumenten dauert
+ * das Sekunden, und ein Fehler betrifft immer nur eine Datei.
+ *
+ * OHNE --anwenden wird nichts geschrieben.
+ */
+import { createRequire } from 'node:module'
+import { readFile, writeFile } from 'node:fs/promises'
+
+/**
+ * "server-only" fuer diesen Lauf neutralisieren.
+ *
+ * Das Paket wirft beim Import ausserhalb einer Server-Umgebung - genau
+ * dafuer ist es da. Hier laufen wir aber bewusst ausserhalb von Next, und
+ * die Alternative waere, den Umschlag im Skript noch einmal zu schreiben.
+ * Zwei Fassungen derselben Krypto sind die schlechtere Wahl: Wenn eine
+ * davon abweicht, merkt es niemand, bis eine Datei nicht mehr aufgeht.
+ *
+ * Deshalb wird der Modullader vorher umgebogen und danach dynamisch
+ * importiert - statische Importe wuerden vorgezogen und liefen in den
+ * Fehler.
+ */
+const verlangen = createRequire(import.meta.url)
+const modulLader = verlangen('node:module') as {
+  _load: (anfrage: string, ...rest: unknown[]) => unknown
+}
+const echterLader = modulLader._load
+modulLader._load = function (anfrage: string, ...rest: unknown[]) {
+  if (anfrage === 'server-only') return {}
+  return echterLader.call(this, anfrage, ...rest)
+}
+
+const { env } = await import('../src/lib/env')
+const { istVerschluesselt, verschluesselnBinaer } = await import('../src/lib/speicher/umschlag')
+
+const anwenden = process.argv.includes('--anwenden')
+
+type Bilanz = { geprueft: number; umgeschrieben: number; schonGut: number; fehler: number }
+
+function zeile(text = ''): void {
+  console.log(text)
+}
+
+/** Objektspeicher: auflisten, lesen, bei Bedarf zurueckschreiben. */
+async function s3Durchgehen(): Promise<Bilanz> {
+  const s3 = await import('../src/lib/speicher/s3')
+  const bilanz: Bilanz = { geprueft: 0, umgeschrieben: 0, schonGut: 0, fehler: 0 }
+
+  const schluessel = await s3.objekteAuflisten()
+  zeile(`  ${schluessel.length} Objekte im Eimer "${env.s3.bucket}".`)
+  zeile()
+
+  for (const eintrag of schluessel) {
+    bilanz.geprueft += 1
+    try {
+      const roh = await s3.rohLesen(eintrag)
+
+      if (istVerschluesselt(roh)) {
+        bilanz.schonGut += 1
+        continue
+      }
+
+      if (anwenden) {
+        // schreiben() legt den Umschlag selbst an - der Inhalt geht also
+        // als Klartext hinein und kommt verschluesselt im Eimer an.
+        await s3.schreiben(eintrag, roh, 'application/octet-stream')
+      }
+      bilanz.umgeschrieben += 1
+      zeile(`    ${anwenden ? 'umgeschrieben' : 'waere umzuschreiben'}: ${eintrag}`)
+    } catch (fehler) {
+      bilanz.fehler += 1
+      zeile(`    FEHLER bei ${eintrag}: ${fehler instanceof Error ? fehler.message : fehler}`)
+    }
+  }
+
+  return bilanz
+}
+
+/** Dateitreiber: dasselbe fuer das Ablageverzeichnis. */
+async function dateienDurchgehen(): Promise<Bilanz> {
+  const { readdir, stat } = await import('node:fs/promises')
+  const { join, relative, sep } = await import('node:path')
+  const treiber = await import('../src/lib/speicher/datei')
+  const bilanz: Bilanz = { geprueft: 0, umgeschrieben: 0, schonGut: 0, fehler: 0 }
+
+  const wurzel = treiber.ablageverzeichnis()
+  zeile(`  Verzeichnis ${wurzel}`)
+  zeile()
+
+  async function absteigen(verzeichnis: string): Promise<void> {
+    let eintraege: string[]
+    try {
+      eintraege = await readdir(verzeichnis)
+    } catch {
+      return // gibt es noch nicht
+    }
+
+    for (const name of eintraege) {
+      const pfad = join(verzeichnis, name)
+      if ((await stat(pfad)).isDirectory()) {
+        await absteigen(pfad)
+        continue
+      }
+
+      bilanz.geprueft += 1
+      try {
+        const roh = await readFile(pfad)
+        if (istVerschluesselt(roh)) {
+          bilanz.schonGut += 1
+          continue
+        }
+
+        // Der Ablageschluessel ist der Pfad unterhalb der Wurzel, mit
+        // Schraegstrichen - genau das, was der Treiber beim Schreiben
+        // benutzt. Er gehoert in die Zusatzdaten, sonst waere die Datei
+        // hinterher zwar verschluesselt, aber nicht an ihren Platz
+        // gebunden, und liesse sich unter fremdem Namen wieder einspielen.
+        const ablageschluessel = relative(wurzel, pfad).split(sep).join('/')
+
+        if (anwenden) {
+          await writeFile(pfad, verschluesselnBinaer(roh, ablageschluessel), { mode: 0o600 })
+        }
+        bilanz.umgeschrieben += 1
+        zeile(`    ${anwenden ? 'umgeschrieben' : 'waere umzuschreiben'}: ${pfad}`)
+      } catch (fehler) {
+        bilanz.fehler += 1
+        zeile(`    FEHLER bei ${pfad}: ${fehler instanceof Error ? fehler.message : fehler}`)
+      }
+    }
+  }
+
+  await absteigen(wurzel)
+  return bilanz
+}
+
+async function main(): Promise<void> {
+  zeile()
+  zeile('  Bestehende Dateien in den Umschlag stecken')
+  zeile('  ' + '-'.repeat(50))
+  zeile()
+
+  if (!anwenden) {
+    zeile('  TROCKENLAUF - es wird nichts geschrieben.')
+    zeile('  Zum Anwenden: npm run speicher:verschluesseln -- --anwenden')
+    zeile()
+  }
+
+  const treiber = env.speicherTreiber
+  zeile(`  Treiber: ${treiber}`)
+  zeile()
+
+  const bilanz = treiber === 's3' ? await s3Durchgehen() : await dateienDurchgehen()
+
+  zeile()
+  zeile(`  Geprueft:        ${bilanz.geprueft}`)
+  zeile(`  Schon im Umschlag: ${bilanz.schonGut}`)
+  zeile(`  ${anwenden ? 'Umgeschrieben' : 'Umzuschreiben'}:   ${bilanz.umgeschrieben}`)
+  if (bilanz.fehler > 0) zeile(`  Fehler:          ${bilanz.fehler}`)
+  zeile()
+
+  if (bilanz.fehler > 0) process.exitCode = 1
+}
+
+main().catch((fehler) => {
+  console.error(fehler)
+  process.exitCode = 1
+})

scripts/totp-geheimnis.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * Das TOTP-Geheimnis eines Zugangs auslesen.
+ *
+ *   node --env-file=.env scripts/totp-geheimnis.mjs <e-mail>
+ *
+ * Wofuer das gut ist: Die Anwendung zeigt das Geheimnis genau einmal an,
+ * beim Einrichten. Wer den Zugang auf ein zweites Geraet legen will -
+ * Handy und Tablet, oder ein Ersatzgeraet im Schrank - braucht es noch
+ * einmal. Ohne dieses Skript bliebe nur, den zweiten Faktor zurueckzusetzen
+ * und alle Wiederherstellungscodes neu zu erzeugen.
+ *
+ * Was es NICHT ist: eine Hintertuer. Es laeuft nur auf dem Server, nur mit
+ * Zugriff auf die Datenbank UND auf ENC_KEY_V1 aus der Umgebung. Wer beides
+ * hat, kann ohnehin alles lesen. Genau deshalb liegt der Schluessel nicht
+ * in der Datenbank.
+ *
+ * Im Docker-Betrieb:
+ *
+ *   docker compose exec app node scripts/totp-geheimnis.mjs fw@example.de
+ *
+ * Die Ausgabe gehoert nicht in ein Protokoll und nicht in eine E-Mail.
+ */
+import { PrismaClient } from '@prisma/client'
+import { createDecipheriv } from 'node:crypto'
+
+const email = (process.argv[2] ?? '').trim().toLowerCase()
+
+if (!email) {
+  console.error('Aufruf: node --env-file=.env scripts/totp-geheimnis.mjs <e-mail>')
+  process.exit(1)
+}
+
+/**
+ * Entschluesselt einen Umschlag aus src/lib/crypto/feld.ts.
+ * Format: bc1.<version>.<iv>.<tag>.<geheimtext>, alles base64url.
+ */
+function entschluesseln(umschlag, kontext) {
+  const teile = umschlag.split('.')
+  if (teile.length !== 5 || teile[0] !== 'bc1') {
+    throw new Error('Der gespeicherte Wert hat nicht das erwartete Format.')
+  }
+
+  const version = Number.parseInt(teile[1], 10)
+  const roh = process.env[`ENC_KEY_V${version}`]
+  if (!roh) {
+    throw new Error(
+      `ENC_KEY_V${version} ist nicht gesetzt. Ohne diesen Schluessel laesst ` +
+        `sich der Wert nicht lesen - auch nicht aus einem Backup.`,
+    )
+  }
+
+  const decipher = createDecipheriv(
+    'aes-256-gcm',
+    Buffer.from(roh, 'base64'),
+    Buffer.from(teile[2], 'base64url'),
+    { authTagLength: 16 },
+  )
+  // Der Feldname wird mitauthentifiziert - er muss exakt stimmen.
+  decipher.setAAD(Buffer.from(`bc1:${version}:${kontext}`, 'utf8'))
+  decipher.setAuthTag(Buffer.from(teile[3], 'base64url'))
+
+  return Buffer.concat([
+    decipher.update(Buffer.from(teile[4], 'base64url')),
+    decipher.final(),
+  ]).toString('utf8')
+}
+
+/** Base32 in Vierergruppen - so tippt es sich von Hand deutlich sicherer. */
+function gruppiert(text) {
+  return text.replace(/(.{4})/g, '$1 ').trim()
+}
+
+const db = new PrismaClient()
+
+try {
+  const benutzer = await db.user.findUnique({
+    where: { email },
+    select: {
+      email: true,
+      name: true,
+      totpSecretVerschluesselt: true,
+      totpAktiviertAm: true,
+      wiederherstellungscodes: true,
+    },
+  })
+
+  if (!benutzer) {
+    console.error(`Kein Zugang mit der Adresse ${email}.`)
+    process.exit(1)
+  }
+
+  if (!benutzer.totpSecretVerschluesselt) {
+    console.error(
+      `Fuer ${email} ist noch kein zweiter Faktor eingerichtet. ` +
+        `Das passiert beim ersten Anmelden.`,
+    )
+    process.exit(1)
+  }
+
+  const secret = entschluesseln(benutzer.totpSecretVerschluesselt, 'totpSecretVerschluesselt')
+  const uri =
+    `otpauth://totp/Betreuungs-Cockpit:${encodeURIComponent(benutzer.email)}` +
+    `?secret=${secret}&issuer=Betreuungs-Cockpit&algorithm=SHA1&digits=6&period=30`
+
+  console.log(`
+Zugang:      ${benutzer.name} <${benutzer.email}>
+Aktiv seit:  ${benutzer.totpAktiviertAm?.toLocaleString('de-DE') ?? 'noch nicht bestaetigt'}
+Codes uebrig: ${benutzer.wiederherstellungscodes.length}
+
+Geheimnis zum Abtippen:
+  ${gruppiert(secret)}
+
+Zum Einscannen (in einen QR-Code-Erzeuger auf DIESEM Rechner geben,
+niemals in einen Dienst im Netz):
+  ${uri}
+
+Diese Ausgabe gehoert nicht in ein Protokoll und nicht in eine E-Mail.
+`)
+} finally {
+  await db.$disconnect()
+}

scripts/update.sh

@@ -0,0 +1,432 @@
+#!/usr/bin/env bash
+#
+# Betreuungs-Cockpit aktualisieren.
+#
+#   ./scripts/update.sh              auf die neueste veroeffentlichte Fassung
+#   ./scripts/update.sh v1.2.0       auf eine bestimmte Fassung
+#   ./scripts/update.sh --ja         ohne Rueckfrage (fuer cron)
+#   ./scripts/update.sh --pruefen    nur nachsehen, nichts aendern
+#   ./scripts/update.sh --verwerfen  eigene Aenderungen an versionierten
+#                                    Dateien wegwerfen statt beiseitelegen
+#
+# Was das Skript tut, in dieser Reihenfolge:
+#
+#   1. Voraussetzungen pruefen (Verzeichnis, git, docker, .env)
+#   2. Fassungen holen und vergleichen
+#   3. Zeigen, was sich aendert (Changelog-Abschnitte dazwischen)
+#   4. Nachfragen
+#   5. SICHERUNG anstossen - und abbrechen, wenn sie nicht klappt
+#   6. Eigene Aenderungen beiseitelegen, umschalten, neu bauen, starten
+#   7. Die beiden SQL-Skripte ausfuehren (sie sind idempotent)
+#   8. Pruefen, ob die neue Fassung wirklich laeuft
+#
+# Die Reihenfolge ist Absicht: Bis einschliesslich Schritt 4 wird nichts
+# veraendert. Wer vorher abbricht - oder wobei etwas schiefgeht -, findet
+# alles so vor wie zuvor. Erst danach wird angefasst.
+#
+# Schritt 5 ist der wichtigste: Eine Datenbank-Migration laesst sich nicht
+# zurueckrollen. Ohne Sicherung wird hier nichts aktualisiert.
+#
+# Schritt 7 ebenfalls: Die SQL-Skripte laufen NICHT mit den Migrationen
+# mit. Wer sie vergisst, hat einen veralteten Trigger und merkt es erst,
+# wenn etwas nicht geht.
+#
+# Die .env wird nie angefasst - sie ist nicht versioniert.
+
+# Die geschweiften Klammern sorgen dafuer, dass bash die ganze Datei liest,
+# bevor sie irgendetwas ausfuehrt. Ohne sie koennte der git-checkout weiter
+# unten das Skript unter den eigenen Fuessen austauschen.
+{
+set -euo pipefail
+
+# --- Ausgabe -----------------------------------------------------------------
+
+if [ -t 1 ]; then
+  ROT=$'\033[31m'; GRUEN=$'\033[32m'; GELB=$'\033[33m'; FETT=$'\033[1m'; AUS=$'\033[0m'
+else
+  ROT=''; GRUEN=''; GELB=''; FETT=''; AUS=''
+fi
+
+schritt()  { printf '\n%s==> %s%s\n' "$FETT" "$1" "$AUS"; }
+gut()      { printf '    %s%s%s\n' "$GRUEN" "$1" "$AUS"; }
+warnung()  { printf '    %s%s%s\n' "$GELB" "$1" "$AUS"; }
+abbruch()  { printf '\n%sAbbruch: %s%s\n\n' "$ROT" "$1" "$AUS" >&2; exit 1; }
+
+# --- Unerwarteter Abbruch ----------------------------------------------------
+#
+# "set -e" beendet das Skript bei jedem Befehl, der nicht 0 zurueckgibt -
+# stumm. Auf dem Bildschirm bricht die Ausgabe dann einfach ab, und man
+# sucht an der falschen Stelle.
+#
+# Genau das ist beim Sprung von v1.5.0 auf v1.10.1 passiert: Eine Leitung
+# der Form "git log ... | head -15" hat den Erzeuger mit SIGPIPE beendet,
+# "pipefail" hat das an die Kette weitergereicht, und das Skript war weg.
+#
+# Diese Falle sagt jetzt wenigstens, WO es passiert ist. Exitcode 141
+# heisst SIGPIPE - dann wurde irgendwo wieder eine Leitung zu frueh
+# geschlossen.
+unerwartet() {
+  code=$1
+  zeile=$2
+  printf '%sAbbruch in Zeile %s (Exitcode %s).%s\n' "$ROT" "$zeile" "$code" "$AUS" >&2
+  if [ "$code" = "141" ]; then
+    printf '%sExitcode 141 ist SIGPIPE: eine Leitung wurde zu frueh geschlossen,%s\n' "$ROT" "$AUS" >&2
+    printf '%setwa durch "| head". Das ist ein Fehler im Skript, nicht bei dir.%s\n' "$ROT" "$AUS" >&2
+  fi
+  printf '%sKam der Abbruch vor Schritt 5, wurde nichts veraendert.%s\n' "$ROT" "$AUS" >&2
+}
+trap 'unerwartet $? $LINENO' ERR
+
+
+# --- Aufrufparameter ---------------------------------------------------------
+
+ZIEL=""
+OHNE_RUECKFRAGE=0
+NUR_PRUEFEN=0
+OHNE_SICHERUNG=0
+VERWERFEN=0
+ENTSCHEIDUNG=""
+
+for arg in "$@"; do
+  case "$arg" in
+    --ja|-j)          OHNE_RUECKFRAGE=1 ;;
+    --pruefen|-p)     NUR_PRUEFEN=1 ;;
+    --ohne-sicherung) OHNE_SICHERUNG=1 ;;
+    --verwerfen)      VERWERFEN=1 ;;
+    --hilfe|-h)
+      sed -n '2,34p' "$0" | sed 's/^#\s\?//'
+      exit 0 ;;
+    -*)               abbruch "Unbekannte Angabe: $arg (--hilfe zeigt die Moeglichkeiten)" ;;
+    *)                ZIEL="$arg" ;;
+  esac
+done
+
+# --- 1. Voraussetzungen ------------------------------------------------------
+
+schritt "Voraussetzungen"
+
+cd "$(dirname "$0")/.." || abbruch "Das Projektverzeichnis ist nicht erreichbar."
+PROJEKT="$(pwd)"
+
+[ -f docker-compose.yml ] || abbruch "Hier liegt keine docker-compose.yml: $PROJEKT"
+[ -f .env ]               || abbruch "Es gibt keine .env. Ohne sie startet die Anwendung nicht."
+command -v git >/dev/null || abbruch "git ist nicht installiert."
+docker compose version >/dev/null 2>&1 || abbruch "docker compose (v2) ist nicht verfuegbar."
+
+gut "Verzeichnis: $PROJEKT"
+
+# Nur nachsehen - angefasst wird die Arbeitskopie erst kurz vor dem
+# Umschalten, wenn Sicherung und Rueckfrage durch sind. Ein Abbruch
+# dazwischen darf keinen Halbzustand hinterlassen.
+SCHMUTZIG=""
+if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
+  SCHMUTZIG="ja"
+  warnung "Es gibt eigene Aenderungen an versionierten Dateien."
+  git status --short --untracked-files=no | sed 's/^/      /'
+  printf '      Sie werden vor dem Umschalten beiseite gelegt.\n'
+else
+  gut "Arbeitskopie ist sauber"
+fi
+
+# --- 2. Was ist da, was kommt ------------------------------------------------
+
+schritt "Fassungen"
+
+if ! git fetch --tags --quiet origin; then
+  abbruch "Konnte die Fassungen nicht vom Server holen.
+         Erreichst du ihn? Stimmen die Zugangsdaten?
+         Es wurde nichts geaendert."
+fi
+
+JETZT="$(git describe --tags --exact-match 2>/dev/null || git rev-parse --short HEAD)"
+# Kein "| head -1": Siehe den Hinweis zu SIGPIPE weiter unten. Die erste
+# Zeile holt die Shell selbst.
+ALLE_TAGS="$(git tag --list 'v*' --sort=-v:refname)"
+NEUESTE="${ALLE_TAGS%%$'
+'*}"
+
+[ -n "$NEUESTE" ] || abbruch "Es gibt keine veroeffentlichte Fassung (kein Tag)."
+
+if [ -z "$ZIEL" ]; then
+  ZIEL="$NEUESTE"
+fi
+
+git rev-parse --verify --quiet "$ZIEL^{commit}" >/dev/null \
+  || abbruch "Die Fassung '$ZIEL' gibt es nicht. Vorhanden:
+$(printf '%s
+' "$ALLE_TAGS" | sed -n '1,5p' | sed 's/^/           /')"
+
+printf '    Jetzt:   %s\n' "$JETZT"
+printf '    Ziel:    %s%s%s\n' "$FETT" "$ZIEL" "$AUS"
+
+if [ "$(git rev-parse HEAD)" = "$(git rev-parse "$ZIEL^{commit}")" ]; then
+  gut "Bereits auf dem gewuenschten Stand - nichts zu tun."
+  exit 0
+fi
+
+# --- 3. Was aendert sich -----------------------------------------------------
+
+schritt "Was sich aendert"
+
+# Der Changelog muss aus der ZIELfassung kommen: Der laufende Stand kennt
+# die neuen Abschnitte ja noch gar nicht.
+CHANGELOG="$(git show "$ZIEL:CHANGELOG.md" 2>/dev/null || true)"
+
+if [ -n "$CHANGELOG" ]; then
+  # Alle Abschnitte zwischen dem laufenden und dem gewuenschten Stand.
+  JETZT_NR="${JETZT#v}"
+  printf '%s
+' "$CHANGELOG" | awk -v jetzt="$JETZT_NR" '
+    /^## \[/ {
+      nummer = $0
+      sub(/^## \[/, "", nummer); sub(/\].*/, "", nummer)
+      if (nummer == jetzt) exit
+      drucken = (nummer != "Unveröffentlicht")
+    }
+    drucken && zeilen < 60 { print "    " $0; zeilen++ }
+  '
+else
+  warnung "Kein CHANGELOG.md in $ZIEL gefunden."
+fi
+
+printf '\n'
+# "-15" statt "| head -15": Bei mehr Commits als der Grenze schliesst head
+# die Leitung, git bekommt SIGPIPE, und mit "set -o pipefail" gilt die ganze
+# Kette als gescheitert - "set -e" beendet das Skript dann OHNE Meldung.
+# Genau das ist beim Sprung von v1.5.0 auf v1.10.1 passiert.
+ANZAHL="$(git rev-list --count "HEAD..$ZIEL")"
+git log --oneline --no-decorate -15 "HEAD..$ZIEL" | sed 's/^/    /'
+if [ "$ANZAHL" -gt 15 ]; then
+  printf '    ... und %s weitere
+' "$((ANZAHL - 15))"
+fi
+
+if [ "$NUR_PRUEFEN" = "1" ]; then
+  printf '\n'
+  gut "Nur geprueft - es wurde nichts geaendert."
+  [ -n "$SCHMUTZIG" ] && warnung "Beim echten Lauf wuerden deine Aenderungen beiseite gelegt."
+  exit 0
+fi
+
+# --- 4. Nachfragen -----------------------------------------------------------
+
+if [ "$OHNE_RUECKFRAGE" != "1" ]; then
+  printf '\n%sJetzt aktualisieren auf %s? [j/N] %s' "$FETT" "$ZIEL" "$AUS"
+  read -r antwort </dev/tty || antwort=""
+  case "$antwort" in
+    [jJ]|[jJ][aA]) ;;
+    *) printf '\n'; warnung "Abgebrochen, nichts geaendert."; exit 0 ;;
+  esac
+fi
+
+# --- 5. Sicherung ------------------------------------------------------------
+
+if [ "$OHNE_SICHERUNG" = "1" ]; then
+  schritt "Sicherung wird uebersprungen"
+  warnung "Auf eigene Gefahr - eine Migration laesst sich nicht zurueckrollen."
+else
+  schritt "Sicherung"
+
+  if docker compose ps --status running --services 2>/dev/null | grep -qx sicherung; then
+    if docker compose exec -T sicherung /bin/sh /sicherung.sh; then
+      gut "Sicherung angelegt und selbst geprueft."
+    else
+      abbruch "Die Sicherung ist fehlgeschlagen. Es wird nichts aktualisiert.
+         Mit --ohne-sicherung laesst sich das uebergehen - aber ueberleg
+         dir das zweimal."
+    fi
+  else
+    warnung "Der Dienst 'sicherung' laeuft nicht - es wurde nichts gesichert."
+    if [ "$OHNE_RUECKFRAGE" != "1" ]; then
+      printf '\n    %sTrotzdem weitermachen? [j/N] %s' "$FETT" "$AUS"
+      read -r weiter </dev/tty || weiter=""
+      case "$weiter" in [jJ]|[jJ][aA]) ;; *) abbruch "Abgebrochen." ;; esac
+    fi
+  fi
+fi
+
+# --- 6. Umschalten und bauen -------------------------------------------------
+
+# Aenderungen an versionierten Dateien blockieren das Umschalten.
+#
+# Im Betrieb ist das der Normalfall: Man passt die docker-compose.yml an,
+# bis etwas laeuft. Genau diese Anpassungen sind spaeter oft schon
+# eingearbeitet - das Skript soll sie also nicht zum Hindernis machen.
+#
+# Verworfen wird trotzdem nichts stillschweigend. Standard ist "beiseite
+# legen": git stash macht es rueckholbar. Wer sie wirklich weghaben will,
+# nimmt --verwerfen.
+#
+# Die .env ist nie betroffen - sie ist nicht versioniert.
+schritt "Eigene Aenderungen"
+
+if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
+  printf '\n    Diese versionierten Dateien sind veraendert:\n\n'
+  git status --short --untracked-files=no | sed 's/^/      /'
+  printf '\n'
+
+  if [ "$VERWERFEN" = "1" ]; then
+    ENTSCHEIDUNG="verwerfen"
+  elif [ "$OHNE_RUECKFRAGE" = "1" ]; then
+    # Ohne jemanden zum Fragen: die sichere Variante.
+    ENTSCHEIDUNG="beiseite"
+  else
+    printf '    %s[b]%s eiseite legen (git stash, spaeter rueckholbar)\n' "$FETT" "$AUS"
+    printf '    %s[v]%s erwerfen (endgueltig weg)\n' "$FETT" "$AUS"
+    printf '    %s[a]%s bbrechen\n\n' "$FETT" "$AUS"
+    printf '    Was soll damit geschehen? [b/v/a] '
+    read -r wahl </dev/tty || wahl=""
+    case "$wahl" in
+      [bB]|'') ENTSCHEIDUNG="beiseite" ;;
+      [vV])    ENTSCHEIDUNG="verwerfen" ;;
+      *)       abbruch "Abgebrochen, nichts geaendert." ;;
+    esac
+  fi
+
+  if [ "$ENTSCHEIDUNG" = "verwerfen" ]; then
+    git checkout -- .
+    warnung "Aenderungen verworfen."
+  else
+    STASH_NAME="vor Update $(date +%Y-%m-%d_%H%M)"
+    git stash push --quiet --message "$STASH_NAME" -- . \
+      || abbruch "Konnte die Aenderungen nicht beiseite legen."
+    gut "Beiseite gelegt als: $STASH_NAME"
+    printf '      Ansehen:    git stash list\n'
+    printf '      Zurueck:    git stash pop\n'
+    printf '      Wegwerfen:  git stash drop\n'
+  fi
+else
+  gut "Arbeitskopie ist sauber"
+fi
+
+schritt "Umschalten auf $ZIEL"
+
+# Eine unversionierte Datei kann im Weg stehen, wenn die Zielfassung sie
+# fuehrt. Das passiert beim Update auf die Fassung, die dieses Skript
+# eingefuehrt hat: Man hat es sich von Hand geholt, jetzt gehoert es dazu.
+# Solche Dateien werden nicht weggeworfen, sondern beiseite geschoben.
+if ! git checkout --quiet "$ZIEL" 2>/dev/null; then
+  IM_WEG="$(git checkout "$ZIEL" 2>&1     | sed -n '/would be overwritten/,/^Aborting/p'     | grep -E '^\s' | tr -d '	 ' | grep -v '^$' || true)"
+
+  if [ -n "$IM_WEG" ]; then
+    ZEIT="$(date +%Y%m%d-%H%M%S)"
+    printf '    Diese unversionierten Dateien stehen im Weg:
+'
+    for datei in $IM_WEG; do
+      [ -e "$datei" ] || continue
+      mv "$datei" "${datei}.vor-update-${ZEIT}"
+      printf '      %s -> %s.vor-update-%s
+' "$datei" "$datei" "$ZEIT"
+    done
+    git checkout --quiet "$ZIEL" || abbruch "Das Umschalten auf $ZIEL ist fehlgeschlagen.
+         Deine Aenderungen liegen im Stash: git stash list"
+  else
+    abbruch "Das Umschalten auf $ZIEL ist fehlgeschlagen.
+$([ -n "$SCHMUTZIG" ] && printf '         Deine Aenderungen liegen im Stash: git stash list')"
+  fi
+fi
+
+gut "$(git describe --tags --always)"
+
+# Das Ausfuehrbarkeitsbit kommt normalerweise aus dem Repository mit. Wer
+# Dateien von Hand kopiert hat - etwa um an dieses Skript zu kommen, bevor
+# es in der laufenden Fassung existierte -, hat es verloren. Dann waere der
+# naechste Aufruf ein "Permission denied", und man sucht an der falschen
+# Stelle.
+chmod +x scripts/*.sh 2>/dev/null || true
+
+schritt "Bauen und starten"
+printf '    Das dauert beim ersten Mal einige Minuten.\n\n'
+
+if ! GIT_COMMIT="$(git rev-parse --short HEAD)" \
+     BUILD_ZEIT="$(date -Iseconds)" \
+     docker compose up -d --build; then
+  printf '\n'
+  abbruch "Bauen oder Starten ist fehlgeschlagen.
+         Die Quellen stehen jetzt auf $ZIEL, die Anwendung laeuft aber
+         noch mit dem alten Abbild - oder gar nicht.
+
+         Zurueck auf den vorherigen Stand:
+           git checkout $JETZT && docker compose up -d --build
+$([ -n "$SCHMUTZIG" ] && printf '\n         Deine Aenderungen liegen im Stash: git stash list')"
+fi
+
+# --- 7. Warten, bis die Anwendung antwortet ----------------------------------
+
+schritt "Warten auf die Anwendung"
+
+# Adresse und Port stehen in der .env - Standard ist die Loopback-Adresse.
+ADRESSE="$(grep -E '^APP_BIND=' .env | tail -1 | cut -d= -f2- | tr -d '"' || true)"
+PORT="$(grep -E '^APP_PORT=' .env | tail -1 | cut -d= -f2- | tr -d '"' || true)"
+[ -n "$ADRESSE" ] || ADRESSE="127.0.0.1"
+[ -n "$PORT" ] || PORT="3000"
+# Auf 0.0.0.0 kann man nicht zugreifen - dann ueber die Loopback-Adresse.
+[ "$ADRESSE" = "0.0.0.0" ] && ADRESSE="127.0.0.1"
+
+GESUND="http://${ADRESSE}:${PORT}/api/gesundheit"
+ANTWORT=""
+
+for _ in $(seq 1 60); do
+  ANTWORT="$(curl -fsS --max-time 5 "$GESUND" 2>/dev/null || true)"
+  case "$ANTWORT" in *'"bereit"'*) break ;; esac
+  printf '.'
+  sleep 3
+done
+printf '\n'
+
+case "$ANTWORT" in
+  *'"bereit"'*) gut "Die Anwendung antwortet." ;;
+  *)
+    printf '\n'
+    docker compose logs app --tail 40 | sed 's/^/    /'
+    abbruch "Die Anwendung antwortet nicht unter $GESUND.
+         Die letzten Zeilen aus dem Log stehen oben.
+         Zurueck geht es mit:  git checkout $JETZT && docker compose up -d --build"
+    ;;
+esac
+
+# --- 8. SQL-Skripte ----------------------------------------------------------
+
+schritt "Volltextsuche und Audit-Schutz"
+printf '    Diese beiden laufen nicht mit den Migrationen mit.\n'
+printf '    Sie sind idempotent - mehrfaches Ausfuehren schadet nicht.\n\n'
+
+PRISMA="node node_modules/prisma/build/index.js"
+
+for skript in volltextsuche audit-schutz; do
+  if docker compose exec -T app $PRISMA db execute \
+       --schema prisma/schema.prisma --file "prisma/sql/${skript}.sql" >/dev/null 2>&1; then
+    gut "${skript}.sql ausgefuehrt"
+  else
+    warnung "${skript}.sql ist fehlgeschlagen - bitte von Hand nachholen:"
+    printf '      docker compose exec app %s db execute \\\n' "$PRISMA"
+    printf '        --schema prisma/schema.prisma --file prisma/sql/%s.sql\n' "$skript"
+  fi
+done
+
+# --- 9. Nachschau ------------------------------------------------------------
+
+schritt "Ergebnis"
+
+LAEUFT="$(printf '%s' "$ANTWORT" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')"
+ERWARTET="${ZIEL#v}"
+
+printf '    Erwartet: %s\n' "$ERWARTET"
+printf '    Laeuft:   %s\n' "${LAEUFT:-unbekannt}"
+
+if [ "$LAEUFT" = "$ERWARTET" ]; then
+  printf '\n'
+  gut "Fertig. Version $ERWARTET laeuft."
+else
+  printf '\n'
+  warnung "Die laufende Fassung stimmt nicht mit der erwarteten ueberein."
+  warnung "Vermutlich hat der Bau den alten Behaelter stehen lassen:"
+  printf '      docker compose up -d --build --force-recreate app\n'
+fi
+
+printf '\n    Zustand:  docker compose ps\n'
+printf '    Log:      docker compose logs app --tail 50\n'
+printf '    Zurueck:  git checkout %s && docker compose up -d --build\n\n' "$JETZT"
+
+exit 0
+}

scripts/version.mjs

@@ -97,7 +97,12 @@ schreiben('src/lib/version.ts', ersetzt)
 
 // --- 3. CHANGELOG.md --------------------------------------------------------
 
-const heute = new Date().toISOString().slice(0, 10)
+// Deutsche Zeit, nicht UTC. Sonst bekommt eine Veroeffentlichung nach
+// 22 Uhr (Sommerzeit) das Datum des Vortages - dieselbe Zeitzonenfalle,
+// derentwegen die Fristen im Schema @db.Date sind.
+const heute = new Intl.DateTimeFormat('sv-SE', {
+  timeZone: 'Europe/Berlin',
+}).format(new Date())
 let changelog = lesen('CHANGELOG.md')
 
 const UNVEROEFFENTLICHT = '## [Unveröffentlicht]'

scripts/wiederherstellung.sh

@@ -9,7 +9,7 @@
 # ausdruecklich nach, weil dabei der aktuelle Datenbestand ueberschrieben
 # wird.
 #
-# ZWEI DINGE, DIE MAN VORHER WISSEN MUSS:
+# DREI DINGE, DIE MAN VORHER WISSEN MUSS:
 #
 # 1. Die Sicherung enthaelt die anwendungsseitig verschluesselten Felder,
 #    aber NICHT den Schluessel. Ohne den passenden ENC_KEY_Vn aus der .env
@@ -20,6 +20,14 @@
 #    das hier einmal im Jahr auf einer Testdatenbank aus, bevor du es im
 #    Ernstfall zum ersten Mal brauchst. Siehe README, Abschnitt
 #    "Wiederherstellung ueben".
+#
+# 3. Die Dokumente werden NICHT selbsttaetig an ihren Platz geschrieben.
+#    Dieses Skript packt sie nach ./backups aus und sagt, wie es
+#    weitergeht. Grund: Der Sicherungsdienst hat auf das Ablageverzeichnis
+#    bewusst nur Lesezugriff (siehe docker-compose.yml), und in ein
+#    laufendes MinIO hineinzuschreiben wuerde dessen Datenbestand
+#    beschaedigen. Der letzte Handgriff bleibt beim Menschen - er ist ein
+#    Einzeiler und im Klartext beschrieben.
 # =============================================================================
 
 set -eu
@@ -87,7 +95,44 @@ openssl enc -d -aes-256-cbc -pbkdf2 -iter 200000 \
   | pg_restore --clean --if-exists --no-owner --no-privileges \
       --dbname="${PGDATABASE:-postgres}" --exit-on-error
 
-echo "$(date -Iseconds) Wiederherstellung abgeschlossen."
+echo "$(date -Iseconds) Datenbank wiederhergestellt."
+
+# --- Dokumente ---------------------------------------------------------------
+# Zu "cockpit_2026-09-01_0315.dump.enc" gehoert
+# "dokumente_2026-09-01_0315.tar.gz.enc" - gleicher Zeitstempel, anderer
+# Name. Fehlt sie, stammt die Sicherung aus einer Fassung vor v1.12.0.
+ZEITSTEMPEL="$(basename "$DATEI" | sed -n 's/^cockpit_\(.*\)\.dump\.enc$/\1/p')"
+DOKUMENTE_DATEI="$(dirname "$DATEI")/dokumente_${ZEITSTEMPEL}.tar.gz.enc"
+AUSPACKZIEL="$(dirname "$DATEI")/dokumente-wiederhergestellt_${ZEITSTEMPEL}"
+
+if [ ! -f "$DOKUMENTE_DATEI" ]; then
+  echo ""
+  echo "WARNUNG: Zu dieser Sicherung gibt es kein Dokumentenarchiv."
+  echo "         Erwartet wurde: $DOKUMENTE_DATEI"
+  echo "         Sicherungen aus Fassungen vor v1.12.0 enthalten nur die"
+  echo "         Datenbank. Die Akte ist dann vollstaendig, die Dateien"
+  echo "         dahinter fehlen."
+else
+  if [ -f "$DOKUMENTE_DATEI.sha256" ]; then
+    echo "Pruefsumme des Dokumentenarchivs wird geprueft ..."
+    if sha256sum -c "$DOKUMENTE_DATEI.sha256" >/dev/null 2>&1; then
+      echo "  in Ordnung."
+    else
+      echo "FEHLER: Die Pruefsumme des Dokumentenarchivs stimmt nicht." >&2
+      exit 1
+    fi
+  fi
+
+  mkdir -p "$AUSPACKZIEL"
+  openssl enc -d -aes-256-cbc -pbkdf2 -iter 200000 \
+      -pass env:SICHERUNG_PASSWORT -in "$DOKUMENTE_DATEI" \
+    | tar -xzf - -C "$AUSPACKZIEL"
+
+  ANZAHL="$(find "$AUSPACKZIEL" -type f | wc -l)"
+  echo "$(date -Iseconds) Dokumente ausgepackt: $ANZAHL Dateien nach"
+  echo "                        $AUSPACKZIEL"
+fi
+
 echo ""
 echo "Naechste Schritte:"
 echo "  1. Die SQL-Skripte erneut ausfuehren (Volltextsuche und Audit-Schutz):"
@@ -95,6 +140,21 @@ echo "       docker compose exec app npm run db:sql"
 echo "  2. Pruefen, ob ENC_KEY_V1 in der .env zu diesem Bestand passt -"
 echo "     ohne den richtigen Schluessel bleiben die verschluesselten"
 echo "     Felder unlesbar."
-echo "  3. In der Anwendung eine betreute Person oeffnen und nachsehen, ob"
-echo "     die Diagnosen im Klartext erscheinen. Erst dann ist die"
+echo "  3. Die Dokumente an ihren Platz bringen. Dazu MinIO anhalten, das"
+echo "     Datenverzeichnis ersetzen und wieder starten - auf dem Host,"
+echo "     nicht in diesem Behaelter:"
+echo ""
+echo "       docker compose stop minio app"
+echo "       docker run --rm \\"
+echo "         -v betreuungs-cockpit_minio-daten:/ziel \\"
+echo "         -v \"\$PWD/backups:/quelle:ro\" alpine \\"
+echo "         sh -c 'rm -rf /ziel/* /ziel/..?* && cp -a /quelle/dokumente-wiederhergestellt_*/. /ziel/'"
+echo "       docker compose up -d"
+echo ""
+echo "     Steht mehr als ein ausgepacktes Verzeichnis unter ./backups,"
+echo "     vorher das richtige auswaehlen statt des Sternchens."
+echo ""
+echo "  4. In der Anwendung eine betreute Person oeffnen und nachsehen, ob"
+echo "     die Diagnosen im Klartext erscheinen. Dann ein Dokument"
+echo "     herunterladen. Erst wenn beides klappt, ist die"
 echo "     Wiederherstellung wirklich gelungen."

src/app/(app)/anleitung/page.tsx

@@ -0,0 +1,55 @@
+import type { Metadata } from 'next'
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+import { BookOpen } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { SeitenKopf } from '@/components/seiten-kopf'
+import { MarkdownSeite } from '@/components/markdown-seite'
+import { DruckKnopf } from '@/components/druck-knopf'
+import { erfordereBenutzer } from '@/lib/auth/sitzung'
+
+export const metadata: Metadata = { title: 'Anleitung' }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Die Bedienungsanleitung, gelesen aus docs/ANLEITUNG.md.
+ *
+ * Dieselbe Datei, die auch im Repository liegt und sich ausdrucken laesst -
+ * zwei Fassungen desselben Textes waeren zwei Fassungen, die auseinander-
+ * laufen. Wer im Heim steht und nicht weiterweiss, hat sie damit auf dem
+ * Telefon dabei.
+ */
+export default async function AnleitungSeite() {
+  await erfordereBenutzer()
+
+  const pfad = path.join(process.cwd(), 'docs', 'ANLEITUNG.md')
+  let inhalt: string
+
+  try {
+    inhalt = await readFile(pfad, 'utf8')
+  } catch {
+    inhalt = ''
+  }
+
+  return (
+    <div className="max-w-3xl space-y-6">
+      <SeitenKopf
+        titel="Bedienungsanleitung"
+        beschreibung="Die Handgriffe, die du tatsächlich brauchst — in der Reihenfolge, in der sie im Alltag vorkommen."
+        aktionen={<DruckKnopf beschriftung="Anleitung drucken" />}
+      />
+
+      {inhalt === '' ? (
+        <Alert variant="warnung">
+          <BookOpen aria-hidden="true" />
+          <AlertDescription>
+            Die Anleitung konnte nicht geladen werden. Sie liegt im Projekt unter{' '}
+            <code>docs/ANLEITUNG.md</code>.
+          </AlertDescription>
+        </Alert>
+      ) : (
+        <MarkdownSeite inhalt={inhalt} />
+      )}
+    </div>
+  )
+}

src/app/(app)/berichte/export/datei/route.ts

@@ -1,6 +1,6 @@
 import { Readable } from 'node:stream'
 import type { NextRequest } from 'next/server'
-import { aktiveBetreute, erfordereBenutzer, reauthGueltig } from '@/lib/auth/sitzung'
+import { aktiveBetreute, benutzerFuerRoute, reauthGueltig } from '@/lib/auth/sitzung'
 import { darf } from '@/lib/auth/rollen'
 import { db, nichtGeloescht } from '@/lib/db'
 import { protokollieren } from '@/lib/audit'
@@ -33,7 +33,11 @@ function abgelehnt(nachricht: string, status: number): Response {
 }
 
 export async function GET(anfrage: NextRequest): Promise<Response> {
-  const benutzer = await erfordereBenutzer('/berichte/export')
+  // Eine Route antwortet mit einem Statuscode, nicht mit einer
+  // Anmeldeseite als Dateiinhalt.
+  const angemeldet = await benutzerFuerRoute()
+  if (!angemeldet.ok) return angemeldet.antwort
+  const benutzer = angemeldet.benutzer
 
   const gewuenscht = anfrage.nextUrl.searchParams.get('betreute')
   const aktive = await aktiveBetreute(benutzer)

src/app/(app)/bestaetigen/formular.tsx

@@ -1,9 +1,16 @@
 'use client'
 
-import { useActionState } from 'react'
+import { useActionState, useEffect, useState } from 'react'
 import { useFormStatus } from 'react-dom'
-import { AlertCircle, Loader2, ShieldCheck } from 'lucide-react'
+import { useRouter } from 'next/navigation'
+import { AlertCircle, Fingerprint, Loader2, ShieldCheck } from 'lucide-react'
 import { anmeldungBestaetigen, type BestaetigenZustand } from '@/server/actions/bestaetigen'
+import { passkeyBestaetigen, passkeyBestaetigungStarten } from '@/server/actions/passkey'
+import {
+  browserSupportsWebAuthn,
+  passkeyBrowserfehler,
+  startAuthentication,
+} from '@/lib/passkey-browser'
 import { Alert, AlertDescription } from '@/components/ui/alert'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
@@ -19,10 +26,17 @@ function Absenden() {
   )
 }
 
-export function BestaetigenFormular({ weiter }: { weiter: string }) {
+export function BestaetigenFormular({
+  weiter,
+  passkeysMoeglich,
+}: {
+  weiter: string
+  passkeysMoeglich: boolean
+}) {
   const [zustand, aktion] = useActionState<BestaetigenZustand, FormData>(anmeldungBestaetigen, {})
 
   return (
+    <div className="space-y-5">
       <form action={aktion} className="space-y-4" noValidate>
         <input type="hidden" name="weiter" value={weiter} />
 
@@ -50,5 +64,95 @@ export function BestaetigenFormular({ weiter }: { weiter: string }) {
 
         <Absenden />
       </form>
+
+      {passkeysMoeglich && <PasskeyBestaetigung weiter={weiter} />}
+    </div>
+  )
+}
+
+/**
+ * Bestaetigung mit Passkey statt mit Passwort und Code.
+ *
+ * Geprueft wird zusaetzlich, dass der Passkey zum angemeldeten Benutzer
+ * gehoert - sonst koennte jemand mit dem eigenen Finger eine fremde,
+ * offen stehende Sitzung freischalten. Genau der Fall, gegen den diese
+ * Seite gebaut ist.
+ */
+function PasskeyBestaetigung({ weiter }: { weiter: string }) {
+  const router = useRouter()
+  const [browserKann, setBrowserKann] = useState(false)
+  const [laeuft, setLaeuft] = useState(false)
+  const [fehler, setFehler] = useState<string | null>(null)
+
+  useEffect(() => {
+    setBrowserKann(browserSupportsWebAuthn())
+  }, [])
+
+  async function bestaetigen() {
+    setFehler(null)
+    setLaeuft(true)
+
+    try {
+      const start = await passkeyBestaetigungStarten()
+      if (!start.ok) {
+        setFehler(start.fehler)
+        return
+      }
+
+      const antwort = await startAuthentication({ optionsJSON: start.optionen })
+      const ergebnis = await passkeyBestaetigen(JSON.stringify(antwort))
+
+      if (!ergebnis.ok) {
+        setFehler(ergebnis.fehler)
+        return
+      }
+
+      router.replace(weiter)
+      router.refresh()
+    } catch (ausnahme) {
+      setFehler(passkeyBrowserfehler(ausnahme))
+    } finally {
+      setLaeuft(false)
+    }
+  }
+
+  if (!browserKann) return null
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center gap-3">
+        <span className="h-px flex-1 bg-border" />
+        <span className="text-xs uppercase tracking-wide text-muted-foreground">oder</span>
+        <span className="h-px flex-1 bg-border" />
+      </div>
+
+      {fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{fehler}</AlertDescription>
+        </Alert>
+      )}
+
+      <Button
+        type="button"
+        variant="outline"
+        size="lg"
+        className="w-full"
+        onClick={() => void bestaetigen()}
+        disabled={laeuft}
+      >
+        {laeuft ? (
+          <>
+            <Loader2 className="animate-spin" aria-hidden="true" />
+            Warte auf das Gerät …
+          </>
+        ) : (
+          <>
+            <Fingerprint aria-hidden="true" />
+            Mit Passkey bestätigen
+          </>
+        )}
+      </Button>
+    </div>
   )
 }

src/app/(app)/bestaetigen/page.tsx

@@ -3,6 +3,7 @@ import { ShieldAlert } from 'lucide-react'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Alert, AlertDescription } from '@/components/ui/alert'
 import { erfordereBenutzer } from '@/lib/auth/sitzung'
+import { passkeysMoeglich } from '@/lib/auth/passkey'
 import { BestaetigenFormular } from './formular'
 
 export const metadata: Metadata = { title: 'Bestätigen' }
@@ -26,7 +27,7 @@ export default async function BestaetigenSeite({
           </CardDescription>
         </CardHeader>
         <CardContent>
-          <BestaetigenFormular weiter={weiter} />
+          <BestaetigenFormular weiter={weiter} passkeysMoeglich={passkeysMoeglich()} />
         </CardContent>
       </Card>
 

src/app/(app)/einstellungen/page.tsx

@@ -1,5 +1,5 @@
 import Link from 'next/link'
-import { KeyRound, Trash2, Users } from 'lucide-react'
+import { KeyRound, FileText, Trash2, Users } from 'lucide-react'
 import { SeitenKopf } from '@/components/seiten-kopf'
 import { Card, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Badge } from '@/components/ui/badge'
@@ -69,6 +69,23 @@ export default async function EinstellungenSeite() {
           </CardHeader>
         </Card>
 
+        <Card>
+          <CardHeader className="flex flex-row items-start gap-3 space-y-0">
+            <FileText className="mt-0.5 size-5 shrink-0 text-primary" aria-hidden="true" />
+            <div>
+              <CardTitle className="text-lg">
+                <Link href="/einstellungen/vorlagen" className="underline-offset-4 hover:underline">
+                  Schreibvorlagen
+                </Link>
+              </CardTitle>
+              <CardDescription className="mt-1">
+                Bewährte Formulierungen mit Platzhaltern hinterlegen – beim Erzeugen eines
+                Schreibens wählbar.
+              </CardDescription>
+            </div>
+          </CardHeader>
+        </Card>
+
         <Card>
           <CardHeader className="flex flex-row items-start gap-3 space-y-0">
             <Trash2 className="mt-0.5 size-5 shrink-0 text-primary" aria-hidden="true" />

src/app/(app)/einstellungen/vorlagen/page.tsx

@@ -0,0 +1,51 @@
+import type { Metadata } from 'next'
+import { redirect } from 'next/navigation'
+import { SeitenKopf } from '@/components/seiten-kopf'
+import { VorlagenVerwaltung } from '@/components/einstellungen/vorlagen-verwaltung'
+import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { db, nichtGeloescht } from '@/lib/db'
+import { MITGELIEFERTE_VORLAGEN } from '@/lib/schreiben/mitgelieferte-vorlagen'
+
+export const metadata: Metadata = { title: 'Vorlagen' }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Einstellungen → Vorlagen.
+ *
+ * Vorlagen hängen an der betreuten Person, nicht am Benutzer: Die
+ * Formulierungen beziehen sich auf ihren Fall, und beim Vollexport ihrer
+ * Akte gehören sie mit hinein.
+ */
+export default async function VorlagenSeite() {
+  const benutzer = await erfordereBenutzer('/einstellungen/vorlagen')
+  const aktive = await aktiveBetreute(benutzer)
+  if (!aktive) redirect('/ersteinrichtung')
+
+  const { darfSchreiben } = await erfordereZugang(aktive.id, 'DOKUMENTE', 'lesen')
+  if (!darfSchreiben('DOKUMENTE')) redirect('/einstellungen')
+
+  const eigene = await db.schreibvorlage.findMany({
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    select: { id: true, name: true, betreff: true, text: true },
+    orderBy: { name: 'asc' },
+  })
+
+  return (
+    <div className="max-w-5xl space-y-6">
+      <SeitenKopf
+        titel="Schreibvorlagen"
+        beschreibung="Bewährte Formulierungen einmal hinterlegen, beim Schreiben auswählen. Platzhalter füllen sich aus den Daten, die ohnehin im System stehen."
+        pfad={[
+          { titel: 'Einstellungen', href: '/einstellungen' },
+          { titel: 'Vorlagen' },
+        ]}
+      />
+
+      <VorlagenVerwaltung
+        betreuteId={aktive.id}
+        eigene={eigene}
+        mitgelieferte={[...MITGELIEFERTE_VORLAGEN]}
+      />
+    </div>
+  )
+}

src/app/(app)/finanzen/buchungen/[id]/page.tsx

@@ -26,7 +26,7 @@ export default async function BuchungSeite({ params }: { params: Promise<{ id: s
 
   const offen = oeffnen('Buchung', buchung)
 
-  const [konten, belege] = await Promise.all([
+  const [konten, belege, vertraege] = await Promise.all([
     db.konto.findMany({
       where: { betreuteId: betreute.id, ...nichtGeloescht },
       select: { id: true, bezeichnung: true, istBetreuerkonto: true },
@@ -38,6 +38,11 @@ export default async function BuchungSeite({ params }: { params: Promise<{ id: s
       orderBy: { erstelltAm: 'desc' },
       take: 200,
     }),
+    db.vertrag.findMany({
+      where: { betreuteId: betreute.id, ...nichtGeloescht },
+      select: { id: true, bezeichnung: true, gesellschaft: true },
+      orderBy: { bezeichnung: 'asc' },
+    }),
   ])
 
   return (
@@ -64,6 +69,7 @@ export default async function BuchungSeite({ params }: { params: Promise<{ id: s
           betreuteId={betreute.id}
           konten={konten}
           belege={belege}
+        vertraege={vertraege}
           buchung={{
             id: buchung.id,
             kontoId: buchung.kontoId,
@@ -75,6 +81,7 @@ export default async function BuchungSeite({ params }: { params: Promise<{ id: s
             gegenstelle: buchung.gegenstelle,
             verwendungszweck: offen.verwendungszweck,
             belegId: buchung.belegId,
+            vertragId: buchung.vertragId,
             belegFehltBegruendung: buchung.belegFehltBegruendung,
             betrifftBetreute: buchung.betrifftBetreute,
             vermoegenswirksam: buchung.vermoegenswirksam,

src/app/(app)/finanzen/buchungen/neu/page.tsx

@@ -30,7 +30,7 @@ export default async function BuchungNeuSeite({
   const schnell = parameter.schnell === '1'
   const kontoId = typeof parameter.kontoId === 'string' ? parameter.kontoId : null
 
-  const [konten, belege] = await Promise.all([
+  const [konten, belege, vertraege] = await Promise.all([
     db.konto.findMany({
       where: { betreuteId: betreute.id, ...nichtGeloescht },
       select: { id: true, bezeichnung: true, istBetreuerkonto: true },
@@ -42,6 +42,11 @@ export default async function BuchungNeuSeite({
       orderBy: { erstelltAm: 'desc' },
       take: 200,
     }),
+    db.vertrag.findMany({
+      where: { betreuteId: betreute.id, ...nichtGeloescht },
+      select: { id: true, bezeichnung: true, gesellschaft: true },
+      orderBy: { bezeichnung: 'asc' },
+    }),
   ])
 
   return (
@@ -93,6 +98,7 @@ export default async function BuchungNeuSeite({
             : konten
         }
         belege={belege}
+        vertraege={vertraege}
         schnellerfassung={schnell}
         standardDatum={tagAlsText(heute())}
       />

src/app/(app)/finanzen/buchungen/page.tsx

@@ -9,10 +9,10 @@ import { Rechtshinweis } from '@/components/rechtshinweis'
 import { Belegzeichen, Betrag, Kennzahl, Vermischungswarnung } from '@/components/finanzen/bausteine'
 import { Buchungsfilter } from '@/components/finanzen/buchungs-filter'
 import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
-import { oeffnen } from '@/lib/crypto/feld'
 import { formatCent, formatDatum } from '@/lib/utils'
 import { finanzKontext } from '@/lib/finanzen/seite'
-import { belegFehlt, kennzahlen, vermischungsWarnung, type BuchungEingabe } from '@/lib/finanzen/kassenbuch'
+import { BUCHUNG_EINBEZUG, zuBuchungEingabe } from '@/lib/berichte/gemeinsam'
+import { belegDurchVertrag, betragPruefen, belegFehlt, kennzahlen, vermischungsWarnung, type BuchungEingabe } from '@/lib/finanzen/kassenbuch'
 import { KATEGORIE_BESCHRIFTUNG, RICHTUNG_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
 import { buchungsfilterSchema } from '@/lib/validierung/finanzen'
 
@@ -82,10 +82,7 @@ export default async function BuchungenSeite({
   const [zeilen, gesamt, konten] = await Promise.all([
     db.buchung.findMany({
       where: bedingung,
-      include: {
-        konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
-        beleg: { select: { id: true, titel: true } },
-      },
+      include: BUCHUNG_EINBEZUG,
       orderBy: [{ datum: 'desc' }, { erstelltAm: 'desc' }],
       take: HOECHSTZAHL,
     }),
@@ -97,26 +94,7 @@ export default async function BuchungenSeite({
     }),
   ])
 
-  const buchungen: BuchungEingabe[] = zeilen.map((zeile) => {
-    const offen = oeffnen('Buchung', zeile)
-    return {
-      id: zeile.id,
-      datum: zeile.datum,
-      betragCent: zeile.betragCent,
-      richtung: zeile.richtung,
-      kategorie: zeile.kategorie,
-      gegenstelle: zeile.gegenstelle,
-      verwendungszweck: offen.verwendungszweck,
-      kontoId: zeile.kontoId,
-      kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
-      belegId: zeile.belegId,
-      belegTitel: zeile.beleg?.titel ?? null,
-      belegFehltBegruendung: zeile.belegFehltBegruendung,
-      betrifftBetreute: zeile.betrifftBetreute,
-      vermoegenswirksam: zeile.vermoegenswirksam,
-      aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
-    }
-  })
+  const buchungen: BuchungEingabe[] = zeilen.map(zuBuchungEingabe)
 
   const zahlen = kennzahlen(buchungen)
 
@@ -261,6 +239,11 @@ export default async function BuchungenSeite({
                       belegId={buchung.belegId}
                       belegTitel={buchung.belegTitel ?? null}
                       begruendung={buchung.belegFehltBegruendung}
+                      vertragBezeichnung={
+                      belegDurchVertrag(buchung) ? (buchung.vertragBezeichnung ?? null) : null
+                      }
+                      vertragAutomatisch={buchung.vertragAutomatisch ?? false}
+                      betragZuPruefen={betragPruefen(buchung)}
                     />
                   </TableCell>
                   <TableCell className="text-right align-top">

src/app/(app)/finanzen/page.tsx

@@ -1,5 +1,6 @@
 import Link from 'next/link'
-import { ArrowRight, Banknote, FileDown, Landmark, Plus, Upload } from 'lucide-react'
+import { ArrowRight, Banknote, FileDown, Landmark, Plus, Repeat, Upload } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
@@ -16,10 +17,11 @@ import { centZuZahl } from '@/lib/db'
 import { formatCent, formatDatum } from '@/lib/utils'
 import { finanzKontext } from '@/lib/finanzen/seite'
 import { heute, monatePlus, tagePlus } from '@/lib/finanzen/datum'
-import { kennzahlen, vermischungsWarnung } from '@/lib/finanzen/kassenbuch'
+import { belegDurchVertrag, betragPruefen, kennzahlen, vermischungsWarnung } from '@/lib/finanzen/kassenbuch'
 import { KATEGORIE_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
 import { laufendesBetreuungsjahr } from '@/lib/finanzen/betreuungsjahr'
 import { buchungenLaden, kontenLaden, kontostaendeZumStichtag, vermoegenLaden } from '@/lib/berichte/gemeinsam'
+import { offeneZahlungsgruppen } from '@/lib/finanzen/wiederkehrend-laden'
 
 export const metadata = { title: 'Vermögen & Kasse' }
 
@@ -48,6 +50,7 @@ export default async function FinanzenSeite() {
   const zwoelfMonate = tagePlus(monatePlus(stichtag, -12), 1)
   const letzteZwoelf = buchungen.filter((b) => b.datum >= zwoelfMonate)
   const zahlen = kennzahlen(letzteZwoelf)
+  const offeneGruppen = await offeneZahlungsgruppen(betreute.id)
 
   const letzte = [...buchungen].sort((a, b) => b.datum.getTime() - a.datum.getTime()).slice(0, 8)
 
@@ -118,8 +121,12 @@ export default async function FinanzenSeite() {
           titel="Belegquote (12 Monate)"
           wert={`${zahlen.beleg.quoteProzent} %`}
           hinweis={
-            zahlen.beleg.ohneNachweis > 0
+            zahlen.beleg.zuPruefen > 0
+              ? `${zahlen.beleg.zuPruefen} Zahlung(en) weichen vom hinterlegten Beitrag ab`
+              : zahlen.beleg.ohneNachweis > 0
                 ? `${zahlen.beleg.ohneNachweis} Buchung(en) ohne Beleg und ohne Begründung`
+                : zahlen.beleg.durchVertrag > 0
+                  ? `Belegt, begründet oder durch Vertrag gedeckt (${zahlen.beleg.durchVertrag} Dauerzahlungen)`
                   : 'Alle Buchungen sind belegt oder begründet'
           }
           ton={zahlen.beleg.ohneNachweis > 0 ? 'achtung' : 'gut'}
@@ -134,6 +141,22 @@ export default async function FinanzenSeite() {
         />
       </div>
 
+      {offeneGruppen > 0 && (
+        <Alert variant="hinweis">
+          <Repeat aria-hidden="true" />
+          <AlertDescription className="flex flex-wrap items-center justify-between gap-3">
+            <span>
+              <strong>{offeneGruppen}</strong> regelmäßige Abbuchung
+              {offeneGruppen === 1 ? '' : 'en'} ohne hinterlegten Vertrag. Wer regelmäßig
+              abbucht, hat einen — und der fehlt dann im Vermögensverzeichnis.
+            </span>
+            <Button asChild size="sm" variant="outline">
+              <Link href="/finanzen/wiederkehrend">Ansehen</Link>
+            </Button>
+          </AlertDescription>
+        </Alert>
+      )}
+
       {zahlen.vermischungen > 0 && <Vermischungswarnung />}
 
       <Hinweisliste hinweise={hinweise} titel="Das solltest du nachtragen" />
@@ -299,6 +322,11 @@ export default async function FinanzenSeite() {
                         belegId={buchung.belegId}
                         belegTitel={buchung.belegTitel ?? null}
                         begruendung={buchung.belegFehltBegruendung}
+                        vertragBezeichnung={
+                        belegDurchVertrag(buchung) ? (buchung.vertragBezeichnung ?? null) : null
+                        }
+                        vertragAutomatisch={buchung.vertragAutomatisch ?? false}
+                        betragZuPruefen={betragPruefen(buchung)}
                       />
                     </TableCell>
                     <TableCell className="text-right">

src/app/(app)/finanzen/vermoegen/page.tsx

@@ -18,6 +18,7 @@ import {
   VERMOEGENS_ART_EINZAHL,
 } from '@/lib/finanzen/kategorien'
 import { vermoegenLaden } from '@/lib/berichte/gemeinsam'
+import { wertVeraltet } from '@/lib/finanzen/wertalter'
 import type { SozialhilfeBewertung } from '@prisma/client'
 
 export const metadata = { title: 'Vermögen' }
@@ -235,7 +236,7 @@ function Postentabelle({
             </TableCell>
             <TableCell className="whitespace-nowrap text-sm text-muted-foreground">
               {formatDatum(eintrag.bewertetAm)}
-              {eintrag.alterTage > 365 && (
+              {wertVeraltet(eintrag.alterTage) && (
                 <Badge variant="gelb" className="ml-2">
                   über ein Jahr alt
                 </Badge>

src/app/(app)/finanzen/wiederkehrend/page.tsx

@@ -0,0 +1,337 @@
+import Link from 'next/link'
+import { AlertCircle, FileSearch, Plus, Repeat } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
+import { Betrag } from '@/components/finanzen/bausteine'
+import {
+  AlsGeklaertAbhaken,
+  ZahlungenZuordnen,
+  Zurueckholen,
+} from '@/components/finanzen/wiederkehrend-aktionen'
+import { finanzKontext } from '@/lib/finanzen/seite'
+import { wiederkehrendLaden } from '@/lib/finanzen/wiederkehrend-laden'
+import {
+  EINZELZAHLUNG_AB_CENT,
+  RHYTHMUS_BESCHRIFTUNG,
+  rhythmusErklaerung,
+} from '@/lib/finanzen/wiederkehrend'
+import { centZuZahl } from '@/lib/db'
+import { formatCent, formatDatum } from '@/lib/utils'
+
+export const metadata = { title: 'Wiederkehrende Zahlungen' }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Wiederkehrende Zahlungen — die Suche nach unbekannten Verträgen.
+ *
+ * Am Anfang einer Betreuung weiß niemand, welche Verträge es gibt. Die
+ * Antwort steht im Kontoauszug: Wer regelmäßig abbucht, hat einen Vertrag.
+ * Diese Seite macht aus hunderten Buchungszeilen eine Arbeitsliste.
+ *
+ * Sie legt von sich aus nichts an. Jede Zeile endet in einer Entscheidung,
+ * die ein Mensch trifft — Vertrag anlegen oder abhaken.
+ */
+export default async function WiederkehrendSeite() {
+  const { betreute, darfSchreiben } = await finanzKontext()
+  const schreiben = darfSchreiben('FINANZEN')
+  const bild = await wiederkehrendLaden(betreute.id)
+
+  const ohneVertrag = bild.gruppen.filter((gruppe) => gruppe.vertragId === null)
+  const mitVertrag = bild.gruppen.filter((gruppe) => gruppe.vertragId !== null)
+
+  return (
+    <div className="space-y-6">
+      <SeitenKopf
+        titel="Wiederkehrende Zahlungen"
+        beschreibung="Wer regelmäßig abbucht, hat einen Vertrag. Hier stehen die Kandidaten, zu denen noch keiner in der Akte liegt."
+        aktionen={
+          <Button asChild variant="outline">
+            <Link href="/finanzen/buchungen">Zu den Buchungen</Link>
+          </Button>
+        }
+      />
+
+      {bild.ausgabenGesamt === 0 ? (
+        <Leerzustand
+          icon={FileSearch}
+          titel="Noch keine Ausgaben erfasst"
+          beschreibung="Diese Auswertung liest die Kontobewegungen. Importiere zuerst einen Kontoauszug, dann findest du hier die regelmäßigen Abbuchungen."
+          aktion={
+            <Button asChild>
+              <Link href="/finanzen/buchungen/import">Kontoauszug einlesen</Link>
+            </Button>
+          }
+        />
+      ) : (
+        <>
+          {/* --- Kandidaten ohne Vertrag ----------------------------------- */}
+          <Card>
+            <CardHeader>
+              <CardTitle className="flex items-center gap-2 text-base">
+                <Repeat className="size-5" aria-hidden="true" />
+                Ohne hinterlegten Vertrag
+                {ohneVertrag.length > 0 && (
+                  <Badge variant="secondary">{ohneVertrag.length}</Badge>
+                )}
+              </CardTitle>
+              <CardDescription>
+                Nach Jahresbetrag sortiert — was am meisten kostet, will man zuerst geklärt haben.
+              </CardDescription>
+            </CardHeader>
+            <CardContent>
+              {ohneVertrag.length === 0 ? (
+                <p className="text-sm text-muted-foreground">
+                  Zu jeder regelmäßigen Abbuchung liegt ein Vertrag in der Akte. Das ist der
+                  Zustand, den man haben will.
+                </p>
+              ) : (
+                <div className="overflow-x-auto">
+                  <Table>
+                    <TableHeader>
+                      <TableRow>
+                        <TableHead>Empfänger</TableHead>
+                        <TableHead>Rhythmus</TableHead>
+                        <TableHead className="text-right">je Zahlung</TableHead>
+                        <TableHead className="text-right">im Jahr</TableHead>
+                        <TableHead>Zeitraum</TableHead>
+                        {schreiben && <TableHead className="text-right">Und jetzt?</TableHead>}
+                      </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                      {ohneVertrag.map((gruppe) => (
+                        <TableRow key={gruppe.schluessel}>
+                          <TableCell className="align-top">
+                            <p className="font-medium">{gruppe.anzeigename}</p>
+                            {gruppe.schreibweisen.length > 1 && (
+                              <p className="mt-0.5 text-xs text-muted-foreground">
+                                {gruppe.schreibweisen.length} Schreibweisen zusammengefasst
+                              </p>
+                            )}
+                          </TableCell>
+
+                          <TableCell className="align-top">
+                            <span
+                              className={
+                                gruppe.rhythmus === 'UNREGELMAESSIG'
+                                  ? 'text-muted-foreground'
+                                  : undefined
+                              }
+                            >
+                              {RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]}
+                            </span>
+                            <p className="mt-0.5 text-xs text-muted-foreground">
+                              {rhythmusErklaerung(gruppe)}
+                            </p>
+                          </TableCell>
+
+                          <TableCell className="text-right align-top">
+                            <Betrag cent={centZuZahl(gruppe.betragCent)} />
+                            {gruppe.betragSchwankt && (
+                              <p className="mt-0.5 text-xs text-ampel-orange">
+                                schwankt: {formatCent(centZuZahl(gruppe.kleinsterBetragCent))} bis{' '}
+                                {formatCent(centZuZahl(gruppe.groessterBetragCent))}
+                              </p>
+                            )}
+                          </TableCell>
+
+                          <TableCell className="text-right align-top">
+                            <Betrag cent={centZuZahl(gruppe.jahresbetragCent)} />
+                            {gruppe.rhythmus === 'UNREGELMAESSIG' && (
+                              <p className="mt-0.5 text-xs text-muted-foreground">
+                                tatsächlich gezahlt
+                              </p>
+                            )}
+                          </TableCell>
+
+                          <TableCell className="align-top text-sm text-muted-foreground">
+                            {formatDatum(gruppe.ersteZahlung)}
+                            <br />
+                            bis {formatDatum(gruppe.letzteZahlung)}
+                          </TableCell>
+
+                          {schreiben && (
+                            <TableCell className="align-top">
+                              <div className="flex flex-col items-end gap-2">
+                                <Button asChild size="sm" variant="outline">
+                                  <Link
+                                    href={`/vertraege/neu?gesellschaft=${encodeURIComponent(
+                                      gruppe.anzeigename,
+                                    )}&beitragCent=${gruppe.betragCent}&rhythmus=${gruppe.rhythmus}`}
+                                  >
+                                    <Plus aria-hidden="true" />
+                                    Vertrag anlegen
+                                  </Link>
+                                </Button>
+                                <AlsGeklaertAbhaken
+                                  betreuteId={betreute.id}
+                                  schluessel={gruppe.schluessel}
+                                  anzeigename={gruppe.anzeigename}
+                                />
+                              </div>
+                            </TableCell>
+                          )}
+                        </TableRow>
+                      ))}
+                    </TableBody>
+                  </Table>
+                </div>
+              )}
+            </CardContent>
+          </Card>
+
+          {/* --- Einzelne groessere Zahlungen ------------------------------ */}
+          {bild.einzelne.length > 0 && (
+            <Card>
+              <CardHeader>
+                <CardTitle className="text-base">Einzelne größere Zahlungen</CardTitle>
+                <CardDescription>
+                  Kein Vertragsverdacht, sondern eine Merkliste. Die Gruppierung oben braucht
+                  mindestens zwei Zahlungen — eine jährlich abgebuchte Prämie erscheint bei
+                  einem importierten Jahr aber nur einmal. Ausgerechnet Versicherungen werden
+                  oft jährlich gezahlt, deshalb steht hier alles ab{' '}
+                  {formatCent(centZuZahl(EINZELZAHLUNG_AB_CENT))}.
+                </CardDescription>
+              </CardHeader>
+              <CardContent>
+                <div className="overflow-x-auto">
+                  <Table>
+                    <TableHeader>
+                      <TableRow>
+                        <TableHead>Empfänger</TableHead>
+                        <TableHead>Datum</TableHead>
+                        <TableHead className="text-right">Betrag</TableHead>
+                        <TableHead>Vertrag</TableHead>
+                      </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                      {bild.einzelne.map((zahlung) => (
+                        <TableRow key={zahlung.buchungId}>
+                          <TableCell className="font-medium">{zahlung.anzeigename}</TableCell>
+                          <TableCell className="text-sm text-muted-foreground">
+                            {formatDatum(zahlung.datum)}
+                          </TableCell>
+                          <TableCell className="text-right">
+                            <Betrag cent={centZuZahl(zahlung.betragCent)} />
+                          </TableCell>
+                          <TableCell className="text-sm">
+                            {zahlung.vertragBezeichnung ? (
+                              <Badge variant="secondary">{zahlung.vertragBezeichnung}</Badge>
+                            ) : (
+                              <span className="text-muted-foreground">keiner</span>
+                            )}
+                          </TableCell>
+                        </TableRow>
+                      ))}
+                    </TableBody>
+                  </Table>
+                </div>
+              </CardContent>
+            </Card>
+          )}
+
+          {/* --- Bereits erklaert ------------------------------------------ */}
+          {mitVertrag.length > 0 && (
+            <Card>
+              <CardHeader>
+                <CardTitle className="text-base">Schon einem Vertrag zugeordnet</CardTitle>
+                <CardDescription>
+                  Erkannt am Namen der Gesellschaft. Steht hier etwas Falsches, stimmt die
+                  Schreibweise am Vertrag nicht mit der auf dem Kontoauszug überein.
+                </CardDescription>
+              </CardHeader>
+              <CardContent>
+                <ul className="divide-y text-sm">
+                  {mitVertrag.map((gruppe) => (
+                    <li key={gruppe.schluessel} className="space-y-2 py-2">
+                      <div className="flex flex-wrap items-center justify-between gap-2">
+                        <span>
+                          <span className="font-medium">{gruppe.anzeigename}</span>
+                          <span className="ml-2 text-muted-foreground">
+                            {RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]},{' '}
+                            {formatCent(centZuZahl(gruppe.jahresbetragCent))} im Jahr
+                          </span>
+                        </span>
+                        <Button asChild variant="ghost" size="sm">
+                          <Link href={`/vertraege/${gruppe.vertragId}`}>
+                            {gruppe.vertragBezeichnung}
+                          </Link>
+                        </Button>
+                      </div>
+
+                      {/* Der Vertrag liegt vor - dann belegt er auch die
+                          Zahlungen. Einzeln anzuklicken waeren bei drei
+                          Jahren Laufzeit 36 Klicks. */}
+                      {schreiben && gruppe.offeneBuchungIds.length > 0 && (
+                        <ZahlungenZuordnen
+                          betreuteId={betreute.id}
+                          vertragId={gruppe.vertragId!}
+                          vertragBezeichnung={gruppe.vertragBezeichnung ?? 'Vertrag'}
+                          buchungIds={gruppe.offeneBuchungIds}
+                        />
+                      )}
+
+                      {gruppe.offeneBuchungIds.length === 0 && (
+                        <p className="text-xs text-ampel-gruen">
+                          Alle {gruppe.anzahl} Zahlungen sind dem Vertrag zugeordnet und damit
+                          belegt.
+                        </p>
+                      )}
+                    </li>
+                  ))}
+                </ul>
+              </CardContent>
+            </Card>
+          )}
+
+          {/* --- Abgehakt --------------------------------------------------- */}
+          {bild.abgehakt.length > 0 && (
+            <Card>
+              <CardHeader>
+                <CardTitle className="text-base">Als „kein Vertrag“ abgehakt</CardTitle>
+                <CardDescription>
+                  Diese Empfänger bleiben aus der Liste heraus, auch nach dem nächsten Import.
+                </CardDescription>
+              </CardHeader>
+              <CardContent>
+                <ul className="divide-y text-sm">
+                  {bild.abgehakt.map((eintrag) => (
+                    <li
+                      key={eintrag.id}
+                      className="flex flex-wrap items-center justify-between gap-2 py-2"
+                    >
+                      <span>
+                        <span className="font-medium">{eintrag.anzeigename}</span>
+                        {eintrag.begruendung && (
+                          <span className="ml-2 text-muted-foreground">
+                            — {eintrag.begruendung}
+                          </span>
+                        )}
+                      </span>
+                      {schreiben && (
+                        <Zurueckholen betreuteId={betreute.id} eintragId={eintrag.id} />
+                      )}
+                    </li>
+                  ))}
+                </ul>
+              </CardContent>
+            </Card>
+          )}
+
+          <Alert variant="hinweis">
+            <AlertCircle aria-hidden="true" />
+            <AlertDescription>
+              Diese Seite wertet nur aus, sie legt nichts an. Gruppiert wird nach dem Empfänger
+              aus dem Kontoauszug — Groß- und Kleinschreibung, Satzzeichen und die Rechtsform
+              werden dabei zusammengefasst. Ähnliche, aber verschiedene Namen bleiben bewusst
+              getrennt: „Stadtwerke Bamberg“ und „Stadtwerke Bayreuth“ sind zwei Rechnungssteller.
+            </AlertDescription>
+          </Alert>
+        </>
+      )}
+    </div>
+  )
+}

src/app/(app)/kontakte/[id]/bearbeiten/page.tsx

@@ -47,6 +47,7 @@ export default async function KontaktBearbeitenSeite({
           name: kontakt.name,
           organisation: kontakt.organisation,
           rolle: kontakt.rolle,
+          anrede: kontakt.anrede,
           telefon: kontakt.telefon,
           mobil: kontakt.mobil,
           fax: kontakt.fax,

src/app/(app)/konto/anschrift-formular.tsx

@@ -0,0 +1,89 @@
+'use client'
+
+import { useActionState } from 'react'
+import { useFormStatus } from 'react-dom'
+import { AlertCircle, CheckCircle2, Loader2 } from 'lucide-react'
+import { anschriftSpeichern, type AnschriftZustand } from '@/server/actions/konto'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Feld } from '@/components/feld'
+
+function Absenden() {
+  const { pending } = useFormStatus()
+  return (
+    <Button type="submit" disabled={pending}>
+      {pending && <Loader2 className="animate-spin" aria-hidden="true" />}
+      {pending ? 'Wird gespeichert …' : 'Anschrift speichern'}
+    </Button>
+  )
+}
+
+export function AnschriftFormular({
+  strasse,
+  plz,
+  ort,
+}: {
+  strasse: string | null
+  plz: string | null
+  ort: string | null
+}) {
+  const [zustand, aktion] = useActionState<AnschriftZustand, FormData>(anschriftSpeichern, {})
+
+  return (
+    <form action={aktion} className="space-y-4" noValidate>
+      {zustand.fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{zustand.fehler}</AlertDescription>
+        </Alert>
+      )}
+      {zustand.erfolg && (
+        <Alert variant="erfolg">
+          <CheckCircle2 aria-hidden="true" />
+          <AlertDescription>{zustand.erfolg}</AlertDescription>
+        </Alert>
+      )}
+
+      <Feld id="strasse" beschriftung="Straße und Hausnummer" fehler={zustand.felder?.strasse}>
+        <Input
+          id="strasse"
+          name="strasse"
+          defaultValue={strasse ?? ''}
+          maxLength={150}
+          autoComplete="street-address"
+        />
+      </Feld>
+
+      <div className="grid gap-4 sm:grid-cols-[8rem_1fr]">
+        <Feld id="plz" beschriftung="PLZ" fehler={zustand.felder?.plz}>
+          <Input
+            id="plz"
+            name="plz"
+            defaultValue={plz ?? ''}
+            maxLength={10}
+            autoComplete="postal-code"
+            inputMode="numeric"
+          />
+        </Feld>
+
+        <Feld
+          id="ort"
+          beschriftung="Ort"
+          erklaerung="Steht außerdem in der Datumszeile: „Bayreuth, den 23.08.2026“."
+          fehler={zustand.felder?.ort}
+        >
+          <Input
+            id="ort"
+            name="ort"
+            defaultValue={ort ?? ''}
+            maxLength={100}
+            autoComplete="address-level2"
+          />
+        </Feld>
+      </div>
+
+      <Absenden />
+    </form>
+  )
+}

src/app/(app)/konto/page.tsx

@@ -1,14 +1,17 @@
 import type { Metadata } from 'next'
 import Link from 'next/link'
-import { KeyRound, ShieldCheck } from 'lucide-react'
+import { Fingerprint, KeyRound, MapPin, ShieldCheck } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { SeitenKopf } from '@/components/seiten-kopf'
 import { erfordereBenutzer } from '@/lib/auth/sitzung'
+import { passkeysDesBenutzers, passkeysMoeglich } from '@/lib/auth/passkey'
+import { PasskeyVerwaltung } from '@/components/konto/passkey-verwaltung'
 import { ROLLEN_BESCHRIFTUNG, ROLLEN_ERKLAERUNG } from '@/lib/auth/rollen'
 import { formatDatumZeit } from '@/lib/utils'
 import { PasswortFormular } from './passwort-formular'
+import { AnschriftFormular } from './anschrift-formular'
 
 export const metadata: Metadata = { title: 'Mein Konto' }
 export const dynamic = 'force-dynamic'
@@ -16,10 +19,14 @@ export const dynamic = 'force-dynamic'
 export default async function KontoSeite() {
   const benutzer = await erfordereBenutzer()
   const codesUebrig = benutzer.wiederherstellungscodes.length
+  const passkeys = await passkeysDesBenutzers(benutzer.id)
 
   return (
     <div className="max-w-2xl space-y-6">
-      <SeitenKopf titel="Mein Konto" beschreibung="Zugangsdaten und zweiter Faktor." />
+      <SeitenKopf
+        titel="Mein Konto"
+        beschreibung="Zugangsdaten, eigene Anschrift, zweiter Faktor und Passkeys."
+      />
 
       <Card>
         <CardHeader className="pb-3">
@@ -52,6 +59,27 @@ export default async function KontoSeite() {
         </CardContent>
       </Card>
 
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="flex items-center gap-2 text-base">
+            <MapPin className="size-5" aria-hidden="true" />
+            Meine Anschrift
+          </CardTitle>
+          <CardDescription>
+            Steht im Absenderblock jedes Schreibens, das hier entsteht, und liefert den Ort für
+            die Datumszeile. Ohne sie geht ein förmlicher Brief ohne Rücksendeadresse hinaus.
+            Jede Angabe ist einzeln freiwillig — was fehlt, bleibt im Brief einfach weg.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <AnschriftFormular
+            strasse={benutzer.strasse}
+            plz={benutzer.plz}
+            ort={benutzer.ort}
+          />
+        </CardContent>
+      </Card>
+
       <Card>
         <CardHeader className="pb-3">
           <CardTitle className="flex items-center gap-2 text-base">
@@ -89,6 +117,28 @@ export default async function KontoSeite() {
         </CardContent>
       </Card>
 
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="flex items-center gap-2 text-base">
+            <Fingerprint className="size-5" aria-hidden="true" />
+            Passkeys
+          </CardTitle>
+          <CardDescription>
+            Anmelden mit Fingerabdruck, Gesicht oder Geräte-PIN — ohne E-Mail, Passwort und Code.
+            Ein Passkey gilt als zweiter Faktor, weil er Besitz des Geräts und dessen Entsperrung
+            verlangt. Er ist an diese Adresse gebunden: Auf einer nachgebauten Anmeldeseite
+            funktioniert er nicht.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <PasskeyVerwaltung
+            passkeys={passkeys}
+            zweiterFaktorAktiv={Boolean(benutzer.totpAktiviertAm)}
+            moeglich={passkeysMoeglich()}
+          />
+        </CardContent>
+      </Card>
+
       <Card>
         <CardHeader className="pb-3">
           <CardTitle className="flex items-center gap-2 text-base">

src/app/(app)/protokoll/page.tsx

@@ -34,6 +34,8 @@ const AKTION_BESCHRIFTUNG: Record<AuditAktion, string> = {
   ANMELDUNG_FEHLGESCHLAGEN: 'Anmeldung fehlgeschlagen',
   ABMELDUNG: 'abgemeldet',
   ZWEITER_FAKTOR_EINGERICHTET: 'zweiter Faktor eingerichtet',
+  PASSKEY_REGISTRIERT: 'Passkey eingerichtet',
+  PASSKEY_ENTFERNT: 'Passkey entfernt',
   PASSWORT_GEAENDERT: 'Passwort geändert',
   ROLLE_GEAENDERT: 'Rolle geändert',
   FREIGABE_GEAENDERT: 'Freigabe geändert',
@@ -41,7 +43,8 @@ const AKTION_BESCHRIFTUNG: Record<AuditAktion, string> = {
 
 function variante(aktion: AuditAktion) {
   if (aktion === 'ANMELDUNG_FEHLGESCHLAGEN' || aktion === 'ENDGUELTIG_GELOESCHT') return 'rot'
-  if (aktion === 'GELOESCHT' || aktion === 'EXPORTIERT') return 'orange'
+  if (aktion === 'GELOESCHT' || aktion === 'EXPORTIERT' || aktion === 'PASSKEY_ENTFERNT')
+    return 'orange'
   if (aktion === 'ERSTELLT') return 'gruen'
   return 'secondary'
 }

src/app/(app)/schreiben/docx/route.ts

@@ -0,0 +1,68 @@
+import { NextResponse } from 'next/server'
+import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
+import { briefDocxErzeugen } from '@/lib/schreiben/docx'
+import { dateinameFuerSchreiben, istSchreibenArt } from '@/lib/schreiben/arten'
+import { heuteAlsTag } from '@/lib/fristen/datum'
+import { tagAusText } from '@/lib/finanzen/datum'
+
+/**
+ * Das Schreiben als Word-Datei herunterladen.
+ *
+ * Warum eine Route und keine Server Action? Eine Action kann keinen
+ * Download ausloesen - sie muesste die Datei kodiert zurueckgeben und der
+ * Browser sie nachbauen. Eine Route liefert sie unmittelbar aus, mit
+ * richtigem Namen und Typ. Denselben Weg geht schon der Vollexport.
+ *
+ * POST und nicht GET, weil der bearbeitete Brieftext mitkommt und in eine
+ * Adresszeile weder hineinpasst noch hineingehoert: Er stuende sonst im
+ * Verlauf des Browsers und in jedem Zwischenspeicher.
+ */
+
+export const dynamic = 'force-dynamic'
+
+const MIME_DOCX = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+
+export async function POST(anfrage: Request): Promise<Response> {
+  let formular: FormData
+  try {
+    formular = await anfrage.formData()
+  } catch {
+    return NextResponse.json({ fehler: 'Ungültige Anfrage.' }, { status: 400 })
+  }
+
+  const betreuteId = String(formular.get('betreuteId') ?? '')
+  const rohArt = String(formular.get('art') ?? '')
+  const text = String(formular.get('text') ?? '')
+  const empfaenger = String(formular.get('empfaengerName') ?? '').trim()
+  const versandRoh = String(formular.get('versandAm') ?? '').trim()
+
+  if (!betreuteId || !istSchreibenArt(rohArt) || text.trim().length < 30) {
+    return NextResponse.json({ fehler: 'Unvollständige Angaben.' }, { status: 400 })
+  }
+
+  try {
+    // Zugriff wird hier geprueft und nicht nur auf der Seite davor: Eine
+    // Route laesst sich unmittelbar aufrufen.
+    await erfordereZugang(betreuteId, 'DOKUMENTE', 'lesen')
+  } catch (ausnahme) {
+    if (ausnahme instanceof ZugriffVerweigert) {
+      return NextResponse.json({ fehler: ausnahme.message }, { status: 403 })
+    }
+    throw ausnahme
+  }
+
+  const datum = tagAusText(versandRoh) ?? heuteAlsTag()
+  const datei = await briefDocxErzeugen(text)
+  const dateiname = dateinameFuerSchreiben(rohArt, empfaenger || null, datum, 'docx')
+
+  return new NextResponse(new Uint8Array(datei), {
+    headers: {
+      'Content-Type': MIME_DOCX,
+      'Content-Disposition': `attachment; filename="${dateiname}"`,
+      'Content-Length': String(datei.length),
+      // Ein Schreiben aus einer Betreuungsakte gehoert in keinen
+      // Zwischenspeicher.
+      'Cache-Control': 'no-store, must-revalidate',
+    },
+  })
+}

src/app/(app)/schreiben/eml/route.ts

@@ -0,0 +1,64 @@
+import { NextResponse } from 'next/server'
+import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
+import { emailFassung, siehtAusWieEmail } from '@/lib/schreiben/email'
+import { emlErzeugen } from '@/lib/schreiben/eml'
+import { dateinameFuerSchreiben, istSchreibenArt } from '@/lib/schreiben/arten'
+import { heuteAlsTag } from '@/lib/fristen/datum'
+
+/**
+ * Das Schreiben als .eml-Entwurf herunterladen.
+ *
+ * Gleicher Aufbau wie der Word-Download (../docx/route.ts): POST, weil der
+ * Text mitkommt und nicht in die Adresszeile gehoert; Zugriff wird hier
+ * geprueft, weil sich eine Route unmittelbar aufrufen laesst.
+ */
+
+export const dynamic = 'force-dynamic'
+
+export async function POST(anfrage: Request): Promise<Response> {
+  let formular: FormData
+  try {
+    formular = await anfrage.formData()
+  } catch {
+    return NextResponse.json({ fehler: 'Ungültige Anfrage.' }, { status: 400 })
+  }
+
+  const betreuteId = String(formular.get('betreuteId') ?? '')
+  const rohArt = String(formular.get('art') ?? '')
+  const text = String(formular.get('text') ?? '')
+  const betreff = String(formular.get('betreff') ?? '').trim()
+  const adresse = String(formular.get('empfaengerEmail') ?? '').trim()
+  const empfaenger = String(formular.get('empfaengerName') ?? '').trim()
+
+  if (!betreuteId || !istSchreibenArt(rohArt) || text.trim().length < 30) {
+    return NextResponse.json({ fehler: 'Unvollständige Angaben.' }, { status: 400 })
+  }
+  if (!siehtAusWieEmail(adresse)) {
+    return NextResponse.json(
+      { fehler: 'Für diesen Empfänger ist keine E-Mail-Adresse hinterlegt.' },
+      { status: 400 },
+    )
+  }
+
+  try {
+    await erfordereZugang(betreuteId, 'DOKUMENTE', 'lesen')
+  } catch (ausnahme) {
+    if (ausnahme instanceof ZugriffVerweigert) {
+      return NextResponse.json({ fehler: ausnahme.message }, { status: 403 })
+    }
+    throw ausnahme
+  }
+
+  const fassung = emailFassung(text, betreff)
+  const datei = emlErzeugen({ an: adresse, betreff: fassung.betreff, text: fassung.text })
+  const dateiname = dateinameFuerSchreiben(rohArt, empfaenger || null, heuteAlsTag(), 'eml')
+
+  return new NextResponse(new Uint8Array(datei), {
+    headers: {
+      'Content-Type': 'message/rfc822',
+      'Content-Disposition': `attachment; filename="${dateiname}"`,
+      'Content-Length': String(datei.length),
+      'Cache-Control': 'no-store, must-revalidate',
+    },
+  })
+}

src/app/(app)/schreiben/neu/page.tsx

@@ -0,0 +1,149 @@
+import type { Metadata } from 'next'
+import { redirect } from 'next/navigation'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { AlertCircle, Scale } from 'lucide-react'
+import { SeitenKopf } from '@/components/seiten-kopf'
+import { SchreibenEditor } from '@/components/schreiben/schreiben-editor'
+import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { db, nichtGeloescht } from '@/lib/db'
+import { entwurfBauen } from '@/lib/schreiben/entwurf'
+import { SCHREIBEN_EIGENSCHAFTEN, istSchreibenArt } from '@/lib/schreiben/arten'
+import { VorlagenWahl } from '@/components/schreiben/vorlagen-wahl'
+
+export const metadata: Metadata = { title: 'Schreiben' }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Ein Schreiben erzeugen, bearbeiten, ausgeben und ablegen.
+ *
+ * Eine Seite für alle Arten und alle drei Empfängerwege — statt die
+ * Bearbeitung dreimal an Vertrag, Vorgang und Freitext nachzubauen. Die
+ * bestehenden Seiten verlinken hierher.
+ *
+ * Der Fall ohne Bezug ist ausdrücklich vorgesehen: Am Anfang einer
+ * Betreuung schreibt man an Stellen, zu denen es noch keinen Datensatz
+ * gibt — man fragt ja gerade an, um zu erfahren, ob dort etwas besteht.
+ */
+export default async function SchreibenSeite({
+  searchParams,
+}: {
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const parameter = await searchParams
+  const benutzer = await erfordereBenutzer('/schreiben/neu')
+  const aktive = await aktiveBetreute(benutzer)
+  if (!aktive) redirect('/ersteinrichtung')
+
+  const { darfSchreiben } = await erfordereZugang(aktive.id, 'DOKUMENTE', 'lesen')
+  if (!darfSchreiben('DOKUMENTE')) redirect('/dokumente')
+
+  const text = (name: string): string => {
+    const wert = parameter[name]
+    return typeof wert === 'string' ? wert.trim() : ''
+  }
+
+  const rohArt = text('art')
+  const art = istSchreibenArt(rohArt) ? rohArt : 'FREI'
+  const eigenschaften = SCHREIBEN_EIGENSCHAFTEN[art]
+
+  let entwurf
+  try {
+    entwurf = await entwurfBauen({
+      betreuteId: aktive.id,
+      benutzer,
+      art,
+      vertragId: text('vertragId') || null,
+      vorgangId: text('vorgangId') || null,
+      vorlageId: text('vorlageId') || null,
+    })
+  } catch (ausnahme) {
+    // Fehlender oder fremder Bezug: Das ist kein Absturz, sondern eine
+    // Angabe, die nicht stimmt. Die Seite sagt es und bietet den freien
+    // Weg an, statt den Benutzer vor eine Fehlerseite zu setzen.
+    const meldung =
+      ausnahme instanceof Error ? ausnahme.message : 'Der Entwurf ließ sich nicht bauen.'
+    return (
+      <div className="max-w-3xl space-y-6">
+        <SeitenKopf titel="Schreiben" beschreibung={eigenschaften.beschriftung} />
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>
+            {meldung} Du kannst stattdessen ein{' '}
+            <a href="/schreiben/neu?art=FREI" className="underline">
+              freies Schreiben
+            </a>{' '}
+            erzeugen.
+          </AlertDescription>
+        </Alert>
+      </div>
+    )
+  }
+
+  const vorlagen =
+    art === 'FREI'
+      ? await db.schreibvorlage.findMany({
+          where: { betreuteId: aktive.id, ...nichtGeloescht },
+          select: { id: true, name: true },
+          orderBy: { name: 'asc' },
+        })
+      : []
+
+  const kontakte = await db.kontakt.findMany({
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    select: {
+      id: true,
+      name: true,
+      organisation: true,
+      strasse: true,
+      plz: true,
+      ort: true,
+      email: true,
+    },
+    orderBy: [{ organisation: 'asc' }, { name: 'asc' }],
+    take: 200,
+  })
+
+  return (
+    <div className="max-w-3xl space-y-6">
+      <SeitenKopf
+        titel={eigenschaften.beschriftung}
+        beschreibung="Bearbeiten, als Word-Datei herunterladen, in die Akte legen — und eine Wiedervorlage setzen, damit das Warten nicht vergessen geht."
+        pfad={[{ titel: 'Dokumente', href: '/dokumente' }, { titel: 'Schreiben' }]}
+      />
+
+      {art === 'FREI' && vorlagen.length > 0 && (
+        <VorlagenWahl vorlagen={vorlagen} aktiveVorlageId={text('vorlageId') || null} />
+      )}
+
+      <SchreibenEditor
+        // Der Editor haelt den Text als eigenen State. Wechselt die Vorlage,
+        // muss er neu aufsetzen - sonst ueberlebt der alte Entwurf die
+        // Navigation und die Vorlage kommt nie im Textfeld an.
+        key={text('vorlageId') || 'ohne-vorlage'}
+        betreuteId={aktive.id}
+        art={art}
+        entwurf={{
+          betreff: entwurf.betreff,
+          text: entwurf.text,
+          empfaengerName: entwurf.empfaengerName,
+          empfaengerAnschrift: entwurf.empfaengerAnschrift,
+          wiedervorlageAm: entwurf.wiedervorlageAm,
+        }}
+        kontakte={kontakte}
+        vertragId={entwurf.vertragId}
+        vorgangId={entwurf.vorgangId}
+        fristBegruendung={eigenschaften.fristBegruendung}
+        warnungen={entwurf.warnungen}
+      />
+
+      <Alert variant="hinweis">
+        <Scale aria-hidden="true" />
+        <AlertDescription>
+          Der vorgeschlagene Wortlaut ist ein Entwurf, keine Rechtsberatung. Bei einem
+          genehmigungspflichtigen Geschäft gehört die Genehmigung des Betreuungsgerichts vor den
+          Versand — nicht danach.
+        </AlertDescription>
+      </Alert>
+    </div>
+  )
+}

src/app/(app)/vertraege/[id]/page.tsx

@@ -18,7 +18,12 @@ import {
   kuendigungsplan,
   laufzeitAusVertrag,
 } from '@/lib/vertraege/kuendigung'
-import { anfrageStatus, rueckkaufswertAnschreiben } from '@/lib/vertraege/rueckkaufswert'
+import {
+  anfrageStatus,
+  rueckkaufswertAnschreiben,
+  wertHistorie,
+} from '@/lib/vertraege/rueckkaufswert'
+import { wertalterBestimmen } from '@/lib/finanzen/wertalter'
 import {
   BEWERTUNG_BESCHRIFTUNG,
   BEWERTUNG_ERKLAERUNG,
@@ -44,8 +49,9 @@ export default async function VertragDetail({ params }: { params: Promise<{ id:
   const vertrag = await db.vertrag.findFirst({
     where: { id, betreuteId: aktive.id, ...nichtGeloescht },
     include: {
+      // Ueber die Verknuepfung, nicht ueber die Art - siehe wertHistorie().
       vermoegensposten: {
-        where: { art: 'VERSICHERUNG', ...nichtGeloescht },
+        where: nichtGeloescht,
         include: { wertstaende: { orderBy: { stichtag: 'desc' } } },
       },
     },
@@ -76,7 +82,7 @@ export default async function VertragDetail({ params }: { params: Promise<{ id:
     heute,
   })
 
-  const wertstaende = vertrag.vermoegensposten[0]?.wertstaende ?? []
+  const wertstaende = wertHistorie(vertrag.vermoegensposten)
 
   return (
     <div className="space-y-6">
@@ -226,6 +232,9 @@ export default async function VertragDetail({ params }: { params: Promise<{ id:
           tageSeitAnfrage={anfrage.tageSeitAnfrage}
           anschreiben={anschreiben}
           stichtagVorschlag={alsIsoTag(heute)}
+          alterHinweis={
+            wertalterBestimmen(wertstaende[0]?.stichtag ?? null, heute)?.hinweis ?? null
+          }
           werte={wertstaende.map((w) => ({
             id: w.id,
             stichtag: w.stichtag.toISOString(),

src/app/(app)/vertraege/neu/page.tsx

@@ -1,11 +1,62 @@
 import { redirect } from 'next/navigation'
+import { Info } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
 import { SeitenKopf } from '@/components/seiten-kopf'
 import { LEERER_VERTRAG, VertragFormular } from '@/components/vertraege/vertrag-formular'
 import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { alsZahlRhythmus, type Rhythmus } from '@/lib/finanzen/wiederkehrend'
+import { betragFormatieren } from '@/lib/finanzen/betrag'
 
 export const dynamic = 'force-dynamic'
 
-export default async function VertragAnlegen() {
+/**
+ * Uebernimmt eine Vorbelegung aus der Adresszeile.
+ *
+ * Sie kommt von "Wiederkehrende Zahlungen": Dort steht schon, wer da
+ * abbucht und wie viel. Diese Angaben noch einmal abzutippen waere genau
+ * die Arbeit, die die Auswertung ersparen soll.
+ *
+ * Uebernommen wird nur, was aus dem Kontoauszug ablesbar ist - Gesellschaft,
+ * Beitrag, Rhythmus. Die Bezeichnung und die Vertragsart bleiben leer: Was
+ * fuer ein Vertrag das ist, steht nicht im Auszug, und eine geratene
+ * Vorbelegung wird uebersehen statt korrigiert.
+ */
+function vorbelegung(parameter: Record<string, string | string[] | undefined>) {
+  const text = (name: string): string => {
+    const wert = parameter[name]
+    return typeof wert === 'string' ? wert.trim() : ''
+  }
+
+  const werte = { ...LEERER_VERTRAG }
+  let etwasUebernommen = false
+
+  const gesellschaft = text('gesellschaft')
+  if (gesellschaft) {
+    werte.gesellschaft = gesellschaft.slice(0, 200)
+    etwasUebernommen = true
+  }
+
+  const cent = text('beitragCent')
+  if (/^[0-9]{1,15}$/.test(cent)) {
+    werte.beitrag = betragFormatieren(BigInt(cent))
+    etwasUebernommen = true
+  }
+
+  const rhythmus = alsZahlRhythmus(text('rhythmus') as Rhythmus)
+  if (rhythmus) {
+    werte.rhythmus = rhythmus as typeof werte.rhythmus
+    etwasUebernommen = true
+  }
+
+  return { werte, etwasUebernommen }
+}
+
+export default async function VertragAnlegen({
+  searchParams,
+}: {
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const parameter = await searchParams
   const benutzer = await erfordereBenutzer('/vertraege/neu')
   const aktive = await aktiveBetreute(benutzer)
   if (!aktive) return null
@@ -13,6 +64,8 @@ export default async function VertragAnlegen() {
   const { darfSchreiben } = await erfordereZugang(aktive.id, 'VERTRAEGE', 'lesen')
   if (!darfSchreiben('VERTRAEGE')) redirect('/vertraege')
 
+  const { werte, etwasUebernommen } = vorbelegung(parameter)
+
   return (
     <div className="space-y-6">
       <SeitenKopf
@@ -25,7 +78,18 @@ export default async function VertragAnlegen() {
         ]}
       />
 
-      <VertragFormular betreuteId={aktive.id} werte={LEERER_VERTRAG} />
+      {etwasUebernommen && (
+        <Alert variant="hinweis">
+          <Info aria-hidden="true" />
+          <AlertDescription>
+            Gesellschaft, Beitrag und Rhythmus sind aus den wiederkehrenden Zahlungen
+            übernommen. Bezeichnung und Art musst du selbst wählen — was für ein Vertrag das
+            ist, steht nicht im Kontoauszug.
+          </AlertDescription>
+        </Alert>
+      )}
+
+      <VertragFormular betreuteId={aktive.id} werte={werte} />
     </div>
   )
 }

src/app/(app)/vertraege/page.tsx

@@ -1,5 +1,5 @@
 import Link from 'next/link'
-import { Plus, Shield } from 'lucide-react'
+import { FileArchive, Plus, Shield } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
@@ -22,10 +22,13 @@ import {
 import {
   BEWERTUNG_BESCHRIFTUNG,
   jahresbeitragCent,
+  kannRueckkaufswertHaben,
   RHYTHMUS_BESCHRIFTUNG,
   VERTRAG_ART_BESCHRIFTUNG,
   VERTRAG_STATUS_BESCHRIFTUNG,
 } from '@/lib/vertraege/konstanten'
+import { juengsterWert } from '@/lib/vertraege/rueckkaufswert'
+import { wertalterBestimmen } from '@/lib/finanzen/wertalter'
 import { formatCent, formatDatum } from '@/lib/utils'
 
 export const dynamic = 'force-dynamic'
@@ -48,8 +51,10 @@ export default async function VertraegeUebersicht() {
   const vertraege = await db.vertrag.findMany({
     where: { betreuteId: aktive.id, ...nichtGeloescht },
     include: {
+      // Ueber die Verknuepfung, nicht ueber die Art: Ein von Hand als
+      // "Sonstiges" angelegter Posten meint denselben Vertrag.
       vermoegensposten: {
-        where: { art: 'VERSICHERUNG', ...nichtGeloescht },
+        where: nichtGeloescht,
         include: { wertstaende: { orderBy: { stichtag: 'desc' }, take: 1 } },
       },
     },
@@ -71,6 +76,8 @@ export default async function VertraegeUebersicht() {
     })
     const ampel = kuendigungsampel(plan)
 
+    const letzterWert = juengsterWert(vertrag.vermoegensposten)
+
     const jahr = jahresbeitragCent(vertrag.beitragCent, vertrag.rhythmus)
     if (jahr && vertrag.status === 'AKTIV') jahresbeitragSumme += jahr
 
@@ -97,11 +104,10 @@ export default async function VertraegeUebersicht() {
       beitragCent: centZuZahl(vertrag.beitragCent),
       rhythmus: vertrag.rhythmus,
       bewertung: vertrag.bewertungSozialhilfe,
-      rueckkaufswertCent: centZuZahl(
-        vertrag.vermoegensposten[0]?.wertstaende[0]?.wertCent ?? null,
-      ),
-      rueckkaufswertStichtag:
-        vertrag.vermoegensposten[0]?.wertstaende[0]?.stichtag.toISOString() ?? null,
+      rueckkaufswertCent: centZuZahl(letzterWert?.wertCent ?? null),
+      rueckkaufswertStichtag: letzterWert?.stichtag.toISOString() ?? null,
+      rueckkaufswertAlter: wertalterBestimmen(letzterWert?.stichtag ?? null, heute),
+      wertErwartet: kannRueckkaufswertHaben(vertrag.art),
       ampel,
     }
   })
@@ -114,12 +120,20 @@ export default async function VertraegeUebersicht() {
         pfad={[{ titel: 'Übersicht', href: '/heute' }, { titel: 'Verträge' }]}
         aktionen={
           schreiben && (
+            <>
+              <Button asChild variant="outline">
+                <Link href="/vertraege/serienabfrage/seite">
+                  <FileArchive aria-hidden="true" />
+                  Rückkaufswerte anfragen
+                </Link>
+              </Button>
               <Button asChild>
                 <Link href="/vertraege/neu">
                   <Plus aria-hidden="true" />
                   Vertrag anlegen
                 </Link>
               </Button>
+            </>
           )
         }
       />
@@ -193,11 +207,22 @@ export default async function VertraegeUebersicht() {
                       )}
                     </TableCell>
                     <TableCell className="text-right tabular-nums">
+                      {zeile.rueckkaufswertStichtag ? (
+                        <>
                           {formatCent(zeile.rueckkaufswertCent)}
-                      {zeile.rueckkaufswertStichtag && (
                           <span className="block text-xs text-muted-foreground">
                             {formatDatum(zeile.rueckkaufswertStichtag)}
                           </span>
+                          {zeile.rueckkaufswertAlter?.veraltet && (
+                            <Badge variant="gelb" className="mt-1">
+                              {zeile.rueckkaufswertAlter.hinweis}
+                            </Badge>
+                          )}
+                        </>
+                      ) : (
+                        <span className="text-sm font-normal text-muted-foreground">
+                          {zeile.wertErwartet ? 'noch nicht erfasst' : '–'}
+                        </span>
                       )}
                     </TableCell>
                     <TableCell>

src/app/(app)/vertraege/serienabfrage/route.ts

@@ -0,0 +1,74 @@
+import { NextResponse } from 'next/server'
+import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
+import { serienlaufDurchfuehren } from '@/lib/vertraege/serienlauf'
+import { tagAusText } from '@/lib/finanzen/datum'
+
+/**
+ * Fuehrt die Serienabfrage durch und liefert das ZIP.
+ *
+ * POST wie bei den anderen Downloads: Die Auswahl kommt mit, und der Lauf
+ * hat Nebenwirkungen (Dokumente, Fristen, Anfragedatum) - ein GET, das
+ * schreibt, waere eine Falle fuer jeden Vorabruf durch den Browser.
+ *
+ * Die Nebenwirkungen passieren VOR der Auslieferung. Faellt danach noch
+ * etwas beim Herunterladen aus, sind Akte und Fristen trotzdem korrekt -
+ * und die Schreiben liegen als PDF ohnehin in der Akte.
+ */
+
+export const dynamic = 'force-dynamic'
+
+export async function POST(anfrage: Request): Promise<Response> {
+  let formular: FormData
+  try {
+    formular = await anfrage.formData()
+  } catch {
+    return NextResponse.json({ fehler: 'Ungültige Anfrage.' }, { status: 400 })
+  }
+
+  const betreuteId = String(formular.get('betreuteId') ?? '')
+  const stichtagRoh = String(formular.get('stichtag') ?? '').trim()
+  const vertragIds = formular
+    .getAll('vertragId')
+    .map((wert) => String(wert).trim())
+    .filter(Boolean)
+
+  if (!betreuteId || vertragIds.length === 0) {
+    return NextResponse.json({ fehler: 'Es ist kein Vertrag ausgewählt.' }, { status: 400 })
+  }
+  // Obergrenze als Schutz vor Unsinn - real sind es fuenf bis zehn.
+  if (vertragIds.length > 100) {
+    return NextResponse.json({ fehler: 'Zu viele Verträge auf einmal.' }, { status: 400 })
+  }
+
+  const stichtag = tagAusText(stichtagRoh)
+  if (!stichtag) {
+    return NextResponse.json({ fehler: 'Bitte einen gültigen Stichtag angeben.' }, { status: 400 })
+  }
+
+  let benutzer
+  try {
+    const zugang = await erfordereZugang(betreuteId, 'VERTRAEGE', 'schreiben')
+    benutzer = zugang.benutzer
+  } catch (ausnahme) {
+    if (ausnahme instanceof ZugriffVerweigert) {
+      return NextResponse.json({ fehler: ausnahme.message }, { status: 403 })
+    }
+    throw ausnahme
+  }
+
+  const ergebnis = await serienlaufDurchfuehren({
+    betreuteId,
+    vertragIds,
+    stichtag,
+    benutzer: { id: benutzer.id, name: benutzer.name, email: benutzer.email },
+  })
+
+  return new NextResponse(new Uint8Array(ergebnis.zip), {
+    headers: {
+      'Content-Type': 'application/zip',
+      'Content-Disposition': `attachment; filename="${ergebnis.dateiname}"`,
+      'Content-Length': String(ergebnis.zip.length),
+      'Cache-Control': 'no-store, must-revalidate',
+    },
+  })
+}

src/app/(app)/vertraege/serienabfrage/seite/page.tsx

@@ -0,0 +1,92 @@
+import type { Metadata } from 'next'
+import { redirect } from 'next/navigation'
+import { Scale } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { SeitenKopf } from '@/components/seiten-kopf'
+import {
+  SerienabfrageFormular,
+  type SerienZeile,
+} from '@/components/vertraege/serienabfrage-formular'
+import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { db, nichtGeloescht } from '@/lib/db'
+import { kandidatenBewerten } from '@/lib/vertraege/serienabfrage'
+import { VERTRAG_ART_BESCHRIFTUNG } from '@/lib/vertraege/konstanten'
+import { heuteAlsTag } from '@/lib/fristen/datum'
+
+export const metadata: Metadata = { title: 'Rückkaufswerte anfragen' }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Die Serienabfrage: alle Rückkaufswerte in einem Zug.
+ *
+ * Liegt unter /vertraege/serienabfrage/seite, weil /vertraege/serienabfrage
+ * die POST-Route ist, die das ZIP liefert. Die Trennung ist Absicht: Die
+ * Route hat Nebenwirkungen und gehört nicht hinter einen GET.
+ */
+export default async function SerienabfrageSeite() {
+  const benutzer = await erfordereBenutzer('/vertraege/serienabfrage/seite')
+  const aktive = await aktiveBetreute(benutzer)
+  if (!aktive) redirect('/ersteinrichtung')
+
+  const { darfSchreiben } = await erfordereZugang(aktive.id, 'VERTRAEGE', 'lesen')
+  if (!darfSchreiben('VERTRAEGE')) redirect('/vertraege')
+
+  const vertraege = await db.vertrag.findMany({
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    select: {
+      id: true,
+      bezeichnung: true,
+      gesellschaft: true,
+      art: true,
+      status: true,
+      rueckkaufswertAngefragtAm: true,
+    },
+  })
+
+  const bewertet = kandidatenBewerten(vertraege)
+
+  // Vertraege ohne jede Aussicht auf einen Rueckkaufswert (Strom, Telefon,
+  // Rundfunk) wuerden die Liste nur verlaengern - sie bleiben draussen.
+  // Alles andere steht drin, notfalls mit Hindernis.
+  const zeilen: SerienZeile[] = bewertet
+    .filter(
+      (k) => k.moeglich || k.hindernis !== 'Diese Vertragsart bildet keinen Rückkaufswert.',
+    )
+    .map((k) => ({
+      vertragId: k.vertrag.id,
+      bezeichnung: k.vertrag.bezeichnung,
+      gesellschaft: k.vertrag.gesellschaft,
+      artBeschriftung: VERTRAG_ART_BESCHRIFTUNG[k.vertrag.art],
+      moeglich: k.moeglich,
+      hindernis: k.hindernis,
+      vorausgewaehlt: k.vorausgewaehlt,
+    }))
+
+  return (
+    <div className="max-w-3xl space-y-6">
+      <SeitenKopf
+        titel="Rückkaufswerte anfragen"
+        beschreibung="Alle Lebens- und Rentenversicherungen in einem Zug — ein ZIP mit einem Schreiben je Gesellschaft, die Nachweise in der Akte, die Wiedervorlagen gesetzt."
+        pfad={[
+          { titel: 'Verträge', href: '/vertraege' },
+          { titel: 'Rückkaufswerte anfragen' },
+        ]}
+      />
+
+      <SerienabfrageFormular
+        betreuteId={aktive.id}
+        zeilen={zeilen}
+        stichtagVorschlag={heuteAlsTag().toISOString().slice(0, 10)}
+      />
+
+      <Alert variant="hinweis">
+        <Scale aria-hidden="true" />
+        <AlertDescription>
+          Die Schreiben sind Entwürfe zum Ausdrucken und Unterschreiben — versendet wird nichts
+          automatisch. Keine Rechtsberatung; bei Fragen zur Verwertungspflicht entscheidet der
+          Sozialhilfeträger.
+        </AlertDescription>
+      </Alert>
+    </div>
+  )
+}

src/app/(app)/vorgaenge/[id]/page.tsx

@@ -1,6 +1,6 @@
 import { notFound } from 'next/navigation'
 import Link from 'next/link'
-import { ArrowLeft, Clock } from 'lucide-react'
+import { ArrowLeft, FileDown, Clock } from 'lucide-react'
 import type { VorgangStatus } from '@prisma/client'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
@@ -56,6 +56,7 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
       buchungen: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
       kontaktprotokolle: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
       verknuepfungen: { include: { dokument: true } },
+      ansprechpartner: true,
     },
   })
   if (!vorgang) notFound()
@@ -65,6 +66,14 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
 
   const offen = oeffnen('Vorgang', vorgang)
 
+  // Kontakte dieser Akte fuer die Wahl des Ansprechpartners.
+  const kontakte = await db.kontakt.findMany({
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    select: { id: true, name: true, organisation: true },
+    orderBy: [{ organisation: 'asc' }, { name: 'asc' }],
+    take: 300,
+  })
+
   // --- Statuswechsel aus dem Audit-Log --------------------------------------
   // Das Log ist ohnehin der Nachweis gegenueber dem Gericht; daraus die
   // Statuschronik zu lesen, spart eine zusaetzliche Tabelle.
@@ -182,6 +191,12 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
           aktenzeichenGericht: aktive.aktenzeichenGericht,
           betreuungsgericht: aktive.betreuungsgericht,
         },
+        ansprechpartner: vorgang.ansprechpartner
+          ? {
+              name: vorgang.ansprechpartner.name,
+              anrede: vorgang.ansprechpartner.anrede,
+            }
+          : null,
       })
     : null
 
@@ -245,6 +260,14 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
                 darfSchreiben={schreiben}
               />
             )}
+            {schreiben && (
+              <Button asChild variant="outline">
+                <Link href={`/schreiben/neu?art=SACHSTAND&vorgangId=${vorgang.id}`}>
+                  <FileDown aria-hidden="true" />
+                  Als Word-Datei und in die Akte
+                </Link>
+              </Button>
+            )}
             {schreiben && <VorgangLoeschen vorgangId={vorgang.id} titel={vorgang.titel} />}
           </>
         }
@@ -277,6 +300,40 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
             <p className="font-medium">{vorgang.aktenzeichen ?? '–'}</p>
           </div>
 
+          {/* Wen frage ich, bevor ich anrufe? Durchwahl und Adresse
+              stehen dabei - sonst schlaegt man sie doch wieder nach. */}
+          <div className="space-y-1">
+            <p className="text-sm text-muted-foreground">Ansprechpartner</p>
+            {vorgang.ansprechpartner ? (
+              <>
+                <p className="font-medium">
+                  <Link
+                    href={`/kontakte/${vorgang.ansprechpartner.id}`}
+                    className="hover:underline"
+                  >
+                    {vorgang.ansprechpartner.name}
+                  </Link>
+                </p>
+                {vorgang.ansprechpartner.organisation && (
+                  <p className="text-sm text-muted-foreground">
+                    {vorgang.ansprechpartner.organisation}
+                  </p>
+                )}
+                {(vorgang.ansprechpartner.telefon || vorgang.ansprechpartner.email) && (
+                  <p className="text-sm text-muted-foreground">
+                    {[vorgang.ansprechpartner.telefon, vorgang.ansprechpartner.email]
+                      .filter(Boolean)
+                      .join(' · ')}
+                  </p>
+                )}
+              </>
+            ) : (
+              <p className="text-sm text-muted-foreground">
+                Keiner benannt — Schreiben gehen an „Sehr geehrte Damen und Herren“.
+              </p>
+            )}
+          </div>
+
           <div className="space-y-1 sm:col-span-2">
             <p className="text-sm text-muted-foreground">Nächster Schritt</p>
             <p className="font-medium">
@@ -355,6 +412,7 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
                 betreuteId={aktive.id}
                 vorgangId={vorgang.id}
                 abbrechenHref={`/vorgaenge/${vorgang.id}`}
+                kontakte={kontakte}
                 werte={{
                   titel: vorgang.titel,
                   kategorie: vorgang.kategorie,
@@ -363,6 +421,7 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
                   beschreibung: offen.beschreibung ?? null,
                   gegenstelle: vorgang.gegenstelle,
                   aktenzeichen: vorgang.aktenzeichen,
+                  ansprechpartnerId: vorgang.ansprechpartnerId,
                   verantwortlich: vorgang.verantwortlich,
                   naechsterSchritt: vorgang.naechsterSchritt,
                   faelligAm: vorgang.faelligAm,

src/app/(app)/vorgaenge/neu/page.tsx

@@ -10,6 +10,7 @@ import { VorlagenKacheln } from '@/components/vorgaenge/vorlagen-kacheln'
 import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
 import { GENEHMIGUNG_WARNUNG } from '@/lib/vorgaenge/genehmigungskette'
 import { vorlageFinden } from '@/lib/vorgaenge/vorlagen'
+import { db, nichtGeloescht } from '@/lib/db'
 import { formatDatum } from '@/lib/utils'
 import { addDays } from 'date-fns'
 
@@ -31,6 +32,14 @@ export default async function NeuerVorgangSeite({
 
   await erfordereZugang(aktive.id, 'VORGAENGE', 'schreiben')
 
+  // Kontakte dieser Akte fuer die Wahl des Ansprechpartners.
+  const kontakte = await db.kontakt.findMany({
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    select: { id: true, name: true, organisation: true },
+    orderBy: [{ organisation: 'asc' }, { name: 'asc' }],
+    take: 300,
+  })
+
   const auswahl = await searchParams
   const vorlage = auswahl.vorlage ? vorlageFinden(auswahl.vorlage) : undefined
   const leer = auswahl.leer === '1'
@@ -155,6 +164,7 @@ export default async function NeuerVorgangSeite({
         betreuteId={aktive.id}
         vorlageSchluessel={vorlage?.schluessel ?? null}
         abbrechenHref="/vorgaenge"
+        kontakte={kontakte}
         werte={{
           titel: vorlage?.titel ?? '',
           kategorie: vorlage?.kategorie ?? 'SONSTIGES',
@@ -163,6 +173,7 @@ export default async function NeuerVorgangSeite({
           beschreibung: vorlage?.beschreibung ?? null,
           gegenstelle: null,
           aktenzeichen: null,
+          ansprechpartnerId: null,
           verantwortlich: benutzer.name,
           naechsterSchritt: vorlage?.aufgaben[0]?.titel ?? null,
           faelligAm: null,

src/app/(auth)/anmelden/page.tsx

@@ -4,6 +4,8 @@ import { ShieldCheck } from 'lucide-react'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { aktuellerBenutzer } from '@/lib/auth/sitzung'
 import { db } from '@/lib/db'
+import { passkeysMoeglich } from '@/lib/auth/passkey'
+import { PasskeyAnmeldung } from '@/components/passkey-anmeldung'
 import { AnmeldeFormular } from './formular'
 
 export const metadata: Metadata = { title: 'Anmelden' }
@@ -32,10 +34,14 @@ export default async function AnmeldenSeite({
           <CardTitle>Anmelden</CardTitle>
           <CardDescription>
             E-Mail, Passwort und der Code aus deiner Authenticator-App — alle drei zusammen.
+            {passkeysMoeglich() && ' Oder in einem Schritt mit deinem Passkey.'}
           </CardDescription>
         </CardHeader>
-        <CardContent>
+        <CardContent className="space-y-5">
           <AnmeldeFormular weiter={weiter} />
+          {/* Nur wenn der Server ueber https laeuft - sonst gibt der
+              Browser WebAuthn gar nicht frei. */}
+          {passkeysMoeglich() && <PasskeyAnmeldung weiter={weiter} />}
         </CardContent>
       </Card>
 
@@ -43,7 +49,9 @@ export default async function AnmeldenSeite({
         <ShieldCheck className="mt-0.5 size-4 shrink-0" aria-hidden="true" />
         <p>
           Hier liegen Gesundheits- und Vermögensdaten einer betreuten Person. Der zweite Faktor ist
-          deshalb Pflicht und lässt sich nicht abschalten.
+          deshalb Pflicht und lässt sich nicht abschalten. Ein Passkey erfüllt ihn ebenfalls: Er
+          verlangt Fingerabdruck, Gesicht oder Geräte-PIN — und lässt sich, anders als ein
+          abgetippter Code, nicht auf einer nachgebauten Seite abgreifen.
         </p>
       </div>
     </>

src/app/(auth)/ersteinrichtung/page.tsx

@@ -21,8 +21,16 @@ export const dynamic = 'force-dynamic'
 export default async function ErsteinrichtungSeite() {
   const anzahlBenutzer = await db.user.count({ where: { geloeschtAm: null } })
 
+  // Die Sperrzeile ist die eigentliche Auskunft darueber, ob eingerichtet
+  // wurde. Der Benutzerzaehler allein genuegt nicht: Liegt der erste Zugang
+  // im Papierkorb, stuende Schritt 1 sonst wieder offen.
+  const sperre = await db.ersteinrichtung.findUnique({
+    where: { id: 'einmalig' },
+    select: { id: true },
+  })
+
   // --- Schritt 1: Es gibt noch keinen Zugang -------------------------------
-  if (anzahlBenutzer === 0) {
+  if (anzahlBenutzer === 0 && !sperre) {
     return (
       <>
         <Card>

src/app/(auth)/ersteinrichtung/zugang-formular.tsx

@@ -61,6 +61,23 @@ export function ZugangFormular() {
         />
       </Feld>
 
+      <Feld
+        id="geheimnis"
+        beschriftung="Einrichtungsgeheimnis"
+        erklaerung="Der Wert von ERSTEINRICHTUNG_GEHEIMNIS aus der .env. Er verhindert, dass jemand
+          anders diesen Zugang anlegt, solange die Seite noch offensteht."
+        fehler={zustand.felder?.geheimnis}
+        pflicht
+      >
+        <Input
+          name="geheimnis"
+          type="password"
+          autoComplete="off"
+          spellCheck={false}
+          required
+        />
+      </Feld>
+
       <Feld
         id="passwort"
         beschriftung="Passwort"

src/app/api/dokumente/datei/[signatur]/route.ts

@@ -2,7 +2,7 @@ import { NextResponse } from 'next/server'
 import type { Modul } from '@prisma/client'
 import { protokollieren } from '@/lib/audit'
 import { darf } from '@/lib/auth/rollen'
-import { aktuellerBenutzer } from '@/lib/auth/sitzung'
+import { benutzerFuerRoute } from '@/lib/auth/sitzung'
 import { db, nichtGeloescht } from '@/lib/db'
 import { typErkennen } from '@/lib/speicher/dateityp'
 import { betreuteIdAusSchluessel, lesen } from '@/lib/speicher'
@@ -55,7 +55,10 @@ function nurText(status: number, meldung: string): NextResponse {
 export async function GET(
   _anfrage: Request,
   { params }: { params: Promise<{ signatur: string }> },
-): Promise<NextResponse> {
+  // Response statt NextResponse: Die Abweisung ohne zweiten Faktor kommt
+  // aus benutzerFuerRoute() und ist eine schlichte Response. NextResponse
+  // erbt davon, die uebrigen Rueckgaben passen also weiterhin.
+): Promise<Response> {
   const { signatur } = await params
 
   // 1. Signatur und Ablauf
@@ -70,9 +73,14 @@ export async function GET(
   }
   const schluessel = geprueft.schluessel
 
-  // 2. Angemeldet?
-  const benutzer = await aktuellerBenutzer()
-  if (!benutzer) return nurText(401, 'Bitte melde dich an.')
+  // 2. Angemeldet - und mit abgeschlossenem zweitem Faktor.
+  //
+  // Frueher stand hier nur die Frage nach der Anmeldung. Damit kam jemand,
+  // der die TOTP-Einrichtung nie abgeschlossen hatte, an jedes Dokument -
+  // die MFA-Pflicht galt nur fuer Seiten, nicht fuer diesen Abruf.
+  const angemeldet = await benutzerFuerRoute()
+  if (!angemeldet.ok) return angemeldet.antwort
+  const benutzer = angemeldet.benutzer
 
   // 3. Zugriff auf genau diese betreute Person
   const betreuteId = betreuteIdAusSchluessel(schluessel)

src/app/api/gesundheit/route.ts

@@ -1,12 +1,18 @@
 import { NextResponse } from 'next/server'
 import { db } from '@/lib/db'
 import { COMMIT, VERSION } from '@/lib/version'
+import { speicherZustand } from '@/lib/speicher/pruefung'
 
 /**
  * Betriebsbereitschaft fuer den Healthcheck in docker-compose.
  *
  * Bewusst ohne Anmeldung, aber ohne jede Auskunft ueber Inhalte: geprueft
- * wird nur, ob die Datenbank antwortet.
+ * wird, ob Datenbank und Dateiablage antworten.
+ *
+ * Nur die Datenbank entscheidet ueber 503. Ein gestoerter Speicher wird
+ * gemeldet, laesst den Behaelter aber laufen - sonst wuerde der
+ * Healthcheck ihn neu starten, und die ganze Akte waere weg wegen eines
+ * Teils, den ein Neustart nicht repariert.
  *
  * Die Version steht dabei: sie wird beim Aktualisieren gebraucht, um zu
  * sehen, ob der neue Stand tatsaechlich laeuft. Das ist keine Auskunft
@@ -19,14 +25,29 @@ export const dynamic = 'force-dynamic'
 export async function GET() {
   try {
     await db.$queryRaw`SELECT 1`
-    return NextResponse.json(
-      { status: 'bereit', version: VERSION, commit: COMMIT || undefined },
-      { headers: { 'Cache-Control': 'no-store' } },
-    )
   } catch {
     return NextResponse.json(
       { status: 'datenbank nicht erreichbar', version: VERSION },
       { status: 503, headers: { 'Cache-Control': 'no-store' } },
     )
   }
+
+  // Der Speicher wird mitgeprueft, aber er entscheidet NICHT ueber die
+  // Betriebsbereitschaft: Faellt er aus, funktioniert alles ausser dem
+  // Ablegen von Dateien. Ein 503 wuerde den Behaelter neu starten lassen
+  // und die ganze Akte unerreichbar machen - wegen eines Teils, den ein
+  // Neustart nicht repariert.
+  const speicher = await speicherZustand()
+
+  return NextResponse.json(
+    {
+      status: 'bereit',
+      version: VERSION,
+      commit: COMMIT || undefined,
+      speicher: speicher.ok
+        ? { status: 'bereit', treiber: speicher.treiber }
+        : { status: 'gestoert', treiber: speicher.treiber, art: speicher.art },
+    },
+    { headers: { 'Cache-Control': 'no-store' } },
+  )
 }

src/app/datenschutz/page.tsx

@@ -2,6 +2,7 @@ import type { Metadata } from 'next'
 import Link from 'next/link'
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
+import { MarkdownSeite } from '@/components/markdown-seite'
 
 export const metadata: Metadata = { title: 'Datenschutz' }
 
@@ -11,83 +12,7 @@ export const metadata: Metadata = { title: 'Datenschutz' }
  * Der Text kommt aus docs/datenschutzhinweise.md - dieselbe Datei, die man
  * auch ausdrucken und der betreuten Person aushaendigen kann. Zwei Quellen
  * fuer denselben Text waeren zwei Quellen fuer Fehler.
- *
- * Die Umsetzung ist bewusst schlicht: keine Markdown-Bibliothek, nur die
- * wenigen Auszeichnungen, die im Dokument wirklich vorkommen.
  */
-function alsAbsaetze(markdown: string) {
-  const zeilen = markdown.split(/\r?\n/)
-  const bloecke: React.ReactNode[] = []
-  let absatz: string[] = []
-
-  const absatzSchliessen = (schluessel: number) => {
-    if (absatz.length === 0) return
-    bloecke.push(
-      <p key={`p-${schluessel}`} className="leading-relaxed">
-        {absatz.join(' ')}
-      </p>,
-    )
-    absatz = []
-  }
-
-  zeilen.forEach((zeile, i) => {
-    const roh = zeile.trim()
-
-    // Der Hinweisblock fuer den Ausfuellenden gehoert nicht auf die Seite.
-    if (roh.startsWith('>')) return
-
-    if (roh === '' || roh === '---') {
-      absatzSchliessen(i)
-      return
-    }
-    if (roh.startsWith('## ')) {
-      absatzSchliessen(i)
-      bloecke.push(
-        <h2 key={i} className="mt-8 text-xl font-semibold">
-          {roh.slice(3)}
-        </h2>,
-      )
-      return
-    }
-    if (roh.startsWith('# ')) {
-      absatzSchliessen(i)
-      bloecke.push(
-        <h1 key={i} className="text-2xl font-semibold">
-          {roh.slice(2)}
-        </h1>,
-      )
-      return
-    }
-    if (roh.startsWith('- ')) {
-      absatzSchliessen(i)
-      bloecke.push(
-        <li key={i} className="ml-5 list-disc leading-relaxed">
-          {roh.slice(2)}
-        </li>,
-      )
-      return
-    }
-    // Tabellenzeilen werden als einfache Aufzaehlung dargestellt.
-    if (roh.startsWith('|')) {
-      absatzSchliessen(i)
-      const spalten = roh.split('|').map((s) => s.trim()).filter(Boolean)
-      if (spalten.every((s) => /^-+$/.test(s))) return
-      bloecke.push(
-        <div key={i} className="flex flex-col gap-0.5 border-l-2 py-1 pl-3 sm:flex-row sm:gap-3">
-          <span className="min-w-56 font-medium">{spalten[0]}</span>
-          <span className="text-muted-foreground">{spalten.slice(1).join(' · ')}</span>
-        </div>,
-      )
-      return
-    }
-
-    absatz.push(roh)
-  })
-
-  absatzSchliessen(zeilen.length)
-  return bloecke
-}
-
 export default async function DatenschutzSeite() {
   const pfad = path.join(process.cwd(), 'docs', 'datenschutzhinweise.md')
   let inhalt: string
@@ -95,14 +20,24 @@ export default async function DatenschutzSeite() {
   try {
     inhalt = await readFile(pfad, 'utf8')
   } catch {
-    inhalt =
-      '# Datenschutzhinweise\n\nDer Text konnte nicht geladen werden. ' +
-      'Er liegt in docs/datenschutzhinweise.md.'
+    inhalt = ''
   }
 
   return (
     <div className="mx-auto max-w-3xl px-4 py-10 sm:px-6">
-      <article className="space-y-3 [&_strong]:font-semibold">{alsAbsaetze(inhalt)}</article>
+      <h1 className="text-2xl font-semibold">Datenschutzhinweise</h1>
+      <p className="mt-1 text-sm text-muted-foreground">nach Art. 13 und 14 DSGVO</p>
+
+      <div className="mt-8">
+        {inhalt === '' ? (
+          <p className="text-muted-foreground">
+            Der Text konnte nicht geladen werden. Er liegt im Projekt unter{' '}
+            <code className="rounded bg-muted px-1.5 py-0.5">docs/datenschutzhinweise.md</code>.
+          </p>
+        ) : (
+          <MarkdownSeite inhalt={inhalt} />
+        )}
+      </div>
 
       <p className="mt-10 border-t pt-6 text-sm text-muted-foreground">
         <Link href="/anmelden" className="underline hover:no-underline">

src/auth.ts

@@ -3,15 +3,19 @@ import Credentials from 'next-auth/providers/credentials'
 import type { Rolle } from '@prisma/client'
 import { db } from '@/lib/db'
 import { env } from '@/lib/env'
-import { hashVeraltet, passwortHashen, passwortPruefen, wiederherstellungscodeFinden } from '@/lib/crypto/hash'
-import { totpPruefen, totpSecretEntschluesseln } from '@/lib/crypto/totp'
+import { hashVeraltet, passwortHashen, passwortPruefen } from '@/lib/crypto/hash'
 import {
   anmeldungErlaubt,
   aufMindestdauerWarten,
   fehlversucheZuruecksetzen,
+  sperreVermerken,
   versuchFesthalten,
 } from '@/lib/auth/ratelimit'
 import { protokollieren } from '@/lib/audit'
+import { zweitenFaktorEinloesen } from '@/lib/auth/zweiter-faktor'
+import { anschlussAus } from '@/lib/auth/anschluss'
+import { PasskeyFehler, anmeldungPruefen } from '@/lib/auth/passkey'
+import type { AuthenticationResponseJSON } from '@simplewebauthn/server'
 
 /**
  * Anmeldung: E-Mail + Passwort + TOTP - alle drei zusammen, in einem Schritt.
@@ -30,6 +34,8 @@ export type AnmeldeGrund =
   | 'gesperrt'
   | 'konto-inaktiv'
   | 'code-falsch'
+  /** Passkey-Fehler; der genaue Grund haengt mit Doppelpunkt daran. */
+  | 'passkey'
 
 /**
  * Auth.js transportiert Fehler aus authorize() nur ueber das Feld "code".
@@ -45,14 +51,28 @@ export class AnmeldeFehler extends CredentialsSignin {
   }
 }
 
+/**
+ * Wie AnmeldeFehler, nur fuer Passkeys: der Grund wird als "passkey:<grund>"
+ * kodiert, damit die Anmeldeseite die passende Erklaerung zeigen kann.
+ */
+export class PasskeyAnmeldeFehler extends CredentialsSignin {
+  code: string
+
+  constructor(grund: string) {
+    super(grund)
+    this.code = `passkey:${grund}`
+  }
+}
+
 function ipAusAnfrage(anfrage: Request | undefined): string | null {
   if (!anfrage) return null
-  const weitergeleitet = anfrage.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
-  return weitergeleitet || anfrage.headers.get('x-real-ip') || null
+  return anschlussAus(anfrage.headers)
 }
 
 export const { handlers, signIn, signOut, auth } = NextAuth({
-  trustHost: true,
+  // Siehe env.vertraueHost: Ist AUTH_URL gesetzt, wird dem Host-Kopf nicht
+  // geglaubt. Vorher stand hier fest "true".
+  trustHost: env.vertraueHost,
   secret: process.env.AUTH_SECRET,
 
   session: {
@@ -93,7 +113,7 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         // 1. Sperre pruefen, bevor teuer gerechnet wird.
         const sperre = await anmeldungErlaubt(email, ip)
         if (sperre.gesperrt) {
-          await versuchFesthalten(email, ip, false, 'gesperrt')
+          await sperreVermerken(email, ip)
           throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
         }
 
@@ -124,33 +144,13 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
           throw new AnmeldeFehler('konto-inaktiv')
         }
 
-        // 3. Zweiter Faktor. Ohne eingerichtetes TOTP kommt der Benutzer
-        //    zwar herein, das App-Layout schickt ihn aber sofort zur
-        //    Einrichtung - er kann nichts anderes tun.
+        // 3. Zweiter Faktor. Ist er noch nicht eingerichtet, kommt der
+        //    Benutzer nur bis zur Einrichtungsseite - erzwungen in
+        //    erfordereBenutzer(), nicht erst im Layout.
         if (benutzer.totpSecretVerschluesselt && benutzer.totpAktiviertAm) {
-          const codeOhneTrenner = code.replace(/[\s-]/g, '')
-          let zweiterFaktorOk = false
+          const eingeloest = await zweitenFaktorEinloesen(benutzer, code)
 
-          if (/^\d{6}$/.test(codeOhneTrenner)) {
-            const secret = totpSecretEntschluesseln(benutzer.totpSecretVerschluesselt)
-            zweiterFaktorOk = totpPruefen(secret, benutzer.email, codeOhneTrenner).gueltig
-          } else if (codeOhneTrenner.length >= 12) {
-            // Wiederherstellungscode - wird nach Gebrauch entfernt.
-            const treffer = await wiederherstellungscodeFinden(
-              benutzer.wiederherstellungscodes,
-              code,
-            )
-            if (treffer >= 0) {
-              zweiterFaktorOk = true
-              const rest = benutzer.wiederherstellungscodes.filter((_, i) => i !== treffer)
-              await db.user.update({
-                where: { id: benutzer.id },
-                data: { wiederherstellungscodes: rest },
-              })
-            }
-          }
-
-          if (!zweiterFaktorOk) {
+          if (!eingeloest.ok) {
             await versuchFesthalten(email, ip, false, 'code-falsch')
             await protokollieren({
               aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
@@ -158,7 +158,10 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
               entitaetId: benutzer.id,
               userEmail: email,
               userId: benutzer.id,
-              bezeichnung: 'Zweiter Faktor falsch',
+              bezeichnung:
+                eingeloest.grund === 'wiederverwendet'
+                  ? 'Zweiter Faktor bereits verbraucht'
+                  : 'Zweiter Faktor falsch',
             })
             await aufMindestdauerWarten(begonnen)
             throw new AnmeldeFehler('code-falsch')
@@ -203,6 +206,101 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         }
       },
     }),
+
+    /**
+     * Anmeldung mit Passkey - ein Schritt, ohne E-Mail und ohne Passwort.
+     *
+     * Die vollstaendige Pruefung laeuft hier drin und nicht in der Server
+     * Action davor. Das ist Absicht: Wuerde die Action pruefen und das
+     * Ergebnis anschliessend an signIn() weiterreichen, gaebe es einen
+     * Zwischenzustand, dem authorize() glauben muesste. Genau solche
+     * "war schon geprueft"-Uebergaben sind die Stelle, an der sich
+     * Anmeldungen faelschen lassen. Hier gibt es sie nicht.
+     */
+    Credentials({
+      id: 'passkey',
+      name: 'Passkey',
+      credentials: {
+        antwort: { label: 'Antwort des Authenticators', type: 'text' },
+      },
+
+      async authorize(daten, anfrage) {
+        const ip = ipAusAnfrage(anfrage)
+
+        let antwort: AuthenticationResponseJSON
+        try {
+          antwort = JSON.parse(String(daten?.antwort ?? '')) as AuthenticationResponseJSON
+        } catch {
+          throw new PasskeyAnmeldeFehler('ungueltig')
+        }
+
+        let geprueft
+        try {
+          geprueft = await anmeldungPruefen(antwort)
+        } catch (fehler) {
+          // Fehlversuche zaehlen mit, auch wenn der Zugang unbekannt ist -
+          // sonst waere der Passkey-Weg ein Schlupfloch an der Sperre vorbei.
+          await versuchFesthalten('(passkey)', ip, false, 'passkey-ungueltig')
+          await protokollieren({
+            aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
+            entitaet: 'User',
+            userEmail: '(passkey)',
+            bezeichnung:
+              fehler instanceof PasskeyFehler ? `Passkey: ${fehler.grund}` : 'Passkey abgewiesen',
+          })
+          throw new PasskeyAnmeldeFehler(
+            fehler instanceof PasskeyFehler ? fehler.grund : 'ungueltig',
+          )
+        }
+
+        const { benutzer, passkey } = geprueft
+
+        // Die Sperre gilt fuer den Zugang, nicht fuer das Verfahren. Sie
+        // wird erst hier geprueft, weil vorher niemand weiss, wer sich
+        // anmeldet - erraten laesst sich ein Passkey ohnehin nicht.
+        const sperre = await anmeldungErlaubt(benutzer.email, ip)
+        if (sperre.gesperrt) {
+          await sperreVermerken(benutzer.email, ip)
+          throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
+        }
+
+        if (!benutzer.aktiv || benutzer.geloeschtAm) {
+          await versuchFesthalten(benutzer.email, ip, false, 'konto-inaktiv')
+          throw new AnmeldeFehler('konto-inaktiv')
+        }
+
+        await Promise.all([
+          versuchFesthalten(benutzer.email, ip, true, 'passkey'),
+          fehlversucheZuruecksetzen(benutzer.email),
+          db.user.update({
+            where: { id: benutzer.id },
+            data: { letzteAnmeldung: new Date() },
+          }),
+          protokollieren({
+            aktion: 'ANMELDUNG',
+            entitaet: 'User',
+            entitaetId: benutzer.id,
+            userId: benutzer.id,
+            userEmail: benutzer.email,
+            userName: benutzer.name,
+            bezeichnung: `Mit Passkey „${passkey.name}“`,
+          }),
+        ])
+
+        return {
+          id: benutzer.id,
+          email: benutzer.email,
+          name: benutzer.name,
+          rolle: benutzer.rolle,
+          sitzungsGeneration: benutzer.sitzungsGeneration,
+          // Ein Passkey mit Nutzerverifikation IST der zweite Faktor. Ohne
+          // eingerichtetes TOTP laesst er sich gar nicht erst anlegen, das
+          // Flag ist hier also immer wahr - es wird trotzdem aus dem
+          // Benutzer gelesen und nicht fest gesetzt.
+          zweiterFaktorAktiv: Boolean(benutzer.totpAktiviertAm),
+        }
+      },
+    }),
   ],
 
   callbacks: {

src/components/app-huelle.tsx

@@ -56,8 +56,21 @@ export function AppHuelle({
         Zum Inhalt springen
       </a>
 
-      {/* --- Seitenleiste am Schreibtisch --------------------------------- */}
-      <aside className="no-print hidden w-72 shrink-0 border-r bg-card lg:flex lg:flex-col">
+      {/* --- Seitenleiste am Schreibtisch ---------------------------------
+
+          sticky + h-dvh, nicht einfach mitwachsen lassen: Ohne feste Hoehe
+          wird die Leiste so hoch wie die laengste Seite. Der Fuss mit dem
+          Benutzermenue - und damit der einzige Weg zu "Mein Konto",
+          Passwort, zweitem Faktor und Passkeys - landet dann am Ende der
+          Seite statt am unteren Bildschirmrand. Auf /heute waren das 1632
+          Pixel bei 900 Pixel Fensterhoehe: unerreichbar, ohne dass etwas
+          kaputt aussah.
+
+          self-start gehoert dazu, weil ein Flex-Kind sonst auf die volle
+          Zeilenhoehe gestreckt wird und die feste Hoehe wieder verliert.
+          Die Navigation dazwischen hat bereits overflow-y-auto und scrollt
+          bei Bedarf in sich selbst.                                        */}
+      <aside className="no-print hidden w-72 shrink-0 border-r bg-card lg:sticky lg:top-0 lg:flex lg:h-dvh lg:flex-col lg:self-start">
         <div className="flex h-16 items-center border-b px-5">
           <Link href="/heute" className="flex items-center gap-2 font-semibold">
             <span

src/components/benutzer-menue.tsx

@@ -3,7 +3,16 @@
 import * as React from 'react'
 import Link from 'next/link'
 import { signOut } from 'next-auth/react'
-import { LogOut, Monitor, Moon, Settings, ShieldCheck, Sun, User as UserIcon } from 'lucide-react'
+import {
+  BookOpen,
+  LogOut,
+  Monitor,
+  Moon,
+  Settings,
+  ShieldCheck,
+  Sun,
+  User as UserIcon,
+} from 'lucide-react'
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -96,6 +105,12 @@ export function BenutzerMenue({
             Einstellungen
           </Link>
         </DropdownMenuItem>
+        <DropdownMenuItem asChild>
+          <Link href="/anleitung">
+            <BookOpen className="size-4" />
+            Anleitung
+          </Link>
+        </DropdownMenuItem>
 
         <DropdownMenuSeparator />
         <DropdownMenuLabel className="text-xs font-normal text-muted-foreground">

src/components/dashboard/belege-kachel.tsx

@@ -1,5 +1,5 @@
 import Link from 'next/link'
-import { ReceiptText } from 'lucide-react'
+import { Repeat, ReceiptText } from 'lucide-react'
 import { Button } from '@/components/ui/button'
 import { Leerzustand } from '@/components/seiten-kopf'
 import { Kachel, KachelZeile } from '@/components/dashboard/kachel'
@@ -17,7 +17,10 @@ import { formatCent, formatDatum } from '@/lib/utils'
 export function BelegeKachel({ daten }: { daten: BelegeDaten | null }) {
   if (!daten) return null
 
-  const offen = daten.belegeOhneBuchungGesamt + daten.buchungenOhneBelegGesamt
+  const offen =
+    daten.belegeOhneBuchungGesamt +
+    daten.buchungenOhneBelegGesamt +
+    daten.wiederkehrendOhneVertrag
 
   return (
     <Kachel
@@ -72,6 +75,29 @@ export function BelegeKachel({ daten }: { daten: BelegeDaten | null }) {
             </section>
           )}
 
+          {daten.wiederkehrendOhneVertrag > 0 && (
+            <section aria-labelledby="wiederkehrend-ohne-vertrag">
+              <h3
+                id="wiederkehrend-ohne-vertrag"
+                className="mb-1 text-sm font-semibold uppercase tracking-wide text-muted-foreground"
+              >
+                Regelmäßige Abbuchungen ohne Vertrag ({daten.wiederkehrendOhneVertrag})
+              </h3>
+              <KachelZeile href="/finanzen/wiederkehrend">
+                <span className="min-w-0 flex-1">
+                  <span className="flex items-center gap-2 font-medium">
+                    <Repeat className="size-4 shrink-0" aria-hidden="true" />
+                    {daten.wiederkehrendOhneVertrag} Empfänger ansehen
+                  </span>
+                  <span className="block text-sm text-muted-foreground">
+                    Wer regelmäßig abbucht, hat einen Vertrag — und der fehlt dann im
+                    Vermögensverzeichnis.
+                  </span>
+                </span>
+              </KachelZeile>
+            </section>
+          )}
+
           {daten.buchungenOhneBelegGesamt > 0 && (
             <section aria-labelledby="buchungen-ohne-beleg">
               <h3

src/components/dokumente/dokument-liste.tsx

@@ -17,6 +17,21 @@ import {
  *
  * Am Handy eine Karte je Dokument, ab Tablet eine Tabelle - die Tabelle
  * scrollt dabei im eigenen Rahmen, nie die ganze Seite.
+ *
+ * ACHTUNG, jeder Inhalt steht ZWEIMAL im DOM: einmal als Karte, einmal
+ * als Tabellenzeile. Eine der beiden Fassungen ist per Breakpoint
+ * versteckt, steht aber trotzdem im Baum.
+ *
+ * Fuer Tests heisst das: getByText(...).first() trifft womoeglich die
+ * unsichtbare Kopie, und die Pruefung scheitert mit "element is not
+ * visible" an einer Stelle, die augenscheinlich in Ordnung ist. Der Weg,
+ * der traegt, steht in e2e/hilfen.ts unter "Doppelt gerenderte Listen".
+ *
+ * Warum nicht eine Fassung fuer beide? Eine Tabelle, die sich zu Karten
+ * umbricht, verlangt display:block auf Zeilen und Zellen. Damit ist es
+ * keine Tabelle mehr - Vorlesesoftware verliert den Zusammenhang von
+ * Spaltenkopf und Wert, und genau der macht eine Dokumentenliste mit
+ * acht Spalten erst benutzbar. Die Verdopplung ist der Preis dafuer.
  */
 export function DokumentListe({ eintraege }: { eintraege: Listeneintrag[] }) {
   return (

src/components/druck-knopf.tsx

@@ -0,0 +1,20 @@
+'use client'
+
+import { Printer } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+
+/**
+ * Druckt die aktuelle Seite.
+ *
+ * Muss eine Client-Komponente sein - window.print() gibt es auf dem
+ * Server nicht. Der Knopf selbst traegt "no-print", damit er auf dem
+ * Ausdruck nicht auftaucht.
+ */
+export function DruckKnopf({ beschriftung = 'Drucken' }: { beschriftung?: string }) {
+  return (
+    <Button variant="outline" className="no-print" onClick={() => window.print()}>
+      <Printer aria-hidden="true" />
+      {beschriftung}
+    </Button>
+  )
+}

src/components/einstellungen/vorlagen-verwaltung.tsx

@@ -0,0 +1,374 @@
+'use client'
+
+import * as React from 'react'
+import { useActionState } from 'react'
+import { AlertCircle, AlertTriangle, CheckCircle2, Copy, Pencil, Plus, Trash2 } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Input } from '@/components/ui/input'
+import { Textarea } from '@/components/ui/textarea'
+import { Feld } from '@/components/feld'
+import { Absendeknopf } from '@/components/finanzen/eingaben'
+import {
+  vorlageLoeschen,
+  vorlageSpeichern,
+  type VorlagenZustand,
+} from '@/server/actions/vorlagen'
+import { PLATZHALTER, benutztePlatzhalter } from '@/lib/schreiben/platzhalter'
+
+export type VorlagenZeile = {
+  id: string
+  name: string
+  betreff: string
+  text: string
+}
+
+export type MitgelieferteVorlage = {
+  schluessel: string
+  name: string
+  beschreibung: string
+  betreff: string
+  text: string
+}
+
+/**
+ * Verwaltung der eigenen Schreibvorlagen.
+ *
+ * Zwei Listen, ein Editor. Die mitgelieferten Vorlagen sind Code und
+ * unveränderlich — von ihnen führt nur ein Weg hierher: „Als Kopie
+ * übernehmen". Damit kann nichts kaputtgehen, was die Anwendung braucht,
+ * und „wiederherstellen" ist schlicht: noch einmal kopieren.
+ */
+export function VorlagenVerwaltung({
+  betreuteId,
+  eigene,
+  mitgelieferte,
+}: {
+  betreuteId: string
+  eigene: VorlagenZeile[]
+  mitgelieferte: MitgelieferteVorlage[]
+}) {
+  const [offen, setOffen] = React.useState(false)
+  const [bearbeitet, setBearbeitet] = React.useState<VorlagenZeile | null>(null)
+  const [name, setName] = React.useState('')
+  const [betreff, setBetreff] = React.useState('')
+  const [text, setText] = React.useState('')
+
+  function neuBeginnen(vorlage?: Partial<VorlagenZeile>) {
+    setBearbeitet(null)
+    setName(vorlage?.name ?? '')
+    setBetreff(vorlage?.betreff ?? '')
+    setText(vorlage?.text ?? '')
+    setOffen(true)
+  }
+
+  function bearbeiten(vorlage: VorlagenZeile) {
+    setBearbeitet(vorlage)
+    setName(vorlage.name)
+    setBetreff(vorlage.betreff)
+    setText(vorlage.text)
+    setOffen(true)
+  }
+
+  return (
+    <div className="space-y-6">
+      {/* --- Eigene Vorlagen ---------------------------------------------- */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">Eigene Vorlagen</CardTitle>
+          <CardDescription>
+            Formulierungen, die sich bewährt haben — einmal hinterlegt, beim Schreiben wählbar.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          {eigene.length === 0 ? (
+            <p className="text-sm text-muted-foreground">
+              Noch keine eigene Vorlage. Fang mit einer Kopie einer mitgelieferten an — oder mit
+              einem leeren Blatt.
+            </p>
+          ) : (
+            <ul className="divide-y rounded-md border">
+              {eigene.map((vorlage) => (
+                <li key={vorlage.id} className="flex flex-wrap items-center gap-2 p-3">
+                  <div className="min-w-0 flex-1">
+                    <p className="font-medium">{vorlage.name}</p>
+                    <p className="text-xs text-muted-foreground">
+                      {benutztePlatzhalter(vorlage.text).length} Platzhalter
+                      {vorlage.betreff ? ` · Betreff: ${vorlage.betreff}` : ''}
+                    </p>
+                  </div>
+                  <Button type="button" variant="ghost" size="sm" onClick={() => bearbeiten(vorlage)}>
+                    <Pencil aria-hidden="true" />
+                    Bearbeiten
+                  </Button>
+                  <VorlageLoeschKnopf betreuteId={betreuteId} vorlage={vorlage} />
+                </li>
+              ))}
+            </ul>
+          )}
+
+          <Button type="button" variant="outline" onClick={() => neuBeginnen()}>
+            <Plus aria-hidden="true" />
+            Neue Vorlage
+          </Button>
+        </CardContent>
+      </Card>
+
+      {/* --- Mitgelieferte ------------------------------------------------- */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">Mitgelieferte Vorlagen</CardTitle>
+          <CardDescription>
+            Unveränderlich — sie sind Teil der Anwendung und lassen sich nicht kaputtmachen. Als
+            Grundlage für eigene Fassungen: kopieren und anpassen.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <ul className="divide-y rounded-md border">
+            {mitgelieferte.map((vorlage) => (
+              <li key={vorlage.schluessel} className="flex flex-wrap items-center gap-2 p-3">
+                <div className="min-w-0 flex-1">
+                  <p className="font-medium">{vorlage.name}</p>
+                  <p className="text-xs text-muted-foreground">{vorlage.beschreibung}</p>
+                </div>
+                <Badge variant="secondary">mitgeliefert</Badge>
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="sm"
+                  onClick={() =>
+                    neuBeginnen({
+                      name: `${vorlage.name} (eigene Fassung)`,
+                      betreff: vorlage.betreff,
+                      text: vorlage.text,
+                    })
+                  }
+                >
+                  <Copy aria-hidden="true" />
+                  Als Kopie übernehmen
+                </Button>
+              </li>
+            ))}
+          </ul>
+        </CardContent>
+      </Card>
+
+      {/* --- Editor --------------------------------------------------------- */}
+      {offen && (
+        <VorlagenEditor
+          betreuteId={betreuteId}
+          vorlageId={bearbeitet?.id ?? ''}
+          name={name}
+          betreff={betreff}
+          text={text}
+          onName={setName}
+          onBetreff={setBetreff}
+          onText={setText}
+          onSchliessen={() => setOffen(false)}
+        />
+      )}
+    </div>
+  )
+}
+
+function VorlageLoeschKnopf({
+  betreuteId,
+  vorlage,
+}: {
+  betreuteId: string
+  vorlage: VorlagenZeile
+}) {
+  const [zustand, absenden] = useActionState<VorlagenZustand, FormData>(vorlageLoeschen, {})
+  const [gefragt, setGefragt] = React.useState(false)
+
+  if (!gefragt) {
+    return (
+      <>
+        {zustand.fehler && <span className="text-xs text-destructive">{zustand.fehler}</span>}
+        <Button type="button" variant="ghost" size="sm" onClick={() => setGefragt(true)}>
+          <Trash2 aria-hidden="true" />
+          Löschen
+        </Button>
+      </>
+    )
+  }
+
+  return (
+    <form action={absenden} className="flex items-center gap-2">
+      <input type="hidden" name="betreuteId" value={betreuteId} />
+      <input type="hidden" name="vorlageId" value={vorlage.id} />
+      <Absendeknopf variant="destructive" size="sm" wartetext="…">
+        In den Papierkorb
+      </Absendeknopf>
+      <Button type="button" variant="ghost" size="sm" onClick={() => setGefragt(false)}>
+        Abbrechen
+      </Button>
+    </form>
+  )
+}
+
+/**
+ * Der Editor mit der Platzhalterliste daneben.
+ *
+ * Die Warnung zum Bestellungsabsatz kommt vom Server (zweistufig): Der
+ * erste Speicherversuch ohne ihn liefert die Warnung zurück, erst die
+ * Bestätigung speichert wirklich. So bleibt die Prüfung an EINER Stelle —
+ * eine zweite Prüfung im Browser könnte von der Serverfassung abweichen.
+ */
+function VorlagenEditor({
+  betreuteId,
+  vorlageId,
+  name,
+  betreff,
+  text,
+  onName,
+  onBetreff,
+  onText,
+  onSchliessen,
+}: {
+  betreuteId: string
+  vorlageId: string
+  name: string
+  betreff: string
+  text: string
+  onName: (wert: string) => void
+  onBetreff: (wert: string) => void
+  onText: (wert: string) => void
+  onSchliessen: () => void
+}) {
+  const [zustand, absenden] = useActionState<VorlagenZustand, FormData>(vorlageSpeichern, {})
+  const [trotzdem, setTrotzdem] = React.useState(false)
+
+  const textfeld = React.useRef<HTMLTextAreaElement>(null)
+
+  function platzhalterEinfuegen(platzhalterName: string) {
+    const feld = textfeld.current
+    const einschub = `{{${platzhalterName}}}`
+    if (!feld) {
+      onText(`${text}${einschub}`)
+      return
+    }
+    const start = feld.selectionStart ?? text.length
+    const ende = feld.selectionEnd ?? text.length
+    onText(`${text.slice(0, start)}${einschub}${text.slice(ende)}`)
+  }
+
+  return (
+    <Card>
+      <CardHeader className="pb-3">
+        <CardTitle className="text-base">
+          {vorlageId ? 'Vorlage bearbeiten' : 'Neue Vorlage'}
+        </CardTitle>
+      </CardHeader>
+      <CardContent>
+        <form action={absenden} className="grid gap-6 lg:grid-cols-[1fr_260px]">
+          <div className="space-y-4">
+            <input type="hidden" name="betreuteId" value={betreuteId} />
+            <input type="hidden" name="vorlageId" value={vorlageId} />
+            <input type="hidden" name="ohneBestellungsabsatz" value={trotzdem ? 'ja' : ''} />
+
+            {zustand.fehler && (
+              <Alert variant="fehler">
+                <AlertCircle aria-hidden="true" />
+                <AlertDescription>{zustand.fehler}</AlertDescription>
+              </Alert>
+            )}
+
+            {zustand.warnung && (
+              <Alert variant="warnung">
+                <AlertTriangle aria-hidden="true" />
+                <AlertDescription>
+                  <p>{zustand.warnung}</p>
+                  <label className="mt-2 flex items-center gap-2 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={trotzdem}
+                      onChange={(ereignis) => setTrotzdem(ereignis.target.checked)}
+                    />
+                    Bewusst ohne Bestellungsabsatz speichern
+                  </label>
+                </AlertDescription>
+              </Alert>
+            )}
+
+            {zustand.erfolg && (
+              <Alert variant="erfolg">
+                <CheckCircle2 aria-hidden="true" />
+                <AlertDescription>{zustand.erfolg}</AlertDescription>
+              </Alert>
+            )}
+
+            <Feld id="name" beschriftung="Name der Vorlage" fehler={zustand.felder?.name} pflicht>
+              <Input
+                name="name"
+                value={name}
+                onChange={(ereignis) => onName(ereignis.target.value)}
+                maxLength={120}
+                placeholder="z. B. Auskunftsersuchen Krankenkasse"
+              />
+            </Feld>
+
+            <Feld
+              id="betreff"
+              beschriftung="Betreff"
+              erklaerung="Darf Platzhalter enthalten. Wird beim Erzeugen zum Betreff des Schreibens."
+            >
+              <Input
+                name="betreff"
+                value={betreff}
+                onChange={(ereignis) => onBetreff(ereignis.target.value)}
+                maxLength={200}
+              />
+            </Feld>
+
+            <Feld id="text" beschriftung="Text der Vorlage" fehler={zustand.felder?.text} pflicht>
+              <Textarea
+                ref={textfeld}
+                name="text"
+                value={text}
+                onChange={(ereignis) => onText(ereignis.target.value)}
+                rows={18}
+                className="font-mono text-sm leading-relaxed"
+              />
+            </Feld>
+
+            <div className="flex gap-2">
+              <Absendeknopf wartetext="Wird gespeichert …">Speichern</Absendeknopf>
+              <Button type="button" variant="ghost" onClick={onSchliessen}>
+                Schließen
+              </Button>
+            </div>
+          </div>
+
+          {/* Die Platzhalterliste - niemand soll Namen raten muessen. */}
+          <aside className="space-y-2 rounded-md border p-3">
+            <p className="text-sm font-medium">Platzhalter</p>
+            <p className="text-xs text-muted-foreground">
+              Klick fügt an der Schreibmarke ein. Fehlt beim Erzeugen der Wert, bleibt eine
+              sichtbare Lücke — nichts verschwindet still.
+            </p>
+            <ul className="space-y-1">
+              {PLATZHALTER.map((platzhalter) => (
+                <li key={platzhalter.name}>
+                  <button
+                    type="button"
+                    onClick={() => platzhalterEinfuegen(platzhalter.name)}
+                    className="w-full rounded px-2 py-1 text-left text-xs hover:bg-accent"
+                    title={platzhalter.quelle}
+                  >
+                    <code className="text-primary">{'{{'}{platzhalter.name}{'}}'}</code>
+                    <span className="block text-muted-foreground">
+                      {platzhalter.beschriftung}
+                    </span>
+                  </button>
+                </li>
+              ))}
+            </ul>
+          </aside>
+        </form>
+      </CardContent>
+    </Card>
+  )
+}

src/components/finanzen/bausteine.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react'
 import Link from 'next/link'
-import { AlertTriangle, FileWarning, Paperclip } from 'lucide-react'
+import { AlertTriangle, FileCheck, FileWarning, Paperclip } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Card, CardContent } from '@/components/ui/card'
 import { cn, formatCent } from '@/lib/utils'
@@ -104,10 +104,19 @@ export function Belegzeichen({
   belegTitel,
   begruendung,
   belegId,
+  vertragBezeichnung = null,
+  vertragAutomatisch = false,
+  betragZuPruefen = false,
 }: {
   belegId: string | null
   belegTitel: string | null
   begruendung: string | null
+  /** Dauerzahlung: gesetzt, wenn der Vertrag als Beleg gilt. */
+  vertragBezeichnung?: string | null
+  /** Beim Import automatisch zugeordnet - eine Vermutung, kein Urteil. */
+  vertragAutomatisch?: boolean
+  /** Zugeordnet, aber der Betrag weicht ab. */
+  betragZuPruefen?: boolean
 }) {
   if (belegId) {
     return (
@@ -118,6 +127,36 @@ export function Belegzeichen({
     )
   }
 
+  // Zugeordnet, aber der Betrag passt nicht. Steht vor allem anderen: Das
+  // ist der Fall, den jemand ansehen soll.
+  if (betragZuPruefen) {
+    return (
+      <Badge
+        variant="rot"
+        title="Der Betrag weicht deutlich vom hinterlegten Beitrag ab. Meist eine Beitragsanpassung, die am Vertrag noch fehlt."
+      >
+        <AlertTriangle className="size-3.5" aria-hidden="true" />
+        Betrag prüfen
+      </Badge>
+    )
+  }
+
+  if (vertragBezeichnung) {
+    return (
+      <Badge
+        variant="gruen"
+        title={
+          vertragAutomatisch
+            ? `Beim Import automatisch dem Vertrag „${vertragBezeichnung}“ zugeordnet. Bitte einmal durchsehen.`
+            : `Dauerzahlung zu Vertrag „${vertragBezeichnung}“.`
+        }
+      >
+        <FileCheck className="size-3.5" aria-hidden="true" />
+        {vertragAutomatisch ? 'Vertrag (automatisch)' : 'durch Vertrag belegt'}
+      </Badge>
+    )
+  }
+
   if (begruendung && begruendung.trim() !== '') {
     return (
       <Badge variant="gelb" title={begruendung}>

src/components/finanzen/buchungs-formular.tsx

@@ -33,6 +33,12 @@ export type BelegAuswahl = {
   titel: string
 }
 
+export type VertragAuswahl = {
+  id: string
+  bezeichnung: string
+  gesellschaft: string | null
+}
+
 export type BuchungWerte = {
   id: string
   kontoId: string | null
@@ -45,6 +51,7 @@ export type BuchungWerte = {
   verwendungszweck: string | null
   belegId: string | null
   belegFehltBegruendung: string | null
+  vertragId: string | null
   betrifftBetreute: boolean
   vermoegenswirksam: boolean
 }
@@ -65,6 +72,7 @@ export function Buchungsformular({
   betreuteId,
   konten,
   belege,
+  vertraege,
   buchung,
   standardDatum,
   schnellerfassung = false,
@@ -72,6 +80,7 @@ export function Buchungsformular({
   betreuteId: string
   konten: KontoAuswahl[]
   belege: BelegAuswahl[]
+  vertraege: VertragAuswahl[]
   buchung?: BuchungWerte
   /** Vorbelegung des Datumsfeldes bei einer neuen Buchung. */
   standardDatum?: string
@@ -87,6 +96,7 @@ export function Buchungsformular({
   )
   const [betrifftBetreute, setBetrifftBetreute] = React.useState(buchung?.betrifftBetreute ?? true)
   const [belegId, setBelegId] = React.useState(buchung?.belegId ?? '')
+  const [vertragId, setVertragId] = React.useState(buchung?.vertragId ?? '')
 
   const konto = konten.find((k) => k.id === kontoId)
   const vermischt = Boolean(konto?.istBetreuerkonto) && betrifftBetreute
@@ -275,7 +285,30 @@ export function Buchungsformular({
           </Select>
         </Feld>
 
-        {belegId === '' && (
+        {belegId === '' && vertraege.length > 0 && (
+          <Feld
+            id="vertragId"
+            beschriftung="Oder: Dauerzahlung zu einem Vertrag"
+            erklaerung="Bei einem Dauerschuldverhältnis ist der Vertrag der Beleg — für zwölf gleiche Lastschriften gibt es keine zwölf Quittungen, sondern eine Police. Weicht der Betrag deutlich vom hinterlegten Beitrag ab, wird die Buchung trotzdem zur Prüfung markiert."
+            fehler={zustand.felder?.vertragId}
+          >
+            <Select
+              name="vertragId"
+              value={vertragId}
+              onChange={(ereignis) => setVertragId(ereignis.target.value)}
+            >
+              <option value="">– keine Dauerzahlung –</option>
+              {vertraege.map((vertrag) => (
+                <option key={vertrag.id} value={vertrag.id}>
+                  {vertrag.bezeichnung}
+                  {vertrag.gesellschaft ? ` (${vertrag.gesellschaft})` : ''}
+                </option>
+              ))}
+            </Select>
+          </Feld>
+        )}
+
+        {belegId === '' && vertragId === '' && (
           <Feld
             id="belegFehltBegruendung"
             beschriftung="Warum fehlt der Beleg?"

src/components/finanzen/wiederkehrend-aktionen.tsx

@@ -0,0 +1,177 @@
+'use client'
+
+import * as React from 'react'
+import { useActionState } from 'react'
+import { AlertCircle, CheckCircle2, Link2, Undo2, XCircle } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Absendeknopf } from '@/components/finanzen/eingaben'
+import {
+  zahlungenVertragZuordnen,
+  zahlungsgruppeAbhaken,
+  zahlungsgruppeZurueckholen,
+  type Formularzustand,
+} from '@/server/actions/finanzen'
+
+/**
+ * „Kein Vertrag" — eine Gruppe dauerhaft aus der Liste nehmen.
+ *
+ * Die Begründung ist freiwillig, steht aber im Formular ganz vorn. In einem
+ * Jahr weiß niemand mehr, warum „Stadtwerke Bamberg" abgehakt wurde, und
+ * dann fängt die Prüfung von vorn an. Ein halber Satz jetzt spart das.
+ */
+export function AlsGeklaertAbhaken({
+  betreuteId,
+  schluessel,
+  anzeigename,
+}: {
+  betreuteId: string
+  schluessel: string
+  anzeigename: string
+}) {
+  const [zustand, absenden] = useActionState<Formularzustand, FormData>(
+    zahlungsgruppeAbhaken,
+    {},
+  )
+  const [offen, setOffen] = React.useState(false)
+
+  if (!offen) {
+    return (
+      <div className="space-y-2">
+        {zustand.fehler && (
+          <Alert variant="fehler">
+            <AlertCircle aria-hidden="true" />
+            <AlertDescription>{zustand.fehler}</AlertDescription>
+          </Alert>
+        )}
+        <Button type="button" variant="ghost" size="sm" onClick={() => setOffen(true)}>
+          <XCircle aria-hidden="true" />
+          Kein Vertrag
+        </Button>
+      </div>
+    )
+  }
+
+  return (
+    <form action={absenden} className="space-y-2 rounded-md border p-3">
+      <input type="hidden" name="betreuteId" value={betreuteId} />
+      <input type="hidden" name="schluessel" value={schluessel} />
+      <input type="hidden" name="anzeigename" value={anzeigename} />
+
+      <p className="text-sm">
+        „{anzeigename}“ verschwindet aus der Liste. Zurückholen geht jederzeit.
+      </p>
+
+      <Input
+        name="begruendung"
+        placeholder="Warum kein Vertrag? (z. B. Miete, Strom, Steuer)"
+        maxLength={200}
+        autoFocus
+      />
+
+      <div className="flex gap-2">
+        <Absendeknopf size="sm" wartetext="Wird abgehakt …">
+          Abhaken
+        </Absendeknopf>
+        <Button type="button" variant="ghost" size="sm" onClick={() => setOffen(false)}>
+          Abbrechen
+        </Button>
+      </div>
+    </form>
+  )
+}
+
+/** Holt eine abgehakte Gruppe zurück in die Liste. */
+export function Zurueckholen({
+  betreuteId,
+  eintragId,
+}: {
+  betreuteId: string
+  eintragId: string
+}) {
+  const [zustand, absenden] = useActionState<Formularzustand, FormData>(
+    zahlungsgruppeZurueckholen,
+    {},
+  )
+
+  return (
+    <form action={absenden} className="inline">
+      <input type="hidden" name="betreuteId" value={betreuteId} />
+      <input type="hidden" name="eintragId" value={eintragId} />
+      {zustand.fehler && (
+        <span className="mr-2 text-xs text-destructive">{zustand.fehler}</span>
+      )}
+      <Absendeknopf variant="ghost" size="sm" wartetext="…">
+        <Undo2 aria-hidden="true" />
+        Zurückholen
+      </Absendeknopf>
+    </form>
+  )
+}
+
+/**
+ * Zeigt die Rückmeldung der letzten Aktion.
+ *
+ * Bewusst getrennt von den Knöpfen: Nach dem Abhaken verschwindet die
+ * ganze Zeile samt Knopf, und mit ihr die Erfolgsmeldung. Sie hier
+ * anzuzeigen wäre sinnlos — deshalb steht der Erfolg als kurzer Hinweis
+ * oben auf der Seite, sobald die Liste neu geladen ist.
+ */
+export function Rueckmeldung({ text }: { text: string | null }) {
+  if (!text) return null
+  return (
+    <Alert variant="erfolg">
+      <CheckCircle2 aria-hidden="true" />
+      <AlertDescription>{text}</AlertDescription>
+    </Alert>
+  )
+}
+
+/**
+ * Ordnet alle noch offenen Buchungen einer Gruppe dem Vertrag zu.
+ *
+ * Der Sinn dieses Knopfes ist die Menge: Eine monatliche Prämie über drei
+ * Jahre sind 36 Buchungen. Sie einzeln anzuklicken wäre genau die stumpfe
+ * Arbeit, die diese Zuordnung abschaffen soll.
+ */
+export function ZahlungenZuordnen({
+  betreuteId,
+  vertragId,
+  vertragBezeichnung,
+  buchungIds,
+}: {
+  betreuteId: string
+  vertragId: string
+  vertragBezeichnung: string
+  buchungIds: string[]
+}) {
+  const [zustand, absenden] = useActionState<Formularzustand, FormData>(
+    zahlungenVertragZuordnen,
+    {},
+  )
+
+  if (buchungIds.length === 0) return null
+
+  return (
+    <form action={absenden} className="flex flex-wrap items-center gap-2">
+      <input type="hidden" name="betreuteId" value={betreuteId} />
+      <input type="hidden" name="vertragId" value={vertragId} />
+      <input type="hidden" name="buchungIds" value={buchungIds.join(',')} />
+
+      {zustand.fehler && (
+        <span className="text-xs text-destructive">{zustand.fehler}</span>
+      )}
+      {zustand.erfolg && (
+        <span className="text-xs text-ampel-gruen">{zustand.erfolg}</span>
+      )}
+
+      <Absendeknopf variant="outline" size="sm" wartetext="Wird zugeordnet …">
+        <Link2 aria-hidden="true" />
+        {buchungIds.length} Zahlung{buchungIds.length === 1 ? '' : 'en'} als belegt zuordnen
+      </Absendeknopf>
+
+      <span className="text-xs text-muted-foreground">zu „{vertragBezeichnung}“</span>
+    </form>
+  )
+}

src/components/kontakte/kontakt-formular.tsx

@@ -9,7 +9,12 @@ import { Input } from '@/components/ui/input'
 import { Select } from '@/components/ui/select'
 import { Textarea } from '@/components/ui/textarea'
 import { Feld, Feldgruppe } from '@/components/feld'
-import { KONTAKT_ROLLEN, KONTAKT_ROLLE_BESCHRIFTUNG } from '@/lib/validierung/kontakte'
+import {
+  KONTAKT_ANREDEN,
+  KONTAKT_ROLLEN,
+  KONTAKT_ROLLE_BESCHRIFTUNG,
+} from '@/lib/validierung/kontakte'
+import { ANREDE_BESCHRIFTUNG } from '@/lib/kontakte/anrede'
 import { kontaktSpeichern, type KontaktZustand } from '@/server/actions/kontakte'
 
 /**
@@ -24,6 +29,7 @@ export type KontaktWerte = {
   name: string
   organisation: string | null
   rolle: string
+  anrede: string
   telefon: string | null
   mobil: string | null
   fax: string | null
@@ -91,6 +97,21 @@ export function KontaktFormular({
           </Select>
         </Feld>
 
+        <Feld
+          id="anrede"
+          beschriftung="Anrede"
+          erklaerung="Für die Briefanrede. Ohne Angabe wird mit vollem Namen angeredet — geraten wird nie."
+          fehler={zustand.felder?.anrede}
+        >
+          <Select name="anrede" defaultValue={wert('anrede') || 'OHNE'}>
+            {KONTAKT_ANREDEN.map((anrede) => (
+              <option key={anrede} value={anrede}>
+                {ANREDE_BESCHRIFTUNG[anrede]}
+              </option>
+            ))}
+          </Select>
+        </Feld>
+
         <Feld
           id="aktenzeichen"
           beschriftung="Aktenzeichen dort"

src/components/konto/passkey-verwaltung.tsx

@@ -0,0 +1,277 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { useRouter } from 'next/navigation'
+import {
+  AlertCircle,
+  CheckCircle2,
+  Fingerprint,
+  Loader2,
+  Plus,
+  Smartphone,
+  Trash2,
+} from 'lucide-react'
+import {
+  passkeyEinrichtungAbschliessen,
+  passkeyEinrichtungStarten,
+  passkeyEntfernen,
+} from '@/server/actions/passkey'
+import {
+  browserSupportsWebAuthn,
+  passkeyBrowserfehler,
+  startRegistration,
+} from '@/lib/passkey-browser'
+import type { PasskeyUebersicht } from '@/lib/auth/passkey'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Feld } from '@/components/feld'
+import { formatDatum, formatDatumZeit } from '@/lib/utils'
+
+/**
+ * Verwaltung der eigenen Passkeys unter "Mein Konto".
+ *
+ * Die Liste kommt vom Server; nach jeder Aenderung wird die Seite neu
+ * geladen (router.refresh) statt den Zustand hier mitzufuehren. Bei einer
+ * Handvoll Eintraegen ist das die ehrlichere Loesung: Was auf dem Bildschirm
+ * steht, steht auch so in der Datenbank.
+ */
+export function PasskeyVerwaltung({
+  passkeys,
+  zweiterFaktorAktiv,
+  moeglich,
+}: {
+  passkeys: PasskeyUebersicht[]
+  zweiterFaktorAktiv: boolean
+  /** Ob der Server Passkeys ueberhaupt anbieten kann (https). */
+  moeglich: boolean
+}) {
+  const router = useRouter()
+  const [browserKann, setBrowserKann] = useState(false)
+  const [name, setName] = useState('')
+  const [laeuft, setLaeuft] = useState(false)
+  const [entfernt, setEntfernt] = useState<string | null>(null)
+  const [fehler, setFehler] = useState<string | null>(null)
+  const [erfolg, setErfolg] = useState<string | null>(null)
+  const [nachfrage, setNachfrage] = useState<string | null>(null)
+
+  useEffect(() => {
+    setBrowserKann(browserSupportsWebAuthn())
+  }, [])
+
+  async function einrichten() {
+    setFehler(null)
+    setErfolg(null)
+
+    if (name.trim() === '') {
+      setFehler('Bitte gib dem Gerät zuerst einen Namen.')
+      return
+    }
+
+    setLaeuft(true)
+    try {
+      const start = await passkeyEinrichtungStarten()
+      if (!start.ok) {
+        setFehler(start.fehler)
+        return
+      }
+
+      const antwort = await startRegistration({ optionsJSON: start.optionen })
+      const ergebnis = await passkeyEinrichtungAbschliessen(name, JSON.stringify(antwort))
+
+      if (!ergebnis.ok) {
+        setFehler(ergebnis.fehler)
+        return
+      }
+
+      setName('')
+      setErfolg(ergebnis.meldung ?? 'Passkey eingerichtet.')
+      router.refresh()
+    } catch (ausnahme) {
+      setFehler(passkeyBrowserfehler(ausnahme, true))
+    } finally {
+      setLaeuft(false)
+    }
+  }
+
+  async function entfernen(id: string) {
+    setFehler(null)
+    setErfolg(null)
+    setNachfrage(null)
+    setEntfernt(id)
+
+    try {
+      const ergebnis = await passkeyEntfernen(id)
+      if (!ergebnis.ok) {
+        setFehler(ergebnis.fehler)
+        return
+      }
+      setErfolg(ergebnis.meldung ?? 'Passkey entfernt.')
+      router.refresh()
+    } finally {
+      setEntfernt(null)
+    }
+  }
+
+  if (!moeglich) {
+    return (
+      <Alert variant="hinweis">
+        <AlertCircle aria-hidden="true" />
+        <AlertDescription>
+          Passkeys brauchen eine verschlüsselte Verbindung. Diese Installation ist nicht über
+          <code className="mx-1 rounded bg-muted px-1 py-0.5 text-xs">https</code>
+          erreichbar — sobald sie es ist, erscheint hier die Verwaltung.
+        </AlertDescription>
+      </Alert>
+    )
+  }
+
+  if (!zweiterFaktorAktiv) {
+    return (
+      <Alert variant="hinweis">
+        <AlertCircle aria-hidden="true" />
+        <AlertDescription>
+          Richte zuerst die Authenticator-App ein. Ein Passkey hängt an einem Gerät — ginge das
+          verloren und wäre er der einzige Weg hinein, käme niemand mehr an die Akte. Der Passkey
+          ist die bequeme Tür, nicht die einzige.
+        </AlertDescription>
+      </Alert>
+    )
+  }
+
+  return (
+    <div className="space-y-4">
+      {fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{fehler}</AlertDescription>
+        </Alert>
+      )}
+
+      {erfolg && (
+        <Alert variant="erfolg">
+          <CheckCircle2 aria-hidden="true" />
+          <AlertDescription>{erfolg}</AlertDescription>
+        </Alert>
+      )}
+
+      {passkeys.length === 0 ? (
+        <p className="text-sm text-muted-foreground">
+          Noch kein Passkey eingerichtet. Du meldest dich weiterhin mit E-Mail, Passwort und Code an
+          — das bleibt auch danach möglich.
+        </p>
+      ) : (
+        <ul className="divide-y rounded-md border">
+          {passkeys.map((passkey) => (
+            <li key={passkey.id} className="flex flex-wrap items-start gap-3 p-3">
+              <Smartphone
+                className="mt-0.5 size-5 shrink-0 text-muted-foreground"
+                aria-hidden="true"
+              />
+
+              <div className="min-w-0 flex-1">
+                <p className="font-medium">{passkey.name}</p>
+                <p className="text-xs text-muted-foreground">
+                  Eingerichtet am {formatDatum(passkey.erstelltAm)}
+                  {passkey.zuletztBenutztAm
+                    ? ` · zuletzt benutzt ${formatDatumZeit(passkey.zuletztBenutztAm)}`
+                    : ' · noch nicht benutzt'}
+                </p>
+                {passkey.geraeteArt === 'singleDevice' && (
+                  <p className="mt-1 text-xs text-muted-foreground">
+                    Liegt nur auf diesem Gerät. Geht es verloren, ist auch der Passkey weg.
+                  </p>
+                )}
+              </div>
+
+              {passkey.gesichert && (
+                <Badge variant="secondary" className="shrink-0">
+                  gesichert
+                </Badge>
+              )}
+
+              {nachfrage === passkey.id ? (
+                <div className="flex shrink-0 items-center gap-2">
+                  <Button
+                    type="button"
+                    variant="destructive"
+                    size="sm"
+                    onClick={() => void entfernen(passkey.id)}
+                    disabled={entfernt === passkey.id}
+                  >
+                    {entfernt === passkey.id ? (
+                      <Loader2 className="animate-spin" aria-hidden="true" />
+                    ) : null}
+                    Wirklich entfernen
+                  </Button>
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => setNachfrage(null)}
+                  >
+                    Abbrechen
+                  </Button>
+                </div>
+              ) : (
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="sm"
+                  className="shrink-0"
+                  onClick={() => setNachfrage(passkey.id)}
+                  aria-label={`Passkey „${passkey.name}“ entfernen`}
+                >
+                  <Trash2 aria-hidden="true" />
+                  Entfernen
+                </Button>
+              )}
+            </li>
+          ))}
+        </ul>
+      )}
+
+      {browserKann ? (
+        <div className="space-y-3 rounded-md border border-dashed p-3">
+          <Feld
+            id="passkey-name"
+            beschriftung="Neues Gerät"
+            erklaerung="Ein Name, an dem du es später wiedererkennst — etwa „iPhone“ oder „Laptop Büro“."
+          >
+            <Input
+              id="passkey-name"
+              value={name}
+              onChange={(ereignis) => setName(ereignis.target.value)}
+              maxLength={60}
+              placeholder="iPhone"
+              autoComplete="off"
+            />
+          </Feld>
+
+          <Button type="button" onClick={() => void einrichten()} disabled={laeuft}>
+            {laeuft ? (
+              <>
+                <Loader2 className="animate-spin" aria-hidden="true" />
+                Warte auf das Gerät …
+              </>
+            ) : (
+              <>
+                <Plus aria-hidden="true" />
+                Passkey einrichten
+              </>
+            )}
+          </Button>
+        </div>
+      ) : (
+        <Alert variant="hinweis">
+          <Fingerprint aria-hidden="true" />
+          <AlertDescription>
+            Dieser Browser kann keine Passkeys. Auf einem anderen Gerät klappt es vermutlich — die
+            bereits eingerichteten bleiben davon unberührt.
+          </AlertDescription>
+        </Alert>
+      )}
+    </div>
+  )
+}

src/components/markdown-seite.tsx

@@ -0,0 +1,324 @@
+import * as React from 'react'
+
+/**
+ * Anzeige einer Markdown-Datei aus dem docs-Verzeichnis.
+ *
+ * Bewusst ohne Markdown-Bibliothek: Die Anwendung zeigt genau zwei solche
+ * Dokumente an - die Datenschutzhinweise und die Anleitung. Beide schreibe
+ * ich selbst, ich weiss also, welche Auszeichnungen darin vorkommen. Eine
+ * Bibliothek waere hier vor allem zusaetzliche Abhaengigkeit und
+ * zusaetzliche Angriffsflaeche.
+ *
+ * Unterstuetzt: Ueberschriften, Absaetze, Aufzaehlungen (auch nummeriert),
+ * Tabellen, Zitatbloecke, Codebloecke, Trennlinien sowie **fett**,
+ * `Code` und [Links](ziel) im Fliesstext.
+ *
+ * Nicht unterstuetzt und auch nicht noetig: eingebettetes HTML, Bilder,
+ * Fussnoten. Rohes HTML wird NICHT durchgereicht - der Text wird immer als
+ * Text ausgegeben, nie als Markup.
+ */
+
+type Block =
+  | { art: 'ueberschrift'; ebene: 2 | 3 | 4; text: string }
+  | { art: 'absatz'; text: string }
+  | { art: 'liste'; nummeriert: boolean; punkte: string[] }
+  | { art: 'tabelle'; kopf: string[]; zeilen: string[][] }
+  | { art: 'zitat'; zeilen: string[] }
+  | { art: 'code'; zeilen: string[] }
+  | { art: 'trenner' }
+
+/** Zerlegt den Fliesstext in fett, Code und Links. */
+function inline(text: string, schluessel: string): React.ReactNode[] {
+  const teile: React.ReactNode[] = []
+  // Reihenfolge zaehlt: Code zuerst, damit Sternchen darin nicht greifen.
+  const muster = /(`[^`]+`)|(\*\*[^*]+\*\*)|(\[[^\]]+\]\([^)]+\))/g
+
+  let letzte = 0
+  let treffer: RegExpExecArray | null
+  let nummer = 0
+
+  while ((treffer = muster.exec(text)) !== null) {
+    if (treffer.index > letzte) {
+      teile.push(text.slice(letzte, treffer.index))
+    }
+
+    const stueck = treffer[0]
+    const id = `${schluessel}-${nummer++}`
+
+    if (stueck.startsWith('`')) {
+      teile.push(
+        <code key={id} className="rounded bg-muted px-1.5 py-0.5 font-mono text-[0.9em]">
+          {stueck.slice(1, -1)}
+        </code>,
+      )
+    } else if (stueck.startsWith('**')) {
+      teile.push(
+        <strong key={id} className="font-semibold">
+          {stueck.slice(2, -2)}
+        </strong>,
+      )
+    } else {
+      const beschriftung = stueck.slice(1, stueck.indexOf(']'))
+      const ziel = stueck.slice(stueck.indexOf('](') + 2, -1)
+      const extern = /^https?:\/\//.test(ziel)
+      teile.push(
+        <a
+          key={id}
+          href={ziel}
+          className="text-primary underline underline-offset-2 hover:no-underline"
+          {...(extern ? { target: '_blank', rel: 'noreferrer noopener' } : {})}
+        >
+          {beschriftung}
+        </a>,
+      )
+    }
+
+    letzte = treffer.index + stueck.length
+  }
+
+  if (letzte < text.length) teile.push(text.slice(letzte))
+  return teile
+}
+
+function zerlegen(markdown: string, ohneTitel: boolean): Block[] {
+  const zeilen = markdown.split(/\r?\n/)
+  const bloecke: Block[] = []
+  let absatz: string[] = []
+
+  const absatzSchliessen = () => {
+    if (absatz.length === 0) return
+    bloecke.push({ art: 'absatz', text: absatz.join(' ') })
+    absatz = []
+  }
+
+  for (let i = 0; i < zeilen.length; i++) {
+    const roh = zeilen[i] ?? ''
+    const zeile = roh.trimEnd()
+    const gekuerzt = zeile.trim()
+
+    // --- Codeblock ---------------------------------------------------------
+    if (gekuerzt.startsWith('```')) {
+      absatzSchliessen()
+      const inhalt: string[] = []
+      i += 1
+      while (i < zeilen.length && !(zeilen[i] ?? '').trim().startsWith('```')) {
+        inhalt.push(zeilen[i] ?? '')
+        i += 1
+      }
+      bloecke.push({ art: 'code', zeilen: inhalt })
+      continue
+    }
+
+    if (gekuerzt === '') {
+      absatzSchliessen()
+      continue
+    }
+
+    if (/^-{3,}$/.test(gekuerzt) || /^\*{3,}$/.test(gekuerzt)) {
+      absatzSchliessen()
+      bloecke.push({ art: 'trenner' })
+      continue
+    }
+
+    // --- Ueberschriften ----------------------------------------------------
+    const ueberschrift = gekuerzt.match(/^(#{1,4})\s+(.*)$/)
+    if (ueberschrift) {
+      absatzSchliessen()
+      const ebene = ueberschrift[1]!.length
+      // Die H1 ist der Dokumenttitel - den setzt die Seite selbst.
+      if (ebene === 1 && ohneTitel) continue
+      bloecke.push({
+        art: 'ueberschrift',
+        ebene: (Math.min(Math.max(ebene, 2), 4) as 2 | 3 | 4),
+        text: ueberschrift[2]!,
+      })
+      continue
+    }
+
+    // --- Zitatblock --------------------------------------------------------
+    if (gekuerzt.startsWith('>')) {
+      absatzSchliessen()
+      const inhalt: string[] = []
+      while (i < zeilen.length && (zeilen[i] ?? '').trim().startsWith('>')) {
+        inhalt.push((zeilen[i] ?? '').trim().replace(/^>\s?/, ''))
+        i += 1
+      }
+      i -= 1
+      bloecke.push({ art: 'zitat', zeilen: [inhalt.join(' ')] })
+      continue
+    }
+
+    // --- Tabelle -----------------------------------------------------------
+    if (gekuerzt.startsWith('|')) {
+      absatzSchliessen()
+      const spalten = (z: string) =>
+        z
+          .trim()
+          .replace(/^\|/, '')
+          .replace(/\|$/, '')
+          .split('|')
+          .map((s) => s.trim())
+
+      const kopf = spalten(gekuerzt)
+      i += 1 // Trennzeile ueberspringen
+      const zeilenInhalt: string[][] = []
+      while (i + 1 < zeilen.length && (zeilen[i + 1] ?? '').trim().startsWith('|')) {
+        i += 1
+        zeilenInhalt.push(spalten(zeilen[i] ?? ''))
+      }
+      bloecke.push({ art: 'tabelle', kopf, zeilen: zeilenInhalt })
+      continue
+    }
+
+    // --- Aufzaehlung -------------------------------------------------------
+    const punkt = gekuerzt.match(/^(?:[-*]|\d+\.)\s+(.*)$/)
+    if (punkt) {
+      absatzSchliessen()
+      const nummeriert = /^\d+\./.test(gekuerzt)
+      const punkte: string[] = [punkt[1]!]
+
+      while (i + 1 < zeilen.length) {
+        const naechste = (zeilen[i + 1] ?? '').trim()
+        const weiterer = naechste.match(/^(?:[-*]|\d+\.)\s+(.*)$/)
+        if (weiterer && /^\d+\./.test(naechste) === nummeriert) {
+          punkte.push(weiterer[1]!)
+          i += 1
+          continue
+        }
+        // Eingerueckte Fortsetzung gehoert zum letzten Punkt.
+        if (naechste !== '' && /^\s{2,}\S/.test(zeilen[i + 1] ?? '')) {
+          punkte[punkte.length - 1] += ` ${naechste}`
+          i += 1
+          continue
+        }
+        break
+      }
+
+      bloecke.push({ art: 'liste', nummeriert, punkte })
+      continue
+    }
+
+    absatz.push(gekuerzt)
+  }
+
+  absatzSchliessen()
+  return bloecke
+}
+
+export function MarkdownSeite({
+  inhalt,
+  ohneTitel = true,
+  className,
+}: {
+  inhalt: string
+  /** Die erste H1 weglassen - die Seite setzt ihre Ueberschrift selbst. */
+  ohneTitel?: boolean
+  className?: string
+}) {
+  const bloecke = zerlegen(inhalt, ohneTitel)
+
+  return (
+    <article className={className}>
+      {bloecke.map((block, i) => {
+        switch (block.art) {
+          case 'ueberschrift': {
+            const Tag = `h${block.ebene}` as 'h2' | 'h3' | 'h4'
+            const groesse =
+              block.ebene === 2
+                ? 'mt-10 text-xl font-semibold'
+                : block.ebene === 3
+                  ? 'mt-7 text-lg font-semibold'
+                  : 'mt-5 text-base font-semibold'
+            return (
+              <Tag key={i} className={`${groesse} scroll-mt-20 first:mt-0`}>
+                {block.text}
+              </Tag>
+            )
+          }
+
+          case 'absatz':
+            return (
+              <p key={i} className="mt-3 leading-relaxed">
+                {inline(block.text, String(i))}
+              </p>
+            )
+
+          case 'liste': {
+            const Tag = block.nummeriert ? 'ol' : 'ul'
+            return (
+              <Tag
+                key={i}
+                className={`mt-3 space-y-1.5 pl-6 ${
+                  block.nummeriert ? 'list-decimal' : 'list-disc'
+                }`}
+              >
+                {block.punkte.map((punkt, j) => (
+                  <li key={j} className="leading-relaxed">
+                    {inline(punkt, `${i}-${j}`)}
+                  </li>
+                ))}
+              </Tag>
+            )
+          }
+
+          case 'tabelle':
+            return (
+              // Tabellen scrollen im eigenen Rahmen - am Handy darf nie die
+              // ganze Seite seitlich wandern.
+              <div key={i} className="mt-4 w-full overflow-x-auto rounded-lg border">
+                <table className="w-full text-sm">
+                  <thead>
+                    <tr className="border-b bg-muted/50">
+                      {block.kopf.map((spalte, j) => (
+                        <th key={j} className="px-3 py-2 text-left font-semibold">
+                          {inline(spalte, `${i}-k-${j}`)}
+                        </th>
+                      ))}
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {block.zeilen.map((zeile, j) => (
+                      <tr key={j} className="border-b last:border-0">
+                        {zeile.map((zelle, k) => (
+                          <td key={k} className="px-3 py-2 align-top">
+                            {inline(zelle, `${i}-${j}-${k}`)}
+                          </td>
+                        ))}
+                      </tr>
+                    ))}
+                  </tbody>
+                </table>
+              </div>
+            )
+
+          case 'zitat':
+            return (
+              <blockquote
+                key={i}
+                className="mt-4 rounded-r-md border-l-4 border-primary/40 bg-muted/40 py-3 pl-4 pr-3"
+              >
+                {block.zeilen.map((zeile, j) => (
+                  <p key={j} className="leading-relaxed">
+                    {inline(zeile, `${i}-${j}`)}
+                  </p>
+                ))}
+              </blockquote>
+            )
+
+          case 'code':
+            return (
+              <pre
+                key={i}
+                className="mt-4 overflow-x-auto rounded-lg border bg-muted/60 p-3 text-sm"
+              >
+                <code className="font-mono">{block.zeilen.join('\n')}</code>
+              </pre>
+            )
+
+          case 'trenner':
+            return <hr key={i} className="my-8" />
+        }
+      })}
+    </article>
+  )
+}

src/components/passkey-anmeldung.tsx

@@ -0,0 +1,104 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { AlertCircle, Fingerprint, Loader2 } from 'lucide-react'
+import { passkeyAnmeldungAbschliessen, passkeyAnmeldungStarten } from '@/server/actions/passkey'
+import {
+  browserSupportsWebAuthn,
+  passkeyBrowserfehler,
+  startAuthentication,
+} from '@/lib/passkey-browser'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Button } from '@/components/ui/button'
+
+/**
+ * Knopf "Mit Passkey anmelden" auf der Anmeldeseite.
+ *
+ * Der Ablauf ist dreiteilig: Optionen vom Server holen, das Geraet fragen,
+ * die Antwort zurueckschicken. Gelingt der letzte Schritt, leitet die Server
+ * Action weiter - dieser Baustein sieht das Ergebnis dann gar nicht mehr.
+ *
+ * Sichtbar ist der Knopf nur, wenn der Server ihn anbietet (https) UND der
+ * Browser WebAuthn kann. Die zweite Pruefung laeuft erst nach dem ersten
+ * Rendern: Auf dem Server gibt es kein navigator-Objekt, und ein Knopf, der
+ * beim Laden verschwindet, ist unangenehmer als einer, der kurz spaeter
+ * erscheint.
+ */
+export function PasskeyAnmeldung({ weiter }: { weiter: string }) {
+  const [laeuft, setLaeuft] = useState(false)
+  const [fehler, setFehler] = useState<string | null>(null)
+  const [browserKann, setBrowserKann] = useState(false)
+
+  useEffect(() => {
+    setBrowserKann(browserSupportsWebAuthn())
+  }, [])
+
+  async function anmelden() {
+    setFehler(null)
+    setLaeuft(true)
+
+    try {
+      const start = await passkeyAnmeldungStarten()
+      if (!start.ok) {
+        setFehler(start.fehler)
+        return
+      }
+
+      const antwort = await startAuthentication({
+        optionsJSON: start.optionen,
+      })
+
+      const ergebnis = await passkeyAnmeldungAbschliessen(JSON.stringify(antwort), weiter)
+      // Bei Erfolg wird gar nichts zurueckgegeben - die Action leitet weiter.
+      if (!ergebnis.ok) setFehler(ergebnis.fehler)
+    } catch (ausnahme) {
+      setFehler(passkeyBrowserfehler(ausnahme))
+    } finally {
+      setLaeuft(false)
+    }
+  }
+
+  if (!browserKann) return null
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center gap-3">
+        <span className="h-px flex-1 bg-border" />
+        <span className="text-xs uppercase tracking-wide text-muted-foreground">oder</span>
+        <span className="h-px flex-1 bg-border" />
+      </div>
+
+      {fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{fehler}</AlertDescription>
+        </Alert>
+      )}
+
+      <Button
+        type="button"
+        variant="outline"
+        size="lg"
+        className="w-full"
+        onClick={anmelden}
+        disabled={laeuft}
+      >
+        {laeuft ? (
+          <>
+            <Loader2 className="animate-spin" aria-hidden="true" />
+            Warte auf das Gerät …
+          </>
+        ) : (
+          <>
+            <Fingerprint aria-hidden="true" />
+            Mit Passkey anmelden
+          </>
+        )}
+      </Button>
+
+      <p className="text-center text-xs text-muted-foreground">
+        Fingerabdruck, Gesicht oder Geräte-PIN — ohne E-Mail und Passwort.
+      </p>
+    </div>
+  )
+}

src/components/schreiben/schreiben-editor.tsx

@@ -0,0 +1,521 @@
+'use client'
+
+import * as React from 'react'
+import { useActionState } from 'react'
+import Link from 'next/link'
+import {
+  AlertCircle,
+  CheckCircle2,
+  Copy,
+  FileDown,
+  FolderInput,
+  Info,
+  Mail,
+  UserPlus,
+} from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Input } from '@/components/ui/input'
+import { Textarea } from '@/components/ui/textarea'
+import { Select } from '@/components/ui/select'
+import { Feld } from '@/components/feld'
+import { Absendeknopf } from '@/components/finanzen/eingaben'
+import {
+  kontaktAusAnschrift,
+  schreibenAblegen,
+  type SchreibenZustand,
+} from '@/server/actions/schreiben'
+import type { SchreibenArt } from '@/lib/schreiben/arten'
+import { emailFassung, mailtoLink, siehtAusWieEmail } from '@/lib/schreiben/email'
+
+export type KontaktAuswahl = {
+  id: string
+  name: string
+  organisation: string | null
+  strasse: string | null
+  plz: string | null
+  ort: string | null
+  email: string | null
+}
+
+/**
+ * Schreiben bearbeiten, herunterladen, ablegen.
+ *
+ * Der Text steht in einem gewöhnlichen Textfeld und ist vollständig
+ * bearbeitbar. Das ist Absicht: Jeder Fall hat eine Besonderheit, die in
+ * den Brief gehört. Ein Formulartext, den man nicht mehr ändern kann,
+ * wird früher oder später falsch abgeschickt.
+ */
+export function SchreibenEditor({
+  betreuteId,
+  art,
+  entwurf,
+  kontakte,
+  vertragId,
+  vorgangId,
+  fristBegruendung,
+  warnungen,
+}: {
+  betreuteId: string
+  art: SchreibenArt
+  entwurf: {
+    betreff: string
+    text: string
+    empfaengerName: string
+    empfaengerAnschrift: string
+    wiedervorlageAm: string
+  }
+  kontakte: KontaktAuswahl[]
+  vertragId: string | null
+  vorgangId: string | null
+  fristBegruendung: string | null
+  warnungen: string[]
+}) {
+  const [text, setText] = React.useState(entwurf.text)
+  const [betreff, setBetreff] = React.useState(entwurf.betreff)
+  const [empfaengerName, setEmpfaengerName] = React.useState(entwurf.empfaengerName)
+  const [empfaengerAnschrift, setEmpfaengerAnschrift] = React.useState(
+    entwurf.empfaengerAnschrift,
+  )
+  const [empfaengerEmail, setEmpfaengerEmail] = React.useState('')
+  const [versandweg, setVersandweg] = React.useState<'BRIEF' | 'EMAIL'>('BRIEF')
+  const [betreffKopiert, setBetreffKopiert] = React.useState(false)
+  const [mailKopiert, setMailKopiert] = React.useState(false)
+  const [versandAm, setVersandAm] = React.useState(new Date().toISOString().slice(0, 10))
+  const [wiedervorlageAm, setWiedervorlageAm] = React.useState(entwurf.wiedervorlageAm)
+  const [kopiert, setKopiert] = React.useState(false)
+
+  const [ablageZustand, ablegen] = useActionState<SchreibenZustand, FormData>(
+    schreibenAblegen,
+    {},
+  )
+  const [kontaktZustand, kontaktAnlegen] = useActionState<SchreibenZustand, FormData>(
+    kontaktAusAnschrift,
+    {},
+  )
+
+  /** Gemeinsame versteckte Felder für beide Formulare und den Download. */
+  function VersteckteFelder() {
+    return (
+      <>
+        <input type="hidden" name="betreuteId" value={betreuteId} />
+        <input type="hidden" name="art" value={art} />
+        <input type="hidden" name="betreff" value={betreff} />
+        <input type="hidden" name="text" value={text} />
+        <input type="hidden" name="empfaengerName" value={empfaengerName} />
+        <input type="hidden" name="empfaengerAnschrift" value={empfaengerAnschrift} />
+        <input type="hidden" name="versandAm" value={versandAm} />
+        <input type="hidden" name="wiedervorlageAm" value={wiedervorlageAm} />
+        <input type="hidden" name="vertragId" value={vertragId ?? ''} />
+        <input type="hidden" name="vorgangId" value={vorgangId ?? ''} />
+        <input type="hidden" name="versandweg" value={versandweg} />
+        <input type="hidden" name="empfaengerEmail" value={empfaengerEmail} />
+      </>
+    )
+  }
+
+  function kontaktUebernehmen(id: string) {
+    const kontakt = kontakte.find((k) => k.id === id)
+    if (!kontakt) return
+    setEmpfaengerName(kontakt.organisation ?? kontakt.name)
+    setEmpfaengerAnschrift(
+      [kontakt.strasse, [kontakt.plz, kontakt.ort].filter(Boolean).join(' ')]
+        .filter(Boolean)
+        .join('\n'),
+    )
+    setEmpfaengerEmail(kontakt.email ?? '')
+  }
+
+  async function textKopieren() {
+    try {
+      await navigator.clipboard.writeText(text)
+      setKopiert(true)
+      window.setTimeout(() => setKopiert(false), 2500)
+    } catch {
+      /* Zwischenablage gesperrt - dann markiert man eben von Hand. */
+    }
+  }
+
+  const abgelegt = Boolean(ablageZustand.erfolg)
+
+  /**
+   * Die E-Mail-Fassung: Betreff und Rumpf getrennt, ohne Briefkopf.
+   *
+   * Abgeleitet aus dem AKTUELLEN Text im Feld - wer den Brief bearbeitet
+   * hat, bekommt die bearbeitete Fassung, nicht den Ursprungsentwurf.
+   */
+  function EmailAusgabe() {
+    const fassung = emailFassung(text, betreff)
+    const adresseGueltig = siehtAusWieEmail(empfaengerEmail)
+    const mailto = adresseGueltig ? mailtoLink(empfaengerEmail, fassung) : null
+
+    async function kopieren(inhalt: string, merker: (wert: boolean) => void) {
+      try {
+        await navigator.clipboard.writeText(inhalt)
+        merker(true)
+        window.setTimeout(() => merker(false), 2500)
+      } catch {
+        /* Zwischenablage gesperrt - dann markiert man eben von Hand. */
+      }
+    }
+
+    return (
+      <div className="space-y-4 rounded-md border p-4">
+        <Feld
+          id="emailBetreff"
+          beschriftung="Betreff der E-Mail"
+          erklaerung="Aus der Betreffzeile des Briefes übernommen."
+        >
+          <div className="flex gap-2">
+            <Input id="emailBetreff" value={fassung.betreff} readOnly className="flex-1" />
+            <Button
+              type="button"
+              variant="outline"
+              onClick={() => void kopieren(fassung.betreff, setBetreffKopiert)}
+            >
+              <Copy aria-hidden="true" />
+              {betreffKopiert ? 'Kopiert' : 'Kopieren'}
+            </Button>
+          </div>
+        </Feld>
+
+        <Feld
+          id="emailText"
+          beschriftung="Text der E-Mail"
+          erklaerung="Ohne Absenderblock, Anschrift und Datumszeile — die gehören in den Brief, nicht in die Mail. Der Nachweis der Bestellung bleibt drin."
+        >
+          <div className="space-y-2">
+            <Textarea
+              id="emailText"
+              value={fassung.text}
+              readOnly
+              rows={14}
+              className="font-mono text-sm leading-relaxed"
+            />
+            <Button
+              type="button"
+              variant="outline"
+              onClick={() => void kopieren(fassung.text, setMailKopiert)}
+            >
+              <Copy aria-hidden="true" />
+              {mailKopiert ? 'Kopiert' : 'Text kopieren'}
+            </Button>
+          </div>
+        </Feld>
+
+        <div className="flex flex-wrap items-center gap-2">
+          {mailto && (
+            <Button asChild variant="outline">
+              <a href={mailto}>
+                <Mail aria-hidden="true" />
+                Im Mailprogramm öffnen
+              </a>
+            </Button>
+          )}
+
+          {adresseGueltig && (
+            <form action="/schreiben/eml" method="post" className="inline">
+              <VersteckteFelder />
+              <Button type="submit" variant="outline">
+                <FileDown aria-hidden="true" />
+                Als E-Mail-Entwurf (.eml)
+              </Button>
+            </form>
+          )}
+        </div>
+
+        {!adresseGueltig && (
+          <p className="text-sm text-muted-foreground">
+            Trag oben eine E-Mail-Adresse ein, dann erscheinen hier die Knöpfe fürs
+            Mailprogramm. Kopieren geht auch ohne.
+          </p>
+        )}
+
+        {adresseGueltig && !mailto && (
+          <p className="text-sm text-muted-foreground">
+            Der Text ist zu lang für einen mailto-Link — manche Mailprogramme würden ihn
+            stillschweigend abschneiden. Nimm die .eml-Datei, sie trägt den vollen Text.
+          </p>
+        )}
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-6">
+      {warnungen.length > 0 && (
+        <Alert variant="warnung">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>
+            <p className="font-medium">Vor dem Abschicken klären:</p>
+            <ul className="mt-1 list-disc space-y-1 pl-4">
+              {warnungen.map((warnung) => (
+                <li key={warnung}>{warnung}</li>
+              ))}
+            </ul>
+          </AlertDescription>
+        </Alert>
+      )}
+
+      {/* --- Empfänger ---------------------------------------------------- */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">An wen geht das Schreiben?</CardTitle>
+          <CardDescription>
+            Der Empfänger steht im Brieftext darunter — was du hier einträgst, landet am Dokument
+            in der Akte und im Dateinamen.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          {kontakte.length > 0 && (
+            <Feld
+              id="kontaktAuswahl"
+              beschriftung="Aus den Kontakten übernehmen"
+              erklaerung="Spart das Abtippen, wenn die Stelle schon im System steht."
+            >
+              <Select
+                id="kontaktAuswahl"
+                defaultValue=""
+                onChange={(ereignis) => kontaktUebernehmen(ereignis.target.value)}
+              >
+                <option value="">– Kontakt wählen –</option>
+                {kontakte.map((kontakt) => (
+                  <option key={kontakt.id} value={kontakt.id}>
+                    {kontakt.organisation ?? kontakt.name}
+                    {kontakt.ort ? ` · ${kontakt.ort}` : ''}
+                  </option>
+                ))}
+              </Select>
+            </Feld>
+          )}
+
+          <Feld id="empfaengerName" beschriftung="Name oder Gesellschaft" pflicht>
+            <Input
+              id="empfaengerName"
+              value={empfaengerName}
+              onChange={(ereignis) => setEmpfaengerName(ereignis.target.value)}
+              maxLength={200}
+              placeholder="z. B. Allianz Lebensversicherungs-AG"
+            />
+          </Feld>
+
+          <Feld
+            id="empfaengerAnschrift"
+            beschriftung="Anschrift"
+            erklaerung="Straße, dann PLZ und Ort — je Zeile eine Angabe. Nur nötig, wenn du daraus einen Kontakt anlegen willst; in den Brieftext trägst du sie unten selbst ein."
+          >
+            <Textarea
+              id="empfaengerAnschrift"
+              value={empfaengerAnschrift}
+              onChange={(ereignis) => setEmpfaengerAnschrift(ereignis.target.value)}
+              rows={3}
+              maxLength={500}
+            />
+          </Feld>
+
+          <Feld
+            id="empfaengerEmail"
+            beschriftung="E-Mail-Adresse"
+            erklaerung="Nur nötig, wenn das Schreiben als E-Mail hinausgehen soll. Wird aus dem gewählten Kontakt übernommen."
+          >
+            <Input
+              id="empfaengerEmail"
+              type="email"
+              value={empfaengerEmail}
+              onChange={(ereignis) => setEmpfaengerEmail(ereignis.target.value)}
+              maxLength={200}
+              placeholder="service@versicherung.de"
+            />
+          </Feld>
+
+          {empfaengerName.trim() !== '' && empfaengerAnschrift.trim() !== '' && (
+            <form action={kontaktAnlegen}>
+              <VersteckteFelder />
+              {kontaktZustand.fehler && (
+                <Alert variant="fehler" className="mb-2">
+                  <AlertCircle aria-hidden="true" />
+                  <AlertDescription>{kontaktZustand.fehler}</AlertDescription>
+                </Alert>
+              )}
+              {kontaktZustand.erfolg && (
+                <Alert variant="erfolg" className="mb-2">
+                  <CheckCircle2 aria-hidden="true" />
+                  <AlertDescription>{kontaktZustand.erfolg}</AlertDescription>
+                </Alert>
+              )}
+              <Absendeknopf variant="outline" size="sm" wartetext="Wird angelegt …">
+                <UserPlus aria-hidden="true" />
+                Als Kontakt merken
+              </Absendeknopf>
+            </form>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* --- Der Brief ---------------------------------------------------- */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">Der Brief</CardTitle>
+          <CardDescription>
+            Vollständig bearbeitbar. Was hier steht, steht auch in der Word-Datei und in der
+            Fassung für die Akte.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <Feld
+            id="betreff"
+            beschriftung="Betreff"
+            erklaerung="Wird zum Titel des Dokuments in der Akte."
+            pflicht
+          >
+            <Input
+              id="betreff"
+              value={betreff}
+              onChange={(ereignis) => setBetreff(ereignis.target.value)}
+              maxLength={200}
+            />
+          </Feld>
+
+          <Feld id="text" beschriftung="Brieftext" pflicht>
+            <Textarea
+              id="text"
+              value={text}
+              onChange={(ereignis) => setText(ereignis.target.value)}
+              rows={26}
+              className="font-mono text-sm leading-relaxed"
+              spellCheck
+            />
+          </Feld>
+
+          <Button type="button" variant="ghost" size="sm" onClick={() => void textKopieren()}>
+            <Copy aria-hidden="true" />
+            {kopiert ? 'Kopiert' : 'Text kopieren'}
+          </Button>
+        </CardContent>
+      </Card>
+
+      {/* --- Ausgabe ------------------------------------------------------ */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">Und jetzt?</CardTitle>
+          <CardDescription>
+            Wie geht es hinaus? Die Wahl bestimmt auch, wie das Schreiben in der Akte
+            gekennzeichnet wird.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-5">
+          <div className="flex gap-2" role="group" aria-label="Versandweg">
+            <Button
+              type="button"
+              variant={versandweg === 'BRIEF' ? 'default' : 'outline'}
+              onClick={() => setVersandweg('BRIEF')}
+            >
+              <FileDown aria-hidden="true" />
+              Als Brief
+            </Button>
+            <Button
+              type="button"
+              variant={versandweg === 'EMAIL' ? 'default' : 'outline'}
+              onClick={() => setVersandweg('EMAIL')}
+            >
+              <Mail aria-hidden="true" />
+              Als E-Mail
+            </Button>
+          </div>
+
+          {versandweg === 'EMAIL' && <EmailAusgabe />}
+          <div className="grid gap-4 sm:grid-cols-2">
+            <Feld
+              id="versandAm"
+              beschriftung="Versandt am"
+              erklaerung="Steht am Dokument in der Akte."
+            >
+              <Input
+                id="versandAm"
+                type="date"
+                value={versandAm}
+                onChange={(ereignis) => setVersandAm(ereignis.target.value)}
+              />
+            </Feld>
+
+            <Feld
+              id="wiedervorlageAm"
+              beschriftung="Wiedervorlage am"
+              erklaerung={fristBegruendung ?? 'Leer lassen, wenn du keine Antwort erwartest.'}
+            >
+              <Input
+                id="wiedervorlageAm"
+                type="date"
+                value={wiedervorlageAm}
+                onChange={(ereignis) => setWiedervorlageAm(ereignis.target.value)}
+              />
+            </Feld>
+          </div>
+
+          {versandweg === 'BRIEF' && (
+            <>
+              {/* Word-Datei: eigene Route, damit der Browser einen echten
+                  Download bekommt. */}
+              <form action="/schreiben/docx" method="post" className="inline">
+                <VersteckteFelder />
+                <Button type="submit" variant="outline">
+                  <FileDown aria-hidden="true" />
+                  Als Word-Datei
+                </Button>
+              </form>
+
+              <Alert variant="hinweis">
+                <Info aria-hidden="true" />
+                <AlertDescription>
+                  In die Akte kommt eine <strong>PDF-Fassung</strong> dieses Textes — sie ist der
+                  Nachweis, was hinausgegangen ist, und lässt sich nicht mehr ändern. Die
+                  Word-Datei ist die Arbeitsfassung zum Ausdrucken und Unterschreiben.{' '}
+                  <strong>Änderst du sie danach noch in Word</strong>, weicht die Akte davon ab —
+                  dann lieber erst dort fertig schreiben, den Text hierher zurückkopieren und dann
+                  ablegen.
+                </AlertDescription>
+              </Alert>
+            </>
+          )}
+
+          {ablageZustand.fehler && (
+            <Alert variant="fehler">
+              <AlertCircle aria-hidden="true" />
+              <AlertDescription>{ablageZustand.fehler}</AlertDescription>
+            </Alert>
+          )}
+
+          {abgelegt && (
+            <Alert variant="erfolg">
+              <CheckCircle2 aria-hidden="true" />
+              <AlertDescription>
+                <p className="font-medium">{ablageZustand.erfolg}</p>
+                {ablageZustand.meldung && (
+                  <ul className="mt-1 list-disc space-y-1 pl-4">
+                    {ablageZustand.meldung.map((zeile) => (
+                      <li key={zeile}>{zeile}</li>
+                    ))}
+                  </ul>
+                )}
+                <p className="mt-2">
+                  <Link href="/dokumente?richtung=AUSGANG" className="underline">
+                    Zu den ausgehenden Dokumenten
+                  </Link>
+                </p>
+              </AlertDescription>
+            </Alert>
+          )}
+
+          <form action={ablegen}>
+            <VersteckteFelder />
+            <Absendeknopf disabled={abgelegt} wartetext="Wird abgelegt …">
+              <FolderInput aria-hidden="true" />
+              {abgelegt ? 'Liegt in der Akte' : 'In die Akte legen'}
+            </Absendeknopf>
+          </form>
+        </CardContent>
+      </Card>
+    </div>
+  )
+}

src/components/schreiben/vorlagen-wahl.tsx

@@ -0,0 +1,57 @@
+'use client'
+
+import { useRouter, useSearchParams } from 'next/navigation'
+import { FileText } from 'lucide-react'
+import { Select } from '@/components/ui/select'
+import { Feld } from '@/components/feld'
+
+/**
+ * Vorlagenauswahl über dem Schreiben-Editor.
+ *
+ * Die Wahl lädt die Seite mit ?vorlageId neu — der Entwurf entsteht
+ * serverseitig, wo die Platzhalter aufgelöst werden. Ein Wechsel wirft
+ * damit auch bewusst den bearbeiteten Text weg; deshalb steht die Auswahl
+ * VOR dem Editor, nicht darin.
+ */
+export function VorlagenWahl({
+  vorlagen,
+  aktiveVorlageId,
+}: {
+  vorlagen: { id: string; name: string }[]
+  aktiveVorlageId: string | null
+}) {
+  const router = useRouter()
+  const parameter = useSearchParams()
+
+  function wechseln(vorlageId: string) {
+    const neu = new URLSearchParams(parameter.toString())
+    if (vorlageId) neu.set('vorlageId', vorlageId)
+    else neu.delete('vorlageId')
+    router.push(`/schreiben/neu?${neu.toString()}`)
+  }
+
+  return (
+    <div className="flex items-start gap-2.5 rounded-md border bg-muted/30 p-3">
+      <FileText className="mt-8 size-4 shrink-0 text-muted-foreground" aria-hidden="true" />
+      <Feld
+        id="vorlageWahl"
+        beschriftung="Aus eigener Vorlage"
+        erklaerung="Ersetzt den Entwurf unten — was dort schon steht, geht dabei verloren."
+        className="flex-1"
+      >
+        <Select
+          id="vorlageWahl"
+          value={aktiveVorlageId ?? ''}
+          onChange={(ereignis) => wechseln(ereignis.target.value)}
+        >
+          <option value="">– leerer Entwurf –</option>
+          {vorlagen.map((vorlage) => (
+            <option key={vorlage.id} value={vorlage.id}>
+              {vorlage.name}
+            </option>
+          ))}
+        </Select>
+      </Feld>
+    </div>
+  )
+}

src/components/vertraege/kuendigungs-assistent.tsx

@@ -1,7 +1,8 @@
 'use client'
 
+import Link from 'next/link'
 import { useActionState } from 'react'
-import { CheckCircle2, FileWarning, Gavel, Scale, TriangleAlert } from 'lucide-react'
+import { CheckCircle2, FileDown, FileWarning, Gavel, Scale, TriangleAlert } from 'lucide-react'
 import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Checkbox } from '@/components/ui/checkbox'
@@ -10,6 +11,7 @@ import { Select } from '@/components/ui/select'
 import { Textarea } from '@/components/ui/textarea'
 import { Feld } from '@/components/feld'
 import { Rechtshinweis } from '@/components/rechtshinweis'
+import { Button } from '@/components/ui/button'
 import { Absendeknopf, Textbaustein, Zustandsmeldung } from '@/components/substanz-formular'
 import { kuendigungVermerken } from '@/server/actions/vertraege'
 import { formatDatum } from '@/lib/utils'
@@ -161,6 +163,15 @@ export function KuendigungsAssistent({
             beschriftung="Kündigungsschreiben"
             hoehe="min-h-[36rem]"
           />
+
+          <div className="mt-4">
+            <Button asChild variant="outline">
+              <Link href={`/schreiben/neu?art=KUENDIGUNG&vertragId=${vertragId}`}>
+                <FileDown aria-hidden="true" />
+                Bearbeiten, als Word-Datei und in die Akte
+              </Link>
+            </Button>
+          </div>
         </CardContent>
       </Card>
 

src/components/vertraege/rueckkaufswert.tsx

@@ -1,8 +1,10 @@
 'use client'
 
+import Link from 'next/link'
 import { useActionState, useState } from 'react'
-import { Coins, Mail, Plus } from 'lucide-react'
+import { Coins, FileDown, Mail, Plus } from 'lucide-react'
 import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Input } from '@/components/ui/input'
@@ -35,6 +37,7 @@ export function Rueckkaufswert({
   anschreiben,
   stichtagVorschlag,
   darfSchreiben,
+  alterHinweis,
 }: {
   betreuteId: string
   vertragId: string
@@ -45,6 +48,8 @@ export function Rueckkaufswert({
   anschreiben: string
   stichtagVorschlag: string
   darfSchreiben: boolean
+  /** Kurztext, wenn der juengste Wert zu alt ist - sonst null. */
+  alterHinweis: string | null
 }) {
   const [erfassen, erfassenAktion] = useActionState<Formularzustand, FormData>(
     rueckkaufswertErfassen,
@@ -54,6 +59,9 @@ export function Rueckkaufswert({
     rueckkaufswertAnfordern,
     {},
   )
+  // Die Liste kommt bereits juengster Wert zuerst von der Seite.
+  const letzter = werte[0] ?? null
+
   const [briefOffen, setBriefOffen] = useState(false)
   const [erfassenOffen, setErfassenOffen] = useState(false)
 
@@ -87,7 +95,7 @@ export function Rueckkaufswert({
           </Alert>
         )}
 
-        {werte.length === 0 ? (
+        {!letzter ? (
           <Leerzustand
             titel="Noch kein Rückkaufswert erfasst"
             beschreibung="Fordere ihn bei der Gesellschaft an. Frag im selben Schreiben nach der beitragsfreien Versicherungssumme — sonst musst du für den Vergleich ein zweites Mal schreiben."
@@ -102,6 +110,25 @@ export function Rueckkaufswert({
             }
           />
         ) : (
+          <>
+            {/* Der zuletzt mitgeteilte Wert gehoert nach oben: Wer beim
+                Telefonat mit der Gesellschaft danach gefragt wird, hat
+                keine Zeit, eine Historie zu lesen. */}
+            <div className="rounded-md border p-4">
+              <p className="text-sm text-muted-foreground">Zuletzt mitgeteilt</p>
+              <p className="text-2xl font-semibold tabular-nums">
+                {formatCent(letzter.wertCent)}
+              </p>
+              <p className="text-sm text-muted-foreground">
+                zum Stichtag {formatDatum(letzter.stichtag)} · {letzter.wertquelle}
+              </p>
+              {alterHinweis && (
+                <Badge variant="gelb" className="mt-2">
+                  {alterHinweis} — vor dem nächsten Bericht neu anfragen
+                </Badge>
+              )}
+            </div>
+
             <Table>
             <TableHeader>
               <TableRow>
@@ -126,6 +153,7 @@ export function Rueckkaufswert({
               ))}
             </TableBody>
             </Table>
+          </>
         )}
 
         {darfSchreiben && (
@@ -149,6 +177,15 @@ export function Rueckkaufswert({
               hoehe="min-h-[32rem]"
             />
 
+            {/* Der Weg, der nicht beim Kopieren endet: bearbeiten,
+                Word-Datei, Ablage in der Akte, Wiedervorlage. */}
+            <Button asChild variant="outline">
+              <Link href={`/schreiben/neu?art=RUECKKAUFSWERT&vertragId=${vertragId}`}>
+                <FileDown aria-hidden="true" />
+                Bearbeiten, als Word-Datei und in die Akte
+              </Link>
+            </Button>
+
             <form action={anfrageAktion} className="space-y-4" noValidate>
               <input type="hidden" name="betreuteId" value={betreuteId} />
               <input type="hidden" name="vertragId" value={vertragId} />

src/components/vertraege/serienabfrage-formular.tsx

@@ -0,0 +1,165 @@
+'use client'
+
+import * as React from 'react'
+import { useRouter } from 'next/navigation'
+import { AlertCircle, FileArchive, Info } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Checkbox } from '@/components/ui/checkbox'
+import { Input } from '@/components/ui/input'
+import { Feld } from '@/components/feld'
+
+export type SerienZeile = {
+  vertragId: string
+  bezeichnung: string
+  gesellschaft: string | null
+  artBeschriftung: string
+  moeglich: boolean
+  hindernis: string | null
+  vorausgewaehlt: boolean
+}
+
+/**
+ * Auswahl und Start der Serienabfrage.
+ *
+ * Die Zusammenfassung ("Es entstehen N Schreiben") steht direkt auf dem
+ * Knopf. Man soll den Fehlgriff bemerken, BEVOR zehn Briefe entstehen —
+ * nicht danach beim Aufräumen.
+ *
+ * Der Start läuft als gewöhnliches Formular-POST gegen die Route: Der
+ * Browser bekommt das ZIP als Download, und die Nebenwirkungen (Akte,
+ * Fristen, Anfragedatum) sind serverseitig schon passiert. Nach dem
+ * Klick wird die Seite neu geladen, damit die Sperrvermerke stimmen.
+ */
+export function SerienabfrageFormular({
+  betreuteId,
+  zeilen,
+  stichtagVorschlag,
+}: {
+  betreuteId: string
+  zeilen: SerienZeile[]
+  stichtagVorschlag: string
+}) {
+  const router = useRouter()
+  const [gewaehlt, setGewaehlt] = React.useState<Set<string>>(
+    () => new Set(zeilen.filter((z) => z.vorausgewaehlt).map((z) => z.vertragId)),
+  )
+  const [stichtag, setStichtag] = React.useState(stichtagVorschlag)
+  const [gestartet, setGestartet] = React.useState(false)
+
+  function umschalten(id: string) {
+    setGewaehlt((bisher) => {
+      const neu = new Set(bisher)
+      if (neu.has(id)) neu.delete(id)
+      else neu.add(id)
+      return neu
+    })
+  }
+
+  const anzahl = gewaehlt.size
+
+  function beimAbsenden() {
+    // Das Formular lädt als Download - die Seite bleibt stehen. Nach
+    // kurzer Zeit neu laden, damit Sperrvermerke und "Wartet auf andere"
+    // den neuen Stand zeigen.
+    setGestartet(true)
+    window.setTimeout(() => {
+      router.refresh()
+      setGestartet(false)
+    }, 4000)
+  }
+
+  return (
+    <form
+      action="/vertraege/serienabfrage"
+      method="post"
+      onSubmit={beimAbsenden}
+      className="space-y-5"
+    >
+      <input type="hidden" name="betreuteId" value={betreuteId} />
+
+      <Feld
+        id="stichtag"
+        beschriftung="Stichtag der Auskünfte"
+        erklaerung="Zu diesem Tag sollen die Gesellschaften den Rückkaufswert mitteilen — üblicherweise der Stichtag des Vermögensverzeichnisses oder der Beginn des Betreuungsjahres."
+        pflicht
+      >
+        <Input
+          id="stichtag"
+          name="stichtag"
+          type="date"
+          value={stichtag}
+          onChange={(ereignis) => setStichtag(ereignis.target.value)}
+          required
+        />
+      </Feld>
+
+      <ul className="divide-y rounded-md border">
+        {zeilen.map((zeile) => (
+          <li key={zeile.vertragId} className="flex items-start gap-3 p-3">
+            {zeile.moeglich ? (
+              <Checkbox
+                id={`vertrag-${zeile.vertragId}`}
+                name="vertragId"
+                value={zeile.vertragId}
+                checked={gewaehlt.has(zeile.vertragId)}
+                onChange={() => umschalten(zeile.vertragId)}
+                className="mt-0.5"
+              />
+            ) : (
+              <span className="mt-0.5 size-4 shrink-0" aria-hidden="true" />
+            )}
+
+            <label
+              htmlFor={zeile.moeglich ? `vertrag-${zeile.vertragId}` : undefined}
+              className={`min-w-0 flex-1 ${zeile.moeglich ? 'cursor-pointer' : 'opacity-60'}`}
+            >
+              <span className="flex flex-wrap items-center gap-2">
+                <span className="font-medium">{zeile.bezeichnung}</span>
+                <Badge variant="secondary">{zeile.artBeschriftung}</Badge>
+              </span>
+              <span className="block text-sm text-muted-foreground">
+                {zeile.gesellschaft ?? 'ohne Gesellschaft'}
+              </span>
+              {zeile.hindernis && (
+                <span className="mt-0.5 block text-xs text-ampel-orange">{zeile.hindernis}</span>
+              )}
+            </label>
+          </li>
+        ))}
+      </ul>
+
+      {zeilen.length === 0 && (
+        <Alert variant="hinweis">
+          <Info aria-hidden="true" />
+          <AlertDescription>
+            Es gibt keine Verträge, die für eine Rückkaufswert-Anfrage in Frage kommen. Lege
+            zuerst die Versicherungen unter <em>Verträge</em> an — oder finde sie über{' '}
+            <em>Vermögen &amp; Kasse → Wiederkehrende Zahlungen</em>.
+          </AlertDescription>
+        </Alert>
+      )}
+
+      {anzahl === 0 && zeilen.length > 0 && (
+        <Alert variant="hinweis">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>Kein Vertrag gewählt — es entsteht nichts.</AlertDescription>
+        </Alert>
+      )}
+
+      <div className="space-y-2">
+        <Button type="submit" disabled={anzahl === 0 || gestartet} size="lg">
+          <FileArchive aria-hidden="true" />
+          {gestartet
+            ? 'Wird erzeugt …'
+            : `${anzahl} Schreiben erzeugen und herunterladen`}
+        </Button>
+        <p className="text-sm text-muted-foreground">
+          Je Vertrag entsteht eine Word-Datei im ZIP, eine PDF-Fassung in der Akte, eine
+          Wiedervorlage nach 28 Tagen — und der Vertrag gilt als angefragt.
+        </p>
+      </div>
+    </form>
+  )
+}

src/components/vorgaenge/vorgangs-formular.tsx

@@ -36,6 +36,7 @@ export type VorgangsFormularWerte = {
   beschreibung: string | null
   gegenstelle: string | null
   aktenzeichen: string | null
+  ansprechpartnerId: string | null
   verantwortlich: string | null
   naechsterSchritt: string | null
   faelligAm: Date | null
@@ -50,6 +51,7 @@ export function VorgangsFormular({
   vorlageSchluessel,
   werte,
   abbrechenHref,
+  kontakte,
 }: {
   modus: 'anlegen' | 'aendern'
   betreuteId: string
@@ -57,6 +59,8 @@ export function VorgangsFormular({
   vorlageSchluessel?: string | null
   werte: VorgangsFormularWerte
   abbrechenHref: string
+  /** Kontakte dieser Akte, zur Wahl des Ansprechpartners. */
+  kontakte: { id: string; name: string; organisation: string | null }[]
 }) {
   const [zustand, aktion, laeuft] = useActionState<Formularzustand, FormData>(
     modus === 'anlegen' ? vorgangAnlegen : vorgangAendern,
@@ -146,6 +150,22 @@ export function VorgangsFormular({
           />
         </Feld>
 
+        <Feld
+          id="ansprechpartnerId"
+          beschriftung="Ansprechpartner"
+          erklaerung="Wer dort die Sache bearbeitet. Schreiben zu diesem Vorgang reden ihn namentlich an — das bringt sie an der Poststelle vorbei."
+          fehler={zustand.felder?.ansprechpartnerId}
+        >
+          <Select name="ansprechpartnerId" defaultValue={werte.ansprechpartnerId ?? ''}>
+            <option value="">– keiner benannt –</option>
+            {kontakte.map((kontakt) => (
+              <option key={kontakt.id} value={kontakt.id}>
+                {[kontakt.name, kontakt.organisation].filter(Boolean).join(' · ')}
+              </option>
+            ))}
+          </Select>
+        </Feld>
+
         <Feld
           id="aktenzeichen"
           beschriftung="Aktenzeichen"