Merge #13: Wiederkehrende Zahlungen aufspueren

Behebt Issue #3: Am Anfang einer Betreuung weiss niemand, welche
Vertraege es gibt. Die Antwort steht im Kontoauszug.

Closes #3

.env.example

@@ -16,9 +16,41 @@ DATABASE_URL="postgresql://cockpit:bitte-aendern@localhost:5432/betreuungs_cockp
 AUTH_SECRET=
 # Oeffentliche Basis-URL der Anwendung (ohne abschliessenden Slash).
 AUTH_URL=http://localhost:3000
-# Hinter einem Reverse Proxy (Caddy) auf true setzen.
+# Hinter einem Reverse Proxy auf true setzen.
 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
 # FELDER UNWIEDERBRINGLICH VERLOREN - unbedingt getrennt vom Backup sichern!

.gitignore

@@ -43,3 +43,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/

CHANGELOG.md

@@ -26,6 +26,434 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [1.2.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Wiederkehrende Zahlungen aufspüren**
+  ([#3](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/3)).
+  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 Kontoauszug: **Wer regelmäßig
+  abbucht, hat einen Vertrag.**
+
+  Neu unter *Vermögen & Kasse → Wiederkehrende Zahlungen*: Die importierten
+  Kontobewegungen werden nach Empfänger gruppiert und nach Jahresbetrag
+  sortiert. Je Zeile stehen Rhythmus, Betrag, Zeitraum und ob dazu schon ein
+  Vertrag in der Akte liegt. Aus der Zeile heraus geht es weiter — *Vertrag
+  anlegen* mit vorbelegter Gesellschaft und vorbelegtem Beitrag, oder *kein
+  Vertrag* mit Begründung.
+
+  Die Seite wertet nur aus. Sie legt von sich aus nichts an; jede Zeile
+  endet in einer Entscheidung, die ein Mensch trifft.
+
+  **Was sie nennt, begründet sie.** Statt „monatlich" zu behaupten, steht
+  daneben „6 Zahlungen, etwa monatlich" — man soll widersprechen können.
+  Schwankt der Betrag, wird die Spanne genannt statt eines Mittelwerts, der
+  Genauigkeit vortäuscht. Und ohne erkennbaren Abstand wird nicht aufs Jahr
+  hochgerechnet, sondern gezeigt, was tatsächlich geflossen ist.
+
+  **Zusammengefasst wird nur, was sicher dasselbe ist:** Groß- und
+  Kleinschreibung, Satzzeichen, Umlaute und die Rechtsform am Ende.
+  „Stadtwerke Bamberg" und „Stadtwerke Bayreuth" unterscheiden sich in drei
+  Zeichen und bleiben zwei Zeilen. Zwei Zeilen zu viel sind harmlos — eine
+  falsch zusammengefasste Gruppe verbirgt dagegen einen Vertrag, und der
+  fehlt dann im Vermögensverzeichnis.
+
+- **Einzelne größere Zahlungen** stehen in einem eigenen Abschnitt darunter.
+  Grund: Die Gruppierung braucht mindestens zwei Zahlungen, eine jährlich
+  abgebuchte Prämie erscheint bei einem importierten Jahr aber nur einmal —
+  und ausgerechnet Versicherungen werden oft jährlich gezahlt. Ohne diese
+  zweite Liste wäre die Suche genau dort blind, wo sie am meisten bringen
+  soll.
+
+- **Hinweis auf „Heute"**, sobald es unbearbeitete Kandidaten gibt. Er steht
+  in der Kachel *Unverbuchte Belege*, nicht in einer eigenen: Es ist
+  dieselbe Frage — wozu gehört diese Zahlung? —, nur eine Ebene höher.
+
+### Zu beachten
+
+- **Eine Datenbank-Migration ist nötig**
+  (`20260823000500_zahlungsgruppe_geklaert`). Sie läuft beim Start des
+  Behälters automatisch mit und legt nur eine neue Tabelle an; bestehende
+  Daten bleiben unberührt.
+- Ausgewertet werden **nur Ausgaben der betreuten Person**. Umbuchungen
+  zwischen eigenen Konten und Auslagen des Betreuers bleiben außen vor —
+  wer monatlich aufs Sparbuch legt, hat deswegen keinen Vertrag.
+
+### Geprüft
+
+- 37 Einheitstests (`tests/wiederkehrend.test.ts`), die Hälfte davon in der
+  Gegenrichtung: dass ähnliche, aber verschiedene Namen **nicht**
+  zusammenfallen.
+- Vier End-to-End-Tests gegen einen echten Browser: Erkennung, getrennte
+  Liste der Einzelzahlungen, Übernahme ins Vertragsformular, Abhaken und
+  Zurückholen samt Neuladen.
+
+  Zwei Fehler hat erst der Browsertest gefunden. Einer davon hätte die
+  Vorbelegung des Beitrags stillschweigend verschluckt — Typprüfung und
+  Einheitstests waren grün.
+
+## [1.1.2] – 2026-08-23
+
+### Behoben
+
+- **„Mein Konto" war am Schreibtisch praktisch nicht zu finden**
+  ([#1](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/1)).
+  Damit kam man dort auch nicht an den Passwortwechsel, den zweiten Faktor
+  und die frisch eingebaute Passkey-Verwaltung.
+
+  Ursache: Die Seitenleiste hatte keine feste Höhe und wuchs mit der Seite
+  mit. Ihr Fuß — und damit das Benutzermenü — landete deshalb am **Ende der
+  Seite** statt am unteren Bildschirmrand. Auf „Heute" waren das 1632 Pixel
+  bei 900 Pixel Fensterhöhe: Man musste bis ganz nach unten scrollen, um
+  an sein eigenes Konto zu kommen.
+
+  Der Fehler sah nach nichts aus. Kein Element fehlte, nichts war kaputt,
+  die Seite sah richtig aus — und genau deshalb sucht man an der falschen
+  Stelle.
+
+  Die Leiste bleibt jetzt stehen (`sticky`, Fensterhöhe). Kopf,
+  Betreutenauswahl und Fuß sind immer sichtbar; die Navigation dazwischen
+  scrollt bei Bedarf in sich selbst. Am Handy war es nie ein Problem —
+  dort sitzt das Menü in der ohnehin festen Kopfzeile.
+
+### Geprüft
+
+- Fünf End-to-End-Tests (`e2e/benutzermenue.spec.ts`) fragen nicht, ob das
+  Menü **im DOM** ist, sondern ob es **im sichtbaren Bereich** steht: auf
+  fünf verschiedenen Seiten, an drei Scrollpositionen, auf einem flachen
+  Laptopfenster (1280 × 620) und am Handy.
+
+  Die Scrollposition in der Mitte ist Absicht. Nur oben und unten zu messen
+  hätte nicht gereicht: Am Seitenende wird eine mitwachsende Leiste
+  zufällig doch sichtbar — der Test wäre grün gewesen und der Fehler
+  trotzdem da. Beide Sichtbarkeitstests sind gegen den kaputten Zustand
+  gegengeprüft und schlagen dort an.
+
+## [1.1.1] – 2026-08-23
+
+### Behoben
+
+- **`./scripts/update.sh` endete in „Permission denied".** Die
+  Shell-Skripte lagen ohne Ausführungsrecht im Repository (Modus 644 statt
+  755). Die Anleitung sagt `./scripts/update.sh` — auf Linux ging genau
+  das nicht.
+
+  Ursache ist der Entwicklungsrechner: Unter Windows steht
+  `core.filemode=false`, dort merkt git von einem fehlenden
+  Ausführungsrecht nichts. Aufgefallen ist es erst auf dem Server.
+
+  **Wer von 1.1.0 oder älter kommt**, braucht einmalig den Umweg — das
+  alte Skript ist ja noch das nicht ausführbare:
+
+  ```bash
+  bash scripts/update.sh
+  ```
+
+  Danach stimmt das Recht, und der Punktschrägstrich funktioniert.
+
+- **`update.sh` setzt das Recht nach dem Umschalten selbst.** Wer Dateien
+  von Hand kopiert hat — etwa um an das Skript zu kommen, bevor es in der
+  laufenden Fassung existierte —, verliert es dabei. Ein `chmod +x` nach
+  dem Umschalten fängt das ab.
+
+- **Das Versionsskript datierte in UTC.** Eine Veröffentlichung nach
+  22 Uhr deutscher Sommerzeit bekam im Changelog das Datum des Vortages —
+  diese Fassung hier war der erste Fall. Es rechnet jetzt in
+  `Europe/Berlin`, wie alles andere in dieser Anwendung auch.
+
+### Geprüft
+
+- Vier neue Prüfungen (`tests/skripte.test.ts`) sehen sich nicht das
+  Programm an, sondern die **Verpackung**: Liegt jedes `.sh` ausführbar im
+  Index? Hat es eine Shebang-Zeile? Kommt `scripts/` ins Docker-Abbild?
+  Sind die Sicherungsskripte in der Compose-Datei eingehängt?
+
+  Das ist der zweite Fehler dieser Art — vorher fehlte `scripts/` ganz im
+  Abbild (1.0.1). Beide Male war der Code richtig und kein Test schlug an,
+  weil keiner hinsah, wie die Dateien beim Server ankommen. Jetzt tut es
+  einer. Die Gegenprobe ist gemacht: Mit zurückgesetztem Recht schlägt er
+  fehl und nennt die Datei.
+
+## [1.1.0] – 2026-08-22
+
+### Hinzugefügt
+
+- **Anmelden mit Passkey.** Auf der Anmeldeseite steht jetzt unter dem
+  Formular ein zweiter Weg: *Mit Passkey anmelden*. Ein Fingerabdruck, ein
+  Blick in die Kamera oder die Geräte-PIN — keine E-Mail, kein Passwort,
+  kein abgetippter Code.
+
+  **Der Passkey ersetzt den zweiten Faktor, er kommt nicht zusätzlich.**
+  Das ist kein Nachlassen: Ein Passkey verlangt den Besitz des Geräts
+  *und* dessen Entsperrung, das sind dieselben zwei Faktoren wie vorher.
+  Die Anwendung fordert die Nutzerverifikation ausdrücklich an und weist
+  eine Antwort ohne sie zurück. Ein Gerät, das auf blosses Antippen hin
+  signiert, kommt nicht herein.
+
+  In einem Punkt ist er dem bisherigen Weg sogar überlegen: Ein Passkey
+  ist an die Adresse gebunden, unter der er eingerichtet wurde. Auf einer
+  nachgebauten Anmeldeseite funktioniert er nicht — und Phishing ist der
+  übliche Weg, an einen TOTP-Code zu kommen.
+
+  **Die Authenticator-App muss trotzdem eingerichtet sein**, bevor sich
+  ein Passkey anlegen lässt. 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 — und darin stehen Unterlagen, die eine betreute Person braucht.
+  Der Passkey ist die bequeme Tür, nicht die einzige.
+
+  Verwaltet werden sie unter **Mein Konto → Passkeys**: einrichten,
+  benennen, entfernen. Die Liste zeigt, wann ein Gerät zuletzt benutzt
+  wurde und ob der Schlüssel gesichert ist (iCloud, Google, Bitwarden)
+  oder nur auf diesem einen Gerät liegt. Einrichten und Entfernen stehen
+  im Protokoll, jede Anmeldung nennt den verwendeten Passkey namentlich.
+
+- **Bestätigen mit Passkey.** Export, endgültiges Löschen und die
+  Benutzerverwaltung verlangen eine frische Anmeldung. Auch die geht jetzt
+  mit dem Passkey. Geprüft wird zusätzlich, dass er zum angemeldeten
+  Zugang gehört — sonst liesse sich mit dem eigenen Finger eine fremde,
+  offen stehende Sitzung freischalten. Genau der Fall, gegen den diese
+  Zwischenfrage gebaut ist.
+
+### Zu beachten
+
+- **Passkeys brauchen `https`.** Der Browser gibt das Verfahren nur in
+  einem sicheren Kontext frei. Läuft die Anwendung ohne TLS, erscheint der
+  Knopf gar nicht erst, statt beim Klick mit einer kryptischen Meldung
+  abzubrechen.
+
+- **`AUTH_URL` muss stimmen — jetzt noch mehr als vorher.** Aus ihr wird
+  die Kennung abgeleitet, an die der Authenticator den Schlüssel bindet.
+  Steht dort eine andere Adresse als die im Browser, lässt sich zwar ein
+  Passkey einrichten, aber nie wieder verwenden.
+
+  **Ein Wechsel der Domain macht alle Passkeys unbrauchbar.** Das ist
+  keine Panne, sondern der Phishingschutz. Nach einem Umzug richtet man
+  sie neu ein; die Anmeldung mit Passwort und Code bleibt währenddessen
+  offen.
+
+- **Eine Datenbank-Migration ist nötig** (`20260822160000_passkey_anmeldung`).
+  Sie läuft beim Start des Behälters automatisch mit. Bestehende Zugänge
+  sind nicht betroffen: Ohne eingerichteten Passkey ändert sich nichts.
+
+### Geprüft
+
+- 21 neue Prüfungen (`tests/passkey.test.ts`), vor allem für die Herleitung
+  von Kennung und Herkunft aus `AUTH_URL`: Port, Schrägstrich am Ende,
+  Unterdomain, `http` gegen `https`, `localhost`. Das ist die Stelle, an
+  der eine Installation still kaputtginge — dieselbe Fehlerklasse wie
+  seinerzeit bei `APP_BIND` und `ENC_KEY_V2`.
+- Drei End-to-End-Tests gegen einen echten Browser (`e2e/passkey.spec.ts`),
+  mit Chromiums virtuellem Authenticator: einrichten, abmelden, mit Passkey
+  anmelden, Benutzung vermerkt, entfernen. Dazu die Bestätigung vor dem
+  Vollexport und der Fall, dass ein Gerät ohne Nutzerverifikation nicht
+  hereinkommt.
+
+## [1.0.5] – 2026-08-22
+
+### Hinzugefügt
+
+- **`scripts/update.sh`** — aktualisiert die Anwendung mit einem Befehl.
+
+  ```bash
+  ./scripts/update.sh              # auf die neueste Fassung
+  ./scripts/update.sh --pruefen    # nur nachsehen, nichts ändern
+  ./scripts/update.sh v1.2.0       # auf eine bestimmte Fassung
+  ```
+
+  Es nimmt die Schritte ab, die man von Hand vergisst: Sicherung
+  anstoßen und bei Misserfolg **abbrechen**, den Changelog zwischen altem
+  und neuem Stand anzeigen, umschalten, neu bauen, warten bis die
+  Anwendung antwortet, **die beiden SQL-Skripte ausführen** und zum
+  Schluss prüfen, ob wirklich die neue Fassung läuft.
+
+  Zwei Eigenschaften, die dabei zählen:
+
+  **Bis zur Rückfrage wird nichts verändert.** Bricht etwas vorher ab —
+  Server nicht erreichbar, falsche Versionsangabe — findest du alles so
+  vor wie zuvor. Kein Halbzustand.
+
+  **Eigene Änderungen an versionierten Dateien blockieren nicht.** Im
+  Betrieb passt man die `docker-compose.yml` an, bis etwas läuft; genau
+  diese Anpassungen sind später oft schon eingearbeitet. Das Skript legt
+  sie vor dem Umschalten mit `git stash` beiseite und sagt, wie man sie
+  zurückholt. Mit `--verwerfen` werden sie stattdessen weggeworfen. Die
+  `.env` bleibt immer unangetastet — sie ist nicht versioniert.
+
+  Schlägt der Bau fehl, nennt das Skript den Weg zurück auf den
+  vorherigen Stand.
+
+### Behoben
+
+- **Der Port der MinIO-Konsole ließ sich nicht ändern.** Er stand fest auf
+  `9001`; lief dort schon etwas, startete der ganze Stapel nicht
+  (`port is already allocated`). Jetzt über `MINIO_KONSOLE_PORT` in der
+  `.env` einstellbar — dieselbe Möglichkeit, die `APP_PORT` schon hatte.
+
+## [1.0.4] – 2026-08-22
+
+### Behoben
+
+- **Die Ersteinrichtung ließ sich nicht abschließen.** Schritt 3 meldete
+  „Bitte prüfe die markierten Felder" — markierte aber keines. Man kam an
+  dieser Stelle nicht weiter.
+
+  Ursache: Das kurze Formular der Ersteinrichtung schickt neun Felder, das
+  vollständige unter *Stammdaten* alle. Beide gehen durch dasselbe Schema,
+  und die optionalen Felder waren zwar `nullable`, aber nicht `optional` —
+  ein Feld, das gar nicht abgeschickt wurde, ist `undefined`, nicht
+  `null`. Beanstandet wurden also zwei Dutzend Felder, die auf dem
+  Bildschirm nie standen.
+
+- **Eine Meldung ohne zugehöriges Feld kann nicht mehr unsichtbar
+  bleiben.** Beanstandet die Prüfung ein Feld, das das Formular gar nicht
+  gesendet hat, sagt die Anwendung das jetzt ausdrücklich und schreibt es
+  ins Serverlog — statt es als Eingabefehler auszugeben, den niemand
+  finden kann. Das ist ein Fehler im Programm, und er soll auch so
+  aussehen.
+
+- **Eine betreute Person ließ sich nicht endgültig löschen.** Beim Löschen
+  setzt Postgres den Verweis im Audit-Log auf NULL (`ON DELETE SET NULL`),
+  und genau dieses UPDATE hat der Unveränderlichkeits-Trigger abgewiesen.
+  Betroffen war damit auch das Leeren des Papierkorbs nach 30 Tagen und
+  das Entfernen des Demofalls.
+
+  Der Trigger erlaubt jetzt genau eine Ausnahme: das Nullen der beiden
+  Fremdschlüssel `betreuteId` und `userId`. Jede andere Änderung bleibt
+  verboten, auch das Setzen eines Fremdschlüssels auf einen **anderen**
+  Wert. Der Nachweis bleibt vollständig — Zeitpunkt, Aktion, Bezeichnung,
+  die verschlüsselte Änderung und die Momentaufnahmen von Name und
+  E-Mail sind unberührt. Es verschwindet nur der Verweis auf einen
+  Datensatz, den es nicht mehr gibt.
+
+  **Beim Update nötig:** das SQL-Skript erneut ausführen, sonst bleibt der
+  alte Trigger stehen.
+
+  ```bash
+  docker compose exec app node node_modules/prisma/build/index.js db execute     --schema prisma/schema.prisma --file prisma/sql/audit-schutz.sql
+  ```
+
+### Geprüft
+
+- Sieben neue Tests (`tests/stammdaten.test.ts`) prüfen genau die
+  Formularinhalte der Ersteinrichtung, dazu das vollständige Formular mit
+  leeren Feldern und die weiterhin verlangten Pflichtangaben.
+- Der Ablauf ist zusätzlich im Browser durchgespielt worden: Anmeldung,
+  zweiter Faktor, Schritt 3, Landung auf dem Dashboard — und die daraus
+  abgeleiteten Pflichtfristen samt Ausschlussfrist für die
+  Aufwandspauschale.
+- Der geänderte Trigger ist gegen eine laufende Datenbank geprüft:
+  Löschen gelingt, Fälschen und Löschen von Einträgen scheitert weiterhin.
+
+## [1.0.3] – 2026-08-22
+
+Keine Änderung am Programm — nur an der Konfigurationsvorlage und der
+Anleitung. Ein Neubau des Abbilds ist nicht nötig.
+
+### Behoben
+
+- **`.env.example` band die Anwendung stillschweigend an `127.0.0.1`.**
+  Der Wert stand dort als fertig ausgefüllte Zeile zwischen lauter anderen
+  fertigen Zeilen. Wer die Datei kopiert hat und seinen Reverse Proxy auf
+  einem **anderen** Server betreibt, kam nicht an die Anwendung heran —
+  und der Fehler sah aus, als läge es am Proxy.
+
+  Jetzt steht dort eine Entscheidung mit drei benannten Fällen statt eines
+  Vorgabewerts. Der sichere Standard bleibt `127.0.0.1`; er wird nur nicht
+  mehr als „schon erledigt" präsentiert.
+
+  Für bestehende Installationen genügt eine Zeile in der `.env`:
+
+  ```bash
+  APP_BIND=10.0.0.5      # Adresse, über die der Proxy diesen Server erreicht
+  docker compose up -d
+  ```
+
+### Geändert
+
+- **`docs/INSTALLATION.md`** nennt `APP_BIND` jetzt schon in Schritt 3, wo
+  die `.env` ausgefüllt wird — nicht erst in Schritt 7, wo der Proxy
+  drankommt. Dazu ein eigener Abschnitt in der Fehlersuche: „Der Proxy
+  erreicht die Anwendung nicht", mit den zwei `curl`-Proben, die den
+  Unterschied zwischen falscher Bindeadresse und Firewall zeigen.
+
+## [1.0.2] – 2026-08-22
+
+### Behoben
+
+- **Die Einrichtung des zweiten Faktors brach mit einem Serverfehler ab**
+  („Application error: a server-side exception has occurred"). Im
+  Serverlog stand `Umgebungsvariable ENC_KEY_V2 fehlt` — obwohl niemand
+  einen zweiten Schlüssel wollte.
+
+  Ursache: `docker-compose.yml` reicht `ENC_KEY_V2` immer an den Behälter
+  durch, mit **leerem Wert**, wenn in der `.env` keiner steht. Die
+  Anwendung erkannte Schlüssel aber am Variablennamen statt am Inhalt,
+  fand also ein leeres `ENC_KEY_V2` und brach ab. Leere
+  Schlüsselvariablen werden jetzt übersprungen.
+
+  Betroffen war jede Stelle, die verschlüsselte Felder schreibt oder
+  liest — also praktisch alles außer der reinen Anmeldung. Die Anmeldung
+  ging durch, weil sie ohne Verschlüsselung auskommt; der Fehler trat
+  deshalb erst auf der nächsten Seite auf.
+
+- **Die Meldung beim Schlüsselwechsel** nennt jetzt, welche Versionen
+  tatsächlich vorhanden sind, und die richtige Reihenfolge: erst den
+  neuen Schlüssel eintragen, dann `ENC_KEY_AKTIV` umstellen.
+
+### Hinzugefügt
+
+- **`scripts/anmeldung-pruefen.mjs`** — beantwortet die Frage, warum eine
+  Anmeldung nicht klappt. Das Formular sagt bewusst nicht, woran es lag,
+  sonst ließe sich daran ablesen, welche Adressen es gibt. Auf dem Server
+  darf man es wissen: Jeder Versuch wird mit Grund protokolliert, und das
+  Skript liest ihn vor — dazu den Zustand des Zugangs, den Stand der
+  Login-Sperre und die eingestellte `AUTH_URL`.
+
+  ```bash
+  docker compose exec app node scripts/anmeldung-pruefen.mjs deine@adresse.de
+  ```
+
+  Es ändert nichts, es liest nur.
+
+### Geprüft
+
+- Sieben neue Tests (`tests/umgebung.test.ts`) decken die
+  Schlüsselauswertung ab, darunter genau die Konstellation aus dem
+  Fehlerbericht: gesetztes `ENC_KEY_V1`, leeres `ENC_KEY_V2`.
+
+## [1.0.1] – 2026-08-22
+
+### Behoben
+
+- **Betriebsskripte fehlten im Docker-Abbild.** Das Verzeichnis `scripts/`
+  wurde beim Bauen nie in die Laufzeitstufe übernommen. `docker compose
+  exec app node scripts/totp-geheimnis.mjs …` endete deshalb mit
+  `Cannot find module`. Betroffen waren alle Skripte, die im laufenden
+  Behälter gedacht sind — auch `wartungsschluessel.mjs` und
+  `schluessel-erzeugen.mjs`.
+
+  Nach dem Update funktioniert der Befehl wie dokumentiert. Wer nicht
+  gleich aktualisieren will, kommt einmalig auch so an das Skript:
+
+  ```bash
+  docker compose cp scripts/totp-geheimnis.mjs app:/app/totp-geheimnis.mjs
+  docker compose exec app node totp-geheimnis.mjs deine@adresse.de
+  ```
+
+### Hinzugefügt
+
+- **`scripts/totp-geheimnis.mjs`** — liest das TOTP-Geheimnis eines Zugangs
+  aus, um denselben Zugang auf einem zweiten Gerät einzurichten (Handy und
+  Tablet, oder ein Ersatzgerät). Die Anwendung zeigt das Geheimnis sonst
+  nur einmal an, beim Einrichten; bisher blieb nur, den zweiten Faktor
+  zurückzusetzen und alle Wiederherstellungscodes neu zu erzeugen.
+
+  Das Skript läuft nur auf dem Server und nur mit Zugriff auf die Datenbank
+  **und** auf `ENC_KEY_V1`. Wer beides hat, kann ohnehin alles lesen — es
+  ist also keine Hintertür, sondern erspart eine unnötige Neueinrichtung.
+
 ## [1.0.0] – 2026-08-22
 
 Erste vollständige Fassung. Alle acht Etappen umgesetzt, alle
@@ -188,5 +616,14 @@ Was davon wann angegangen wird, steht in [`docs/ROADMAP.md`](docs/ROADMAP.md).
 
 ---
 
-[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.0...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.2.0...HEAD
+[1.2.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.2...v1.2.0
+[1.1.2]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.1...v1.1.2
+[1.1.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.0...v1.1.1
+[1.1.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.5...v1.1.0
+[1.0.5]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.4...v1.0.5
+[1.0.4]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.3...v1.0.4
+[1.0.3]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.2...v1.0.3
+[1.0.2]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.1...v1.0.2
+[1.0.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.0...v1.0.1
 [1.0.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/releases/tag/v1.0.0

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**.
@@ -113,6 +131,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 +177,72 @@ existiert.
 ### Aktualisieren
 
 ```bash
-git pull
+./scripts/update.sh
-docker compose up -d --build
 ```
 
-Die Migrationen laufen beim Start des Anwendungsbehälters mit. **Vorher ein
+> **Kommst du von 1.1.0 oder älter?** Dort lag `update.sh` ohne
-Backup anstoßen** (siehe unten) — eine Migration lässt sich nicht zurückrollen.
+> 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
+Die Anwendung **beendet selbst kein TLS** und bringt keinen Proxy mit. Sie
-weiterreicht. Sie liest `X-Forwarded-For` bzw. `X-Real-IP` für das
+horcht standardmäßig auf `127.0.0.1:3000`.
-Rate-Limiting am Login und für das Audit-Log (dort nur als Hash).
 
-**Caddy**
+**Läuft der Proxy auf demselben Server**, ist damit alles gesagt: Er zeigt
+auf `127.0.0.1:3000`, fertig.
 
-```caddyfile
+**Läuft er auf einem anderen Server**, setz in der `.env` die Adresse, über
-cockpit.example.de {
+die er herankommt — am besten die eines privaten Netzes oder eines
-    encode zstd gzip
+WireGuard-Tunnels:
-    reverse_proxy 127.0.0.1:3000
 
-    # Uploads: Fotos von Behördenschreiben können groß sein.
+```bash
-    request_body {
+APP_BIND=10.0.0.5
-        max_size 30MB
+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
+### Was der Proxy leisten muss
-server {
-    listen 443 ssl http2;
-    server_name cockpit.example.de;
 
-    ssl_certificate     /etc/letsencrypt/live/cockpit.example.de/fullchain.pem;
+| Anforderung | Was ohne sie passiert |
-    ssl_certificate_key /etc/letsencrypt/live/cockpit.example.de/privkey.pem;
+|---|---|
+| 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 / {
+**Fertige Konfigurationen** für Caddy, nginx und Traefik, mit Zeitgrenzen
-        proxy_pass         http://127.0.0.1:3000;
+und den Gegenproben, stehen in
-        proxy_http_version 1.1;
+[`docs/INSTALLATION.md`](docs/INSTALLATION.md), Schritt 7.
-        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.
 
 ---
 
@@ -281,6 +303,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,6 +510,7 @@ 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
 ```
 
 Konventionen — verbindlich für alle Beiträge:
@@ -546,14 +578,17 @@ Fehler, die während des Baus aufgefallen sind.
 
 ## Stand
 
-| | |
+| | | nachzuzählen mit |
-|---|---:|
+|---|---:|---|
-| Zeilen TypeScript/TSX | 71.051 |
+| Zeilen TypeScript/TSX | 74.119 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
-| Prisma-Modelle | 24 |
+| Prisma-Modelle | 34 | `grep -c '^model ' prisma/schema.prisma` |
-| Seiten | 46 |
+| Seiten | 79 | `find src/app -name page.tsx \| wc -l` |
-| Unit-Tests (Vitest) | 458 |
+| Unit-Tests (Vitest) | 537 | `npm test` |
-| End-to-End-Tests (Playwright) | 34 |
+| End-to-End-Tests (Playwright) | 53 | `npm run test:e2e` — 30 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
-| TypeScript-Fehler | 0 |
+| 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
+# Kein Reverse Proxy in dieser Datei: der ist bereits vorhanden. Die
-# vorhanden. Die Anwendung horcht nur auf 127.0.0.1:3000 - von aussen
+# Anwendung beendet selbst kein TLS und horcht standardmaessig nur auf
-# erreichbar wird sie ausschliesslich ueber den vorhandenen Proxy, der
+# 127.0.0.1:3000.
-# auch TLS beendet. Siehe README, Abschnitt "Reverse Proxy".
+#
+# 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:
@@ -88,7 +94,9 @@ services:
       AUTH_URL: ${AUTH_URL:?AUTH_URL fehlt in der .env}
       AUTH_TRUST_HOST: 'true'
       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}
@@ -111,9 +119,19 @@ services:
       SMTP_FROM: ${SMTP_FROM:-}
       TZ: Europe/Berlin
     ports:
-      # Nur Loopback. Der vorhandene Reverse Proxy auf dem Host reicht
+      # Standard ist die Loopback-Adresse: dann erreicht die Anwendung nur
-      # von aussen hierher durch und beendet TLS.
+      # ein Proxy, der auf demselben Rechner laeuft.
-      - '127.0.0.1:${APP_PORT:-3000}:3000'
+      #
+      # 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))"]

docs/ANLEITUNG.md

@@ -0,0 +1,535 @@
+# 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.
+
+---
+
+## 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.1.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.

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/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/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-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "betreuungs-cockpit",
-  "version": "0.1.0",
+  "version": "1.0.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "betreuungs-cockpit",
-      "version": "0.1.0",
+      "version": "1.0.5",
       "hasInstallScript": true,
       "dependencies": {
         "@aws-sdk/client-s3": "3.735.0",
@@ -18,6 +18,8 @@
         "@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",
@@ -1573,6 +1575,12 @@
       "integrity": "sha512-HpCo8tmWzLVad5s2d19EhAz5zqrrQ6s69qd6moPMQvkOuSwDT1YgRfWSVuc4ennqrgv3OHppiOGMQ7oC13yIww==",
       "license": "MIT"
     },
+    "node_modules/@hexagon/base64": {
+      "version": "1.1.28",
+      "resolved": "https://registry.npmjs.org/@hexagon/base64/-/base64-1.1.28.tgz",
+      "integrity": "sha512-lhqDEAvWixy3bZ+UOYbPwUbBkwBq5C1LAJ/xPC8Oi+lL54oyakv/npbA0aU2hgCsx/1NUd4IBvV03+aUBWxerw==",
+      "license": "MIT"
+    },
     "node_modules/@humanfs/core": {
       "version": "0.19.2",
       "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
@@ -2161,6 +2169,12 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@levischuck/tiny-cbor": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmjs.org/@levischuck/tiny-cbor/-/tiny-cbor-0.2.11.tgz",
+      "integrity": "sha512-llBRm4dT4Z89aRsm6u2oEZ8tfwL/2l6BwpZ7JcyieouniDECM5AqNgr/y08zalEIvW3RSK4upYyybDcmjXqAow==",
+      "license": "MIT"
+    },
     "node_modules/@napi-rs/lzma-linux-x64-gnu": {
       "version": "1.5.1",
       "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
@@ -2706,6 +2720,207 @@
         "pako": "^1.0.10"
       }
     },
+    "node_modules/@peculiar/asn1-android": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-android/-/asn1-android-2.9.4.tgz",
+      "integrity": "sha512-SYHm4SoWSI0nRCoos6jpGusIqhPH9bbGBqv7ohlZ+H6BunrDzzQPk2ePgDuEUzV82OdvbLgtW4twUDwhU9P3YQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-cms": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.9.4.tgz",
+      "integrity": "sha512-cben7oxmQsUGZqotus7yt0srYdncOT6RNWcTQ77T2RFOXejYVYkXadrfePdRcrVpO9K95IRLKKglG2k38jKXuw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "@peculiar/asn1-x509-attr": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-csr": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.9.4.tgz",
+      "integrity": "sha512-xd4YN4vpRjkDAQWVfZZkeu12IEND7DOpkqaHSIHxZl1uggUNa9Ju0QxY2jHvDAS9pP0zhRBytg8ifsnGo3V0jw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-ecc": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.9.4.tgz",
+      "integrity": "sha512-JJXefFshRAuVAjWQo/39bkg1ywc1VaiO44S8RRC+Ykvf/u2KDmYffoDb0ZBPCR5uJy4AGKQhl8mX+Q8ShcWaXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pfx": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.9.4.tgz",
+      "integrity": "sha512-khuGzHTzNzk4GDlIBEILyIs6Lce0yn0ZBdoI9v93kmNncfZRhD+AQ5ODFqdhvoE8cMJF/JMTQ8yA+t1D14kqCw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.9.4",
+        "@peculiar/asn1-pkcs8": "^2.9.4",
+        "@peculiar/asn1-rsa": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs8": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.9.4.tgz",
+      "integrity": "sha512-duRdotlUx9eDZe6QrQpQKl61RbWykCHBCkKayP8V8XdEFwlKHZ8qGGDMyS6Pye7OX7nLFttTTpRkJeet78ckwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs9": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.9.4.tgz",
+      "integrity": "sha512-kaL4cNxBpdQE2dKlyZBqz4ygCrwffO+8wfoxTEqM1Z8RadvCeELBRzcv0dzM8aY9azHMwODO5nxU65zXmhToOQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.9.4",
+        "@peculiar/asn1-pfx": "^2.9.4",
+        "@peculiar/asn1-pkcs8": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "@peculiar/asn1-x509-attr": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-rsa": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.9.4.tgz",
+      "integrity": "sha512-pZ96eD1PptovcWQ/GSmuNFXd/7EQJNlKfDaNCyE2rx3W0v6QFelkzquVqRSRyyDXXCYD69ZXJDzZ8GhIiQzKoA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-schema": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.9.4.tgz",
+      "integrity": "sha512-GjzePcT9Iw8NzeOPf73iNS9xM+TBhd/FilAfP+RQGkTMQJTVWtytN3JHJACCjf/ABNau5S7mS3g+DcuxmRgYEg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.9.4.tgz",
+      "integrity": "sha512-CxhBo/RdEbMMob7T31ZdQjGuoyRFLVwrDzTn25bihzBasRg9kRm/0IxIPvhgQtcK/9dNcO1XQL2fuPugwELL0Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509-attr": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.9.4.tgz",
+      "integrity": "sha512-ehQXbpQaQYycgu8OrvigwSPTFfVRcu0ECNYCWw+yzBp02Lw5paRqzzhUpfOgO2K38+WfFZuEz/0RPtam5g0OMg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/utils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/utils/-/utils-2.0.3.tgz",
+      "integrity": "sha512-+oL3HPFRIZ1St2K50lWCXiioIgSoxzz7R1J3uF6neO2yl1sgmpgY6XXJH4BdpoDkMWznQTeYF6oWNDZLCdQ4eQ==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/x509": {
+      "version": "1.14.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz",
+      "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.6.0",
+        "@peculiar/asn1-csr": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.0",
+        "@peculiar/asn1-pkcs9": "^2.6.0",
+        "@peculiar/asn1-rsa": "^2.6.0",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.0",
+        "pvtsutils": "^1.3.6",
+        "reflect-metadata": "^0.2.2",
+        "tslib": "^2.8.1",
+        "tsyringe": "^4.10.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
       "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
@@ -4033,6 +4248,31 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@simplewebauthn/browser": {
+      "version": "13.3.0",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/browser/-/browser-13.3.0.tgz",
+      "integrity": "sha512-BE/UWv6FOToAdVk0EokzkqQQDOWtNydYlY6+OrmiZ5SCNmb41VehttboTetUM3T/fr6EAFYVXjz4My2wg230rQ==",
+      "license": "MIT"
+    },
+    "node_modules/@simplewebauthn/server": {
+      "version": "13.3.2",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/server/-/server-13.3.2.tgz",
+      "integrity": "sha512-KEDhfcGP1PAKRVSDjA3npTQFqS2b/srm+ipoNBNHdkzrHAlaRQUTE+a5f4ywsx6thxAw1NU2rYcLEY1949RGbQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@hexagon/base64": "^1.1.27",
+        "@levischuck/tiny-cbor": "^0.2.2",
+        "@peculiar/asn1-android": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.1",
+        "@peculiar/asn1-rsa": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/x509": "^1.14.3"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/@smithy/config-resolver": {
       "version": "4.7.2",
       "resolved": "https://registry.npmjs.org/@smithy/config-resolver/-/config-resolver-4.7.2.tgz",
@@ -5855,6 +6095,20 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/asn1js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
+      "integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.5",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/assertion-error": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
@@ -10192,6 +10446,24 @@
         "node": ">=6"
       }
     },
+    "node_modules/pvtsutils": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz",
+      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/pvutils": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.2.0.tgz",
+      "integrity": "sha512-BbubeCEyTuQjVMakvJQ/Sxbc93F2pwmbsxONT/ZRrwU7Ua38d8unYTwXpTVLAKJ4BDuH9IGztCjQcd/N/39Dvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/qrcode": {
       "version": "1.5.4",
       "resolved": "https://registry.npmjs.org/qrcode/-/qrcode-1.5.4.tgz",
@@ -10398,6 +10670,12 @@
         "node": ">=8.10.0"
       }
     },
+    "node_modules/reflect-metadata": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
+      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
+      "license": "Apache-2.0"
+    },
     "node_modules/reflect.getprototypeof": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -11687,6 +11965,24 @@
         "fsevents": "~2.3.3"
       }
     },
+    "node_modules/tsyringe": {
+      "version": "4.10.0",
+      "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz",
+      "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^1.9.3"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/tsyringe/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
     "node_modules/type-check": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "betreuungs-cockpit",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "private": true,
   "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
   "engines": {
@@ -44,6 +44,8 @@
     "@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",
@@ -90,5 +92,11 @@
     "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"
+    }
   }
 }

prisma/migrations/20260822160000_passkey_anmeldung/migration.sql

@@ -0,0 +1,67 @@
+-- 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/suche.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.
+
+-- 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,30 @@
+-- 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/suche.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.
+
+-- 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/schema.prisma

@@ -89,6 +89,7 @@ model User {
   geloeschtAm    DateTime?
 
   zugaenge           BetreuungsZugang[]
+  passkeys           Passkey[]
   auditEintraege     AuditLog[]
   angelegteVorgaenge Vorgang[]          @relation("VorgangAngelegtVon")
   berichte           Bericht[]
@@ -135,6 +136,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 +312,7 @@ model Betreute {
   dokumente             Dokument[]
   konten                Konto[]
   buchungen             Buchung[]
+  zahlungsgruppen       ZahlungsgruppeGeklaert[]
   vermoegensposten      Vermoegensposten[]
   immobilien            Immobilie[]
   vertraege             Vertrag[]
@@ -742,6 +829,42 @@ 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.
+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())
 
@@ -1527,6 +1650,8 @@ enum AuditAktion {
   ANMELDUNG_FEHLGESCHLAGEN
   ABMELDUNG
   ZWEITER_FAKTOR_EINGERICHTET
+  PASSKEY_REGISTRIERT
+  PASSKEY_ENTFERNT
   PASSWORT_GEAENDERT
   ROLLE_GEAENDERT
   FREIGABE_GEAENDERT

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/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,392 @@
+#!/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; }
+
+# --- 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)"
+NEUESTE="$(git tag --list 'v*' --sort=-v:refname | head -1)"
+
+[ -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:
+$(git tag --list 'v*' --sort=-v:refname | head -5 | 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 { print "    " $0 }
+  ' | head -60
+else
+  warnung "Kein CHANGELOG.md in $ZIEL gefunden."
+fi
+
+printf '\n'
+git log --oneline --no-decorate "HEAD..$ZIEL" | head -15 | sed 's/^/    /'
+
+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]'

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)/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)/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'
@@ -20,6 +21,7 @@ import { 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)
 
@@ -134,6 +137,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" />

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

@@ -0,0 +1,318 @@
+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,
+  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="flex flex-wrap items-center justify-between gap-2 py-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>
+                    </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)/konto/page.tsx

@@ -1,11 +1,13 @@
 import type { Metadata } from 'next'
 import Link from 'next/link'
-import { KeyRound, ShieldCheck } from 'lucide-react'
+import { Fingerprint, KeyRound, 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'
@@ -16,10 +18,11 @@ 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, zweiter Faktor und Passkeys." />
 
       <Card>
         <CardHeader className="pb-3">
@@ -89,6 +92,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)/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/(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/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 =
+    inhalt = ''
-      '# Datenschutzhinweise\n\nDer Text konnte nicht geladen werden. ' +
-      'Er liegt in docs/datenschutzhinweise.md.'
   }
 
   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

@@ -12,6 +12,8 @@ import {
   versuchFesthalten,
 } from '@/lib/auth/ratelimit'
 import { protokollieren } from '@/lib/audit'
+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 +32,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,6 +49,19 @@ 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()
@@ -203,6 +220,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 versuchFesthalten(benutzer.email, ip, false, 'gesperrt')
+          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 --------------------------------- */}
+      {/* --- Seitenleiste am Schreibtisch ---------------------------------
-      <aside className="no-print hidden w-72 shrink-0 border-r bg-card lg:flex lg:flex-col">
+
+          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/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/finanzen/wiederkehrend-aktionen.tsx

@@ -0,0 +1,128 @@
+'use client'
+
+import * as React from 'react'
+import { useActionState } from 'react'
+import { AlertCircle, CheckCircle2, 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 {
+  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>
+  )
+}

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/lib/auth/passkey.ts

@@ -0,0 +1,464 @@
+import 'server-only'
+import {
+  generateAuthenticationOptions,
+  generateRegistrationOptions,
+  verifyAuthenticationResponse,
+  verifyRegistrationResponse,
+} from '@simplewebauthn/server'
+import type {
+  AuthenticationResponseJSON,
+  AuthenticatorTransportFuture,
+  PublicKeyCredentialCreationOptionsJSON,
+  PublicKeyCredentialRequestOptionsJSON,
+  RegistrationResponseJSON,
+} from '@simplewebauthn/server'
+import type { Passkey, PasskeyAnfrageArt, User } from '@prisma/client'
+import { db } from '@/lib/db'
+import { env } from '@/lib/env'
+
+/**
+ * Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg.
+ *
+ * ---------------------------------------------------------------------------
+ * Warum ein Passkey hier den zweiten Faktor ERSETZEN darf
+ * ---------------------------------------------------------------------------
+ *
+ * Die Zusage dieser Anwendung lautet: zwei Faktoren, nicht abschaltbar. Ein
+ * Passkey sieht auf den ersten Blick nach einem einzigen Klick aus - er ist
+ * aber zwei Faktoren, sofern der Authenticator die Nutzerverifikation
+ * durchfuehrt:
+ *
+ *   1. Besitz  - der private Schluessel liegt im Sicherheitsbaustein des
+ *                Geraets und laesst sich nicht auslesen.
+ *   2. Wissen  - Geraete-PIN
+ *      oder Sein - Fingerabdruck, Gesicht.
+ *
+ * Diese Bedingung wird nicht gehofft, sondern erzwungen: bei der Anmeldung
+ * ebenso wie beim Einrichten steht userVerification auf "required", und die
+ * Pruefung laeuft mit requireUserVerification. Ein Authenticator, der nur
+ * Anwesenheit meldet (blosses Antippen), wird abgewiesen.
+ *
+ * Zusaetzlich ist ein Passkey dem Zahlenkomma aus Passwort + TOTP in einem
+ * Punkt ueberlegen: Er ist an die Domain gebunden. Eine nachgebaute
+ * Anmeldeseite bekommt keine Signatur - Phishing, der haeufigste Weg an
+ * einen TOTP-Code zu kommen, laeuft ins Leere.
+ *
+ * ---------------------------------------------------------------------------
+ * Warum TOTP trotzdem zuerst eingerichtet sein muss
+ * ---------------------------------------------------------------------------
+ *
+ * Ein Passkey haengt am Geraet. Geht das Handy verloren und ist es der
+ * einzige Zugangsweg, ist die Akte zu - und in ihr stehen Unterlagen, die
+ * eine betreute Person braucht. Deshalb laesst sich ein Passkey erst
+ * anlegen, wenn der zweite Faktor samt Wiederherstellungscodes steht. Der
+ * Passkey ist die bequeme Tuer, nicht die einzige.
+ */
+
+/**
+ * Wie lange eine begonnene Passkey-Aktion abgeschlossen werden kann.
+ *
+ * Fuenf Minuten sind reichlich fuer "Handy suchen, Finger auflegen" und
+ * kurz genug, dass eine abgefangene Challenge nichts mehr wert ist.
+ */
+export const ANFRAGE_GUELTIG_SEKUNDEN = 300
+
+/**
+ * Obergrenze je Benutzer. Nicht aus technischen Gruenden - die Liste soll
+ * uebersichtlich bleiben, damit ein fremder Eintrag auffaellt.
+ */
+export const MAX_PASSKEYS_JE_BENUTZER = 10
+
+/**
+ * Obergrenze fuer gleichzeitig offene Anmeldeversuche.
+ *
+ * Eine Anmeldung darf jeder beginnen, auch ohne angemeldet zu sein - anders
+ * ginge es nicht. Damit daraus kein Weg wird, die Tabelle vollzuschreiben,
+ * gilt eine Decke. Fuer eine Handvoll Benutzer ist sie unerreichbar; fuer
+ * ein Skript ist sie schnell erreicht, und dann ist Schluss.
+ */
+export const MAX_OFFENE_ANMELDUNGEN = 200
+
+export type PasskeyGrund =
+  | 'nicht-verfuegbar'
+  | 'anfrage-abgelaufen'
+  | 'unbekannt'
+  | 'nicht-verifiziert'
+  | 'geklont'
+  | 'bereits-vorhanden'
+  | 'zu-viele'
+  | 'zweiter-faktor-fehlt'
+  | 'zu-viele-anfragen'
+  | 'ungueltig'
+
+/** Traegt einen Grund, damit die Oberflaeche einen brauchbaren Satz daraus macht. */
+export class PasskeyFehler extends Error {
+  constructor(
+    readonly grund: PasskeyGrund,
+    nachricht?: string,
+  ) {
+    super(nachricht ?? grund)
+    this.name = 'PasskeyFehler'
+  }
+}
+
+export const PASSKEY_MELDUNG: Record<PasskeyGrund, string> = {
+  'nicht-verfuegbar':
+    'Passkeys brauchen eine verschlüsselte Verbindung. Diese Installation läuft nicht über https — ' +
+    'melde dich mit Passwort und Code an.',
+  'anfrage-abgelaufen':
+    'Das hat zu lange gedauert. Bitte klicke noch einmal auf „Mit Passkey anmelden“.',
+  unbekannt:
+    'Dieser Passkey ist hier nicht hinterlegt. Vielleicht gehört er zu einer anderen Adresse ' +
+    'oder wurde inzwischen entfernt.',
+  'nicht-verifiziert':
+    'Dein Gerät hat den Passkey ohne Fingerabdruck, Gesichtserkennung oder PIN freigegeben. ' +
+    'Das wäre nur ein Faktor — und hier liegen Gesundheitsdaten. Bitte richte die Gerätesperre ein.',
+  geklont:
+    'Der Zähler dieses Passkeys ist nicht weitergelaufen. Das kann auf eine Kopie hindeuten. ' +
+    'Der Passkey wurde nicht akzeptiert — bitte entferne ihn und richte einen neuen ein.',
+  'bereits-vorhanden': 'Dieser Passkey ist bereits hinterlegt.',
+  'zu-viele': `Es sind höchstens ${MAX_PASSKEYS_JE_BENUTZER} Passkeys möglich. Entferne zuerst einen alten.`,
+  'zweiter-faktor-fehlt':
+    'Richte zuerst die Authenticator-App ein. Ein Passkey hängt an einem Gerät — ohne einen ' +
+    'zweiten Weg wäre der Zugang bei Verlust zu.',
+  'zu-viele-anfragen':
+    'Gerade laufen ungewöhnlich viele Anmeldeversuche. Bitte versuche es in ein paar Minuten ' +
+    'noch einmal oder melde dich mit Passwort und Code an.',
+  ungueltig: 'Der Passkey konnte nicht geprüft werden. Bitte versuche es noch einmal.',
+}
+
+/**
+ * Kopiert Bytes in ein Uint8Array mit eigenem, nicht geteiltem Puffer.
+ *
+ * Prisma liefert einen Buffer, TextEncoder ein Uint8Array<ArrayBufferLike> -
+ * die Bibliothek verlangt ausdruecklich Uint8Array<ArrayBuffer>. Der
+ * Unterschied ist nicht kosmetisch: ArrayBufferLike schliesst
+ * SharedArrayBuffer ein, und auf geteiltem Speicher darf keine
+ * Signaturpruefung arbeiten, weil sich der Inhalt waehrenddessen aendern
+ * koennte.
+ */
+function alsUint8(daten: Uint8Array): Uint8Array<ArrayBuffer> {
+  const kopie = new Uint8Array(new ArrayBuffer(daten.byteLength))
+  kopie.set(daten)
+  return kopie
+}
+
+/**
+ * Holt die Challenge aus der Antwort des Browsers.
+ *
+ * Sie steckt in den clientData, die der Authenticator mitsigniert hat. Wir
+ * lesen sie hier nur, um die passende Zeile zu finden - geprueft wird sie
+ * anschliessend von der Bibliothek gegen genau diesen Wert.
+ *
+ * Exportiert, damit sie sich ohne Datenbank pruefen laesst.
+ */
+export function challengeAusAntwort(clientDataJSON: string): string {
+  try {
+    const roh = Buffer.from(clientDataJSON, 'base64url').toString('utf8')
+    const gelesen: unknown = JSON.parse(roh)
+    const challenge =
+      typeof gelesen === 'object' && gelesen !== null && 'challenge' in gelesen
+        ? (gelesen as { challenge: unknown }).challenge
+        : null
+    if (typeof challenge !== 'string' || challenge.length === 0) {
+      throw new PasskeyFehler('ungueltig')
+    }
+    return challenge
+  } catch (fehler) {
+    if (fehler instanceof PasskeyFehler) throw fehler
+    throw new PasskeyFehler('ungueltig')
+  }
+}
+
+/** Legt eine Challenge ab. Nur der Server kennt sie, bis der Browser antwortet. */
+async function anfrageMerken(
+  challenge: string,
+  art: PasskeyAnfrageArt,
+  userId: string | null,
+): Promise<void> {
+  await db.passkeyAnfrage.create({
+    data: {
+      challenge,
+      art,
+      userId,
+      ablaufAm: new Date(Date.now() + ANFRAGE_GUELTIG_SEKUNDEN * 1000),
+    },
+  })
+}
+
+/**
+ * Verbraucht eine Challenge - und zwar genau einmal.
+ *
+ * Das DELETE ist der eigentliche Schutz gegen das erneute Einspielen einer
+ * mitgeschnittenen Antwort: Die Datenbank entscheidet, wer die Zeile
+ * bekommt. Wurde keine Zeile geloescht, war sie schon verbraucht oder
+ * abgelaufen - beides fuehrt zum Abbruch.
+ */
+async function anfrageVerbrauchen(
+  challenge: string,
+  art: PasskeyAnfrageArt,
+  userId?: string,
+): Promise<void> {
+  const { count } = await db.passkeyAnfrage.deleteMany({
+    where: {
+      challenge,
+      art,
+      ablaufAm: { gt: new Date() },
+      ...(userId ? { userId } : {}),
+    },
+  })
+  if (count !== 1) throw new PasskeyFehler('anfrage-abgelaufen')
+}
+
+/** Wirft, wenn die Installation gar nicht ueber https erreichbar ist. */
+function verfuegbarkeitPruefen(): void {
+  if (!env.passkey.sicherAufrufbar) throw new PasskeyFehler('nicht-verfuegbar')
+}
+
+/** Ob Passkeys unter der aktuellen Adresse ueberhaupt angeboten werden koennen. */
+export function passkeysMoeglich(): boolean {
+  return env.passkey.sicherAufrufbar
+}
+
+// ---------------------------------------------------------------------------
+// Einrichten
+// ---------------------------------------------------------------------------
+
+export async function registrierungVorbereiten(
+  benutzer: User,
+): Promise<PublicKeyCredentialCreationOptionsJSON> {
+  verfuegbarkeitPruefen()
+
+  // Ohne Authenticator-App kein Passkey - siehe Kopfkommentar.
+  if (!benutzer.totpAktiviertAm) throw new PasskeyFehler('zweiter-faktor-fehlt')
+
+  const vorhandene = await db.passkey.findMany({
+    where: { userId: benutzer.id },
+    select: { credentialId: true, transports: true },
+  })
+
+  if (vorhandene.length >= MAX_PASSKEYS_JE_BENUTZER) throw new PasskeyFehler('zu-viele')
+
+  const optionen = await generateRegistrationOptions({
+    rpName: env.passkey.rpName,
+    rpID: env.passkey.rpId,
+    // Stabil aus der Benutzer-ID. Damit erkennt ein Geraet beim zweiten
+    // Einrichten, dass es derselbe Zugang ist, und ersetzt den Eintrag,
+    // statt einen zweiten anzulegen.
+    userID: alsUint8(new TextEncoder().encode(benutzer.id)),
+    userName: benutzer.email,
+    userDisplayName: benutzer.name,
+    // Keine Attestierung anfordern: Wir wollen nicht wissen, welches
+    // Fabrikat der Benutzer benutzt. Das ist ein Datum, das uns nichts
+    // angeht, und es macht den Ablauf auf manchen Geraeten umstaendlicher.
+    attestationType: 'none',
+    // Schon hinterlegte Schluessel ausschliessen, sonst legt dasselbe
+    // Geraet stillschweigend einen zweiten an.
+    excludeCredentials: vorhandene.map((eintrag) => ({
+      id: eintrag.credentialId,
+      transports: eintrag.transports as AuthenticatorTransportFuture[],
+    })),
+    authenticatorSelection: {
+      // "required": der Schluessel wird auf dem Geraet auffindbar
+      // gespeichert. Nur dann geht die Anmeldung ohne vorherige Eingabe
+      // der E-Mail-Adresse.
+      residentKey: 'required',
+      requireResidentKey: true,
+      // Der Punkt, an dem aus einem Faktor zwei werden.
+      userVerification: 'required',
+    },
+    timeout: ANFRAGE_GUELTIG_SEKUNDEN * 1000,
+  })
+
+  await anfrageMerken(optionen.challenge, 'REGISTRIERUNG', benutzer.id)
+  return optionen
+}
+
+export async function registrierungPruefen(
+  benutzer: User,
+  name: string,
+  antwort: RegistrationResponseJSON,
+): Promise<Passkey> {
+  verfuegbarkeitPruefen()
+  if (!benutzer.totpAktiviertAm) throw new PasskeyFehler('zweiter-faktor-fehlt')
+
+  const challenge = challengeAusAntwort(antwort.response.clientDataJSON)
+  await anfrageVerbrauchen(challenge, 'REGISTRIERUNG', benutzer.id)
+
+  let ergebnis
+  try {
+    ergebnis = await verifyRegistrationResponse({
+      response: antwort,
+      expectedChallenge: challenge,
+      expectedOrigin: env.passkey.herkunft,
+      expectedRPID: env.passkey.rpId,
+      requireUserVerification: true,
+    })
+  } catch {
+    throw new PasskeyFehler('ungueltig')
+  }
+
+  if (!ergebnis.verified) throw new PasskeyFehler('ungueltig')
+
+  const { credential, credentialDeviceType, credentialBackedUp, userVerified } =
+    ergebnis.registrationInfo
+
+  // Doppelte Absicherung: die Bibliothek prueft es bereits, aber diese
+  // Zusage ist zu wichtig, um sie an einer Voreinstellung haengen zu lassen.
+  if (!userVerified) throw new PasskeyFehler('nicht-verifiziert')
+
+  const schonDa = await db.passkey.findUnique({
+    where: { credentialId: credential.id },
+    select: { id: true },
+  })
+  if (schonDa) throw new PasskeyFehler('bereits-vorhanden')
+
+  return db.passkey.create({
+    data: {
+      userId: benutzer.id,
+      credentialId: credential.id,
+      publicKey: Buffer.from(credential.publicKey),
+      counter: BigInt(credential.counter),
+      transports: credential.transports ?? [],
+      name,
+      geraeteArt: credentialDeviceType,
+      gesichert: credentialBackedUp,
+    },
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Anmelden
+// ---------------------------------------------------------------------------
+
+export async function anmeldungVorbereiten(): Promise<PublicKeyCredentialRequestOptionsJSON> {
+  verfuegbarkeitPruefen()
+
+  // Erst aufraeumen, dann die Decke pruefen: Abgelaufenes soll nicht als
+  // laufender Versuch zaehlen.
+  await abgelaufeneAnfragenEntfernen()
+  const offen = await db.passkeyAnfrage.count({ where: { art: 'ANMELDUNG' } })
+  if (offen >= MAX_OFFENE_ANMELDUNGEN) throw new PasskeyFehler('zu-viele-anfragen')
+
+  const optionen = await generateAuthenticationOptions({
+    rpID: env.passkey.rpId,
+    // Bewusst ohne allowCredentials: Der Server soll vor der Anmeldung
+    // nicht verraten, welche Schluessel es zu einer Adresse gibt - und der
+    // Benutzer soll seine E-Mail gar nicht erst eintippen muessen. Das
+    // Geraet weiss selbst, welchen Schluessel es fuer diese Domain hat.
+    userVerification: 'required',
+    timeout: ANFRAGE_GUELTIG_SEKUNDEN * 1000,
+  })
+
+  await anfrageMerken(optionen.challenge, 'ANMELDUNG', null)
+  return optionen
+}
+
+export type PasskeyAnmeldung = {
+  benutzer: User
+  passkey: Passkey
+}
+
+/**
+ * Prueft eine Anmeldeantwort vollstaendig und meldet, wem sie gehoert.
+ *
+ * Alles, was hier durchgeht, ist kryptografisch belegt: die Signatur passt
+ * zum hinterlegten oeffentlichen Schluessel, die Challenge war frisch und
+ * genau einmal gueltig, die Domain stimmt, und das Geraet hat den Benutzer
+ * verifiziert.
+ *
+ * Rate-Limiting und Audit-Log passieren NICHT hier, sondern beim Aufrufer -
+ * dort ist bekannt, ob es eine Anmeldung oder eine erneute Bestaetigung ist.
+ */
+export async function anmeldungPruefen(
+  antwort: AuthenticationResponseJSON,
+): Promise<PasskeyAnmeldung> {
+  verfuegbarkeitPruefen()
+
+  const challenge = challengeAusAntwort(antwort.response.clientDataJSON)
+  await anfrageVerbrauchen(challenge, 'ANMELDUNG')
+
+  const passkey = await db.passkey.findUnique({
+    where: { credentialId: antwort.id },
+    include: { user: true },
+  })
+
+  if (!passkey) throw new PasskeyFehler('unbekannt')
+
+  let ergebnis
+  try {
+    ergebnis = await verifyAuthenticationResponse({
+      response: antwort,
+      expectedChallenge: challenge,
+      expectedOrigin: env.passkey.herkunft,
+      expectedRPID: env.passkey.rpId,
+      requireUserVerification: true,
+      credential: {
+        id: passkey.credentialId,
+        publicKey: alsUint8(passkey.publicKey),
+        counter: Number(passkey.counter),
+        transports: passkey.transports as AuthenticatorTransportFuture[],
+      },
+    })
+  } catch (fehler) {
+    // Die Bibliothek meldet einen nicht weitergelaufenen Zaehler als
+    // gewoehnlichen Fehler. Der verdient eine eigene Meldung: er ist der
+    // einzige Hinweis auf einen kopierten Schluessel, den wir bekommen.
+    const text = fehler instanceof Error ? fehler.message : ''
+    if (text.includes('counter value')) throw new PasskeyFehler('geklont')
+    throw new PasskeyFehler('ungueltig')
+  }
+
+  if (!ergebnis.verified) throw new PasskeyFehler('ungueltig')
+  if (!ergebnis.authenticationInfo.userVerified) throw new PasskeyFehler('nicht-verifiziert')
+
+  await db.passkey.update({
+    where: { id: passkey.id },
+    data: {
+      counter: BigInt(ergebnis.authenticationInfo.newCounter),
+      zuletztBenutztAm: new Date(),
+      // Beides kann sich nachtraeglich aendern, etwa wenn der Benutzer die
+      // Schluesselbund-Synchronisierung einschaltet.
+      geraeteArt: ergebnis.authenticationInfo.credentialDeviceType,
+      gesichert: ergebnis.authenticationInfo.credentialBackedUp,
+    },
+  })
+
+  return { benutzer: passkey.user, passkey }
+}
+
+// ---------------------------------------------------------------------------
+// Verwalten und Aufraeumen
+// ---------------------------------------------------------------------------
+
+export type PasskeyUebersicht = {
+  id: string
+  name: string
+  geraeteArt: string | null
+  gesichert: boolean
+  erstelltAm: Date
+  zuletztBenutztAm: Date | null
+}
+
+export async function passkeysDesBenutzers(userId: string): Promise<PasskeyUebersicht[]> {
+  return db.passkey.findMany({
+    where: { userId },
+    orderBy: [{ zuletztBenutztAm: { sort: 'desc', nulls: 'last' } }, { erstelltAm: 'desc' }],
+    select: {
+      id: true,
+      name: true,
+      geraeteArt: true,
+      gesichert: true,
+      erstelltAm: true,
+      zuletztBenutztAm: true,
+    },
+  })
+}
+
+/** Raeumt liegengebliebene Challenges weg; wird vom Wartungslauf aufgerufen. */
+export async function abgelaufeneAnfragenEntfernen(): Promise<number> {
+  const { count } = await db.passkeyAnfrage.deleteMany({
+    where: { ablaufAm: { lt: new Date() } },
+  })
+  return count
+}

src/lib/dashboard/laden.ts

@@ -21,6 +21,7 @@ import type {
   PosteingangDaten,
   WartetAufAndereDaten,
 } from '@/lib/dashboard/typen'
+import { offeneZahlungsgruppen } from '@/lib/finanzen/wiederkehrend-laden'
 
 /**
  * Alles, was das Dashboard "Heute" braucht - in einem Rutsch.
@@ -267,6 +268,11 @@ export async function dashboardLaden(
         }
       : null
 
+  // Regelmaessige Abbuchungen ohne Vertrag. Eigene Abfrage, weil sie andere
+  // Spalten braucht als der Belegzwang - und weil sie ganz entfaellt, wenn
+  // das Finanzmodul nicht lesbar ist.
+  const wiederkehrendOhneVertrag = darfFinanzen ? await offeneZahlungsgruppen(betreuteId) : 0
+
   const belege: BelegeDaten | null =
     buchungenOhneBeleg && buchungenOhneBelegGesamt !== null
       ? {
@@ -286,6 +292,7 @@ export async function dashboardLaden(
             gegenstelle: b.gegenstelle,
           })),
           buchungenOhneBelegGesamt,
+          wiederkehrendOhneVertrag,
         }
       : null
 

src/lib/dashboard/typen.ts

@@ -149,6 +149,15 @@ export type BelegeDaten = {
   belegeOhneBuchungGesamt: number
   buchungenOhneBeleg: BuchungOhneBeleg[]
   buchungenOhneBelegGesamt: number
+  /**
+   * Regelmaessige Abbuchungen ohne hinterlegten Vertrag.
+   *
+   * Steht bewusst in dieser Kachel und nicht in einer eigenen: Es ist
+   * dieselbe Frage - "wozu gehoert diese Zahlung?" -, nur eine Ebene
+   * hoeher. Eine sechste Kachel auf "Heute" waere eine Kachel, die man
+   * nach zwei Wochen nicht mehr sieht.
+   */
+  wiederkehrendOhneVertrag: number
 }
 
 // -----------------------------------------------------------------------------

src/lib/env.ts

@@ -58,14 +58,25 @@ function einmal<T>(fn: () => T): () => T {
 
 const holeVerschluesselungsschluessel = einmal((): Map<number, Buffer> => {
   const schluessel = new Map<number, Buffer>()
+
   // ENC_KEY_V1, ENC_KEY_V2, ... - alte Versionen bleiben zum Entschluesseln
   // stehen, verschluesselt wird immer mit der aktiven Version.
-  for (const [name] of Object.entries(process.env)) {
+  for (const [name, wert] of Object.entries(process.env)) {
     const treffer = name.match(/^ENC_KEY_V(\d+)$/)
-    if (treffer) {
+    if (!treffer) continue
+
+    // Eine LEERE Variable ist kein Schluessel.
+    //
+    // docker compose reicht ENC_KEY_V2 immer durch - mit leerem Wert, wenn
+    // in der .env keiner steht. Wuerde hier allein der Name zaehlen, waere
+    // jede Installation ohne zweiten Schluessel kaputt, und zwar mit der
+    // irrefuehrenden Meldung "ENC_KEY_V2 fehlt" - obwohl niemand einen
+    // zweiten Schluessel wollte.
+    if (!wert || wert.trim() === '') continue
+
     schluessel.set(Number.parseInt(treffer[1]!, 10), schluessel32(name))
   }
-  }
+
   if (schluessel.size === 0) {
     throw new Error(
       'Kein Verschluesselungsschluessel gefunden. Es muss mindestens ENC_KEY_V1 ' +
@@ -78,8 +89,11 @@ const holeVerschluesselungsschluessel = einmal((): Map<number, Buffer> => {
 const holeAktiveVersion = einmal((): number => {
   const version = zahl('ENC_KEY_AKTIV', 1)
   if (!holeVerschluesselungsschluessel().has(version)) {
+    const vorhanden = [...holeVerschluesselungsschluessel().keys()].sort().join(', ')
     throw new Error(
-      `ENC_KEY_AKTIV=${version}, aber ENC_KEY_V${version} ist nicht gesetzt.`,
+      `ENC_KEY_AKTIV=${version}, aber ENC_KEY_V${version} ist nicht gesetzt oder leer. ` +
+        `Vorhanden sind die Versionen: ${vorhanden}. Beim Rotieren zuerst den ` +
+        `neuen Schluessel eintragen, danach ENC_KEY_AKTIV umstellen.`,
     )
   }
   return version
@@ -171,6 +185,35 @@ export const env = {
     return (process.env.AUTH_URL ?? 'http://localhost:3000').replace(/\/$/, '')
   },
 
+  /**
+   * Herkunft und Bereichskennung fuer Passkeys (WebAuthn).
+   *
+   * Beides wird aus AUTH_URL abgeleitet und nicht getrennt konfiguriert -
+   * eine zweite Quelle waere eine zweite Gelegenheit, sie auseinanderlaufen
+   * zu lassen.
+   *
+   * Die "rpId" ist der nackte Hostname ohne Schema und ohne Port. An sie
+   * bindet der Authenticator den Schluessel: Ein Passkey fuer
+   * cockpit.example.de funktioniert auf keiner anderen Adresse - genau das
+   * macht ihn gegen Phishing immun. Umgekehrt heisst das: Wer die Domain
+   * wechselt, muss alle Passkeys neu einrichten.
+   *
+   * Der Browser gibt WebAuthn ausserdem nur in einem sicheren Kontext frei -
+   * also unter https oder auf localhost. Hinter einem Proxy, der auf http
+   * weiterreicht, muss AUTH_URL trotzdem die oeffentliche https-Adresse
+   * nennen; verglichen wird gegen das, was im Browser in der Adresszeile
+   * stand.
+   */
+  get passkey() {
+    const url = new URL(process.env.AUTH_URL ?? 'http://localhost:3000')
+    return {
+      rpId: url.hostname,
+      rpName: 'Betreuungs-Cockpit',
+      herkunft: url.origin,
+      sicherAufrufbar: url.protocol === 'https:' || url.hostname === 'localhost',
+    }
+  },
+
   get istProduktion() {
     return process.env.NODE_ENV === 'production'
   },

src/lib/finanzen/wiederkehrend-laden.ts

@@ -0,0 +1,82 @@
+import 'server-only'
+import { db, nichtGeloescht } from '@/lib/db'
+import {
+  einzelneZahlungen,
+  gruppieren,
+  offeneKandidaten,
+  type Einzelzahlung,
+  type Zahlungsgruppe,
+} from '@/lib/finanzen/wiederkehrend'
+
+/**
+ * Holt die Daten fuer die Ansicht "Wiederkehrende Zahlungen".
+ *
+ * Getrennt von wiederkehrend.ts, damit die Erkennung selbst ohne Datenbank
+ * bleibt und sich mit Einheitstests festnageln laesst. Hier steht nur, was
+ * ohne Postgres nicht geht.
+ */
+
+export type WiederkehrendBild = {
+  gruppen: Zahlungsgruppe[]
+  einzelne: Einzelzahlung[]
+  /** Wie viele Gruppen noch keinem Vertrag zugeordnet sind. */
+  offen: number
+  /** Bereits abgehakte Gruppen - zum Zurueckholen. */
+  abgehakt: { id: string; schluessel: string; anzeigename: string; begruendung: string | null }[]
+  /** Wurde ueberhaupt schon etwas importiert? Sonst ist die Seite leer aus gutem Grund. */
+  ausgabenGesamt: number
+}
+
+export async function wiederkehrendLaden(betreuteId: string): Promise<WiederkehrendBild> {
+  const [buchungen, vertraege, abgehakt] = await Promise.all([
+    db.buchung.findMany({
+      where: {
+        betreuteId,
+        // Nur echte Ausgaben der betreuten Person. Umbuchungen zwischen
+        // eigenen Konten sind kein Vertragshinweis - wer monatlich aufs
+        // Sparbuch legt, hat deswegen keinen Vertrag. Auslagen des
+        // Betreuers gehoeren ebenfalls nicht hierher.
+        richtung: 'AUSGABE',
+        betrifftBetreute: true,
+        ...nichtGeloescht,
+      },
+      select: { id: true, datum: true, betragCent: true, gegenstelle: true },
+      orderBy: { datum: 'asc' },
+    }),
+    db.vertrag.findMany({
+      where: { betreuteId, ...nichtGeloescht },
+      select: { id: true, bezeichnung: true, gesellschaft: true },
+    }),
+    db.zahlungsgruppeGeklaert.findMany({
+      where: { betreuteId },
+      select: { id: true, schluessel: true, anzeigename: true, begruendung: true },
+      orderBy: { anzeigename: 'asc' },
+    }),
+  ])
+
+  const optionen = {
+    abgehakt: new Set(abgehakt.map((eintrag) => eintrag.schluessel)),
+    vertraege,
+  }
+
+  const gruppen = gruppieren(buchungen, optionen)
+
+  return {
+    gruppen,
+    einzelne: einzelneZahlungen(buchungen, optionen),
+    offen: offeneKandidaten(gruppen),
+    abgehakt,
+    ausgabenGesamt: buchungen.length,
+  }
+}
+
+/**
+ * Nur die Zahl fuer das Dashboard - ohne die vollen Listen aufzubauen.
+ *
+ * Laedt dieselben Buchungen, gibt aber nur die Anzahl offener Gruppen
+ * zurueck. Die Kachel soll die Seite nicht spuerbar verlangsamen.
+ */
+export async function offeneZahlungsgruppen(betreuteId: string): Promise<number> {
+  const bild = await wiederkehrendLaden(betreuteId)
+  return bild.offen
+}

src/lib/finanzen/wiederkehrend.ts

@@ -0,0 +1,512 @@
+import { summe } from '@/lib/finanzen/betrag'
+import { nachTagSortieren, tageZwischen } from '@/lib/finanzen/datum'
+
+/**
+ * Wiederkehrende Zahlungen aufspueren - ohne Datenbank, damit sich jede
+ * Entscheidung einzeln nachrechnen laesst.
+ *
+ * Der Anlass: Am Anfang einer Betreuung weiss niemand, welche Vertraege es
+ * gibt. Die Antwort steht aber im Kontoauszug - wer regelmaessig abbucht,
+ * hat einen Vertrag. Diese Datei macht aus hunderten Buchungszeilen eine
+ * Arbeitsliste.
+ *
+ * Zwei Haltungen liegen allem zugrunde:
+ *
+ * 1. **Im Zweifel getrennt lassen.** Zwei Zeilen zu viel sind harmlos - man
+ *    sieht hin und hakt ab. Eine falsch zusammengefasste Gruppe verbirgt
+ *    dagegen einen Vertrag, und der fehlt dann im Vermoegensverzeichnis.
+ *    Deshalb wird nur zusammengefasst, was sicher dasselbe ist.
+ *
+ * 2. **Nichts behaupten, was nicht belegt ist.** Die Erkennung nennt immer
+ *    mit, worauf sie sich stuetzt ("4 Zahlungen, etwa alle 3 Monate").
+ *    Eine Einordnung ohne nachvollziehbare Grundlage waere geraten, und
+ *    geratene Zahlen landen sonst im Bericht ans Gericht.
+ */
+
+// -----------------------------------------------------------------------------
+// Eingabe und Ergebnis
+// -----------------------------------------------------------------------------
+
+export type ZahlungEingabe = {
+  id: string
+  datum: Date
+  betragCent: bigint
+  gegenstelle: string | null
+}
+
+/** Ein hinterlegter Vertrag - zum Abgleich, ob die Zahlung schon erklaert ist. */
+export type VertragAbgleich = {
+  id: string
+  bezeichnung: string
+  gesellschaft: string | null
+}
+
+export type Rhythmus =
+  | 'MONATLICH'
+  | 'ZWEIMONATLICH'
+  | 'VIERTELJAEHRLICH'
+  | 'HALBJAEHRLICH'
+  | 'JAEHRLICH'
+  | 'UNREGELMAESSIG'
+
+export const RHYTHMUS_BESCHRIFTUNG: Record<Rhythmus, string> = {
+  MONATLICH: 'monatlich',
+  ZWEIMONATLICH: 'zweimonatlich',
+  VIERTELJAEHRLICH: 'vierteljährlich',
+  HALBJAEHRLICH: 'halbjährlich',
+  JAEHRLICH: 'jährlich',
+  UNREGELMAESSIG: 'unregelmäßig',
+}
+
+/** Wie oft der Rhythmus im Jahr zuschlaegt. Fuer die Hochrechnung. */
+const ZAHLUNGEN_JE_JAHR: Record<Rhythmus, number> = {
+  MONATLICH: 12,
+  ZWEIMONATLICH: 6,
+  VIERTELJAEHRLICH: 4,
+  HALBJAEHRLICH: 2,
+  JAEHRLICH: 1,
+  UNREGELMAESSIG: 0,
+}
+
+export type Zahlungsgruppe = {
+  /** Normalisierter Name - der Schluessel, unter dem abgehakt wird. */
+  schluessel: string
+  /** Die laengste vorgefundene Schreibweise, fuer die Anzeige. */
+  anzeigename: string
+  /** Alle vorgefundenen Schreibweisen, falls mehrere zusammengefasst wurden. */
+  schreibweisen: string[]
+  anzahl: number
+  ersteZahlung: Date
+  letzteZahlung: Date
+  /** Median der Betraege - unempfindlicher gegen einen Ausreisser als der Schnitt. */
+  betragCent: bigint
+  kleinsterBetragCent: bigint
+  groessterBetragCent: bigint
+  /** Schwanken die Betraege stark? Dann ist es eher keine feste Praemie. */
+  betragSchwankt: boolean
+  rhythmus: Rhythmus
+  /** Medianabstand in Tagen - die Grundlage der Rhythmuserkennung. */
+  abstandTage: number | null
+  /** Hochgerechnet auf ein Jahr. Bei unregelmaessigem Rhythmus: das
+   *  tatsaechlich Gezahlte, nicht hochgerechnet. */
+  jahresbetragCent: bigint
+  /** Passt der Name zu einem hinterlegten Vertrag? */
+  vertragId: string | null
+  vertragBezeichnung: string | null
+  buchungIds: string[]
+}
+
+// -----------------------------------------------------------------------------
+// Namen vergleichbar machen
+// -----------------------------------------------------------------------------
+
+/**
+ * Rechtsformen und Zusaetze, die keinen Unterschied machen.
+ *
+ * Bewusst kurz gehalten. Jeder Eintrag hier ist eine Behauptung "das darf
+ * weg" - und jede falsche Behauptung wirft zwei verschiedene Empfaenger
+ * zusammen. "Versicherung" steht deshalb NICHT in der Liste: Zwischen
+ * "Allianz Versicherung" und "Allianz Lebensversicherung" liegt ein
+ * Unterschied, der im Vermoegensverzeichnis zaehlt.
+ */
+const RECHTSFORMEN = [
+  'gmbh & co kg',
+  'gmbh und co kg',
+  'gmbh',
+  'mbh',
+  'ohg',
+  'kgaa',
+  'kg',
+  'ag',
+  'se',
+  'ev',
+  'vvag',
+  'ag',
+  'aoer',
+  'koer',
+]
+
+/** Ersetzt Umlaute, damit "Muenchener" und "Münchener" zusammenfallen. */
+function umlauteAufloesen(text: string): string {
+  return text
+    .replace(/ä/g, 'ae')
+    .replace(/ö/g, 'oe')
+    .replace(/ü/g, 'ue')
+    .replace(/ß/g, 'ss')
+}
+
+/**
+ * Macht zwei Schreibweisen desselben Empfaengers vergleichbar.
+ *
+ * Was hier zusammenfaellt, wird spaeter in einer Zeile angezeigt. Deshalb
+ * nur das Unstrittige: Gross- und Kleinschreibung, Satzzeichen, doppelte
+ * Leerzeichen, Umlaute und die Rechtsform am Ende.
+ *
+ * Was ausdruecklich NICHT passiert: Aehnlichkeitssuche ueber Abstandsmasse.
+ * "Stadtwerke Bamberg" und "Stadtwerke Bayreuth" unterscheiden sich in drei
+ * Zeichen und sind zwei voellig verschiedene Rechnungssteller.
+ */
+export function normalisieren(gegenstelle: string | null | undefined): string {
+  if (!gegenstelle) return ''
+
+  let text = umlauteAufloesen(gegenstelle.toLowerCase())
+
+  // Satzzeichen zu Leerzeichen, damit "vers.ag" zu "vers ag" wird und die
+  // Rechtsform anschliessend als eigenes Wort erkennbar ist.
+  text = text.replace(/[.,;:/\\()[\]{}"'`*+_-]/g, ' ')
+  text = text.replace(/\s+/g, ' ').trim()
+
+  // Rechtsform nur am ENDE entfernen. Mitten im Namen kann dieselbe
+  // Zeichenfolge etwas anderes sein - "ag" steckt in "Agentur".
+  let geaendert = true
+  while (geaendert) {
+    geaendert = false
+    for (const form of RECHTSFORMEN) {
+      if (text.endsWith(` ${form}`)) {
+        text = text.slice(0, -(form.length + 1)).trim()
+        geaendert = true
+        break
+      }
+    }
+  }
+
+  return text
+}
+
+// -----------------------------------------------------------------------------
+// Rhythmus
+// -----------------------------------------------------------------------------
+
+function median(werte: number[]): number {
+  if (werte.length === 0) return 0
+  const sortiert = [...werte].sort((a, b) => a - b)
+  const mitte = Math.floor(sortiert.length / 2)
+  return sortiert.length % 2 === 1
+    ? sortiert[mitte]!
+    : Math.round((sortiert[mitte - 1]! + sortiert[mitte]!) / 2)
+}
+
+function medianBigInt(werte: bigint[]): bigint {
+  if (werte.length === 0) return 0n
+  const sortiert = [...werte].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+  const mitte = Math.floor(sortiert.length / 2)
+  return sortiert.length % 2 === 1
+    ? sortiert[mitte]!
+    : (sortiert[mitte - 1]! + sortiert[mitte]!) / 2n
+}
+
+/**
+ * Ordnet einen Medianabstand einem Rhythmus zu.
+ *
+ * Die Spannen sind bewusst weit: Lastschriften kommen am ersten Werktag,
+ * und der wandert. Zwischen dem 1. Februar und dem 1. Maerz liegen 28 Tage,
+ * zwischen dem 1. Juli und dem 1. August 31 - beides ist monatlich.
+ */
+export function rhythmusAusAbstand(tage: number): Rhythmus {
+  if (tage >= 24 && tage <= 38) return 'MONATLICH'
+  if (tage >= 50 && tage <= 70) return 'ZWEIMONATLICH'
+  if (tage >= 80 && tage <= 100) return 'VIERTELJAEHRLICH'
+  if (tage >= 160 && tage <= 200) return 'HALBJAEHRLICH'
+  if (tage >= 330 && tage <= 400) return 'JAEHRLICH'
+  return 'UNREGELMAESSIG'
+}
+
+/** Der Medianabstand zwischen aufeinanderfolgenden Zahlungen, in Tagen. */
+export function abstandInTagen(daten: Date[]): number | null {
+  if (daten.length < 2) return null
+  const sortiert = nachTagSortieren(daten, (d) => d)
+  const abstaende: number[] = []
+  for (let i = 1; i < sortiert.length; i++) {
+    abstaende.push(Math.abs(tageZwischen(sortiert[i - 1]!, sortiert[i]!)))
+  }
+  return median(abstaende)
+}
+
+/**
+ * Schwanken die Betraege so stark, dass es keine feste Zahlung mehr ist?
+ *
+ * Ein Fuenftel Abweichung vom Median ist grosszuegig - Beitragsanpassungen
+ * und Stromabschlaege bewegen sich in dieser Groessenordnung. Wer darueber
+ * liegt, zahlt eher nach Verbrauch als nach Vertrag.
+ */
+export function betraegeSchwanken(betraege: bigint[]): boolean {
+  if (betraege.length < 2) return false
+  const mitte = medianBigInt(betraege)
+  if (mitte === 0n) return true
+
+  return betraege.some((betrag) => {
+    const abweichung = betrag > mitte ? betrag - mitte : mitte - betrag
+    // Ganzzahlig gerechnet: |x - m| * 100 > m * 20
+    return abweichung * 100n > mitte * 20n
+  })
+}
+
+// -----------------------------------------------------------------------------
+// Gruppieren
+// -----------------------------------------------------------------------------
+
+/**
+ * Ab wann gilt eine Zahlung als wiederkehrend?
+ *
+ * Zwei ist das Minimum, das ueberhaupt einen Abstand ergibt. Damit bleibt
+ * eine Luecke, die man kennen muss: Eine JAEHRLICH abgebuchte Praemie
+ * erscheint bei nur einem importierten Jahr genau einmal und wird hier
+ * nicht gefunden. Deshalb gibt es daneben die Liste der einzelnen groesseren
+ * Zahlungen - siehe einzelneZahlungen().
+ */
+export const MINDESTANZAHL = 2
+
+export type GruppierungsOptionen = {
+  /** Schon abgehakte Schluessel - "das ist kein Vertrag". */
+  abgehakt?: ReadonlySet<string>
+  /** Hinterlegte Vertraege, zum Abgleich. */
+  vertraege?: VertragAbgleich[]
+}
+
+/** Ordnet Vertraege ihrem normalisierten Gesellschaftsnamen zu. */
+function vertragsIndex(vertraege: VertragAbgleich[]): Map<string, VertragAbgleich> {
+  const index = new Map<string, VertragAbgleich>()
+  for (const vertrag of vertraege) {
+    const schluessel = normalisieren(vertrag.gesellschaft)
+    // Erster Treffer gewinnt. Zwei Vertraege bei derselben Gesellschaft sind
+    // moeglich (Hausrat und Haftpflicht bei der Allianz); fuer die Frage
+    // "ist das schon erklaert?" genuegt einer.
+    if (schluessel && !index.has(schluessel)) index.set(schluessel, vertrag)
+  }
+  return index
+}
+
+/**
+ * Waehlt aus mehreren Schreibweisen die, die man jemandem zeigen kann.
+ *
+ * Banken liefern denselben Empfaenger mal als "Allianz Lebensversicherung
+ * AG", mal als "ALLIANZ LEBENSVERS AG". Die laengste zu nehmen waere
+ * naheliegend - und faellt regelmaessig auf die geschriene Fassung herein,
+ * weil Versalien nicht kuerzer sind.
+ *
+ * Das ist mehr als Kosmetik: Dieser Name wird beim "Vertrag anlegen" in das
+ * Feld Gesellschaft uebernommen. Steht dort alles in Grossbuchstaben, tippt
+ * man es von Hand neu - und dann war die Vorbelegung wertlos.
+ *
+ * Also: erst die Schreibweisen mit Klein- und Grossbuchstaben, unter denen
+ * die laengste. Gibt es nur geschriene, nimmt man eben die laengste davon.
+ */
+export function besteSchreibweise(schreibweisen: string[]): string {
+  if (schreibweisen.length === 0) return ''
+
+  const gemischt = schreibweisen.filter((name) => name !== name.toUpperCase())
+  const auswahl = gemischt.length > 0 ? gemischt : schreibweisen
+
+  return auswahl.reduce((a, b) => (b.length > a.length ? b : a), auswahl[0]!)
+}
+
+/**
+ * Fasst Zahlungen zu Gruppen zusammen und bewertet sie.
+ *
+ * Erwartet werden ausschliesslich Ausgaben, die die betreute Person
+ * betreffen - die Auswahl trifft der Aufrufer, weil sie von der Datenbank
+ * kommt. Umbuchungen zwischen eigenen Konten gehoeren nicht hierher: Wer
+ * monatlich aufs Sparbuch legt, hat deswegen keinen Vertrag.
+ */
+export function gruppieren(
+  zahlungen: ZahlungEingabe[],
+  optionen: GruppierungsOptionen = {},
+): Zahlungsgruppe[] {
+  const abgehakt = optionen.abgehakt ?? new Set<string>()
+  const index = vertragsIndex(optionen.vertraege ?? [])
+
+  const nachSchluessel = new Map<string, ZahlungEingabe[]>()
+  for (const zahlung of zahlungen) {
+    const schluessel = normalisieren(zahlung.gegenstelle)
+    // Ohne Gegenstelle gibt es nichts zu gruppieren. Solche Buchungen sind
+    // Bargeldabhebungen oder handerfasste Zeilen - kein Vertragshinweis.
+    if (!schluessel) continue
+    if (abgehakt.has(schluessel)) continue
+
+    const bisher = nachSchluessel.get(schluessel)
+    if (bisher) bisher.push(zahlung)
+    else nachSchluessel.set(schluessel, [zahlung])
+  }
+
+  const gruppen: Zahlungsgruppe[] = []
+
+  for (const [schluessel, posten] of nachSchluessel) {
+    if (posten.length < MINDESTANZAHL) continue
+
+    const sortiert = nachTagSortieren(posten, (p) => p.datum)
+    const betraege = posten.map((p) => p.betragCent)
+    const abstandTage = abstandInTagen(posten.map((p) => p.datum))
+    const rhythmus = abstandTage === null ? 'UNREGELMAESSIG' : rhythmusAusAbstand(abstandTage)
+    const betragCent = medianBigInt(betraege)
+
+    const jeJahr = ZAHLUNGEN_JE_JAHR[rhythmus]
+    const jahresbetragCent =
+      jeJahr > 0 ? betragCent * BigInt(jeJahr) : summe(betraege)
+
+    const schreibweisen = [
+      ...new Set(posten.map((p) => (p.gegenstelle ?? '').trim()).filter(Boolean)),
+    ].sort()
+
+    const vertrag = index.get(schluessel) ?? null
+
+    gruppen.push({
+      schluessel,
+      anzeigename: besteSchreibweise(schreibweisen) || schluessel,
+      schreibweisen,
+      anzahl: posten.length,
+      ersteZahlung: sortiert[0]!.datum,
+      letzteZahlung: sortiert[sortiert.length - 1]!.datum,
+      betragCent,
+      kleinsterBetragCent: betraege.reduce((a, b) => (b < a ? b : a), betraege[0]!),
+      groessterBetragCent: betraege.reduce((a, b) => (b > a ? b : a), betraege[0]!),
+      betragSchwankt: betraegeSchwanken(betraege),
+      rhythmus,
+      abstandTage,
+      jahresbetragCent,
+      vertragId: vertrag?.id ?? null,
+      vertragBezeichnung: vertrag?.bezeichnung ?? null,
+      buchungIds: sortiert.map((p) => p.id),
+    })
+  }
+
+  // Absteigend nach Jahresbetrag: Was am meisten kostet, will man zuerst
+  // geklaert haben.
+  return gruppen.sort((a, b) =>
+    a.jahresbetragCent > b.jahresbetragCent
+      ? -1
+      : a.jahresbetragCent < b.jahresbetragCent
+        ? 1
+        : a.anzeigename.localeCompare(b.anzeigename, 'de'),
+  )
+}
+
+// -----------------------------------------------------------------------------
+// Die Luecke: einmalige Zahlungen
+// -----------------------------------------------------------------------------
+
+/**
+ * Ab welchem Betrag eine einzelne Zahlung erwaehnenswert ist.
+ *
+ * 150 EUR ist die Grenze, ab der sich das Nachsehen lohnt. Darunter stehen
+ * Einkaeufe und Gebuehren, darueber faengt es an, nach Jahresbeitrag
+ * auszusehen.
+ */
+export const EINZELZAHLUNG_AB_CENT = 15_000n
+
+export type Einzelzahlung = {
+  schluessel: string
+  anzeigename: string
+  buchungId: string
+  datum: Date
+  betragCent: bigint
+  vertragId: string | null
+  vertragBezeichnung: string | null
+}
+
+/**
+ * Einzelne groessere Zahlungen ohne hinterlegten Vertrag.
+ *
+ * Der Grund fuer diese zweite Liste: Die Gruppierung braucht mindestens
+ * zwei Zahlungen. Eine jaehrlich abgebuchte Versicherungspraemie erscheint
+ * bei einem importierten Jahr aber genau einmal - und ausgerechnet
+ * Versicherungen werden oft jaehrlich gezahlt. Ohne diese Liste waere die
+ * Suche genau dort blind, wo sie am meisten bringen soll.
+ *
+ * Sie ist ausdruecklich kein Vertragsverdacht, sondern eine Merkliste. In
+ * der Oberflaeche steht sie deshalb getrennt und mit eigener Ueberschrift.
+ */
+export function einzelneZahlungen(
+  zahlungen: ZahlungEingabe[],
+  optionen: GruppierungsOptionen = {},
+): Einzelzahlung[] {
+  const abgehakt = optionen.abgehakt ?? new Set<string>()
+  const index = vertragsIndex(optionen.vertraege ?? [])
+
+  const anzahlJeSchluessel = new Map<string, number>()
+  for (const zahlung of zahlungen) {
+    const schluessel = normalisieren(zahlung.gegenstelle)
+    if (!schluessel) continue
+    anzahlJeSchluessel.set(schluessel, (anzahlJeSchluessel.get(schluessel) ?? 0) + 1)
+  }
+
+  const treffer: Einzelzahlung[] = []
+
+  for (const zahlung of zahlungen) {
+    const schluessel = normalisieren(zahlung.gegenstelle)
+    if (!schluessel) continue
+    if (abgehakt.has(schluessel)) continue
+    // Alles, was mehrfach vorkommt, steht bereits in der Gruppenliste.
+    if ((anzahlJeSchluessel.get(schluessel) ?? 0) >= MINDESTANZAHL) continue
+    if (zahlung.betragCent < EINZELZAHLUNG_AB_CENT) continue
+
+    const vertrag = index.get(schluessel) ?? null
+
+    treffer.push({
+      schluessel,
+      anzeigename: (zahlung.gegenstelle ?? '').trim() || schluessel,
+      buchungId: zahlung.id,
+      datum: zahlung.datum,
+      betragCent: zahlung.betragCent,
+      vertragId: vertrag?.id ?? null,
+      vertragBezeichnung: vertrag?.bezeichnung ?? null,
+    })
+  }
+
+  return treffer.sort((a, b) =>
+    a.betragCent > b.betragCent ? -1 : a.betragCent < b.betragCent ? 1 : 0,
+  )
+}
+
+// -----------------------------------------------------------------------------
+// Fuer die Anzeige
+// -----------------------------------------------------------------------------
+
+/**
+ * Der Satz, der unter einer Gruppe steht.
+ *
+ * Er nennt die Grundlage der Einordnung, statt nur das Ergebnis zu
+ * behaupten - damit man widersprechen kann, wenn es nicht stimmt.
+ */
+export function rhythmusErklaerung(gruppe: Zahlungsgruppe): string {
+  const zahlungen = `${gruppe.anzahl} ${gruppe.anzahl === 1 ? 'Zahlung' : 'Zahlungen'}`
+
+  if (gruppe.rhythmus === 'UNREGELMAESSIG' || gruppe.abstandTage === null) {
+    return `${zahlungen}, ohne erkennbaren Abstand`
+  }
+
+  const tage = gruppe.abstandTage
+  const monate = Math.round(tage / 30)
+  const abstand =
+    monate <= 1 ? 'etwa monatlich' : `etwa alle ${monate} Monate`
+
+  return `${zahlungen}, ${abstand}`
+}
+
+/**
+ * Uebersetzt den erkannten Rhythmus in den Zahlrhythmus des Vertrags.
+ *
+ * Zwei Faelle haben dort keine Entsprechung: ZWEIMONATLICH kennt das
+ * Vertragsmodell nicht, und UNREGELMAESSIG ist keine Aussage, sondern das
+ * Eingestaendnis, keine zu haben. Beide liefern null - dann bleibt im
+ * Formular die Vorgabe stehen, statt etwas Falsches vorzublenden. Eine
+ * vorbelegte falsche Angabe wird uebersehen; ein leeres Feld nicht.
+ */
+export function alsZahlRhythmus(rhythmus: Rhythmus): string | null {
+  switch (rhythmus) {
+    case 'MONATLICH':
+      return 'MONATLICH'
+    case 'VIERTELJAEHRLICH':
+      return 'VIERTELJAEHRLICH'
+    case 'HALBJAEHRLICH':
+      return 'HALBJAEHRLICH'
+    case 'JAEHRLICH':
+      return 'JAEHRLICH'
+    default:
+      return null
+  }
+}
+
+/** Wie viele Gruppen warten noch auf eine Entscheidung? Fuer das Dashboard. */
+export function offeneKandidaten(gruppen: Zahlungsgruppe[]): number {
+  return gruppen.filter((gruppe) => gruppe.vertragId === null).length
+}

src/lib/passkey-browser.ts

@@ -0,0 +1,55 @@
+/**
+ * Browserseitige Hilfen fuer Passkeys.
+ *
+ * Bewusst ohne "server-only" und ohne Datenbankzugriff: Diese Datei laeuft
+ * im Browser. Die eigentliche Pruefung passiert auf dem Server
+ * (src/lib/auth/passkey.ts) - hier geht es nur darum, das Geraet
+ * anzusprechen und seine Fehler in verstaendliche Saetze zu uebersetzen.
+ */
+
+import {
+  browserSupportsWebAuthn,
+  startAuthentication,
+  startRegistration,
+} from '@simplewebauthn/browser'
+
+export { browserSupportsWebAuthn, startAuthentication, startRegistration }
+
+/**
+ * Uebersetzt die Ausnahmen der WebAuthn-Schnittstelle.
+ *
+ * Der Browser wirft DOMExceptions mit sehr knappen Namen und einer
+ * englischen Beschreibung, die man niemandem zeigen kann. Vor allem
+ * "NotAllowedError" ist irrefuehrend: Er bedeutet meistens schlicht, dass
+ * der Vorgang abgebrochen wurde oder die Zeit abgelaufen ist - nicht, dass
+ * etwas verboten waere.
+ */
+export function passkeyBrowserfehler(fehler: unknown, beimEinrichten = false): string {
+  const name = fehler instanceof Error ? fehler.name : ''
+
+  switch (name) {
+    case 'NotAllowedError':
+      return 'Abgebrochen oder zu lange gewartet. Du kannst es gleich noch einmal versuchen.'
+
+    case 'InvalidStateError':
+      return beimEinrichten
+        ? 'Für dieses Gerät ist hier bereits ein Passkey hinterlegt. Ein zweiter bringt nichts — ' +
+            'nimm ein anderes Gerät oder entferne zuerst den vorhandenen.'
+        : 'Dieses Gerät kann den Passkey gerade nicht verwenden.'
+
+    case 'SecurityError':
+      return (
+        'Die Adresse im Browser passt nicht zu der, für die der Passkey ausgestellt wurde. ' +
+        'Das ist genau der Schutz, der Phishing verhindert — prüfe die Adresszeile.'
+      )
+
+    case 'NotSupportedError':
+      return 'Dieses Gerät unterstützt keine Passkeys mit Fingerabdruck, Gesicht oder PIN.'
+
+    case 'AbortError':
+      return 'Abgebrochen.'
+
+    default:
+      return 'Der Passkey konnte nicht verwendet werden. Bitte versuche es noch einmal.'
+  }
+}

src/lib/validierung/betreute.ts

@@ -8,21 +8,36 @@ import { z } from 'zod'
  * ist, nicht was falsch war.
  */
 
-/** Leere Zeichenketten aus einem Formular sollen zu null werden, nicht zu "". */
+/**
+ * Optionales Textfeld.
+ *
+ * Drei Eingaben muessen zu null werden:
+ *   ""         das Feld war da, blieb aber leer
+ *   null       ausdruecklich geleert
+ *   undefined  das Feld war im Formular ueberhaupt nicht dabei
+ *
+ * Der letzte Fall ist der wichtige: Das kurze Formular der Ersteinrichtung
+ * schickt nur eine Handvoll Felder, das vollstaendige unter Stammdaten
+ * alle. Beide gehen durch dasselbe Schema. Ohne .optional() wuerde die
+ * Ersteinrichtung an zwei Dutzend Feldern scheitern, die gar nicht auf dem
+ * Bildschirm stehen - und die Meldung liesse sich keinem Feld zuordnen.
+ */
 const optionalerText = (max = 200) =>
   z
     .string()
     .trim()
     .max(max, `Bitte höchstens ${max} Zeichen.`)
-    .transform((wert) => (wert === '' ? null : wert))
+    .optional()
     .nullable()
+    .transform((wert) => (wert === undefined || wert === '' ? null : wert))
 
-/** HTML-Datumsfelder liefern "" oder "2026-01-15". */
+/** HTML-Datumsfelder liefern "" oder "2026-01-15" - oder gar nichts. */
 const optionalesDatum = z
   .string()
   .trim()
-  .transform((wert) => (wert === '' ? null : wert))
+  .optional()
   .nullable()
+  .transform((wert) => (wert === undefined || wert === '' ? null : wert))
   .refine((wert) => wert === null || /^\d{4}-\d{2}-\d{2}$/.test(wert), {
     message: 'Bitte ein Datum im Format TT.MM.JJJJ wählen.',
   })

src/lib/version.ts

@@ -17,7 +17,7 @@
  */
 
 /** Muss zur "version" in der package.json passen. */
-export const VERSION = '1.0.0'
+export const VERSION = '1.2.0'
 
 /**
  * Kurzer Git-Stand, beim Bauen hineingereicht:

src/lib/wartung.ts

@@ -3,6 +3,7 @@ import { db, papierkorbGrenze } from '@/lib/db'
 import { env } from '@/lib/env'
 import { fristErinnerung, mailSenden } from '@/lib/mail'
 import { alteVersucheEntfernen } from '@/lib/auth/ratelimit'
+import { abgelaufeneAnfragenEntfernen } from '@/lib/auth/passkey'
 
 /**
  * Taeglicher Wartungslauf.
@@ -14,6 +15,7 @@ import { alteVersucheEntfernen } from '@/lib/auth/ratelimit'
  *   2. Papierkorb leeren (30 Tage)
  *   3. Alte Anmeldeversuche entfernen (30 Tage)
  *   4. Altes Audit-Log entfernen (10 Jahre, ueber die DB-Funktion)
+ *   5. Liegengebliebene Passkey-Challenges entfernen (5 Minuten)
  *
  * Jeder Schritt faengt seine Fehler selbst ab. Faellt die Mail aus, soll
  * trotzdem aufgeraeumt werden - sonst laeuft die Datenbank voll, weil ein
@@ -25,6 +27,7 @@ export type Wartungsergebnis = {
   papierkorbGeleert: number
   loginversucheEntfernt: number
   auditEintraegeEntfernt: number
+  passkeyAnfragenEntfernt: number
   fehler: string[]
 }
 
@@ -56,6 +59,7 @@ export async function wartungslauf(): Promise<Wartungsergebnis> {
     papierkorbGeleert: 0,
     loginversucheEntfernt: 0,
     auditEintraegeEntfernt: 0,
+    passkeyAnfragenEntfernt: 0,
     fehler: [],
   }
 
@@ -93,6 +97,15 @@ export async function wartungslauf(): Promise<Wartungsergebnis> {
     ergebnis.fehler.push(`Audit-Log: ${beschreiben(fehler)}`)
   }
 
+  // --- 5. Passkey-Challenges ----------------------------------------------
+  try {
+    // Normalerweise raeumt jede Anmeldung selbst auf. Bleibt der letzte
+    // Versuch des Tages liegen, faengt es dieser Lauf ab.
+    ergebnis.passkeyAnfragenEntfernt = await abgelaufeneAnfragenEntfernen()
+  } catch (fehler) {
+    ergebnis.fehler.push(`Passkey-Anfragen: ${beschreiben(fehler)}`)
+  }
+
   return ergebnis
 }
 

src/server/actions/betreute.ts

@@ -53,6 +53,49 @@ function felderAusFehler(fehler: z.ZodError): Record<string, string> {
   return ergebnis
 }
 
+/**
+ * Baut die Antwort auf einen Pruefungsfehler.
+ *
+ * Der wichtige Teil ist die Unterscheidung: Beanstandet die Pruefung ein
+ * Feld, das gar nicht abgeschickt wurde, dann passt das Formular nicht zum
+ * Schema - und die Meldung liesse sich auf dem Bildschirm keinem Feld
+ * zuordnen. Der Nutzer saehe "Bitte pruefe die markierten Felder", ohne
+ * dass irgendetwas markiert waere, und kaeme nie weiter.
+ *
+ * Das ist ein Fehler im Programm, keiner in der Eingabe. Er wird deshalb
+ * benannt und ins Serverlog geschrieben, statt ihn dem Nutzer als
+ * Eingabefehler unterzuschieben.
+ */
+function antwortAufFehler(fehler: z.ZodError, formular: FormData): BetreuteZustand {
+  const felder = felderAusFehler(fehler)
+  const gesendet = new Set(formular.keys())
+  const nichtZuordenbar = Object.entries(felder).filter(([feld]) => !gesendet.has(feld))
+
+  if (nichtZuordenbar.length > 0) {
+    const liste = nichtZuordenbar.map(([feld, meldung]) => `${feld}: ${meldung}`).join('; ')
+    console.error(
+      `[stammdaten] Das Formular passt nicht zum Schema. Beanstandet wurden ` +
+        `Felder, die es gar nicht abgeschickt hat: ${liste}`,
+    )
+    return {
+      fehler:
+        'Das Formular passt nicht zur Prüfung — betroffen sind Felder, die ' +
+        'hier gar nicht stehen: ' +
+        nichtZuordenbar.map(([feld]) => feld).join(', ') +
+        '. Das ist ein Fehler in der Anwendung, nicht in deiner Eingabe. ' +
+        'Einzelheiten stehen im Serverlog.',
+      felder,
+      werte: werteMerken(formular),
+    }
+  }
+
+  return {
+    fehler: 'Bitte prüfe die markierten Felder.',
+    felder,
+    werte: werteMerken(formular),
+  }
+}
+
 function werteMerken(formular: FormData): Record<string, string> {
   const werte: Record<string, string> = {}
   for (const [name, wert] of formular.entries()) {
@@ -77,13 +120,7 @@ export async function betreuteAnlegen(
   }
 
   const gelesen = BetreuteSchema.safeParse(formularLesen(formular))
-  if (!gelesen.success) {
+  if (!gelesen.success) return antwortAufFehler(gelesen.error, formular)
-    return {
-      fehler: 'Bitte prüfe die markierten Felder.',
-      felder: felderAusFehler(gelesen.error),
-      werte: werteMerken(formular),
-    }
-  }
 
   const { offen, verschluesselt } = aufteilen(gelesen.data)
 
@@ -134,13 +171,7 @@ export async function betreuteAendern(
   const { benutzer, betreute } = await erfordereZugang(betreuteId, 'STAMMDATEN', 'schreiben')
 
   const gelesen = BetreuteSchema.safeParse(formularLesen(formular))
-  if (!gelesen.success) {
+  if (!gelesen.success) return antwortAufFehler(gelesen.error, formular)
-    return {
-      fehler: 'Bitte prüfe die markierten Felder.',
-      felder: felderAusFehler(gelesen.error),
-      werte: werteMerken(formular),
-    }
-  }
 
   const { offen, verschluesselt } = aufteilen(gelesen.data)
 

src/server/actions/finanzen.ts

@@ -821,3 +821,106 @@ export async function wertstandLoeschen(
   revalidatePath('/finanzen/vermoegen')
   return { erfolg: 'Wert gelöscht.' }
 }
+
+// -----------------------------------------------------------------------------
+// Wiederkehrende Zahlungen
+// -----------------------------------------------------------------------------
+
+/**
+ * Hakt eine Gruppe wiederkehrender Zahlungen als "kein Vertrag" ab.
+ *
+ * Der Schluessel kommt aus normalisieren() und wird hier NICHT noch einmal
+ * gebildet: Was der Benutzer auf dem Bildschirm gesehen hat, soll auch
+ * abgehakt werden. Bildeten Anzeige und Aktion den Schluessel getrennt,
+ * koennten sie auseinanderlaufen - und dann verschwaende eine andere
+ * Gruppe als die angeklickte.
+ */
+export async function zahlungsgruppeAbhaken(
+  _zustand: Formularzustand,
+  daten: FormData,
+): Promise<Formularzustand> {
+  const betreuteId = String(daten.get('betreuteId') ?? '')
+  const schluessel = String(daten.get('schluessel') ?? '').trim()
+  const anzeigename = String(daten.get('anzeigename') ?? '').trim()
+  const begruendung = String(daten.get('begruendung') ?? '').trim()
+
+  if (!schluessel || !anzeigename) {
+    return { fehler: 'Diese Zahlungsgruppe lässt sich nicht zuordnen.' }
+  }
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'FINANZEN', 'schreiben')
+
+    await db.zahlungsgruppeGeklaert.upsert({
+      where: { betreuteId_schluessel: { betreuteId, schluessel } },
+      create: {
+        betreuteId,
+        schluessel,
+        anzeigename,
+        begruendung: begruendung === '' ? null : begruendung,
+      },
+      update: { begruendung: begruendung === '' ? null : begruendung },
+    })
+
+    await protokollieren({
+      aktion: 'ERSTELLT',
+      entitaet: 'ZahlungsgruppeGeklaert',
+      bezeichnung: `${anzeigename} — kein Vertrag`,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[finanzen] Zahlungsgruppe konnte nicht abgehakt werden:', ausnahme)
+    return { fehler: 'Die Zahlungsgruppe konnte nicht abgehakt werden.' }
+  }
+
+  revalidatePath('/finanzen/wiederkehrend')
+  revalidatePath('/heute')
+  return { erfolg: `„${anzeigename}“ gilt als geklärt.` }
+}
+
+/** Holt eine abgehakte Gruppe zurueck in die Liste. */
+export async function zahlungsgruppeZurueckholen(
+  _zustand: Formularzustand,
+  daten: FormData,
+): Promise<Formularzustand> {
+  const betreuteId = String(daten.get('betreuteId') ?? '')
+  const eintragId = String(daten.get('eintragId') ?? '')
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'FINANZEN', 'schreiben')
+
+    // Zeilenweise Pruefung: Die ID muss zu DIESER betreuten Person gehoeren.
+    const eintrag = await db.zahlungsgruppeGeklaert.findFirst({
+      where: { id: eintragId, betreuteId },
+      select: { id: true, anzeigename: true },
+    })
+    if (!eintrag) return { fehler: 'Diesen Eintrag gibt es nicht (mehr).' }
+
+    await db.zahlungsgruppeGeklaert.delete({ where: { id: eintrag.id } })
+
+    await protokollieren({
+      aktion: 'GELOESCHT',
+      entitaet: 'ZahlungsgruppeGeklaert',
+      entitaetId: eintrag.id,
+      bezeichnung: `${eintrag.anzeigename} — wieder offen`,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[finanzen] Zahlungsgruppe konnte nicht zurückgeholt werden:', ausnahme)
+    return { fehler: 'Der Eintrag konnte nicht zurückgeholt werden.' }
+  }
+
+  revalidatePath('/finanzen/wiederkehrend')
+  revalidatePath('/heute')
+  return { erfolg: 'Die Gruppe steht wieder in der Liste.' }
+}

src/server/actions/passkey.ts

@@ -0,0 +1,313 @@
+'use server'
+
+import { AuthError } from 'next-auth'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+import type {
+  AuthenticationResponseJSON,
+  PublicKeyCredentialCreationOptionsJSON,
+  PublicKeyCredentialRequestOptionsJSON,
+  RegistrationResponseJSON,
+} from '@simplewebauthn/server'
+import { signIn } from '@/auth'
+import { db } from '@/lib/db'
+import { protokollieren } from '@/lib/audit'
+import {
+  PASSKEY_MELDUNG,
+  PasskeyFehler,
+  anmeldungPruefen,
+  anmeldungVorbereiten,
+  registrierungPruefen,
+  registrierungVorbereiten,
+} from '@/lib/auth/passkey'
+import { erfordereBenutzer, reauthBestaetigen } from '@/lib/auth/sitzung'
+
+/**
+ * Server Actions rund um Passkeys.
+ *
+ * Ein Passkey-Vorgang besteht immer aus zwei Aufrufen: erst holt der Browser
+ * die Optionen samt Challenge, dann schickt er die Antwort des Geraets
+ * zurueck. Dazwischen liegt der Griff zum Fingerabdrucksensor, und der
+ * dauert unbestimmt lange - deshalb zwei Schritte und keine Sitzungsvariable.
+ *
+ * Die Antworten des Authenticators kommen als JSON-Zeichenkette herein, nicht
+ * als Objekt. Grund: Was ueber die Grenze zum Server geht, wird hier
+ * ausdruecklich geparst und geprueft, statt sich auf die Serialisierung von
+ * React zu verlassen.
+ */
+
+/** Ergebnis eines Schritts, der Optionen liefert. */
+export type PasskeyStart<T> = { ok: true; optionen: T } | { ok: false; fehler: string }
+
+/** Ergebnis eines abschliessenden Schritts. */
+export type PasskeyErgebnis = { ok: true; meldung?: string } | { ok: false; fehler: string }
+
+function alsFehler(fehler: unknown): { ok: false; fehler: string } {
+  if (fehler instanceof PasskeyFehler) {
+    return { ok: false, fehler: PASSKEY_MELDUNG[fehler.grund] }
+  }
+  console.error('[passkey] Unerwarteter Fehler:', fehler)
+  return { ok: false, fehler: PASSKEY_MELDUNG.ungueltig }
+}
+
+/**
+ * Parst die Antwort des Browsers.
+ *
+ * Absichtlich nur eine grobe Formpruefung: Was zaehlt, prueft anschliessend
+ * die Bibliothek kryptografisch. Hier geht es nur darum, dass kein
+ * offensichtlicher Unsinn bis dorthin durchlaeuft.
+ */
+const AntwortSchema = z.object({
+  id: z.string().min(1),
+  rawId: z.string().min(1),
+  type: z.literal('public-key'),
+  response: z.object({ clientDataJSON: z.string().min(1) }).passthrough(),
+})
+
+function antwortLesen<T>(roh: string): T {
+  const gelesen = AntwortSchema.safeParse(JSON.parse(roh))
+  if (!gelesen.success) throw new PasskeyFehler('ungueltig')
+  return gelesen.data as T
+}
+
+// ---------------------------------------------------------------------------
+// Einrichten (angemeldet, unter "Mein Konto")
+// ---------------------------------------------------------------------------
+
+export async function passkeyEinrichtungStarten(): Promise<
+  PasskeyStart<PublicKeyCredentialCreationOptionsJSON>
+> {
+  try {
+    const benutzer = await erfordereBenutzer()
+    return { ok: true, optionen: await registrierungVorbereiten(benutzer) }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+const NameSchema = z
+  .string()
+  .trim()
+  .min(1, 'Bitte gib dem Gerät einen Namen.')
+  .max(60, 'Bitte höchstens 60 Zeichen.')
+
+export async function passkeyEinrichtungAbschliessen(
+  name: string,
+  antwortJson: string,
+): Promise<PasskeyErgebnis> {
+  try {
+    const benutzer = await erfordereBenutzer()
+
+    const geprueft = NameSchema.safeParse(name)
+    if (!geprueft.success) {
+      return {
+        ok: false,
+        fehler: geprueft.error.issues[0]?.message ?? 'Der Name passt nicht.',
+      }
+    }
+
+    const antwort = antwortLesen<RegistrationResponseJSON>(antwortJson)
+    const passkey = await registrierungPruefen(benutzer, geprueft.data, antwort)
+
+    await protokollieren({
+      aktion: 'PASSKEY_REGISTRIERT',
+      entitaet: 'Passkey',
+      entitaetId: passkey.id,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+      bezeichnung: passkey.name,
+    })
+
+    revalidatePath('/konto')
+    return { ok: true, meldung: `„${passkey.name}“ ist eingerichtet.` }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Verwalten
+// ---------------------------------------------------------------------------
+
+export async function passkeyEntfernen(id: string): Promise<PasskeyErgebnis> {
+  try {
+    const benutzer = await erfordereBenutzer()
+
+    // Zeilenweise Pruefung: Es genuegt nicht, dass die ID existiert - sie
+    // muss zu DIESEM Benutzer gehoeren. deleteMany mit userId im WHERE
+    // erledigt Pruefung und Loeschen in einem Zug; ein fremder Passkey
+    // trifft dann auf null Zeilen.
+    const passkey = await db.passkey.findFirst({
+      where: { id, userId: benutzer.id },
+      select: { id: true, name: true },
+    })
+    if (!passkey)
+      return {
+        ok: false,
+        fehler: 'Dieser Passkey gehört nicht zu deinem Zugang.',
+      }
+
+    await db.passkey.delete({ where: { id: passkey.id } })
+
+    await protokollieren({
+      aktion: 'PASSKEY_ENTFERNT',
+      entitaet: 'Passkey',
+      entitaetId: passkey.id,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+      bezeichnung: passkey.name,
+    })
+
+    revalidatePath('/konto')
+    return { ok: true, meldung: `„${passkey.name}“ wurde entfernt.` }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Anmelden (nicht angemeldet)
+// ---------------------------------------------------------------------------
+
+export async function passkeyAnmeldungStarten(): Promise<
+  PasskeyStart<PublicKeyCredentialRequestOptionsJSON>
+> {
+  try {
+    return { ok: true, optionen: await anmeldungVorbereiten() }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+/** Verhindert offene Weiterleitungen auf fremde Seiten. */
+function sicheresZiel(ziel: string): string {
+  if (!ziel.startsWith('/') || ziel.startsWith('//')) return '/heute'
+  return ziel
+}
+
+/**
+ * Erkennt die Weiterleitung, die Next.js intern als Ausnahme wirft.
+ * Wie in anmelden.ts ueber das digest-Feld statt ueber einen Import aus
+ * next/dist - interne Pfade aendern sich zwischen Nebenversionen.
+ */
+function istWeiterleitung(fehler: unknown): boolean {
+  return (
+    typeof fehler === 'object' &&
+    fehler !== null &&
+    'digest' in fehler &&
+    typeof (fehler as { digest?: unknown }).digest === 'string' &&
+    (fehler as { digest: string }).digest.startsWith('NEXT_REDIRECT')
+  )
+}
+
+/**
+ * Uebersetzt den Fehlercode aus authorize() in einen lesbaren Satz.
+ * "passkey:<grund>" kommt aus PasskeyAnmeldeFehler, alles andere aus dem
+ * gewoehnlichen Anmeldeweg.
+ */
+function fehlertext(code: string): string {
+  const [art, wert] = code.split(':')
+
+  if (art === 'passkey') {
+    const grund = wert as keyof typeof PASSKEY_MELDUNG
+    return PASSKEY_MELDUNG[grund] ?? PASSKEY_MELDUNG.ungueltig
+  }
+  if (art === 'gesperrt') {
+    const minuten = Math.ceil(Number.parseInt(wert ?? '0', 10) / 60)
+    return (
+      `Zu viele Fehlversuche. Aus Sicherheitsgründen ist die Anmeldung für ` +
+      `${minuten > 1 ? `etwa ${minuten} Minuten` : 'kurze Zeit'} gesperrt.`
+    )
+  }
+  if (art === 'konto-inaktiv') {
+    return 'Dieser Zugang ist deaktiviert. Bitte wende dich an den Administrator.'
+  }
+  return PASSKEY_MELDUNG.ungueltig
+}
+
+export async function passkeyAnmeldungAbschliessen(
+  antwortJson: string,
+  weiter: string,
+): Promise<PasskeyErgebnis> {
+  try {
+    // Nur die Form pruefen; signIn() macht die eigentliche Arbeit.
+    antwortLesen<AuthenticationResponseJSON>(antwortJson)
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+
+  try {
+    await signIn('passkey', {
+      antwort: antwortJson,
+      redirectTo: sicheresZiel(weiter),
+    })
+  } catch (fehler) {
+    // Bei Erfolg wirft signIn eine Weiterleitung - die muss durch.
+    if (istWeiterleitung(fehler)) throw fehler
+
+    if (fehler instanceof AuthError) {
+      const code =
+        'code' in fehler && typeof fehler.code === 'string' ? fehler.code : 'passkey:ungueltig'
+      return { ok: false, fehler: fehlertext(code) }
+    }
+
+    throw fehler
+  }
+
+  // Wird nicht erreicht - signIn leitet weiter.
+  return { ok: true }
+}
+
+// ---------------------------------------------------------------------------
+// Erneut bestaetigen (angemeldet, vor sensiblen Aktionen)
+// ---------------------------------------------------------------------------
+
+export async function passkeyBestaetigungStarten(): Promise<
+  PasskeyStart<PublicKeyCredentialRequestOptionsJSON>
+> {
+  try {
+    await erfordereBenutzer()
+    return { ok: true, optionen: await anmeldungVorbereiten() }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}
+
+/**
+ * Bestaetigt die laufende Sitzung mit einem Passkey.
+ *
+ * Wichtig ist die letzte Pruefung: Der Passkey muss dem angemeldeten
+ * Benutzer gehoeren. Sonst koennte jemand mit seinem eigenen Passkey die
+ * fremde Sitzung freischalten, die auf einem unbeaufsichtigten Rechner
+ * offen steht - genau der Fall, gegen den die erneute Bestaetigung da ist.
+ */
+export async function passkeyBestaetigen(antwortJson: string): Promise<PasskeyErgebnis> {
+  try {
+    const benutzer = await erfordereBenutzer()
+    const antwort = antwortLesen<AuthenticationResponseJSON>(antwortJson)
+
+    const { benutzer: eigentuemer } = await anmeldungPruefen(antwort)
+
+    if (eigentuemer.id !== benutzer.id) {
+      await protokollieren({
+        aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
+        entitaet: 'User',
+        entitaetId: benutzer.id,
+        userId: benutzer.id,
+        userEmail: benutzer.email,
+        bezeichnung: 'Bestätigung mit fremdem Passkey',
+      })
+      return {
+        ok: false,
+        fehler: 'Dieser Passkey gehört zu einem anderen Zugang als dem gerade angemeldeten.',
+      }
+    }
+
+    await reauthBestaetigen(benutzer.id)
+    return { ok: true }
+  } catch (fehler) {
+    return alsFehler(fehler)
+  }
+}

tests/passkey.test.ts

@@ -0,0 +1,193 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import {
+  MAX_PASSKEYS_JE_BENUTZER,
+  PASSKEY_MELDUNG,
+  PasskeyFehler,
+  challengeAusAntwort,
+  passkeysMoeglich,
+} from '@/lib/auth/passkey'
+import { passkeyBrowserfehler } from '@/lib/passkey-browser'
+import { env } from '@/lib/env'
+
+/**
+ * Passkeys — die Teile, die sich ohne Datenbank und ohne Browser prüfen
+ * lassen.
+ *
+ * Der Schwerpunkt liegt auf der Herleitung von `rpId` und Herkunft aus
+ * `AUTH_URL`. Das ist bei WebAuthn die Stelle, an der eine Installation
+ * still kaputtgeht: Stimmt die Bereichskennung nicht, lässt sich zwar ein
+ * Passkey einrichten, aber nie wieder verwenden — und die Fehlermeldung des
+ * Browsers zeigt auf alles Mögliche, nur nicht auf die Konfiguration.
+ *
+ * Dieselbe Fehlerklasse hat uns bei `APP_BIND` und `ENC_KEY_V2` schon zwei
+ * Fassungen gekostet: eine Umgebungsvariable, die falsch ausgewertet wird,
+ * und ein Fehlerbild, das woandershin zeigt.
+ */
+
+let vorher: string | undefined
+
+beforeEach(() => {
+  vorher = process.env.AUTH_URL
+})
+
+afterEach(() => {
+  if (vorher === undefined) delete process.env.AUTH_URL
+  else process.env.AUTH_URL = vorher
+})
+
+describe('Bereichskennung aus AUTH_URL', () => {
+  it('nimmt den nackten Hostnamen als rpId, ohne Schema und ohne Port', () => {
+    process.env.AUTH_URL = 'https://cockpit.example.de'
+    expect(env.passkey.rpId).toBe('cockpit.example.de')
+    expect(env.passkey.herkunft).toBe('https://cockpit.example.de')
+  })
+
+  it('lässt den Port in der Herkunft stehen, aber nicht in der rpId', () => {
+    // Die Herkunft wird zeichengenau mit dem verglichen, was im Browser in
+    // der Adresszeile stand - der Port gehoert dazu. Die rpId ist dagegen
+    // die Domain, an die der Schluessel gebunden wird; ein Port darf dort
+    // nicht auftauchen, sonst weist der Authenticator sie zurueck.
+    process.env.AUTH_URL = 'https://cockpit.example.de:8443'
+    expect(env.passkey.rpId).toBe('cockpit.example.de')
+    expect(env.passkey.herkunft).toBe('https://cockpit.example.de:8443')
+  })
+
+  it('verträgt einen Schrägstrich am Ende', () => {
+    process.env.AUTH_URL = 'https://cockpit.example.de/'
+    expect(env.passkey.herkunft).toBe('https://cockpit.example.de')
+  })
+
+  it('erkennt eine Unterdomain als eigene Kennung', () => {
+    // Ein Passkey fuer betreuung.example.de gilt NICHT fuer example.de -
+    // genau das ist der Phishingschutz.
+    process.env.AUTH_URL = 'https://betreuung.example.de'
+    expect(env.passkey.rpId).toBe('betreuung.example.de')
+  })
+})
+
+describe('Verfügbarkeit', () => {
+  it('bietet Passkeys über https an', () => {
+    process.env.AUTH_URL = 'https://cockpit.example.de'
+    expect(env.passkey.sicherAufrufbar).toBe(true)
+    expect(passkeysMoeglich()).toBe(true)
+  })
+
+  it('bietet sie auf localhost an, auch ohne https', () => {
+    // Der Browser wertet localhost als sicheren Kontext - sonst liesse
+    // sich in der Entwicklung nichts ausprobieren.
+    process.env.AUTH_URL = 'http://localhost:3000'
+    expect(env.passkey.sicherAufrufbar).toBe(true)
+  })
+
+  it('bietet sie NICHT über einfaches http an', () => {
+    // Wichtig, dass das der Server entscheidet und nicht der Browser: Ein
+    // Knopf, der beim Klick eine kryptische DOMException wirft, ist
+    // schlechter als gar kein Knopf.
+    process.env.AUTH_URL = 'http://cockpit.example.de'
+    expect(env.passkey.sicherAufrufbar).toBe(false)
+    expect(passkeysMoeglich()).toBe(false)
+  })
+
+  it('bietet sie auch über eine nackte IP ohne https nicht an', () => {
+    process.env.AUTH_URL = 'http://10.0.0.5:3000'
+    expect(env.passkey.sicherAufrufbar).toBe(false)
+  })
+})
+
+describe('Challenge aus der Antwort des Browsers', () => {
+  function clientData(inhalt: unknown): string {
+    return Buffer.from(JSON.stringify(inhalt), 'utf8').toString('base64url')
+  }
+
+  it('liest die Challenge aus den clientData', () => {
+    const daten = clientData({
+      type: 'webauthn.get',
+      challenge: 'AbCdEf-1234_xyz',
+      origin: 'https://cockpit.example.de',
+    })
+    expect(challengeAusAntwort(daten)).toBe('AbCdEf-1234_xyz')
+  })
+
+  it('weist eine Antwort ohne Challenge ab', () => {
+    const daten = clientData({ type: 'webauthn.get', origin: 'https://cockpit.example.de' })
+    expect(() => challengeAusAntwort(daten)).toThrowError(PasskeyFehler)
+  })
+
+  it('weist eine leere Challenge ab', () => {
+    expect(() => challengeAusAntwort(clientData({ challenge: '' }))).toThrowError(PasskeyFehler)
+  })
+
+  it('weist eine Challenge ab, die keine Zeichenkette ist', () => {
+    expect(() => challengeAusAntwort(clientData({ challenge: 42 }))).toThrowError(PasskeyFehler)
+  })
+
+  it('weist Unsinn ab, statt daran abzustürzen', () => {
+    expect(() => challengeAusAntwort('das ist kein base64url-JSON')).toThrowError(PasskeyFehler)
+    expect(() => challengeAusAntwort('')).toThrowError(PasskeyFehler)
+  })
+})
+
+describe('Meldungen', () => {
+  it('hat zu jedem Grund einen Satz, den man jemandem zeigen kann', () => {
+    // Ein fehlender Eintrag wuerde als "undefined" auf dem Bildschirm
+    // landen. Der Typ verhindert das beim Uebersetzen; hier wird geprueft,
+    // dass auch nichts Leeres durchrutscht.
+    for (const [grund, text] of Object.entries(PASSKEY_MELDUNG)) {
+      expect(text.length, `Meldung für "${grund}"`).toBeGreaterThan(20)
+      expect(text, `Meldung für "${grund}"`).not.toMatch(/undefined/)
+    }
+  })
+
+  it('nennt in der Obergrenze die tatsächliche Zahl', () => {
+    expect(PASSKEY_MELDUNG['zu-viele']).toContain(String(MAX_PASSKEYS_JE_BENUTZER))
+  })
+
+  it('erklärt bei fehlender Nutzerverifikation, warum abgelehnt wird', () => {
+    // Das ist die Meldung, die am ehesten nach Schikane aussieht. Sie muss
+    // den Grund nennen, sonst haelt man sie fuer einen Fehler.
+    expect(PASSKEY_MELDUNG['nicht-verifiziert']).toMatch(/Fingerabdruck|PIN/)
+  })
+})
+
+describe('Fehler des Browsers', () => {
+  function dom(name: string): Error {
+    const fehler = new Error('irgendwas Englisches')
+    fehler.name = name
+    return fehler
+  }
+
+  it('deutet NotAllowedError als Abbruch, nicht als Verbot', () => {
+    // Der Name ist irrefuehrend: Er kommt auch, wenn schlicht niemand den
+    // Finger aufgelegt hat. "Nicht erlaubt" waere die falsche Auskunft.
+    const text = passkeyBrowserfehler(dom('NotAllowedError'))
+    expect(text).toMatch(/Abgebrochen/)
+    expect(text).not.toMatch(/verboten|nicht erlaubt/i)
+  })
+
+  it('erklärt beim Einrichten, dass dieses Gerät schon einen Passkey hat', () => {
+    expect(passkeyBrowserfehler(dom('InvalidStateError'), true)).toMatch(/bereits/)
+  })
+
+  it('sagt bei SecurityError, dass die Adresse nicht passt', () => {
+    expect(passkeyBrowserfehler(dom('SecurityError'))).toMatch(/Adress/)
+  })
+
+  it('fällt bei unbekannten Fehlern auf einen brauchbaren Satz zurück', () => {
+    expect(passkeyBrowserfehler(dom('VoellingNeuerFehler'))).toMatch(/noch einmal/)
+    expect(passkeyBrowserfehler('gar kein Fehlerobjekt')).toMatch(/noch einmal/)
+    expect(passkeyBrowserfehler(undefined)).toMatch(/noch einmal/)
+  })
+
+  it('gibt nie die englische Originalmeldung weiter', () => {
+    for (const name of [
+      'NotAllowedError',
+      'InvalidStateError',
+      'SecurityError',
+      'NotSupportedError',
+      'AbortError',
+      'Unbekannt',
+    ]) {
+      expect(passkeyBrowserfehler(dom(name))).not.toContain('irgendwas Englisches')
+    }
+  })
+})

tests/skripte.test.ts

@@ -0,0 +1,87 @@
+import { execFileSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { describe, expect, it } from 'vitest'
+
+/**
+ * Die Betriebsskripte müssen im Repository so liegen, dass sie auf dem
+ * Server auch laufen.
+ *
+ * Anlass sind zwei Fehler, die beide erst im Betrieb aufgefallen sind und
+ * beide nichts mit dem Programm zu tun hatten, sondern mit der Verpackung:
+ *
+ *   1. `scripts/` fehlte im Docker-Abbild — `node scripts/totp-geheimnis.mjs`
+ *      lief ins Leere (behoben in 1.0.1).
+ *   2. Die `.sh`-Dateien lagen mit Modus 644 im Repository. Die Anleitung
+ *      sagt `./scripts/update.sh`, auf Linux kam „Permission denied".
+ *
+ * Beide Male hat kein Test angeschlagen, weil beide Male der Code richtig
+ * war. Diese Datei prüft deshalb nicht Verhalten, sondern Verpackung.
+ *
+ * Der Ausführbarkeitsbit wird aus dem Git-Index gelesen, nicht vom
+ * Dateisystem: Unter Windows steht `core.filemode=false`, dort sagt das
+ * Dateisystem nichts aus. Maßgeblich ist, was ausgecheckt wird.
+ */
+
+function gitVerfuegbar(): boolean {
+  try {
+    execFileSync('git', ['rev-parse', '--git-dir'], { stdio: 'pipe' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Liefert [Modus, Pfad] je Datei, so wie sie im Index steht. */
+function eintraegeImIndex(muster: string): [string, string][] {
+  const ausgabe = execFileSync('git', ['ls-files', '-s', muster], { encoding: 'utf8' })
+  return ausgabe
+    .split('\n')
+    .filter((zeile) => zeile.trim() !== '')
+    .map((zeile) => {
+      const [angaben, pfad] = zeile.split('\t')
+      return [angaben!.split(' ')[0]!, pfad!]
+    })
+}
+
+const mitGit = gitVerfuegbar()
+
+describe.skipIf(!mitGit)('Betriebsskripte', () => {
+  it('legt jedes Shell-Skript ausführbar ab', () => {
+    const skripte = eintraegeImIndex('scripts/*.sh')
+
+    // Wenn hier nichts steht, stimmt das Muster nicht mehr - das waere
+    // ein stiller Ausfall der Pruefung.
+    expect(skripte.length).toBeGreaterThan(0)
+
+    for (const [modus, pfad] of skripte) {
+      expect(modus, `${pfad} muss ausführbar sein (100755, ist ${modus})`).toBe('100755')
+    }
+  })
+
+  it('gibt jedem Shell-Skript eine Shebang-Zeile', () => {
+    for (const [, pfad] of eintraegeImIndex('scripts/*.sh')) {
+      const ersteZeile = readFileSync(pfad, 'utf8').split('\n')[0] ?? ''
+      expect(ersteZeile, `${pfad} braucht eine Shebang-Zeile`).toMatch(/^#!/)
+    }
+  })
+
+  it('nimmt scripts/ ins Docker-Abbild auf', () => {
+    // Der Fehler aus 1.0.1: Die Wartungsskripte lagen im Repository, aber
+    // nicht im Behaelter. Aufgefallen ist es erst, als sie gebraucht wurden.
+    const dockerfile = readFileSync('Dockerfile', 'utf8')
+    // Die Zeile traegt zusaetzliche Schalter (--from, --chown) - deshalb
+    // nicht auf eine feste Reihenfolge festlegen, sondern nur darauf, dass
+    // scripts/ ins Abbild kopiert wird.
+    expect(dockerfile).toMatch(/^COPY.*\/scripts\s+\.\/scripts\s*$/m)
+  })
+
+  it('bindet die Sicherungsskripte aus scripts/ in die Compose-Datei ein', () => {
+    // Sie werden als Volume in den Sicherungsdienst gehaengt. Ein
+    // umbenanntes Skript faellt sonst erst um 03:15 Uhr auf - im Log,
+    // das niemand liest.
+    const compose = readFileSync('docker-compose.yml', 'utf8')
+    for (const name of ['sicherung.sh', 'wiederherstellung.sh']) {
+      expect(compose, `${name} wird nicht eingebunden`).toContain(`./scripts/${name}:`)
+    }
+  })
+})

tests/stammdaten.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest'
+import { BetreuteSchema, formularLesen } from '@/lib/validierung/betreute'
+
+/**
+ * Eingabepruefung der Stammdaten.
+ *
+ * Anlass für diese Datei war ein Fehler im Betrieb: Die Ersteinrichtung
+ * ließ sich nicht abschließen. Das Formular meldete „Bitte prüfe die
+ * markierten Felder", markierte aber keines — weil die Meldungen zu
+ * Feldern gehörten, die dort gar nicht stehen.
+ *
+ * Ursache: Das kurze Formular der Ersteinrichtung schickt neun Felder,
+ * das vollständige unter Stammdaten alle. Beide gehen durch dasselbe
+ * Schema, und die optionalen Felder waren zwar `nullable`, aber nicht
+ * `optional` — ein fehlendes Feld ist `undefined`, nicht `null`.
+ */
+
+/** Die Felder, die das kurze Formular der Ersteinrichtung tatsächlich schickt. */
+function ersteinrichtungsFormular(): FormData {
+  const f = new FormData()
+  f.set('vorname', 'Franziska')
+  f.set('nachname', 'Wilde')
+  f.set('geburtsdatum', '1963-09-23')
+  f.set('betreuungsgericht', 'Lichtenfels')
+  f.set('aktenzeichenGericht', 'XVII 355/25')
+  f.set('bestellungAm', '2025-11-07')
+  f.append('aufgabenkreise', 'VERMOEGENSSORGE')
+  f.append('aufgabenkreise', 'GESUNDHEITSSORGE')
+  f.set('befreiterBetreuer', 'on')
+  f.set('ehrenamtlich', 'on')
+  return f
+}
+
+describe('Ersteinrichtung', () => {
+  it('nimmt das kurze Formular an, obwohl es die meisten Felder nicht schickt', () => {
+    const gelesen = BetreuteSchema.safeParse(formularLesen(ersteinrichtungsFormular()))
+
+    if (!gelesen.success) {
+      const felder = Object.keys(gelesen.error.flatten().fieldErrors).join(', ')
+      throw new Error(`Abgelehnt wegen: ${felder}`)
+    }
+
+    expect(gelesen.data.vorname).toBe('Franziska')
+    expect(gelesen.data.nachname).toBe('Wilde')
+    expect(gelesen.data.geburtsdatum.toISOString()).toBe('1963-09-23T00:00:00.000Z')
+    expect(gelesen.data.bestellungAm?.toISOString()).toBe('2025-11-07T00:00:00.000Z')
+    expect(gelesen.data.aufgabenkreise).toEqual(['VERMOEGENSSORGE', 'GESUNDHEITSSORGE'])
+    expect(gelesen.data.befreiterBetreuer).toBe(true)
+    expect(gelesen.data.ehrenamtlich).toBe(true)
+  })
+
+  it('macht aus nicht gesendeten Feldern null, nicht undefined', () => {
+    const gelesen = BetreuteSchema.parse(formularLesen(ersteinrichtungsFormular()))
+
+    // Diese Felder standen nie auf dem Bildschirm. Sie muessen als null in
+    // der Datenbank landen, sonst schreibt Prisma sie gar nicht.
+    expect(gelesen.heimName).toBeNull()
+    expect(gelesen.diagnosen).toBeNull()
+    expect(gelesen.geburtsname).toBeNull()
+    expect(gelesen.heimEinzugAm).toBeNull()
+    expect(gelesen.bestellungBis).toBeNull()
+    expect(gelesen.aktenzeichenBezirk).toBeNull()
+    expect(gelesen.pflegegrad).toBeNull()
+    expect(gelesen.schwerbehinderungGdB).toBeNull()
+  })
+
+  it('haelt auch das vollstaendige Formular aus', () => {
+    const f = ersteinrichtungsFormular()
+    // So kommt es aus dem Bearbeitungsformular: alle Felder da, viele leer.
+    for (const feld of [
+      'anrede', 'geburtsname', 'geburtsort',
+      'heimName', 'heimStrasse', 'heimPlz', 'heimOrt', 'heimZimmer', 'heimTelefon',
+      'fruehereStrasse', 'frueherePlz', 'fruehererOrt',
+      'krankenkasse', 'krankenversichertennummer', 'pflegekasse',
+      'schwerbehinderungMerkzeichen', 'diagnosen', 'ermittelterWille',
+      'aufgabenkreiseFreitext', 'aktenzeichenBezirk', 'aktenzeichenSozialamt',
+      'rentenversicherungsnummer', 'steuerId', 'notizen',
+    ]) {
+      f.set(feld, '')
+    }
+    for (const feld of ['heimEinzugAm', 'pflegegradSeit', 'pflegegradBescheidVom', 'bestellungBis']) {
+      f.set(feld, '')
+    }
+    f.set('pflegegrad', '')
+    f.set('schwerbehinderungGdB', '')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success, 'Leere Felder duerfen nicht abgelehnt werden').toBe(true)
+  })
+
+  it('nimmt ausgefuellte Angaben unveraendert an', () => {
+    const f = ersteinrichtungsFormular()
+    f.set('heimName', '  Seniorenzentrum St. Katharina  ')
+    f.set('pflegegrad', '3')
+    f.set('diagnosen', 'COPD GOLD III')
+
+    const gelesen = BetreuteSchema.parse(formularLesen(f))
+    // Fuehrende und nachlaufende Leerzeichen fliegen raus.
+    expect(gelesen.heimName).toBe('Seniorenzentrum St. Katharina')
+    expect(gelesen.pflegegrad).toBe(3)
+    expect(gelesen.diagnosen).toBe('COPD GOLD III')
+  })
+
+  it('besteht weiterhin auf Vorname, Nachname und Geburtsdatum', () => {
+    const f = new FormData()
+    f.set('vorname', '')
+    f.set('nachname', '')
+    f.set('geburtsdatum', '')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success).toBe(false)
+
+    if (!gelesen.success) {
+      const felder = gelesen.error.flatten().fieldErrors
+      expect(Object.keys(felder).sort()).toEqual(['geburtsdatum', 'nachname', 'vorname'])
+    }
+  })
+
+  it('weist ein Geburtsdatum in der Zukunft ab', () => {
+    const f = ersteinrichtungsFormular()
+    f.set('geburtsdatum', '2099-01-01')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success).toBe(false)
+    if (!gelesen.success) {
+      expect(gelesen.error.flatten().fieldErrors.geburtsdatum?.[0]).toMatch(/Zukunft/)
+    }
+  })
+
+  it('weist ein unfertiges Datum ab, statt es stillschweigend zu verwerfen', () => {
+    const f = ersteinrichtungsFormular()
+    f.set('bestellungAm', '2025-11')
+
+    const gelesen = BetreuteSchema.safeParse(formularLesen(f))
+    expect(gelesen.success).toBe(false)
+  })
+})

tests/umgebung.test.ts

@@ -0,0 +1,105 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+/**
+ * Auswertung der Umgebungsvariablen.
+ *
+ * Der Anlass für diese Datei war ein Fehler im Betrieb: docker compose
+ * reicht `ENC_KEY_V2` immer durch — mit leerem Wert, wenn in der .env
+ * keiner steht. Die Schlüsselsammlung erkannte Schlüssel aber am
+ * Variablennamen statt am Inhalt, fand also ein leeres `ENC_KEY_V2` und
+ * brach ab. Die Meldung lautete „ENC_KEY_V2 fehlt", obwohl niemand einen
+ * zweiten Schlüssel wollte.
+ *
+ * Jede Prüfung hier lädt `@/lib/env` frisch, weil die Werte beim ersten
+ * Zugriff gemerkt werden.
+ */
+
+const ECHT = Buffer.alloc(32, 7).toString('base64')
+const ECHT_ZWEI = Buffer.alloc(32, 9).toString('base64')
+
+let vorher: NodeJS.ProcessEnv
+
+async function frischesEnv() {
+  // Leert die Modulregistrierung, damit der naechste Import das Modul neu
+  // auswertet - die Schluessel werden sonst nur beim ersten Mal gelesen.
+  vi.resetModules()
+  const { env } = await import('@/lib/env')
+  return env
+}
+
+beforeEach(() => {
+  vorher = { ...process.env }
+  for (const name of Object.keys(process.env)) {
+    if (/^ENC_KEY_V\d+$/.test(name)) delete process.env[name]
+  }
+  delete process.env.ENC_KEY_AKTIV
+})
+
+afterEach(() => {
+  process.env = vorher
+})
+
+describe('Verschlüsselungsschlüssel aus der Umgebung', () => {
+  it('nimmt einen einzelnen Schlüssel an', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
+    expect(env.aktiveSchluesselversion).toBe(1)
+  })
+
+  it('überspringt eine leere Schlüsselvariable', async () => {
+    // Genau das setzt docker compose, wenn in der .env kein zweiter
+    // Schlüssel steht: ENC_KEY_V2: ${ENC_KEY_V2:-}
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = ''
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
+    expect(env.aktiveSchluesselversion).toBe(1)
+  })
+
+  it('überspringt eine Variable, in der nur Leerzeichen stehen', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = '   '
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
+  })
+
+  it('nimmt beide Schlüssel an, wenn wirklich rotiert wird', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = ECHT_ZWEI
+    process.env.ENC_KEY_AKTIV = '2'
+
+    const env = await frischesEnv()
+    expect([...env.verschluesselungsschluessel.keys()].sort()).toEqual([1, 2])
+    expect(env.aktiveSchluesselversion).toBe(2)
+  })
+
+  it('sagt beim Rotieren deutlich, wenn der neue Schlüssel fehlt', async () => {
+    process.env.ENC_KEY_V1 = ECHT
+    process.env.ENC_KEY_V2 = ''
+    process.env.ENC_KEY_AKTIV = '2'
+
+    const env = await frischesEnv()
+    expect(() => env.aktiveSchluesselversion).toThrow(/ENC_KEY_AKTIV=2/)
+    // Die Meldung nennt, was da ist, und die richtige Reihenfolge.
+    expect(() => env.aktiveSchluesselversion).toThrow(/Vorhanden sind die Versionen: 1/)
+    expect(() => env.aktiveSchluesselversion).toThrow(/zuerst den neuen Schluessel/)
+  })
+
+  it('beschwert sich, wenn gar kein Schlüssel gesetzt ist', async () => {
+    process.env.ENC_KEY_V2 = ''
+
+    const env = await frischesEnv()
+    expect(() => env.verschluesselungsschluessel).toThrow(/mindestens ENC_KEY_V1/)
+  })
+
+  it('weist einen Schlüssel falscher Länge ab', async () => {
+    process.env.ENC_KEY_V1 = Buffer.alloc(16, 1).toString('base64')
+
+    const env = await frischesEnv()
+    expect(() => env.verschluesselungsschluessel).toThrow(/32 Bytes/)
+  })
+})

tests/wiederkehrend.test.ts

@@ -0,0 +1,353 @@
+import { describe, expect, it } from 'vitest'
+import {
+  EINZELZAHLUNG_AB_CENT,
+  MINDESTANZAHL,
+  abstandInTagen,
+  besteSchreibweise,
+  betraegeSchwanken,
+  einzelneZahlungen,
+  gruppieren,
+  normalisieren,
+  offeneKandidaten,
+  rhythmusAusAbstand,
+  rhythmusErklaerung,
+  type ZahlungEingabe,
+} from '@/lib/finanzen/wiederkehrend'
+
+/**
+ * Wiederkehrende Zahlungen aufspüren.
+ *
+ * Der teuerste Fehler dieser Funktion ist nicht eine übersehene Zahlung —
+ * die sieht man beim Durchgehen der Liste. Es ist eine **falsch
+ * zusammengefasste Gruppe**: Dann verschwindet ein Vertrag hinter einem
+ * fremden Namen, und im Vermögensverzeichnis fehlt er.
+ *
+ * Die Prüfungen sind deshalb in beide Richtungen gebaut: Was
+ * zusammengehört, muss zusammenfallen — und was nur ähnlich aussieht, muss
+ * getrennt bleiben.
+ */
+
+function zahlung(
+  gegenstelle: string | null,
+  datum: string,
+  euro: number,
+  id = `${gegenstelle}-${datum}`,
+): ZahlungEingabe {
+  return {
+    id,
+    gegenstelle,
+    datum: new Date(`${datum}T00:00:00.000Z`),
+    betragCent: BigInt(Math.round(euro * 100)),
+  }
+}
+
+/** Eine Reihe monatlicher Abbuchungen, jeweils am Monatsersten. */
+function monatlich(gegenstelle: string, euro: number, monate: number, jahr = 2026) {
+  return Array.from({ length: monate }, (_, i) =>
+    zahlung(
+      gegenstelle,
+      `${jahr}-${String(i + 1).padStart(2, '0')}-01`,
+      euro,
+      `${gegenstelle}-${i}`,
+    ),
+  )
+}
+
+describe('Schreibweisen vergleichbar machen', () => {
+  it('fasst Groß- und Kleinschreibung, Satzzeichen und Rechtsform zusammen', () => {
+    const erwartet = normalisieren('Allianz Lebensversicherung AG')
+    expect(normalisieren('ALLIANZ LEBENSVERSICHERUNG AG')).toBe(erwartet)
+    expect(normalisieren('allianz  lebensversicherung  ag')).toBe(erwartet)
+    expect(normalisieren('Allianz Lebensversicherung-AG')).toBe(erwartet)
+  })
+
+  it('löst Umlaute auf', () => {
+    expect(normalisieren('Münchener Verein')).toBe(normalisieren('Muenchener Verein'))
+    expect(normalisieren('Süddeutsche Krankenversicherung')).toBe(
+      normalisieren('Sueddeutsche Krankenversicherung'),
+    )
+  })
+
+  it('entfernt die Rechtsform nur am Ende, nicht mitten im Namen', () => {
+    // "ag" steckt in "Agentur" - wer stumpf ersetzt, macht daraus "entur".
+    expect(normalisieren('Agentur für Arbeit')).toContain('agentur')
+    expect(normalisieren('Debeka AG')).toBe(normalisieren('Debeka'))
+  })
+
+  it('entfernt auch mehrteilige Rechtsformen', () => {
+    expect(normalisieren('Stadtwerke Bamberg GmbH & Co KG')).toBe(
+      normalisieren('Stadtwerke Bamberg'),
+    )
+  })
+
+  it('hält verschiedene Empfänger auseinander, auch bei ähnlichem Namen', () => {
+    // Der wichtigste Test der Datei. Drei Zeichen Unterschied, zwei völlig
+    // verschiedene Rechnungssteller.
+    expect(normalisieren('Stadtwerke Bamberg')).not.toBe(normalisieren('Stadtwerke Bayreuth'))
+    // Und: "Versicherung" ist kein wegwerfbarer Zusatz.
+    expect(normalisieren('Allianz Versicherung')).not.toBe(
+      normalisieren('Allianz Lebensversicherung'),
+    )
+  })
+
+  it('verträgt leere Angaben', () => {
+    expect(normalisieren(null)).toBe('')
+    expect(normalisieren(undefined)).toBe('')
+    expect(normalisieren('   ')).toBe('')
+  })
+})
+
+describe('Welche Schreibweise angezeigt wird', () => {
+  it('zieht die gemischte Schreibweise der geschrienen vor', () => {
+    // Nicht Kosmetik: Dieser Name landet beim „Vertrag anlegen" im Feld
+    // Gesellschaft. Steht dort alles in Versalien, tippt man es neu — und
+    // dann war die Vorbelegung wertlos.
+    expect(
+      besteSchreibweise(['ALLIANZ LEBENSVERSICHERUNG AG', 'Allianz Lebensvers. AG']),
+    ).toBe('Allianz Lebensvers. AG')
+  })
+
+  it('nimmt unter mehreren gemischten die längste', () => {
+    expect(besteSchreibweise(['Allianz', 'Allianz Lebensversicherung AG'])).toBe(
+      'Allianz Lebensversicherung AG',
+    )
+  })
+
+  it('nimmt die längste geschriene, wenn es nichts anderes gibt', () => {
+    expect(besteSchreibweise(['ALLIANZ AG', 'ALLIANZ LEBENSVERSICHERUNG AG'])).toBe(
+      'ALLIANZ LEBENSVERSICHERUNG AG',
+    )
+  })
+
+  it('verträgt eine leere Liste', () => {
+    expect(besteSchreibweise([])).toBe('')
+  })
+})
+
+describe('Rhythmus', () => {
+  it('erkennt monatlich trotz unterschiedlich langer Monate', () => {
+    // Februar auf März sind 28 Tage, Juli auf August 31 - beides monatlich.
+    expect(rhythmusAusAbstand(28)).toBe('MONATLICH')
+    expect(rhythmusAusAbstand(31)).toBe('MONATLICH')
+    expect(rhythmusAusAbstand(30)).toBe('MONATLICH')
+  })
+
+  it('erkennt die übrigen üblichen Rhythmen', () => {
+    expect(rhythmusAusAbstand(61)).toBe('ZWEIMONATLICH')
+    expect(rhythmusAusAbstand(91)).toBe('VIERTELJAEHRLICH')
+    expect(rhythmusAusAbstand(182)).toBe('HALBJAEHRLICH')
+    expect(rhythmusAusAbstand(365)).toBe('JAEHRLICH')
+  })
+
+  it('nennt Unpassendes unregelmäßig, statt es zu erzwingen', () => {
+    expect(rhythmusAusAbstand(3)).toBe('UNREGELMAESSIG')
+    expect(rhythmusAusAbstand(45)).toBe('UNREGELMAESSIG')
+    expect(rhythmusAusAbstand(250)).toBe('UNREGELMAESSIG')
+  })
+
+  it('nimmt den Median, nicht den Durchschnitt', () => {
+    // Vier monatliche Zahlungen, dann eine Lücke von einem Jahr. Der
+    // Durchschnitt läge bei über 100 Tagen und ergäbe Unsinn.
+    const daten = [
+      new Date('2026-01-01T00:00:00Z'),
+      new Date('2026-02-01T00:00:00Z'),
+      new Date('2026-03-01T00:00:00Z'),
+      new Date('2026-04-01T00:00:00Z'),
+      new Date('2027-04-01T00:00:00Z'),
+    ]
+    const abstand = abstandInTagen(daten)
+    expect(abstand).not.toBeNull()
+    expect(rhythmusAusAbstand(abstand!)).toBe('MONATLICH')
+  })
+
+  it('liefert ohne zweite Zahlung keinen Abstand', () => {
+    expect(abstandInTagen([new Date('2026-01-01T00:00:00Z')])).toBeNull()
+    expect(abstandInTagen([])).toBeNull()
+  })
+})
+
+describe('Schwankende Beträge', () => {
+  it('lässt eine Beitragsanpassung durchgehen', () => {
+    expect(betraegeSchwanken([4250n, 4250n, 4390n])).toBe(false)
+  })
+
+  it('meldet einen Stromabschlag, der nach Verbrauch schwankt', () => {
+    expect(betraegeSchwanken([8000n, 12000n, 4000n])).toBe(true)
+  })
+
+  it('meldet nichts bei einer einzelnen Zahlung', () => {
+    expect(betraegeSchwanken([4250n])).toBe(false)
+  })
+})
+
+describe('Gruppieren', () => {
+  it('fasst monatliche Abbuchungen zu einer Gruppe zusammen', () => {
+    const gruppen = gruppieren(monatlich('Allianz Lebensversicherung AG', 42.5, 6))
+
+    expect(gruppen).toHaveLength(1)
+    const gruppe = gruppen[0]!
+    expect(gruppe.anzahl).toBe(6)
+    expect(gruppe.rhythmus).toBe('MONATLICH')
+    expect(gruppe.betragCent).toBe(4250n)
+    // Sechs Monate à 42,50 EUR sind hochgerechnet 510 EUR im Jahr.
+    expect(gruppe.jahresbetragCent).toBe(51_000n)
+    expect(gruppe.betragSchwankt).toBe(false)
+  })
+
+  it('fasst verschiedene Schreibweisen derselben Stelle zusammen', () => {
+    const gruppen = gruppieren([
+      zahlung('Allianz Lebensversicherung AG', '2026-01-01', 42.5, 'a'),
+      zahlung('ALLIANZ LEBENSVERSICHERUNG AG', '2026-02-01', 42.5, 'b'),
+      zahlung('allianz lebensversicherung', '2026-03-01', 42.5, 'c'),
+    ])
+
+    expect(gruppen).toHaveLength(1)
+    expect(gruppen[0]!.anzahl).toBe(3)
+    // Alle Schreibweisen bleiben sichtbar - man soll nachvollziehen können,
+    // was zusammengeworfen wurde.
+    expect(gruppen[0]!.schreibweisen).toHaveLength(3)
+  })
+
+  it('zeigt die lesbare Schreibweise an, nicht die geschriene', () => {
+    const gruppen = gruppieren([
+      zahlung('Prüfhausen Lebensversicherung AG', '2026-01-01', 42.5, 'a'),
+      zahlung('PRUEFHAUSEN LEBENSVERSICHERUNG AG', '2026-02-01', 42.5, 'b'),
+    ])
+    expect(gruppen[0]!.anzeigename).toBe('Prüfhausen Lebensversicherung AG')
+  })
+
+  it('hält verschiedene Empfänger getrennt', () => {
+    const gruppen = gruppieren([
+      ...monatlich('Stadtwerke Bamberg', 80, 3),
+      ...monatlich('Stadtwerke Bayreuth', 80, 3),
+    ])
+    expect(gruppen).toHaveLength(2)
+  })
+
+  it('übergeht eine einzelne Zahlung', () => {
+    const gruppen = gruppieren([zahlung('Irgendwer', '2026-01-01', 42.5)])
+    expect(gruppen).toHaveLength(0)
+    expect(MINDESTANZAHL).toBe(2)
+  })
+
+  it('übergeht Buchungen ohne Gegenstelle', () => {
+    // Bargeldabhebungen und handerfasste Zeilen - kein Vertragshinweis.
+    const gruppen = gruppieren([
+      zahlung(null, '2026-01-01', 100, 'a'),
+      zahlung(null, '2026-02-01', 100, 'b'),
+      zahlung('', '2026-03-01', 100, 'c'),
+    ])
+    expect(gruppen).toHaveLength(0)
+  })
+
+  it('sortiert nach Jahresbetrag, nicht nach Anzahl', () => {
+    const gruppen = gruppieren([
+      ...monatlich('Kleiner Beitrag', 5, 12),
+      // Zwei Zahlungen im Jahresabstand à 1200 EUR.
+      zahlung('Große Police', '2025-06-01', 1200, 'g1'),
+      zahlung('Große Police', '2026-06-01', 1200, 'g2'),
+    ])
+
+    expect(gruppen[0]!.anzeigename).toBe('Große Police')
+    expect(gruppen[0]!.rhythmus).toBe('JAEHRLICH')
+    expect(gruppen[1]!.anzeigename).toBe('Kleiner Beitrag')
+  })
+
+  it('erkennt einen hinterlegten Vertrag', () => {
+    const gruppen = gruppieren(monatlich('Debeka AG', 30, 4), {
+      vertraege: [{ id: 'v1', bezeichnung: 'Krankenzusatz', gesellschaft: 'Debeka' }],
+    })
+
+    expect(gruppen[0]!.vertragId).toBe('v1')
+    expect(gruppen[0]!.vertragBezeichnung).toBe('Krankenzusatz')
+  })
+
+  it('lässt abgehakte Gruppen verschwinden', () => {
+    const abgehakt = new Set([normalisieren('Rundfunk ARD ZDF')])
+    const gruppen = gruppieren(monatlich('Rundfunk ARD ZDF', 18.36, 6), { abgehakt })
+    expect(gruppen).toHaveLength(0)
+  })
+
+  it('rechnet unregelmäßige Zahlungen nicht hoch', () => {
+    // Ohne erkennbaren Rhythmus wäre jede Hochrechnung geraten. Dann steht
+    // dort, was tatsächlich geflossen ist.
+    const gruppen = gruppieren([
+      zahlung('Wechselnd', '2026-01-01', 100, 'a'),
+      zahlung('Wechselnd', '2026-01-08', 100, 'b'),
+      zahlung('Wechselnd', '2026-01-20', 100, 'c'),
+    ])
+
+    expect(gruppen[0]!.rhythmus).toBe('UNREGELMAESSIG')
+    expect(gruppen[0]!.jahresbetragCent).toBe(30_000n)
+  })
+
+  it('zählt für das Dashboard nur ungeklärte Gruppen', () => {
+    const gruppen = gruppieren(
+      [...monatlich('Debeka AG', 30, 4), ...monatlich('Unbekannt Versicherung', 20, 4)],
+      { vertraege: [{ id: 'v1', bezeichnung: 'Krankenzusatz', gesellschaft: 'Debeka' }] },
+    )
+
+    expect(gruppen).toHaveLength(2)
+    expect(offeneKandidaten(gruppen)).toBe(1)
+  })
+})
+
+describe('Einzelne größere Zahlungen', () => {
+  it('findet die jährliche Prämie, die nur einmal im Auszug steht', () => {
+    // Die eigentliche Lücke der Gruppierung: Bei einem importierten Jahr
+    // erscheint ein Jahresbeitrag genau einmal.
+    const treffer = einzelneZahlungen([zahlung('Feuersozietät', '2026-03-15', 480)])
+
+    expect(treffer).toHaveLength(1)
+    expect(treffer[0]!.betragCent).toBe(48_000n)
+  })
+
+  it('übergeht Kleinbeträge', () => {
+    expect(einzelneZahlungen([zahlung('Bäckerei', '2026-03-15', 12.4)])).toHaveLength(0)
+    expect(EINZELZAHLUNG_AB_CENT).toBe(15_000n)
+  })
+
+  it('übergeht, was ohnehin schon als Gruppe erscheint', () => {
+    const zahlungen = monatlich('Allianz', 200, 3)
+    expect(gruppieren(zahlungen)).toHaveLength(1)
+    expect(einzelneZahlungen(zahlungen)).toHaveLength(0)
+  })
+
+  it('übergeht Abgehaktes', () => {
+    const abgehakt = new Set([normalisieren('Finanzamt Coburg')])
+    expect(
+      einzelneZahlungen([zahlung('Finanzamt Coburg', '2026-03-15', 900)], { abgehakt }),
+    ).toHaveLength(0)
+  })
+
+  it('nennt den Vertrag, wenn es schon einen gibt', () => {
+    const treffer = einzelneZahlungen([zahlung('Debeka', '2026-03-15', 480)], {
+      vertraege: [{ id: 'v1', bezeichnung: 'Krankenzusatz', gesellschaft: 'Debeka AG' }],
+    })
+    expect(treffer[0]!.vertragId).toBe('v1')
+  })
+})
+
+describe('Erklärung unter der Gruppe', () => {
+  it('nennt die Grundlage, nicht nur das Ergebnis', () => {
+    const gruppe = gruppieren(monatlich('Allianz', 42.5, 4))[0]!
+    expect(rhythmusErklaerung(gruppe)).toBe('4 Zahlungen, etwa monatlich')
+  })
+
+  it('formuliert größere Abstände in Monaten', () => {
+    const gruppe = gruppieren([
+      zahlung('Quartalsweise', '2026-01-01', 100, 'a'),
+      zahlung('Quartalsweise', '2026-04-01', 100, 'b'),
+      zahlung('Quartalsweise', '2026-07-01', 100, 'c'),
+    ])[0]!
+    expect(rhythmusErklaerung(gruppe)).toBe('3 Zahlungen, etwa alle 3 Monate')
+  })
+
+  it('sagt offen, wenn kein Abstand erkennbar ist', () => {
+    const gruppe = gruppieren([
+      zahlung('Wechselnd', '2026-01-01', 100, 'a'),
+      zahlung('Wechselnd', '2026-01-08', 100, 'b'),
+    ])[0]!
+    expect(rhythmusErklaerung(gruppe)).toContain('ohne erkennbaren Abstand')
+  })
+})