Merge #32: Absenderanschrift in jedem Schreiben

Behebt Issue #21: Strasse, PLZ und Ort unter "Mein Konto", von dort in
den Absenderblock jedes Schreibens und als Ort in die Datumszeile. Was
fehlt, bleibt weg.

Closes #21

.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,896 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [1.10.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Deine Anschrift steht jetzt in jedem Schreiben**
+  ([#21](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/21)).
+  Bisher ging jeder Brief ohne Rücksendeadresse hinaus — im
+  Absenderblock stand nur dein Name, und in der Datumszeile fehlte der
+  Ort. Bei einer Versicherung oder Behörde wirkt das unseriös und macht
+  es der Gegenstelle unnötig schwer zu antworten.
+
+  Unter **Mein Konto → Meine Anschrift** einmal Straße, PLZ und Ort
+  hinterlegen. Ab da stehen sie im Absenderblock jedes erzeugten
+  Schreibens, und die Datumszeile lautet „Bayreuth, den 23.08.2026".
+  Betroffen ist alles: Rückkaufswert-Anfrage, Serienabfrage, Kündigung,
+  Sachstandsanfrage und die eigenen Vorlagen.
+
+- **Zwei neue Platzhalter** für eigene Vorlagen: `{{betreuer_anschrift}}`
+  und `{{betreuer_ort}}`.
+
+### Eine Zusage
+
+**Was fehlt, bleibt weg.** Jede der drei Angaben ist einzeln freiwillig.
+Hinterlegst du nur den Ort, bekommst du die Datumszeile mit Ort und einen
+Absenderblock, der weiterhin nur aus deinem Namen besteht — keine leeren
+Zeilen, kein Komma ohne Ort. Eine halb ausgefüllte Adresse sieht nach
+Fehler aus, ein bloßer Name nach Absicht.
+
+### Datenbank
+
+Eine Migration: drei Felder am Benutzer. Die Anschrift hängt an dir und
+nicht an der betreuten Person — sie gilt für alle Akten.
+
+### Geprüft
+
+- Sieben Einheitstests für den Absenderblock, darunter jede
+  Teilbefüllung und die Gegenprobe, dass nie die Heimadresse der
+  betreuten Person im Absender landet.
+- Vier End-to-End-Tests: der Brief ohne hinterlegte Anschrift, das
+  Speichern unter *Mein Konto*, der Brief danach und die Gegenprobe am
+  Rückkaufswert-Schreiben.
+
+## [1.9.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Ansprechpartner am Vorgang**
+  ([#9](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/9)).
+  Ein namentlich adressiertes Schreiben landet bei der Person, die den
+  Vorgang kennt, statt in der Poststelle — beim Bezirk ist das der
+  Unterschied zwischen zwei Wochen und zwei Monaten. Am Vorgang lässt
+  sich jetzt ein Kontakt aus dem Verzeichnis als Ansprechpartner
+  benennen.
+
+- **Die Sachstandsanfrage redet ihn an.** Aus „Sehr geehrte Damen und
+  Herren" wird „Sehr geehrte Frau Sachs" — und der Name steht über der
+  Behörde, damit die Poststelle den Brief zur Person sortiert. Auch das
+  Schreiben aus dem Editor übernimmt Anrede, Empfänger und Anschrift,
+  sodass nichts abgetippt werden muss.
+
+- **Anrede am Kontakt.** Damit die Briefanrede stimmt, trägt ein Kontakt
+  wahlweise „Frau" oder „Herr". **Geraten wird nie:** Ohne Angabe wird
+  mit vollem Namen angeredet („Sehr geehrte(r) Kim Berger,"). Eine
+  falsch geratene Anrede fällt dem Empfänger sofort auf und kostet genau
+  die Aufmerksamkeit, die man gewinnen wollte.
+
+- **Vor dem Anruf weiß man, wen man fragt.** Auf der Vorgangsseite steht
+  der Ansprechpartner mit Organisation, Durchwahl und E-Mail, verlinkt
+  auf den Kontakt.
+
+### Zwei Zusagen
+
+**Ohne Ansprechpartner ändert sich nichts.** Ist keiner benannt, bleibt
+es bei „Sehr geehrte Damen und Herren" — und die Vorgangsseite sagt das
+auch, statt ein leeres Feld zu zeigen. Ein halb gefüllter Name führt nie
+zu einer verstümmelten Anrede wie „Sehr geehrte Frau ,".
+
+**Der Wechsel bleibt nachvollziehbar.** Wer den Ansprechpartner
+austauscht, findet den Vorgänger im Protokoll — mit **Namen**, nicht mit
+der internen Kennung. Zwei Kennungen nebeneinander wären protokolliert,
+aber nicht nachvollziehbar.
+
+### Datenbank
+
+Eine Migration: `ansprechpartnerId` am Vorgang und `anrede` am Kontakt.
+Wird ein Kontakt gelöscht, bleibt der Vorgang bestehen und verliert nur
+den Verweis — ein Vorgang darf nicht daran hängen, dass es den Kontakt
+noch gibt.
+
+### Geprüft
+
+- Neun Einheitstests für die Anrede, darunter der Nachname aus „Dr. Anna
+  Maria Schmitt", der Doppelname und der Fall, der nie passieren darf:
+  leerer Name mit gesetzter Anrede.
+- Fünf End-to-End-Tests: die allgemeine Anrede ohne Ansprechpartner, das
+  Benennen samt Anzeige mit Durchwahl, die namentliche Anrede in der
+  Sachstandsanfrage, die vorbelegte Anschrift im Schreiben und der
+  Wechsel im Protokoll.
+
+## [1.8.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Der Rückkaufswert steht jetzt beim Vertrag**
+  ([#8](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/8)).
+  Am Telefon mit der Gesellschaft braucht man die Zahl dort, wo man sie
+  gefragt hat — nicht nach einem Umweg über das Vermögensverzeichnis.
+  Auf der Vertragsseite steht deshalb oben der zuletzt mitgeteilte Wert
+  mit Stichtag und Quelle, darunter die vollständige Historie.
+
+- **Ein alter Wert sagt, dass er alt ist.** Ist der jüngste Wert älter
+  als ein Jahr, steht „über ein Jahr alt" daneben — in der
+  Vertragsübersicht wie auf der Vertragsseite. Ein veralteter Betrag
+  ohne erkennbares Alter ist schlimmer als kein Betrag: Man rechnet mit
+  ihm weiter und merkt es erst, wenn der Bezirk nachfragt. Die Grenze von
+  einem Jahr gilt jetzt überall dieselbe; im Vermögensverzeichnis stand
+  sie schon, am Vertrag fehlte sie.
+
+- **Verträge ohne Wert bleiben nicht stumm.** Wo ein Rückkaufswert zu
+  erwarten wäre, aber keiner erfasst ist, steht „noch nicht erfasst"
+  statt einer leeren Zelle.
+
+### Behoben
+
+- **Ein Vertrag hatte unter Umständen zwei Wertreihen.** Vertrag und
+  Vermögensposten wurden über die *Art* des Postens zusammengeführt.
+  Wer einen Posten von Hand anlegte und ihn als etwas anderes als
+  „Versicherung" führte, bekam beim ersten Eintragen am Vertrag
+  klammheimlich einen zweiten Posten — und damit zwei Wahrheiten, von
+  denen der Bericht die eine und der Vertrag die andere zeigte.
+  Maßgeblich ist jetzt die Verknüpfung mit dem Vertrag, nicht die Art.
+
+- **Fehlende Prüfung bei Verweisen auf Vertrag und Immobilie.** Beim
+  Speichern eines Vermögenspostens wurde geprüft, ob das verknüpfte
+  *Konto* zur betreuten Person gehört — bei Vertrag und Immobilie fehlte
+  dieselbe Prüfung, ebenso beim Vertragsverweis einer Buchung. Bei
+  mehreren betreuten Personen hätte ein manipuliertes Formular eine
+  Verknüpfung über Aktengrenzen hinweg anlegen können. Jetzt wird jeder
+  der drei Verweise gleich behandelt.
+
+### Geprüft
+
+- Zehn Einheitstests: die Ein-Jahres-Grenze (auch der Tag davor und
+  danach), das Alter taggenau und ohne Uhrzeiteinfluss, ein künftiger
+  Stichtag, und die Zusammenführung mehrerer Posten zu einer Historie.
+- Vier End-to-End-Tests: Wert und Stichtag in der Übersicht, das
+  Abzeichen am alten Wert, die Historie am Vertrag, und ein neu
+  eingetragener Wert, der unverändert im Vermögensverzeichnis
+  wiederauftaucht.
+
+## [1.7.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Eigene Vorlagen für Anschreiben**
+  ([#7](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/7)).
+  Wer zum dritten Mal denselben Brief tippt, tippt ihn beim vierten Mal
+  falsch. Neu unter **Einstellungen → Schreibvorlagen**: eigene Texte
+  hinterlegen, beim freien Schreiben auswählen — der Rest füllt sich aus
+  den Daten, die ohnehin im System stehen.
+
+- **Platzhalter, die sich selbst erklären.** Neben dem Editor steht die
+  vollständige Liste — Name, wofür er steht, woher der Wert kommt. Ein
+  Klick setzt ihn an die Cursorstelle; niemand muss `{{…}}`-Namen raten
+  oder abtippen. Verfügbar sind unter anderem Name und Geburtsdatum der
+  betreuten Person, ihre Anschrift, Betreuungsgericht und Aktenzeichen,
+  das Bestellungsdatum, der Stichtag und das heutige Datum.
+
+- **Vier mitgelieferte Vorlagen** als Ausgangspunkt: Auskunftsersuchen an
+  eine noch unbekannte Stelle, Adressänderung nach Heimeinzug, Nachweis
+  der Vertretungsmacht (wenn eine Stelle die Auskunft verweigert) und die
+  Kurzfassung der Rückkaufswert-Anfrage. Sie lassen sich nicht kaputt
+  bearbeiten — „Als Kopie übernehmen" legt eine eigene Fassung an, das
+  Original bleibt liegen. Für Rückkaufswert und Kündigung führt die
+  Oberfläche weiter zuerst zu den fallbezogenen Erzeugern: Die rechnen
+  Kündigungstermine aus, was eine Vorlage nicht kann.
+
+### Zwei Zusagen
+
+**Nichts geht stillschweigend schief.** Fehlt ein Wert (etwa das
+Aktenzeichen), steht im Brief eine sichtbare Lücke `[Aktenzeichen des
+Gerichts]` — kein Leerraum, den erst der Empfänger bemerkt. Ein
+Tippfehler im Platzhalternamen bricht nicht ab, sondern wird im Text
+markiert und über dem Editor benannt.
+
+**Der Bestellungsabsatz wird nicht vergessen.** Ohne den Nachweis der
+Vertretungsmacht kommt keine Auskunft — und das fällt erst nach vier
+Wochen auf. Beim Speichern einer Vorlage ohne Bestellungsabsatz kommt
+deshalb eine Rückfrage. Wer ihn bewusst weglässt (etwa für die zweite
+Mail an eine Stelle, die den Nachweis schon hat), bestätigt einmal und
+wird nicht weiter gefragt. Ein ausformulierter Absatz zählt genauso wie
+der Platzhalter.
+
+### Geändert
+
+- Gelöschte Vorlagen liegen wie alles andere **30 Tage im Papierkorb**
+  und lassen sich zurückholen. Beim Vollexport der Akte sind sie mit
+  dabei.
+
+### Geprüft
+
+- Dreizehn Einheitstests für die Platzhalter-Ersetzung, darunter jeder
+  der drei Fälle (Wert einsetzen, sichtbare Lücke, unbekannter
+  Platzhalter) und die Bestellungsabsatz-Erkennung, die sich nicht von
+  einem halben Nachweis („Beschluss der Eigentümerversammlung") täuschen
+  lässt.
+- Sechs End-to-End-Tests: die zweistufige Warnung, das Übernehmen einer
+  mitgelieferten Vorlage, die Auflösung im Editor samt markierter
+  Tippfehler und der Weg durch den Papierkorb.
+
+## [1.6.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Rückkaufswerte aller Versicherungen in einem Zug anfragen**
+  ([#6](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/6)).
+  Vor dem Vermögensverzeichnis und vor jedem Jahresbericht braucht es von
+  jeder Lebens- und Rentenversicherung den Rückkaufswert zum Stichtag —
+  jedes Mal dieselben fünf bis zehn Briefe. Das war der Handgriff, der im
+  Jahr am meisten Zeit gekostet hat.
+
+  Neu unter **Verträge → Rückkaufswerte anfragen**: Stichtag wählen, Liste
+  prüfen, ein Klick. Heraus kommt ein **ZIP mit einer Word-Datei je
+  Gesellschaft** plus Begleitblatt — und je Vertrag entsteht nebenbei die
+  PDF-Fassung in der Akte, die Wiedervorlage nach 28 Tagen und der
+  Vermerk, dass angefragt wurde. Auf „Heute" steht danach unter *Wartet
+  auf andere*, worauf gewartet wird und seit wann.
+
+- **Die Auswahl begründet sich selbst.** Vorausgewählt ist nur, was in
+  Frage kommt. Was nicht in Frage kommt, wird nicht stumm ausgeblendet,
+  sondern steht mit Grund in der Liste: „Ohne Gesellschaft fehlt der
+  Empfänger", „bereits vor 10 Tagen angefragt". Nur Vertragsarten, die
+  nie einen Rückkaufswert bilden (Strom, Haftpflicht), bleiben draußen.
+  Gekündigte Verträge bleiben anfragbar — bis zum Wirksamwerden besteht
+  der Vertrag, und genau dann will der Sozialhilfeträger den Wert sehen.
+
+- **Die Zahl steht vor dem Klick auf dem Knopf** („4 Schreiben erzeugen").
+  Einen Fehlgriff soll man bemerken, bevor zehn Briefe entstehen — nicht
+  danach beim Aufräumen.
+
+### Zwei Zusagen
+
+**Kein Alles-oder-nichts.** Jeder Vertrag läuft für sich. Scheitert einer
+(etwa am Objektspeicher), steht er mit Grund im Begleitblatt des ZIP —
+die übrigen laufen durch. Eine Transaktion über alle wäre die falsche
+Zusage: Wenn der neunte Brief scheitert, sollen die acht fertigen nicht
+verworfen werden.
+
+**Der Doppelklick kostet nichts.** Ein zweiter Lauf am selben Tag
+überspringt bereits angefragte Verträge und sagt es im Begleitblatt —
+keine doppelten Dokumente, keine doppelten Wiedervorlagen. Eine bewusste
+zweite Anfrage nach einer Woche (Brief verloren) bleibt möglich: von Hand
+anwählen genügt.
+
+### Geprüft
+
+- Zwölf Einheitstests für die Auswahllogik, darunter der Gleichschritt
+  von Sperrfrist und Wiedervorlage (beide 28 Tage — liefen sie
+  auseinander, würde gemahnt und zugleich neu angefragt).
+- Drei End-to-End-Tests: Vorauswahl samt Begründungen, der volle Lauf mit
+  allen Nebenwirkungen in der Datenbank, und der Dublettenschutz beim
+  zweiten Lauf.
+
+## [1.5.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Schreiben als E-Mail übernehmen**
+  ([#5](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/5)).
+  Vieles geht heute per E-Mail hinaus, nicht per Brief. Im Schreiben-Editor
+  gibt es jetzt den Umschalter **Als Brief / Als E-Mail**.
+
+  Die E-Mail-Fassung wird aus dem — womöglich schon bearbeiteten —
+  Brieftext abgeleitet: ohne Absenderblock, Anschrift und Datumszeile, die
+  gehören in den Brief und nicht in die Mail. **Der Bestellungsabsatz
+  bleibt drin** — ohne ihn kommt die Auskunft nicht. Betreff und Text sind
+  einzeln kopierbar.
+
+- **Zwei Wege ins Mailprogramm.** Die offene Entscheidung aus dem Issue
+  (mailto oder .eml) ist mit *beides* beantwortet:
+
+  **„Im Mailprogramm öffnen"** (mailto) für kurze Texte — der Knopf
+  verschwindet, sobald der kodierte Link 1800 Zeichen übersteigt. mailto
+  übergibt den Text in der Adresszeile, deren Länge nirgends zugesichert
+  ist; ein stillschweigend halbierter Brief fällt erst beim Empfänger auf.
+
+  **„Als E-Mail-Entwurf (.eml)"** immer: eine Datei, die sich im
+  Mailprogramm als fertiger Entwurf öffnet — Adresse, Betreff und voller
+  Text garantiert vollständig, mit korrekt kodierten Umlauten. Die Datei
+  erfindet bewusst keinen Absender: den trägt das Mailprogramm beim
+  Senden selbst ein.
+
+  Beide Knöpfe erscheinen nur, wenn eine E-Mail-Adresse da ist — aus dem
+  gewählten Kontakt übernommen oder von Hand eingetragen. Ohne Adresse
+  bleibt das Kopieren.
+
+- **Die Ablage kennt den Unterschied.** Eine als E-Mail abgelegte
+  Nachricht heißt in der Akte „E-Mail: …" und die PDF-Fassung trägt die
+  Empfängeradresse im Kopf — abgelegt wird die E-Mail-Fassung, nicht der
+  Brieftext. In der Akte soll stehen, was tatsächlich hinausging.
+
+### Geprüft
+
+- 20 Einheitstests: die Ableitung der E-Mail-Fassung (nichts geht
+  stillschweigend verloren, der Bestellungsabsatz bleibt), die
+  mailto-Längengrenze **nach** der Kodierung, das .eml-Format samt
+  Umlauten nach RFC 2047 und quoted-printable.
+- Vier End-to-End-Tests: Fassung ohne Briefkopf, .eml-Download, kein
+  Mailknopf ohne Adresse, Ablage als gekennzeichnete E-Mail.
+
+## [1.4.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Schreiben erzeugen, ausgeben und ablegen**
+  ([#4](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/4)).
+  Die Anschreiben an Versicherer und Behörden gab es bisher nur als Text
+  zum Kopieren. Danach war Handarbeit: in Word nachbauen, ausdrucken,
+  abschicken — und noch einmal von Hand als Dokument in die Akte legen.
+  Vier Schritte, und der letzte wurde am häufigsten vergessen. Dann fehlt
+  der Nachweis genau dort, wo er gebraucht wird.
+
+  Neu unter **Schreiben**: Text bearbeiten, als **Word-Datei**
+  herunterladen, **in die Akte legen** und dabei eine **Wiedervorlage**
+  setzen — in einem Zug.
+
+  Der Text bleibt vollständig bearbeitbar. Jeder Fall hat eine
+  Besonderheit, die in den Brief gehört; ein Formulartext, den man nicht
+  mehr ändern kann, wird früher oder später falsch abgeschickt.
+
+- **Schreiben ohne Vertrag und ohne Vorgang.** Bisher ging ein Anschreiben
+  nur zu einem vorhandenen Datensatz. Am Anfang einer Betreuung schreibt
+  man aber gerade an Stellen, zu denen es noch keinen gibt — man fragt ja
+  an, um zu erfahren, ob dort überhaupt etwas besteht. Jetzt geht es an
+  einen **Kontakt** oder an eine **frei getippte Anschrift**, aus der sich
+  mit einem Klick ein Kontakt anlegen lässt. So wächst das Adressbuch
+  nebenbei beim Schreiben statt durch Pflege.
+
+- **Die Wiedervorlage entsteht mit.** Rückkaufswert 28 Tage, Kündigung 21,
+  Sachstandsanfrage 42 — jeweils änderbar, und daneben steht, warum die
+  Frist so lang ist. Bei einer Sachstandsanfrage wird zusätzlich der letzte
+  Kontakt am Vorgang nachgezogen, damit *Wartet auf andere* auf „Heute"
+  stimmt.
+
+### Zwei Entscheidungen, die erklärt gehören
+
+**In die Akte kommt eine PDF-Fassung, heruntergeladen wird eine
+Word-Datei.** Der Objektspeicher nimmt nur PDF und Bilder an, geprüft an
+den Magic Bytes — eine Word-Datei ist ein ZIP-Archiv, sie durchzulassen
+hieße jedes ZIP durchzulassen. Diese Prüfung ist eine bewusste Zusage der
+Anwendung; sie für eine Bequemlichkeit aufzuweichen wäre der falsche
+Handel. Und sachlich ist PDF für den Nachweis ohnehin das richtige Format:
+Es ändert sich nicht mehr.
+
+Daraus folgt eine Einschränkung, die auch in der Oberfläche steht:
+**Änderst du die Word-Datei danach noch**, weicht die Akte davon ab. Dann
+lieber dort fertig schreiben, den Text zurückkopieren und erst dann
+ablegen.
+
+**Der Berichtssatz wurde nicht umgebogen.** Die vorhandene DOCX-Ausgabe
+setzt einen Bericht mit Kopfzeilen und Unterschriftenblock; ein Brief
+braucht Absender, Anschriftenfeld, Datumszeile und Grußformel. Beides in
+eine Funktion zu zwingen hätte beide Ausgaben schlechter gemacht.
+
+### Geprüft
+
+- Zehn Einheitstests, darunter der Gleichschritt der Wiedervorlagefristen:
+  Sie stehen an zwei Stellen und dürfen nicht auseinanderlaufen, sonst
+  mahnt die Anwendung zu zwei verschiedenen Terminen.
+- Fünf End-to-End-Tests: Entwurf mit Bestellungsabsatz, Vertragsbezug,
+  Word-Download, Ablage samt Wiedervorlage und Kontakt aus freier
+  Anschrift.
+
+  Zwei Fehler hat erst der Browsertest gefunden — beide in den Tests
+  selbst: Die Dokumentenliste rendert Tabelle **und** Karten, je nach
+  Bildschirmbreite ist eine davon versteckt. Ein Treffer auf die
+  unsichtbare Fassung sieht aus wie ein Fehler in der Anwendung.
+
+## [1.3.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Dauerzahlungen zu einem Vertrag gelten als belegt**
+  ([#11](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/11)).
+  Bei einer monatlichen Versicherungsprämie gibt es keinen Beleg — es gibt
+  einen Vertrag, und der wird einmal abgeschlossen, nicht monatlich
+  quittiert. Bisher blieb nur ein Freitextfeld pro Buchung: zwölfmal im
+  Jahr derselbe Satz, mal Anzahl der Verträge.
+
+  Eine Buchung lässt sich jetzt einem **Vertrag** zuordnen, und diese
+  Zuordnung zählt als Nachweis. Bei einem Dauerschuldverhältnis ist der
+  Vertrag der Beleg: Ein Rechtspfleger will für zwölf gleiche Lastschriften
+  keine zwölf Quittungen sehen, sondern die Police.
+
+  **Die Belegquote weist drei Fälle getrennt aus** — mit Beleg, durch
+  Vertrag belegt, begründet ohne Beleg. Zusammengeworfen verlöre die Zahl
+  ihre Aussage.
+
+- **Automatisch beim Import**, wenn die Gegenstelle zu genau *einem*
+  Vertrag passt. Bei Mehrdeutigkeit geschieht nichts: Hausrat und
+  Haftpflicht bei derselben Gesellschaft lassen sich nicht auseinanderhalten,
+  und eine falsche Zuordnung wäre schlimmer als gar keine — sie behauptet
+  einen Beleg, und niemand sieht noch einmal hin. Automatisch gesetzte
+  Zuordnungen sind in der Liste als solche gekennzeichnet.
+
+- **Sammelzuordnung** unter *Wiederkehrende Zahlungen*: Liegt zu einer
+  Gruppe ein Vertrag vor, werden alle ihre Zahlungen mit einem Klick
+  zugeordnet. Bei drei Jahren Laufzeit sind das 36 Buchungen.
+
+- **Die Rechnungslegung nennt den Vertrag.** Statt „ohne Beleg – …" steht
+  dort „Dauerzahlung zu Vertrag «Bezeichnung», Nr. …". Die Lücke wird nicht
+  versteckt, sondern erklärt: Wer nachprüfen will, weiß sofort, welches
+  Papier er aus dem Ordner holt.
+
+### Die Sicherung dagegen
+
+**Weicht der Betrag um mehr als ein Fünftel vom hinterlegten Beitrag ab,
+gilt die Zahlung nicht als belegt**, sondern wird als *Betrag prüfen*
+markiert. Sonst wäre die Zuordnung eine Hintertür, durch die auch eine
+verzehnfachte Prämie unbemerkt durchginge.
+
+Ein Fünftel ist bewusst großzügig: Beitragsanpassungen und
+Versicherungsteuer bewegen sich in dieser Größenordnung, und dabei soll
+die Anwendung nicht meckern. Wer die Grenze enger zieht, bekommt täglich
+Warnungen und sieht die eine wichtige nicht mehr.
+
+Steht am Vertrag **kein** Beitrag, findet keine Prüfung statt. Die
+Zuordnung gilt trotzdem — es wird nur nicht so getan, als wäre geprüft
+worden.
+
+Und: **Verschwindet der Vertrag, fällt die Buchung zurück in „Beleg
+fehlt".** Ein Nachweis, der auf etwas zeigt, das es nicht mehr gibt, wäre
+schlimmer als gar keiner.
+
+### Zu beachten
+
+- **Eine Datenbank-Migration ist nötig**
+  (`20260823062000_buchung_vertragszahlung`). Sie fügt zwei Spalten hinzu
+  und ändert nichts an vorhandenen Daten.
+- Bestehende Buchungen sind nicht betroffen: Ohne Zuordnung bleibt alles,
+  wie es war.
+
+### Geprüft
+
+- 23 neue Einheitstests. Die Hälfte prüft, dass die Anerkennung auch
+  wirklich **wegfällt** — der gefährliche Fehler wäre hier ein zu mildes
+  Urteil, nicht ein zu strenges.
+- Fünf End-to-End-Tests: Sammelzuordnung, Anzeige in der Buchungsliste,
+  die abweichende Zahlung, die Kachel auf „Heute", und der Rückfall nach
+  dem Löschen des Vertrags.
+
+  Der Browsertest hat zwei Fehler gefunden, die alle anderen Prüfungen
+  durchgelassen haben — siehe unten.
+
+### Behoben
+
+- **Die Buchungsliste hatte eine eigene, fast gleiche Datenabfrage** neben
+  der gemeinsamen aus `berichte/gemeinsam.ts`. Als die Dauerzahlungen
+  dazukamen, wurde nur eine von beiden nachgezogen: In der Liste stand
+  weiter „Beleg fehlt", obwohl der Vertrag hinterlegt war. Beide benutzen
+  jetzt dieselbe Abbildung — die kann nicht halb vergessen werden.
+
+## [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 +1078,22 @@ 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.10.0...HEAD
+[1.10.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.9.0...v1.10.0
+[1.9.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.8.0...v1.9.0
+[1.8.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.7.0...v1.8.0
+[1.7.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.6.0...v1.7.0
+[1.6.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.5.0...v1.6.0
+[1.5.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.4.0...v1.5.0
+[1.4.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.3.0...v1.4.0
+[1.3.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.2.0...v1.3.0
+[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**.
@@ -79,11 +97,12 @@ DATABASE_URL="postgresql://cockpit:entwicklung@localhost:5433/betreuungs_cockpit
 **3. Datenbank einrichten:**
 
 ```bash
-npx prisma migrate dev --name fundament
+npm run setup             # Migrationen, Volltextsuche, Audit-Schutz, Beispieldaten
-npm run db:sql            # Volltextsuche und Audit-Schutz
-npm run db:seed
 ```
 
+Das ist die Kurzform für `db:deploy`, `db:sql` und `db:seed` — die drei
+Schritte laufen ohne Rückfrage durch.
+
 **4. Starten:**
 
 ```bash
@@ -113,6 +132,10 @@ laufender Antrag beim Bezirk Oberfranken mit acht Nachforderungen.
 
 ## Produktivbetrieb mit Docker Compose
 
+> **Zum ersten Mal?** Nimm die [Schritt-für-Schritt-Anleitung](docs/INSTALLATION.md).
+> Sie fängt beim leeren Server an, hat nach jedem Abschnitt eine Kontrolle
+> und endet mit einer Abnahmeliste. Was hier steht, ist die Kurzfassung.
+
 Das Compose-Setup bringt drei Dienste mit: die Anwendung, PostgreSQL und
 MinIO als S3-kompatiblen Objektspeicher, dazu einen Sicherungsdienst.
 
@@ -155,72 +178,72 @@ existiert.
 ### Aktualisieren
 
 ```bash
-git pull
+./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 +304,15 @@ entscheiden kann. Was dafür umgesetzt ist:
 - Passwörter mit **Argon2id** (19 MiB, t=2, p=1 — OWASP-Empfehlung).
 - **Zweiter Faktor ist Pflicht** und lässt sich nicht abschalten. TOTP nach
   RFC 6238, kompatibel mit Aegis, 2FAS, Bitwarden, 1Password.
+- **Passkeys** (WebAuthn/FIDO2) als zweiter Anmeldeweg — auch für die
+  erneute Bestätigung vor sensiblen Aktionen. Sie *ersetzen* den zweiten
+  Faktor, statt zu ihm hinzuzukommen: Nutzerverifikation wird verlangt
+  (`userVerification: 'required'`) und serverseitig nachgeprüft, ein
+  Schlüssel ohne sie wird abgewiesen. Damit sind es dieselben zwei
+  Faktoren — Besitz des Geräts und dessen Entsperrung —, nur an die Domain
+  gebunden und deshalb nicht abphishbar. TOTP muss trotzdem eingerichtet
+  sein, bevor sich ein Passkey anlegen lässt: Er hängt an einem Gerät und
+  darf nicht der einzige Weg hinein sein.
 - **Rate-Limiting** am Login, nach E-Mail *und* nach Anschluss. Die Sperre
   wird geprüft, bevor Argon2 überhaupt rechnet.
 - Die Antwortzeit ist auf eine Mindestdauer gestreckt, damit sie nicht
@@ -479,8 +511,38 @@ npm test                 # Vitest: Fachlogik
 npm run test:e2e         # Playwright: kritische Abläufe
 npm run db:studio        # Prisma Studio
 npm run protokoll        # Bauprotokoll aus der Git-Historie
+npm run version -- patch # Version anheben, Changelog vorbereiten
 ```
 
+### Die Datenbankbefehle
+
+Welcher Befehl wofür — und welcher am Terminal Rückfragen stellt. Nur
+`db:migrate` ist interaktiv; alle anderen laufen in Skripten, in der CI
+und im Container durch.
+
+| Befehl | Wofür | Rückfragen? |
+|---|---|---|
+| `npm run setup` | Ersteinrichtung: Migrationen, SQL-Skripte, Beispieldaten | nein |
+| `npm run db:migration -- <name>` | Schemaänderung während der Entwicklung — erzeugt die Migration und nimmt die `DROP INDEX`-Zeilen zur Volltextsuche heraus | nein |
+| `npm run db:deploy` | Vorhandene Migrationen anwenden (Server, CI, Container) | nein |
+| `npm run db:migrate` | `prisma migrate dev` — fragt nach dem Namen und bietet an, die Datenbank zurückzusetzen | **ja** |
+| `npm run db:sql` | Volltextsuche und Audit-Schutz; läuft nicht mit den Migrationen mit | nein |
+| `npm run db:pruefen` | Nachsehen, ob die Trigramm-Indizes noch stehen | nein |
+| `npm run db:seed` | Beispieldaten einspielen | nein |
+
+Der übliche Weg für eine Schemaänderung:
+
+```bash
+# Schema in prisma/schema.prisma ändern, dann
+npm run db:migration -- ansprechpartner   # erzeugen und lesen
+npm run db:deploy                          # anwenden
+npm run db:pruefen                         # Indizes nachsehen
+```
+
+`db:migrate` braucht man dafür nicht mehr. Es bleibt für die Fälle, in
+denen man wirklich den interaktiven Prisma-Ablauf will — etwa um eine
+verkorkste Entwicklungsdatenbank zurückzusetzen.
+
 Konventionen — verbindlich für alle Beiträge:
 [`docs/KONVENTIONEN.md`](docs/KONVENTIONEN.md).
 Schnittstellen zwischen den Modulen:
@@ -513,7 +575,8 @@ Produktion.
   über den Abschnitt `environment:`.
 - Beim ersten Start eines Containers laufen die Migrationen automatisch
   mit. Die beiden SQL-Skripte (Volltextsuche, Audit-Schutz) sind
-  **einmalig von Hand** anzustoßen, siehe oben.
+  **einmalig von Hand** anzustoßen, siehe oben. Beim Aktualisieren
+  erledigt das `scripts/update.sh` mit — beide Skripte sind idempotent.
 
 ### Technische Grundlage
 
@@ -546,14 +609,17 @@ Fehler, die während des Baus aufgefallen sind.
 
 ## Stand
 
-| | |
+| | | nachzuzählen mit |
-|---|---:|
+|---|---:|---|
-| Zeilen TypeScript/TSX | 71.051 |
+| Zeilen TypeScript/TSX | 79.102 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
-| Prisma-Modelle | 24 |
+| Prisma-Modelle | 34 | `grep -c '^model ' prisma/schema.prisma` |
-| Seiten | 46 |
+| Seiten | 82 | `find src/app -name page.tsx \| wc -l` |
-| Unit-Tests (Vitest) | 458 |
+| Unit-Tests (Vitest) | 602 | `npm test` |
-| End-to-End-Tests (Playwright) | 34 |
+| End-to-End-Tests (Playwright) | 87 | `npm run test:e2e` — 47 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.10.0** ([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/absenderanschrift.spec.ts

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

e2e/ansprechpartner.spec.ts

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

e2e/benutzermenue.spec.ts

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

e2e/dauerzahlung.spec.ts

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

e2e/email.spec.ts

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

e2e/passkey.spec.ts

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

e2e/rueckkaufswert-vertrag.spec.ts

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

e2e/schreiben.spec.ts

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

e2e/serienabfrage.spec.ts

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

e2e/vorlagen.spec.ts

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

e2e/wiederkehrend.spec.ts

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

next.config.mjs

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

package-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.10.0",
   "private": true,
   "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
   "engines": {
@@ -17,6 +17,8 @@
     "db:generate": "prisma generate",
     "db:migrate": "prisma migrate dev",
     "db:deploy": "prisma migrate deploy",
+    "db:migration": "node scripts/migration-erzeugen.mjs",
+    "db:pruefen": "node -e \"import('./scripts/migration-erzeugen.mjs').then(m => m.indizesPruefen())\"",
     "db:volltext": "prisma db execute --schema prisma/schema.prisma --file prisma/sql/volltextsuche.sql",
     "db:seed": "prisma db seed",
     "db:studio": "prisma studio",
@@ -44,6 +46,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 +94,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,68 @@
+-- Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg.
+--
+-- ACHTUNG beim Erzeugen weiterer Migrationen: "prisma migrate diff" wollte
+-- hier zusaetzlich die Trigramm-Indizes "dokument_absender_trgm" und
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/volltextsuche.sql und
+-- sind Prisma unbekannt - ein DROP haette die unscharfe Suche stillgelegt,
+-- ohne dass irgendetwas fehlgeschlagen waere. Solche Zeilen gehoeren aus
+-- jeder erzeugten Migration entfernt.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
+
+-- CreateEnum
+CREATE TYPE "PasskeyAnfrageArt" AS ENUM ('REGISTRIERUNG', 'ANMELDUNG');
+
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_REGISTRIERT';
+ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_ENTFERNT';
+
+-- CreateTable
+CREATE TABLE "passkey" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "credentialId" TEXT NOT NULL,
+    "publicKey" BYTEA NOT NULL,
+    "counter" BIGINT NOT NULL DEFAULT 0,
+    "transports" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "name" TEXT NOT NULL,
+    "geraeteArt" TEXT,
+    "gesichert" BOOLEAN NOT NULL DEFAULT false,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "zuletztBenutztAm" TIMESTAMP(3),
+
+    CONSTRAINT "passkey_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "passkey_anfrage" (
+    "id" TEXT NOT NULL,
+    "challenge" TEXT NOT NULL,
+    "art" "PasskeyAnfrageArt" NOT NULL,
+    "userId" TEXT,
+    "ablaufAm" TIMESTAMP(3) NOT NULL,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "passkey_anfrage_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "passkey_credentialId_key" ON "passkey"("credentialId");
+
+-- CreateIndex
+CREATE INDEX "passkey_userId_idx" ON "passkey"("userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "passkey_anfrage_challenge_key" ON "passkey_anfrage"("challenge");
+
+-- CreateIndex
+CREATE INDEX "passkey_anfrage_ablaufAm_idx" ON "passkey_anfrage"("ablaufAm");
+
+-- AddForeignKey
+ALTER TABLE "passkey" ADD CONSTRAINT "passkey_userId_fkey" FOREIGN KEY ("userId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

prisma/migrations/20260823000500_zahlungsgruppe_geklaert/migration.sql

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

prisma/migrations/20260823062000_buchung_vertragszahlung/migration.sql

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

prisma/migrations/20260823102500_schreibvorlage/migration.sql

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

prisma/migrations/20260823153000_ansprechpartner/migration.sql

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

prisma/migrations/20260823193832_betreuer_anschrift/migration.sql

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

prisma/schema.prisma

@@ -81,6 +81,13 @@ model User {
   // (Passwortwechsel, Rollenaenderung, Verdacht auf Kompromittierung).
   sitzungsGeneration Int @default(0)
 
+  /// Die eigene Anschrift - Absenderblock und Ort in der Datumszeile
+  /// jedes erzeugten Schreibens. Sie gehoert zum Betreuer und nicht zur
+  /// betreuten Person: Sie gilt fuer alle Akten.
+  strasse String?
+  plz     String?
+  ort     String?
+
   // Oberflaechen-Einstellungen
   theme String @default("system") // "system" | "hell" | "dunkel"
 
@@ -89,6 +96,7 @@ model User {
   geloeschtAm    DateTime?
 
   zugaenge           BetreuungsZugang[]
+  passkeys           Passkey[]
   auditEintraege     AuditLog[]
   angelegteVorgaenge Vorgang[]          @relation("VorgangAngelegtVon")
   berichte           Bericht[]
@@ -135,6 +143,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 +319,8 @@ model Betreute {
   dokumente             Dokument[]
   konten                Konto[]
   buchungen             Buchung[]
+  zahlungsgruppen       ZahlungsgruppeGeklaert[]
+  schreibvorlagen       Schreibvorlage[]
   vermoegensposten      Vermoegensposten[]
   immobilien            Immobilie[]
   vertraege             Vertrag[]
@@ -285,6 +380,14 @@ model Vorgang {
   gegenstelle  String?
   aktenzeichen String?
 
+  /// Die Person bei der Gegenstelle, die den Vorgang bearbeitet. Ein
+  /// namentlich adressiertes Schreiben landet bei ihr statt in der
+  /// Poststelle - beim Bezirk ist das der Unterschied zwischen zwei
+  /// Wochen und zwei Monaten. SetNull: Ein Vorgang darf nicht daran
+  /// haengen, dass es den Kontakt noch gibt.
+  ansprechpartnerId String?
+  ansprechpartner   Kontakt? @relation("VorgangAnsprechpartner", fields: [ansprechpartnerId], references: [id], onDelete: SetNull)
+
   verantwortlich String?
   angelegtVonId  String?
   angelegtVon    User?   @relation("VorgangAngelegtVon", fields: [angelegtVonId], references: [id], onDelete: SetNull)
@@ -742,6 +845,75 @@ enum BuchungKategorie {
   UMBUCHUNG
 }
 
+/// Eine Gruppe wiederkehrender Zahlungen, zu der bewusst KEIN Vertrag
+/// gefuehrt wird - Miete, Strom, Rundfunkbeitrag, Finanzamt.
+///
+/// Die Entscheidung haengt am normalisierten Namen der Gegenstelle, nicht
+/// an den Buchungen. Nur so ueberlebt sie den naechsten Kontoauszug: Beim
+/// Import entstehen neue Buchungszeilen, der Empfaenger bleibt derselbe.
+///
+/// ACHTUNG: Der Schluessel wird von normalisieren() in
+/// src/lib/finanzen/wiederkehrend.ts gebildet. Aendert sich diese Funktion,
+/// passen bestehende Schluessel nicht mehr und abgehakte Gruppen tauchen
+/// wieder auf. Das ist unangenehm, aber ungefaehrlich - schlimmer waere,
+/// eine Gruppe stillschweigend weiter zu verbergen, die inzwischen anders
+/// zugeschnitten ist.
+/// Eine eigene Schreibvorlage.
+///
+/// Die mitgelieferten Vorlagen (Rueckkaufswert, Kuendigung,
+/// Sachstandsanfrage) stehen bewusst NICHT in dieser Tabelle - sie sind
+/// Code, getestet und unveraenderlich. "Wiederherstellen" heisst: die
+/// mitgelieferte Fassung als neue Kopie hierher holen.
+///
+/// Der Text traegt Platzhalter im Format {{name}} - aufgeloest in
+/// src/lib/schreiben/platzhalter.ts. Er ist bewusst NICHT verschluesselt:
+/// Eine Vorlage ist ein Textbaustein ohne Fallbezug; die Fachdaten kommen
+/// erst beim Erzeugen hinein.
+model Schreibvorlage {
+  id String @id @default(cuid())
+
+  betreuteId String
+  betreute   Betreute @relation(fields: [betreuteId], references: [id], onDelete: Cascade)
+
+  name    String
+  betreff String @default("")
+  text    String
+
+  /// Beim Speichern bestaetigt, dass der fehlende Bestellungsabsatz
+  /// Absicht ist - dann wird nicht bei jedem Bearbeiten erneut gewarnt.
+  ohneBestellungsabsatz Boolean @default(false)
+
+  erstelltAm     DateTime  @default(now())
+  aktualisiertAm DateTime  @updatedAt
+  geloeschtAm    DateTime?
+
+  @@index([betreuteId])
+  @@map("schreibvorlage")
+}
+
+model ZahlungsgruppeGeklaert {
+  id String @id @default(cuid())
+
+  betreuteId String
+  betreute   Betreute @relation(fields: [betreuteId], references: [id], onDelete: Cascade)
+
+  /// Normalisierter Name der Gegenstelle.
+  schluessel String
+
+  /// Die Schreibweise, wie sie beim Abhaken auf dem Bildschirm stand -
+  /// damit spaeter noch erkennbar ist, worum es ging.
+  anzeigename String
+
+  /// Warum kein Vertrag? Freiwillig, aber in einem Jahr Gold wert.
+  begruendung String?
+
+  erstelltAm DateTime @default(now())
+
+  @@unique([betreuteId, schluessel])
+  @@index([betreuteId])
+  @@map("zahlungsgruppe_geklaert")
+}
+
 model Buchung {
   id String @id @default(cuid())
 
@@ -767,6 +939,21 @@ model Buchung {
   /// Buchung ohne Beleg wird in der Liste markiert - Belegzwang.
   belegFehltBegruendung String?
 
+  /// Dauerzahlung zu einem Vertrag. Bei einem Dauerschuldverhaeltnis IST
+  /// der Vertrag der Beleg - fuer zwoelf gleiche Lastschriften gibt es
+  /// keine zwoelf Quittungen, sondern eine Police.
+  ///
+  /// onDelete: SetNull ist Absicht und Teil der Zusage: Verschwindet der
+  /// Vertrag, faellt die Buchung zurueck in "Beleg fehlt". Ein Nachweis,
+  /// der auf etwas zeigt, das es nicht mehr gibt, waere schlimmer als
+  /// gar keiner.
+  vertragId String?
+  vertrag   Vertrag? @relation("Vertragszahlung", fields: [vertragId], references: [id], onDelete: SetNull)
+
+  /// Wurde die Zuordnung beim Import automatisch gesetzt? Dann ist sie
+  /// eine Vermutung der Maschine und in der Liste als solche erkennbar.
+  vertragAutomatisch Boolean @default(false)
+
   /// false = Auslage des Betreuers, die erstattet werden muss.
   betrifftBetreute  Boolean @default(true)
   /// Verschiebt das Vermoegen (z.B. Verkaufserloes), nicht nur laufende
@@ -785,6 +972,7 @@ model Buchung {
   @@unique([kontoId, importReferenz])
   @@index([betreuteId, datum])
   @@index([betreuteId, kategorie])
+  @@index([vertragId])
   @@map("buchung")
 }
 
@@ -1050,6 +1238,7 @@ model Vertrag {
 
   vermoegensposten Vermoegensposten[]
   verknuepfungen   DokumentVerknuepfung[]
+  zahlungen        Buchung[]              @relation("Vertragszahlung")
 
   @@index([betreuteId, status])
   @@map("vertrag")
@@ -1059,6 +1248,13 @@ model Vertrag {
 // Kontakte und Kontaktprotokoll
 // =============================================================================
 
+/// Anrede fuer die Briefanrede eines Kontakts.
+enum KontaktAnrede {
+  OHNE
+  FRAU
+  HERR
+}
+
 enum KontaktRolle {
   RECHTSPFLEGER
   RICHTER
@@ -1094,6 +1290,9 @@ model Kontakt {
   name         String
   organisation String?
   rolle        KontaktRolle  @default(SONSTIGES)
+  /// Fuer die Briefanrede. Ohne Angabe wird mit vollem Namen angeredet -
+  /// nie geraten, das faellt dem Empfaenger sofort auf.
+  anrede       KontaktAnrede @default(OHNE)
 
   telefon      String?
   mobil        String?
@@ -1113,6 +1312,7 @@ model Kontakt {
 
   protokolle        Kontaktprotokoll[]
   vorgaenge         Vorgang[]              @relation("VorgangKontakte")
+  betreuteVorgaenge Vorgang[]              @relation("VorgangAnsprechpartner")
   verknuepfungen    DokumentVerknuepfung[]
 
   @@index([betreuteId, rolle])
@@ -1527,6 +1727,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/migration-erzeugen.d.mts

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

scripts/migration-erzeugen.mjs

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

scripts/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)/einstellungen/page.tsx

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/app/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/einstellungen/vorlagen-verwaltung.tsx

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

src/components/finanzen/bausteine.tsx

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

src/components/finanzen/buchungs-formular.tsx

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

src/components/finanzen/wiederkehrend-aktionen.tsx

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

src/components/kontakte/kontakt-formular.tsx

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

src/components/konto/passkey-verwaltung.tsx

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

src/components/markdown-seite.tsx

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

src/components/passkey-anmeldung.tsx

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

src/components/schreiben/schreiben-editor.tsx

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

src/components/schreiben/vorlagen-wahl.tsx

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

src/components/vertraege/kuendigungs-assistent.tsx

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

src/components/vertraege/rueckkaufswert.tsx

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

src/components/vertraege/serienabfrage-formular.tsx

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

src/components/vorgaenge/vorgangs-formular.tsx

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

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/berichte/gemeinsam.ts

@@ -1,4 +1,5 @@
 import 'server-only'
+import type { Prisma } from '@prisma/client'
 import type { Betreute, User } from '@prisma/client'
 import { db, nichtGeloescht } from '@/lib/db'
 import { protokollieren } from '@/lib/audit'
@@ -85,6 +86,62 @@ export function berichtskopf(eingabe: {
 // Laden
 // -----------------------------------------------------------------------------
 
+/**
+ * Was eine Buchung mitbringen muss, damit sich daraus eine BuchungEingabe
+ * bauen laesst.
+ *
+ * Steht hier und nicht in jeder Seite einzeln: Die Buchungsliste hatte
+ * lange eine eigene, fast gleiche Abfrage. Als die Dauerzahlungen
+ * dazukamen, wurde nur eine der beiden nachgezogen - und in der Liste
+ * stand weiter "Beleg fehlt", obwohl der Vertrag hinterlegt war. Ein
+ * gemeinsamer Einbezug kann nicht halb vergessen werden.
+ */
+export const BUCHUNG_EINBEZUG = {
+  konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
+  beleg: { select: { id: true, titel: true } },
+  // Bei einer Dauerzahlung ist der Vertrag der Beleg, und sein Beitrag ist
+  // der Massstab fuer die Betragspruefung.
+  vertrag: {
+    select: {
+      id: true,
+      bezeichnung: true,
+      beitragCent: true,
+      rhythmus: true,
+      vertragsnummerVerschluesselt: true,
+    },
+  },
+} as const
+
+type BuchungMitBezug = Prisma.BuchungGetPayload<{ include: typeof BUCHUNG_EINBEZUG }>
+
+/** Wandelt eine geladene Zeile in die Form um, mit der die Auswertung rechnet. */
+export function zuBuchungEingabe(zeile: BuchungMitBezug): BuchungEingabe {
+  const offen = oeffnen('Buchung', zeile)
+  return {
+    id: zeile.id,
+    datum: zeile.datum,
+    betragCent: zeile.betragCent,
+    richtung: zeile.richtung,
+    kategorie: zeile.kategorie,
+    gegenstelle: zeile.gegenstelle,
+    verwendungszweck: offen.verwendungszweck,
+    kontoId: zeile.kontoId,
+    kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
+    belegId: zeile.belegId,
+    belegTitel: zeile.beleg?.titel ?? null,
+    belegFehltBegruendung: zeile.belegFehltBegruendung,
+    vertragId: zeile.vertragId,
+    vertragBezeichnung: zeile.vertrag?.bezeichnung ?? null,
+    vertragsnummer: zeile.vertrag ? oeffnen('Vertrag', zeile.vertrag).vertragsnummer : null,
+    vertragBeitragCent: zeile.vertrag?.beitragCent ?? null,
+    vertragRhythmus: zeile.vertrag?.rhythmus ?? null,
+    vertragAutomatisch: zeile.vertragAutomatisch,
+    betrifftBetreute: zeile.betrifftBetreute,
+    vermoegenswirksam: zeile.vermoegenswirksam,
+    aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
+  }
+}
+
 /**
  * Alle Buchungen einer betreuten Person, entschluesselt und um die
  * Angaben ergaenzt, die die Auswertung braucht (Kontoname, Belegtitel,
@@ -102,33 +159,11 @@ export async function buchungenLaden(
         ? { datum: { gte: alsTag(zeitraum.von), lte: alsTag(zeitraum.bis) } }
         : {}),
     },
-    include: {
+    include: BUCHUNG_EINBEZUG,
-      konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
-      beleg: { select: { id: true, titel: true } },
-    },
     orderBy: [{ datum: 'asc' }, { erstelltAm: 'asc' }],
   })
 
-  return zeilen.map((zeile) => {
+  return zeilen.map(zuBuchungEingabe)
-    const offen = oeffnen('Buchung', zeile)
-    return {
-      id: zeile.id,
-      datum: zeile.datum,
-      betragCent: zeile.betragCent,
-      richtung: zeile.richtung,
-      kategorie: zeile.kategorie,
-      gegenstelle: zeile.gegenstelle,
-      verwendungszweck: offen.verwendungszweck,
-      kontoId: zeile.kontoId,
-      kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
-      belegId: zeile.belegId,
-      belegTitel: zeile.beleg?.titel ?? null,
-      belegFehltBegruendung: zeile.belegFehltBegruendung,
-      betrifftBetreute: zeile.betrifftBetreute,
-      vermoegenswirksam: zeile.vermoegenswirksam,
-      aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
-    }
-  })
 }
 
 /** Konten mit ihrer vollstaendigen Saldostand-Historie. */

src/lib/berichte/rechnungslegung.tsx

@@ -444,6 +444,15 @@ export function RechnungslegungDokument({
                 <View style={stile.mittel}>
                   {beleg.belegTitel ? (
                     <Text style={stile.klein}>{beleg.belegTitel}</Text>
+                  ) : beleg.vertragBezeichnung ? (
+                    <Text style={stile.klein}>
+                      Dauerzahlung zu Vertrag „{beleg.vertragBezeichnung}“
+                      {beleg.vertragsnummer ? `, Nr. ${beleg.vertragsnummer}` : ''}
+                    </Text>
+                  ) : beleg.betragZuPruefen ? (
+                    <Text style={[stile.klein, stile.fett]}>
+                      Beleg fehlt – Betrag weicht vom Vertrag ab
+                    </Text>
                   ) : beleg.belegFehltBegruendung ? (
                     <Text style={stile.klein}>
                       ohne Beleg – {beleg.belegFehltBegruendung}

src/lib/berichte/vollexport.ts

@@ -157,6 +157,13 @@ function tabellen(betreuteId: string, optionen: VollexportOptionen): Tabelle[] {
       laden: () => db.genehmigung.findMany({ where: { betreuteId } }),
     },
     { name: 'frist', modell: null, laden: () => db.frist.findMany({ where: { betreuteId } }) },
+    {
+      // Eigene Schreibvorlagen gehoeren zur Akte: Sie tragen die im Fall
+      // bewaehrten Formulierungen und waeren beim Umzug sonst verloren.
+      name: 'schreibvorlage',
+      modell: null,
+      laden: () => db.schreibvorlage.findMany({ where: { betreuteId } }),
+    },
     {
       name: 'dokument',
       modell: 'Dokument',

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.
@@ -166,7 +167,17 @@ export async function dashboardLaden(
     // 5b. Buchungen ohne Beleg und ohne Begruendung - Belegzwang.
     darfFinanzen
       ? db.buchung.findMany({
-          where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
+          where: {
+            betreuteId,
+            belegId: null,
+            belegFehltBegruendung: null,
+            // Dauerzahlungen sind durch ihren Vertrag belegt - sie gehoeren
+            // nicht in die Liste der offenen Belege. Die Betragspruefung
+            // laeuft erst spaeter auf den geladenen Zeilen; hier wird nur
+            // grob vorgefiltert.
+            vertragId: null,
+            ...nichtGeloescht,
+          },
           orderBy: { datum: 'desc' },
           take: KACHEL_ZEILEN,
           select: {
@@ -181,7 +192,17 @@ export async function dashboardLaden(
       : null,
     darfFinanzen
       ? db.buchung.count({
-          where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
+          where: {
+            betreuteId,
+            belegId: null,
+            belegFehltBegruendung: null,
+            // Dauerzahlungen sind durch ihren Vertrag belegt - sie gehoeren
+            // nicht in die Liste der offenen Belege. Die Betragspruefung
+            // laeuft erst spaeter auf den geladenen Zeilen; hier wird nur
+            // grob vorgefiltert.
+            vertragId: null,
+            ...nichtGeloescht,
+          },
         })
       : null,
 
@@ -267,6 +288,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 +312,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/kassenbuch.ts

@@ -1,4 +1,4 @@
-import type { BuchungKategorie, BuchungRichtung } from '@prisma/client'
+import type { BuchungKategorie, BuchungRichtung, ZahlRhythmus } from '@prisma/client'
 import { summe, teileGerundet } from '@/lib/finanzen/betrag'
 import { alsTag, imZeitraum, nachTagSortieren } from '@/lib/finanzen/datum'
 import {
@@ -39,6 +39,15 @@ export type BuchungEingabe = {
   belegId: string | null
   belegTitel?: string | null
   belegFehltBegruendung: string | null
+  /** Dauerzahlung zu einem Vertrag - dann ist der Vertrag der Beleg. */
+  vertragId?: string | null
+  vertragBezeichnung?: string | null
+  vertragsnummer?: string | null
+  /** Hinterlegter Beitrag samt Zahlweise - Grundlage der Betragspruefung. */
+  vertragBeitragCent?: bigint | null
+  vertragRhythmus?: ZahlRhythmus | null
+  /** Wurde die Zuordnung beim Import automatisch gesetzt? */
+  vertragAutomatisch?: boolean
   betrifftBetreute: boolean
   vermoegenswirksam: boolean
   /** Laeuft die Buchung ueber ein Konto des Betreuers? */
@@ -54,24 +63,134 @@ export function istVermoegensbuchung(buchung: BuchungEingabe): boolean {
 // Belegzwang
 // -----------------------------------------------------------------------------
 
+/**
+ * Wie weit darf die Zahlung vom hinterlegten Beitrag abweichen?
+ *
+ * Ein Fuenftel. Das ist grosszuegig und mit Absicht: Beitragsanpassungen,
+ * Versicherungsteuer und ein nachtraeglich geaenderter Selbstbehalt bewegen
+ * sich in dieser Groessenordnung, und bei jeder davon soll die Anwendung
+ * nicht meckern.
+ *
+ * Was sie fangen soll, ist die andere Groessenordnung: die Praemie, die von
+ * 42 auf 420 Euro springt, oder die Lastschrift, die versehentlich zweimal
+ * lief. Wer die Grenze enger zieht, bekommt taeglich Warnungen und sieht
+ * die eine wichtige nicht mehr.
+ */
+export const BETRAGS_TOLERANZ_PROZENT = 20n
+
+/**
+ * Passt der Betrag zu dem, was am Vertrag steht?
+ *
+ * Verglichen wird gegen den hinterlegten Beitrag, unveraendert. Kein
+ * Umrechnen auf andere Zahlweisen.
+ *
+ * Der erste Entwurf tat genau das - Jahresbetrag bilden und gegen
+ * jaehrlich, halbjaehrlich, vierteljaehrlich und monatlich pruefen, damit
+ * es auch passt, wenn die Bank anders abbucht als der Vertrag es fuehrt.
+ * Das Ergebnis war ein Toleranzband mit vier Loechern: Bei einem
+ * Monatsbeitrag von 42,50 EUR liegen 420 EUR innerhalb von 20 Prozent des
+ * Jahresbetrags von 510 EUR. Ausgerechnet der Fall, vor dem diese Pruefung
+ * schuetzen soll, waere durchgerutscht.
+ *
+ * Bucht die Bank tatsaechlich jaehrlich ab, waehrend am Vertrag "monatlich"
+ * steht, dann stimmen die Vertragsdaten nicht - und dann soll die
+ * Buchung als "zu pruefen" auffallen, statt stillschweigend akzeptiert zu
+ * werden. Die Zahlweise am Vertrag zu berichtigen dauert zehn Sekunden und
+ * macht die Akte richtiger.
+ *
+ * Ohne hinterlegten Beitrag gibt es nichts zu vergleichen - dann lautet die
+ * Antwort "unbekannt" (null), nicht "in Ordnung". Der Unterschied zaehlt:
+ * Es soll nicht so aussehen, als waere geprueft worden.
+ */
+export function betragPasstZumVertrag(
+  betragCent: bigint,
+  beitragCent: bigint | null | undefined,
+  rhythmus: ZahlRhythmus | null | undefined,
+): boolean | null {
+  if (beitragCent === null || beitragCent === undefined || beitragCent <= 0n) return null
+  // Zu einer Einmalzahlung gibt es keine wiederkehrende Rate, gegen die
+  // sich vergleichen liesse.
+  if (!rhythmus || rhythmus === 'EINMALIG') return null
+
+  const betrag = betragCent < 0n ? -betragCent : betragCent
+  const abweichung = betrag > beitragCent ? betrag - beitragCent : beitragCent - betrag
+
+  return abweichung * 100n <= beitragCent * BETRAGS_TOLERANZ_PROZENT
+}
+
+/**
+ * Ist die Buchung durch einen Vertrag belegt?
+ *
+ * Bei einem Dauerschuldverhaeltnis ist der Vertrag der Beleg - fuer zwoelf
+ * gleiche Lastschriften gibt es keine zwoelf Quittungen, sondern eine
+ * Police.
+ *
+ * Die Anerkennung faellt weg, sobald der Betrag deutlich abweicht. Sonst
+ * waere die Zuordnung eine Hintertuer, durch die auch eine verdreifachte
+ * Praemie unbemerkt als "belegt" durchginge.
+ */
+export function belegDurchVertrag(buchung: BuchungEingabe): boolean {
+  if (buchung.belegId) return false
+  if (!buchung.vertragId) return false
+  return (
+    betragPasstZumVertrag(
+      buchung.betragCent,
+      buchung.vertragBeitragCent,
+      buchung.vertragRhythmus,
+    ) !== false
+  )
+}
+
+/**
+ * Zugeordnet, aber der Betrag passt nicht - das will jemand ansehen.
+ *
+ * Kein Fehler und kein Vorwurf: Meistens ist es eine Beitragsanpassung, die
+ * am Vertrag noch nicht nachgetragen wurde. Genau deshalb steht sie hier
+ * und nicht wortlos unter "Beleg fehlt".
+ */
+export function betragPruefen(buchung: BuchungEingabe): boolean {
+  if (buchung.belegId) return false
+  if (!buchung.vertragId) return false
+  return (
+    betragPasstZumVertrag(
+      buchung.betragCent,
+      buchung.vertragBeitragCent,
+      buchung.vertragRhythmus,
+    ) === false
+  )
+}
+
 /**
  * Fehlt der Beleg? Eine Begruendung heilt das Fehlen fuer die Statistik,
  * nicht fuer den Aktenordner - aber sie beantwortet die Frage des
  * Rechtspflegers "und wo ist der Beleg?" schon vorab.
  */
 export function belegFehlt(buchung: BuchungEingabe): boolean {
-  return !buchung.belegId && !(buchung.belegFehltBegruendung ?? '').trim()
+  if (buchung.belegId) return false
+  if (belegDurchVertrag(buchung)) return false
+  return !(buchung.belegFehltBegruendung ?? '').trim()
 }
 
 export function belegBegruendet(buchung: BuchungEingabe): boolean {
-  return !buchung.belegId && (buchung.belegFehltBegruendung ?? '').trim() !== ''
+  if (buchung.belegId) return false
+  if (belegDurchVertrag(buchung)) return false
+  return (buchung.belegFehltBegruendung ?? '').trim() !== ''
 }
 
 export type Belegquote = {
   gesamt: number
   mitBeleg: number
+  /**
+   * Dauerzahlung zu einem Vertrag - eigene Kategorie, NICHT eingerechnet in
+   * "begruendet". Ein Vertrag belegt, eine Begruendung erklaert nur; das
+   * zusammenzuwerfen nimmt der Zahl ihre Aussage gegenueber dem
+   * Rechtspfleger.
+   */
+  durchVertrag: number
   begruendet: number
   ohneNachweis: number
+  /** Zugeordnet, aber der Betrag weicht ab. Teilmenge von ohneNachweis. */
+  zuPruefen: number
   /** 0 bis 100, ganzzahlig. Bei null Buchungen: 100 - es fehlt ja nichts. */
   quoteProzent: number
 }
@@ -79,11 +198,13 @@ export type Belegquote = {
 export function belegquote(buchungen: BuchungEingabe[]): Belegquote {
   const gesamt = buchungen.length
   const mitBeleg = buchungen.filter((b) => Boolean(b.belegId)).length
+  const durchVertrag = buchungen.filter((b) => belegDurchVertrag(b)).length
   const begruendet = buchungen.filter((b) => belegBegruendet(b)).length
   const ohneNachweis = buchungen.filter((b) => belegFehlt(b)).length
+  const zuPruefen = buchungen.filter((b) => betragPruefen(b)).length
   const quoteProzent =
-    gesamt === 0 ? 100 : Math.round(((mitBeleg + begruendet) / gesamt) * 100)
+    gesamt === 0 ? 100 : Math.round(((mitBeleg + durchVertrag + begruendet) / gesamt) * 100)
-  return { gesamt, mitBeleg, begruendet, ohneNachweis, quoteProzent }
+  return { gesamt, mitBeleg, durchVertrag, begruendet, ohneNachweis, zuPruefen, quoteProzent }
 }
 
 /**

src/lib/finanzen/rechnungslegung.ts

@@ -3,7 +3,9 @@ import { alsTag, imZeitraum, nachTagSortieren, tagePlus, vorOderGleich } from '@
 import type { Betreuungsjahr } from '@/lib/finanzen/betreuungsjahr'
 import {
   ausgabenGruppiert,
+  belegDurchVertrag,
   belegFehlt,
+  betragPruefen,
   einnahmenGruppiert,
   istVermoegensbuchung,
   belegquote,
@@ -158,6 +160,16 @@ export type Belegzeile = {
   belegId: string | null
   belegTitel: string | null
   belegFehltBegruendung: string | null
+  /**
+   * Dauerzahlung zu einem Vertrag. Steht im Bericht anstelle von
+   * "Beleg fehlt" - die Luecke wird damit nicht versteckt, sondern
+   * erklaert: Wer nachpruefen will, weiss, welches Papier er aus dem
+   * Ordner holt.
+   */
+  vertragBezeichnung: string | null
+  vertragsnummer: string | null
+  /** Zugeordnet, aber der Betrag weicht ab - im Bericht ausgewiesen. */
+  betragZuPruefen: boolean
   fehlt: boolean
 }
 
@@ -179,6 +191,9 @@ export function beleglisteErstellen(buchungen: BuchungEingabe[]): Belegzeile[] {
     belegId: buchung.belegId,
     belegTitel: buchung.belegTitel ?? null,
     belegFehltBegruendung: buchung.belegFehltBegruendung,
+    vertragBezeichnung: belegDurchVertrag(buchung) ? (buchung.vertragBezeichnung ?? null) : null,
+    vertragsnummer: belegDurchVertrag(buchung) ? (buchung.vertragsnummer ?? null) : null,
+    betragZuPruefen: betragPruefen(buchung),
     fehlt: belegFehlt(buchung),
   }))
 }

src/lib/finanzen/wertalter.ts

@@ -0,0 +1,52 @@
+import { tageZwischen } from '@/lib/finanzen/datum'
+
+/**
+ * Wie alt ist ein Wert - und ab wann ist das ein Problem?
+ *
+ * Ein Rueckkaufswert ohne Datum ist schlimmer als kein Rueckkaufswert:
+ * Man rechnet mit einer Zahl, die drei Jahre alt sein kann, und merkt es
+ * erst, wenn der Bezirk nachfragt. Deshalb steht neben jedem Betrag der
+ * Stichtag, und ab einem Jahr steht daneben, dass er alt ist.
+ *
+ * Die Grenze liegt bei 365 Tagen, weil der Bezirk jaehrlich prueft und
+ * das Betreuungsgericht jaehrlich Rechnung legen laesst. Ein Wert, der
+ * den letzten Jahresbericht ueberlebt hat, gehoert erneuert.
+ *
+ * Bewusst eine eigene Datei und nicht in vermoegen.ts: Die Regel gilt am
+ * Vertrag genauso wie im Vermoegensverzeichnis, und sie soll an beiden
+ * Stellen dieselbe sein - nicht zweimal als `> 365` hingeschrieben.
+ */
+
+export const WERT_VERALTET_TAGE = 365
+
+export type Wertalter = {
+  /** Tage zwischen Stichtag und heute. Negativ bei kuenftigem Stichtag. */
+  alterTage: number
+  veraltet: boolean
+  /** Kurztext fuer ein Abzeichen neben dem Betrag, sonst null. */
+  hinweis: string | null
+}
+
+/** Ist ein Wert dieses Alters erneuerungsbeduerftig? */
+export function wertVeraltet(alterTage: number): boolean {
+  return alterTage > WERT_VERALTET_TAGE
+}
+
+/**
+ * Das Alter eines Werts zum Stichtag.
+ *
+ * Ohne Stichtag gibt es kein Alter - dann null, und die Oberflaeche
+ * zeigt gar nichts an, statt eine Null zu behaupten.
+ */
+export function wertalterBestimmen(stichtag: Date | null, heute: Date): Wertalter | null {
+  if (!stichtag) return null
+
+  const alterTage = tageZwischen(stichtag, heute)
+  const veraltet = wertVeraltet(alterTage)
+
+  return {
+    alterTage,
+    veraltet,
+    hinweis: veraltet ? 'über ein Jahr alt' : null,
+  }
+}

src/lib/finanzen/wiederkehrend-laden.ts

@@ -0,0 +1,88 @@
+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,
+        vertragId: 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,546 @@
+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
+  /** Haengt die Buchung schon an einem Vertrag? (Issue #11) */
+  vertragId?: 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[]
+  /**
+   * Wie viele Buchungen der Gruppe haengen bereits an einem Vertrag?
+   * Grundlage fuer die Sammelzuordnung: Nur der Rest muss noch verknuepft
+   * werden.
+   */
+  bereitsZugeordnet: number
+  /** Buchungen der Gruppe ohne Vertragsbezug. */
+  offeneBuchungIds: 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),
+      bereitsZugeordnet: posten.filter((p) => Boolean(p.vertragId)).length,
+      offeneBuchungIds: sortiert.filter((p) => !p.vertragId).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
+  }
+}
+
+/**
+ * Sucht den Vertrag, zu dem eine Gegenstelle EINDEUTIG passt.
+ *
+ * Gedacht fuer die automatische Zuordnung beim Import. Die Betonung liegt
+ * auf eindeutig: Passen zwei Vertraege (Hausrat und Haftpflicht bei
+ * derselben Gesellschaft), wird nichts zugeordnet. Eine falsche Zuordnung
+ * waere schlimmer als gar keine - sie behauptet einen Beleg, den es nicht
+ * gibt, und niemand sieht noch einmal hin.
+ *
+ * Gibt null zurueck, wenn nichts oder mehr als eines passt.
+ */
+export function eindeutigerVertrag(
+  gegenstelle: string | null | undefined,
+  vertraege: VertragAbgleich[],
+): VertragAbgleich | null {
+  const schluessel = normalisieren(gegenstelle)
+  if (!schluessel) return null
+
+  const treffer = vertraege.filter((vertrag) => normalisieren(vertrag.gesellschaft) === schluessel)
+  return treffer.length === 1 ? treffer[0]! : 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/kontakte/anrede.ts

@@ -0,0 +1,61 @@
+import type { KontaktAnrede } from '@prisma/client'
+
+/**
+ * Die Briefanrede eines Ansprechpartners.
+ *
+ * Ein namentlich adressiertes Schreiben landet bei der Person, die den
+ * Vorgang kennt, statt in der Poststelle. Beim Bezirk Oberfranken ist das
+ * der Unterschied zwischen zwei Wochen und zwei Monaten.
+ *
+ * Zwei Regeln, die hier nicht verhandelbar sind:
+ *
+ * 1. Es wird nie geraten. Ohne hinterlegte Anrede wird mit dem vollen
+ *    Namen angeredet ("Sehr geehrte(r) Anna Schmitt,"). Eine falsch
+ *    geratene Anrede faellt dem Empfaenger sofort auf und kostet genau
+ *    die Aufmerksamkeit, die man gewinnen wollte.
+ * 2. Ohne Ansprechpartner bleibt es bei "Sehr geehrte Damen und Herren,".
+ *    Ein halb gefuellter Name darf nie zu "Sehr geehrte Frau ," werden -
+ *    lieber unpersoenlich als offensichtlich automatisch.
+ */
+
+export const ANREDE_BESCHRIFTUNG: Record<KontaktAnrede, string> = {
+  OHNE: 'keine Angabe',
+  FRAU: 'Frau',
+  HERR: 'Herr',
+}
+
+export const ALLGEMEINE_ANREDE = 'Sehr geehrte Damen und Herren,'
+
+/**
+ * Der Nachname aus einem vollen Namen.
+ *
+ * Titel und Vornamen fallen weg: "Dr. Anna Schmitt" wird zu "Schmitt".
+ * Doppelnamen mit Bindestrich bleiben ganz, weil sie ein Wort sind.
+ */
+export function nachnameAus(name: string): string {
+  const teile = name.trim().split(/\s+/).filter(Boolean)
+  return teile.length > 0 ? teile[teile.length - 1]! : ''
+}
+
+export type Ansprechpartner = {
+  name: string
+  anrede: KontaktAnrede
+}
+
+/**
+ * Die Anredezeile fuer ein Schreiben, einschliesslich Komma.
+ *
+ * Ohne Ansprechpartner - oder mit einem, dessen Name leer ist - die
+ * allgemeine Anrede.
+ */
+export function anredeZeile(ansprechpartner: Ansprechpartner | null): string {
+  if (!ansprechpartner) return ALLGEMEINE_ANREDE
+
+  const name = ansprechpartner.name.trim()
+  if (!name) return ALLGEMEINE_ANREDE
+
+  if (ansprechpartner.anrede === 'FRAU') return `Sehr geehrte Frau ${nachnameAus(name)},`
+  if (ansprechpartner.anrede === 'HERR') return `Sehr geehrter Herr ${nachnameAus(name)},`
+
+  return `Sehr geehrte(r) ${name},`
+}

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/schreiben/arten.ts

@@ -0,0 +1,113 @@
+/**
+ * Die Arten von Schreiben, die die Anwendung erzeugen kann.
+ *
+ * Rein und ohne Datenbank - der Entwurfstext entsteht anderswo
+ * (src/lib/schreiben/entwurf.ts), hier steht nur, was eine Art ausmacht.
+ *
+ * Warum ueberhaupt eine Aufzaehlung? Damit die Wiedervorlagefrist,
+ * die Beschriftung und der Dokumenttitel an EINER Stelle stehen. Vorher
+ * lagen sie verstreut: 28 Tage in rueckkaufswert.ts, 42 in
+ * sachstandsanfrage.ts, die Beschriftungen jeweils in der Seite.
+ */
+
+export type SchreibenArt = 'RUECKKAUFSWERT' | 'KUENDIGUNG' | 'SACHSTAND' | 'FREI'
+
+export const SCHREIBEN_ARTEN: readonly SchreibenArt[] = [
+  'RUECKKAUFSWERT',
+  'KUENDIGUNG',
+  'SACHSTAND',
+  'FREI',
+]
+
+export type SchreibenEigenschaften = {
+  beschriftung: string
+  /**
+   * Vorgeschlagene Wiedervorlage in Tagen.
+   *
+   * null heisst: keine vorschlagen. Bei einem freien Schreiben weiss
+   * niemand, ob und wann eine Antwort kommt - eine erfundene Frist waere
+   * schlechter als keine.
+   */
+  wiedervorlageTage: number | null
+  /** Woran haengt das Schreiben? Bestimmt, was die Seite laden muss. */
+  bezug: 'VERTRAG' | 'VORGANG' | 'KEINER'
+  /** Kurze Erklaerung, warum die Frist so lang ist. */
+  fristBegruendung: string | null
+}
+
+export const SCHREIBEN_EIGENSCHAFTEN: Record<SchreibenArt, SchreibenEigenschaften> = {
+  RUECKKAUFSWERT: {
+    beschriftung: 'Auskunft über Rückkaufswert',
+    // Dieselbe Zahl wie RUECKKAUFSWERT_WIEDERVORLAGE_TAGE - dort steht sie
+    // fuer die Anzeige am Vertrag, hier fuer die erzeugte Frist. Ein Test
+    // haelt beide zusammen.
+    wiedervorlageTage: 28,
+    bezug: 'VERTRAG',
+    fristBegruendung:
+      'Vier Wochen sind bei Versicherern die übliche Bearbeitungszeit. Kommt bis dahin ' +
+      'nichts, lohnt das Nachfassen.',
+  },
+  KUENDIGUNG: {
+    beschriftung: 'Kündigung',
+    // Kuerzer als beim Rueckkaufswert: Eine Kuendigung muss bestaetigt
+    // werden, und ohne Bestaetigung ist nicht belegt, dass sie ankam.
+    wiedervorlageTage: 21,
+    bezug: 'VERTRAG',
+    fristBegruendung:
+      'Drei Wochen. Eine Kündigung ohne schriftliche Bestätigung ist nicht nachgewiesen — ' +
+      'und wenn sie untergegangen ist, läuft die Frist weiter.',
+  },
+  SACHSTAND: {
+    beschriftung: 'Sachstandsanfrage',
+    wiedervorlageTage: 42,
+    bezug: 'VORGANG',
+    fristBegruendung:
+      'Sechs Wochen. Behörden brauchen länger als Versicherer; früher nachzufassen bringt ' +
+      'meist nur die Antwort, dass es noch dauert.',
+  },
+  FREI: {
+    beschriftung: 'Freies Schreiben',
+    wiedervorlageTage: null,
+    bezug: 'KEINER',
+    fristBegruendung: null,
+  },
+}
+
+/** Ist der Wert eine bekannte Art? Fuer Parameter aus der Adresszeile. */
+export function istSchreibenArt(wert: string | null | undefined): wert is SchreibenArt {
+  return typeof wert === 'string' && (SCHREIBEN_ARTEN as readonly string[]).includes(wert)
+}
+
+/**
+ * Dateiname fuer die Word-Datei und die Ablage.
+ *
+ * Sprechend, sortierbar, ohne Zeichen, die ein Dateisystem nicht mag:
+ * "2026-08-23_Kuendigung_Allianz.docx"
+ */
+export function dateinameFuerSchreiben(
+  art: SchreibenArt,
+  empfaenger: string | null,
+  datum: Date,
+  endung: 'docx' | 'pdf' | 'eml',
+): string {
+  const tag = datum.toISOString().slice(0, 10)
+
+  const sauber = (text: string) =>
+    text
+      .replace(/ä/g, 'ae')
+      .replace(/ö/g, 'oe')
+      .replace(/ü/g, 'ue')
+      .replace(/Ä/g, 'Ae')
+      .replace(/Ö/g, 'Oe')
+      .replace(/Ü/g, 'Ue')
+      .replace(/ß/g, 'ss')
+      .replace(/[^A-Za-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .slice(0, 40)
+
+  const teile = [tag, sauber(SCHREIBEN_EIGENSCHAFTEN[art].beschriftung)]
+  const ziel = empfaenger ? sauber(empfaenger) : ''
+  if (ziel) teile.push(ziel)
+
+  return `${teile.join('_')}.${endung}`
+}