Merge #17: Rueckkaufswerte in einem Zug anfragen

Behebt Issue #6: Ein Klick statt fuenf bis zehn einzelner Briefe - ZIP
je Gesellschaft, PDF in der Akte, Wiedervorlage, Anfragevermerk.

Closes #6

.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,408 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [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
@@ -466,7 +868,14 @@ Was davon wann angegangen wird, steht in [`docs/ROADMAP.md`](docs/ROADMAP.md).
 
 ---
 
-[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.0...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.6.0...HEAD
+[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

README.md

@@ -180,6 +180,16 @@ existiert.
 ./scripts/update.sh
 ```
 
+> **Kommst du von 1.1.0 oder älter?** Dort lag `update.sh` ohne
+> Ausführungsrecht im Repository — `./scripts/update.sh` endet dann in
+> „Permission denied". Einmalig hilft:
+>
+> ```bash
+> bash scripts/update.sh
+> ```
+>
+> Ab 1.1.1 ist das Recht gesetzt und der Punktschrägstrich funktioniert.
+
 Das Skript sichert zuerst, zeigt den Changelog zwischen altem und neuem
 Stand, fragt nach, schaltet um, baut neu und führt danach die beiden
 SQL-Skripte aus. Schlägt die Sicherung fehl, wird nicht aktualisiert.
@@ -570,11 +580,11 @@ Fehler, die während des Baus aufgefallen sind.
 
 | | | nachzuzählen mit |
 |---|---:|---|
-| Zeilen TypeScript/TSX | 72.080 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
-| Prisma-Modelle | 33 | `grep -c '^model ' prisma/schema.prisma` |
-| Seiten | 79 | `find src/app -name page.tsx \| wc -l` |
-| Unit-Tests (Vitest) | 496 | `npm test` |
-| End-to-End-Tests (Playwright) | 37 | `npm run test:e2e` |
+| Zeilen TypeScript/TSX | 79.102 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
+| Prisma-Modelle | 34 | `grep -c '^model ' prisma/schema.prisma` |
+| Seiten | 82 | `find src/app -name page.tsx \| wc -l` |
+| Unit-Tests (Vitest) | 602 | `npm test` |
+| End-to-End-Tests (Playwright) | 87 | `npm run test:e2e` — 47 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
 | TypeScript-Fehler | 0 | `npm run typecheck` |
 
 Die Befehle stehen dabei, weil die Zahlen sonst altern, ohne dass es

docs/INSTALLATION.md

@@ -131,14 +131,14 @@ cd /opt/betreuungs-cockpit
 
 # Auf die letzte veröffentlichte Fassung wechseln,
 # nicht auf den laufenden Entwicklungsstand
-git checkout v1.1.0
+git checkout v1.6.0
 ```
 
 ### Kontrolle
 
 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.1.0
+git describe --tags                              # v1.6.0
 ```
 
 ---
@@ -299,7 +299,7 @@ betreuungs-cockpit-sicherung-1  Up
 ```bash
 # Antwortet die Anwendung? (Port anpassen, falls du APP_PORT gesetzt hast)
 curl -s http://127.0.0.1:3000/api/gesundheit
-# {"status":"bereit","version":"1.1.0","commit":"..."}
+# {"status":"bereit","version":"1.6.0","commit":"..."}
 ```
 
 Kommt hier nichts, sieh in die Logs:
@@ -649,7 +649,7 @@ Erst **vom Proxy-Server aus** — kommt er überhaupt an?
 
 ```bash
 curl -s http://10.0.0.5:3000/api/gesundheit
-# {"status":"bereit","version":"1.1.0",...}
+# {"status":"bereit","version":"1.6.0",...}
 ```
 
 Kommt hier nichts, liegt es an 7a: falsche `APP_BIND`, Firewall, oder der
@@ -700,7 +700,7 @@ Zum Schluss: **Fristen → Pflichtfristen ableiten**.
 - Du kommst mit E-Mail, Passwort und dem Code aus der App herein.
 - Unter **Fristen** stehen Einträge mit Paragraphenbezug.
 - Unter **Protokoll** siehst du deine eigene Anmeldung.
-- Unten links in der Seitenleiste steht `Version 1.1.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.6.0 · <commit>`.
 
 ---
 
@@ -843,6 +843,16 @@ cd /opt/betreuungs-cockpit
 ./scripts/update.sh
 ```
 
+> **Kommst du von 1.1.0 oder älter?** Dort lag `update.sh` ohne
+> Ausführungsrecht im Repository — `./scripts/update.sh` endet dann in
+> „Permission denied". Einmalig hilft:
+>
+> ```bash
+> bash scripts/update.sh
+> ```
+>
+> Ab 1.1.1 ist das Recht gesetzt und der Punktschrägstrich funktioniert.
+
 Das war es. Das Skript nimmt dir die Schritte ab, die man von Hand
 vergisst:
 
@@ -865,7 +875,7 @@ alles so vor wie zuvor.
 | Aufruf | Wirkung |
 |---|---|
 | `./scripts/update.sh` | auf die neueste veröffentlichte Fassung |
-| `./scripts/update.sh v1.2.0` | auf eine bestimmte Fassung |
+| `./scripts/update.sh v1.6.0` | auf eine bestimmte Fassung |
 | `./scripts/update.sh --pruefen` | nur nachsehen, nichts ändern |
 | `./scripts/update.sh --ja` | ohne Rückfrage (für cron) |
 | `./scripts/update.sh --verwerfen` | eigene Änderungen wegwerfen statt beiseitelegen |
@@ -903,7 +913,7 @@ git fetch --tags
 git log --oneline HEAD..origin/main
 
 # 3. Umschalten
-git checkout v1.1.0
+git checkout v1.6.0
 
 # 4. Neu bauen und starten
 GIT_COMMIT=$(git rev-parse --short HEAD) BUILD_ZEIT=$(date -Iseconds) docker compose up -d --build

docs/ROADMAP.md

@@ -9,7 +9,7 @@ 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: 22.08.2026 · Aktuelle Fassung: **1.1.0** ([CHANGELOG](../CHANGELOG.md))
+Stand: 23.08.2026 · Aktuelle Fassung: **1.6.0** ([CHANGELOG](../CHANGELOG.md))
 
 ---
 
@@ -61,9 +61,10 @@ Auszug erzeugt dann doppelte Buchungen.
 
 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.
+Versicherer braucht. Es ist derselbe Wert, um den es im Anschreiben an den
+Versicherer geht — siehe 1.2a.
 
-*Aufwand: klein.*
+*Aufwand: klein. Issue: [#8](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/8).*
 
 ### Genau eine Zielspalte je Dokumentverknüpfung
 
@@ -120,7 +121,10 @@ 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.
+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
 
@@ -136,6 +140,106 @@ 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
@@ -254,7 +358,6 @@ Sinnvoll, aber nicht dringend:
 
 - **Kalendarische Wiedervorlage per E-Mail als Wochenübersicht** statt
   einzelner Erinnerungen.
-- **Vorlagen für eigene Anschreiben**, über die mitgelieferten hinaus.
 - **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

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/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/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)
+  })
+})

package.json

@@ -1,6 +1,6 @@
 {
   "name": "betreuungs-cockpit",
-  "version": "1.1.0",
+  "version": "1.6.0",
   "private": true,
   "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
   "engines": {

prisma/migrations/20260823000500_zahlungsgruppe_geklaert/migration.sql

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

prisma/migrations/20260823062000_buchung_vertragszahlung/migration.sql

@@ -0,0 +1,19 @@
+-- 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/suche.sql und sind Prisma
+-- unbekannt; ein DROP legt die unscharfe Suche stumm, ohne dass etwas
+-- fehlschlaegt. Zeilen entfernt. Wer die naechste Migration erzeugt:
+-- nachsehen.
+
+-- 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/schema.prisma

@@ -312,6 +312,7 @@ model Betreute {
   dokumente             Dokument[]
   konten                Konto[]
   buchungen             Buchung[]
+  zahlungsgruppen       ZahlungsgruppeGeklaert[]
   vermoegensposten      Vermoegensposten[]
   immobilien            Immobilie[]
   vertraege             Vertrag[]
@@ -828,6 +829,42 @@ enum BuchungKategorie {
   UMBUCHUNG
 }
 
+/// Eine Gruppe wiederkehrender Zahlungen, zu der bewusst KEIN Vertrag
+/// gefuehrt wird - Miete, Strom, Rundfunkbeitrag, Finanzamt.
+///
+/// Die Entscheidung haengt am normalisierten Namen der Gegenstelle, nicht
+/// an den Buchungen. Nur so ueberlebt sie den naechsten Kontoauszug: Beim
+/// Import entstehen neue Buchungszeilen, der Empfaenger bleibt derselbe.
+///
+/// ACHTUNG: Der Schluessel wird von normalisieren() in
+/// src/lib/finanzen/wiederkehrend.ts gebildet. Aendert sich diese Funktion,
+/// passen bestehende Schluessel nicht mehr und abgehakte Gruppen tauchen
+/// wieder auf. Das ist unangenehm, aber ungefaehrlich - schlimmer waere,
+/// eine Gruppe stillschweigend weiter zu verbergen, die inzwischen anders
+/// zugeschnitten ist.
+model ZahlungsgruppeGeklaert {
+  id String @id @default(cuid())
+
+  betreuteId String
+  betreute   Betreute @relation(fields: [betreuteId], references: [id], onDelete: Cascade)
+
+  /// Normalisierter Name der Gegenstelle.
+  schluessel String
+
+  /// Die Schreibweise, wie sie beim Abhaken auf dem Bildschirm stand -
+  /// damit spaeter noch erkennbar ist, worum es ging.
+  anzeigename String
+
+  /// Warum kein Vertrag? Freiwillig, aber in einem Jahr Gold wert.
+  begruendung String?
+
+  erstelltAm DateTime @default(now())
+
+  @@unique([betreuteId, schluessel])
+  @@index([betreuteId])
+  @@map("zahlungsgruppe_geklaert")
+}
+
 model Buchung {
   id String @id @default(cuid())
 
@@ -853,6 +890,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
@@ -871,6 +923,7 @@ model Buchung {
   @@unique([kontoId, importReferenz])
   @@index([betreuteId, datum])
   @@index([betreuteId, kategorie])
+  @@index([vertragId])
   @@map("buchung")
 }
 
@@ -1136,6 +1189,7 @@ model Vertrag {
 
   vermoegensposten Vermoegensposten[]
   verknuepfungen   DokumentVerknuepfung[]
+  zahlungen        Buchung[]              @relation("Vertragszahlung")
 
   @@index([betreuteId, status])
   @@map("vertrag")

scripts/update.sh

@@ -288,6 +288,13 @@ 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'
 

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)/finanzen/buchungen/[id]/page.tsx

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

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

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

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

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

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

@@ -1,5 +1,6 @@
 import Link from 'next/link'
-import { ArrowRight, Banknote, FileDown, Landmark, Plus, Upload } from 'lucide-react'
+import { ArrowRight, Banknote, FileDown, Landmark, Plus, Repeat, Upload } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
@@ -16,10 +17,11 @@ import { centZuZahl } from '@/lib/db'
 import { formatCent, formatDatum } from '@/lib/utils'
 import { finanzKontext } from '@/lib/finanzen/seite'
 import { heute, monatePlus, tagePlus } from '@/lib/finanzen/datum'
-import { kennzahlen, vermischungsWarnung } from '@/lib/finanzen/kassenbuch'
+import { belegDurchVertrag, betragPruefen, kennzahlen, vermischungsWarnung } from '@/lib/finanzen/kassenbuch'
 import { KATEGORIE_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
 import { laufendesBetreuungsjahr } from '@/lib/finanzen/betreuungsjahr'
 import { buchungenLaden, kontenLaden, kontostaendeZumStichtag, vermoegenLaden } from '@/lib/berichte/gemeinsam'
+import { offeneZahlungsgruppen } from '@/lib/finanzen/wiederkehrend-laden'
 
 export const metadata = { title: 'Vermögen & Kasse' }
 
@@ -48,6 +50,7 @@ export default async function FinanzenSeite() {
   const zwoelfMonate = tagePlus(monatePlus(stichtag, -12), 1)
   const letzteZwoelf = buchungen.filter((b) => b.datum >= zwoelfMonate)
   const zahlen = kennzahlen(letzteZwoelf)
+  const offeneGruppen = await offeneZahlungsgruppen(betreute.id)
 
   const letzte = [...buchungen].sort((a, b) => b.datum.getTime() - a.datum.getTime()).slice(0, 8)
 
@@ -118,9 +121,13 @@ export default async function FinanzenSeite() {
           titel="Belegquote (12 Monate)"
           wert={`${zahlen.beleg.quoteProzent} %`}
           hinweis={
-            zahlen.beleg.ohneNachweis > 0
-              ? `${zahlen.beleg.ohneNachweis} Buchung(en) ohne Beleg und ohne Begründung`
-              : 'Alle Buchungen sind belegt oder begründet'
+            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'}
           href="/finanzen/buchungen?nurOhneBeleg=on"
@@ -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/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)/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,129 @@
+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'
+
+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,
+      benutzerName: benutzer.name,
+      art,
+      vertragId: text('vertragId') || null,
+      vorgangId: text('vorgangId') || 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 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' }]}
+      />
+
+      <SchreibenEditor
+        betreuteId={aktive.id}
+        art={art}
+        entwurf={{
+          betreff: entwurf.betreff,
+          text: entwurf.text,
+          empfaengerName: entwurf.empfaengerName,
+          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/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,235 +1,243 @@
-import Link from 'next/link'
-import { 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'
-import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
-import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
-import { Rechtshinweis } from '@/components/rechtshinweis'
-import {
-  KuendigungsUebersicht,
-  type Kuendigungswarnung,
-} from '@/components/vertraege/kuendigungs-uebersicht'
-import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
-import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
-import { oeffnen } from '@/lib/crypto/feld'
-import { heuteAlsTag } from '@/lib/fristen/datum'
-import {
-  kuendigungsampel,
-  kuendigungsplan,
-  laufzeitAusVertrag,
-} from '@/lib/vertraege/kuendigung'
-import {
-  BEWERTUNG_BESCHRIFTUNG,
-  jahresbeitragCent,
-  RHYTHMUS_BESCHRIFTUNG,
-  VERTRAG_ART_BESCHRIFTUNG,
-  VERTRAG_STATUS_BESCHRIFTUNG,
-} from '@/lib/vertraege/konstanten'
-import { formatCent, formatDatum } from '@/lib/utils'
-
-export const dynamic = 'force-dynamic'
-
-const BEWERTUNG_VARIANTE = {
-  UNGEPRUEFT: 'outline',
-  VERWERTBAR: 'orange',
-  GESCHUETZT: 'gruen',
-  STRITTIG: 'gelb',
-} as const
-
-export default async function VertraegeUebersicht() {
-  const benutzer = await erfordereBenutzer('/vertraege')
-  const aktive = await aktiveBetreute(benutzer)
-  if (!aktive) return null
-
-  const { darfSchreiben } = await erfordereZugang(aktive.id, 'VERTRAEGE', 'lesen')
-  const schreiben = darfSchreiben('VERTRAEGE')
-
-  const vertraege = await db.vertrag.findMany({
-    where: { betreuteId: aktive.id, ...nichtGeloescht },
-    include: {
-      vermoegensposten: {
-        where: { art: 'VERSICHERUNG', ...nichtGeloescht },
-        include: { wertstaende: { orderBy: { stichtag: 'desc' }, take: 1 } },
-      },
-    },
-    orderBy: [{ status: 'asc' }, { bezeichnung: 'asc' }],
-  })
-
-  const heute = heuteAlsTag()
-  const warnungen: Kuendigungswarnung[] = []
-  let jahresbeitragSumme = 0n
-
-  const zeilen = vertraege.map((vertrag) => {
-    const offen = oeffnen('Vertrag', vertrag)
-    const plan = kuendigungsplan({
-      beginnAm: vertrag.beginnAm,
-      endeAm: vertrag.endeAm,
-      laufzeitJahre: laufzeitAusVertrag(vertrag.beginnAm, vertrag.endeAm),
-      kuendigungsfristMonate: vertrag.kuendigungsfristMonate,
-      heute,
-    })
-    const ampel = kuendigungsampel(plan)
-
-    const jahr = jahresbeitragCent(vertrag.beitragCent, vertrag.rhythmus)
-    if (jahr && vertrag.status === 'AKTIV') jahresbeitragSumme += jahr
-
-    const laufend = vertrag.status === 'AKTIV' || vertrag.status === 'BEITRAGSFREI'
-    if (laufend && ampel && (ampel.variante === 'rot' || ampel.variante === 'orange')) {
-      warnungen.push({
-        vertragId: vertrag.id,
-        bezeichnung: vertrag.bezeichnung,
-        absendetag: plan.spaetesterAbsendetag?.toISOString() ?? null,
-        tageBisAbsendetag: plan.tageBisAbsendetag,
-        verpasst: plan.verpasst,
-        variante: ampel.variante,
-        text: ampel.text,
-      })
-    }
-
-    return {
-      id: vertrag.id,
-      bezeichnung: vertrag.bezeichnung,
-      gesellschaft: vertrag.gesellschaft,
-      art: vertrag.art,
-      status: vertrag.status,
-      vertragsnummer: offen.vertragsnummer,
-      beitragCent: centZuZahl(vertrag.beitragCent),
-      rhythmus: vertrag.rhythmus,
-      bewertung: vertrag.bewertungSozialhilfe,
-      rueckkaufswertCent: centZuZahl(
-        vertrag.vermoegensposten[0]?.wertstaende[0]?.wertCent ?? null,
-      ),
-      rueckkaufswertStichtag:
-        vertrag.vermoegensposten[0]?.wertstaende[0]?.stichtag.toISOString() ?? null,
-      ampel,
-    }
-  })
-
-  return (
-    <div className="space-y-6">
-      <SeitenKopf
-        titel="Versicherungen & Verträge"
-        beschreibung="Alle laufenden Verträge mit Beitrag, Kündigungsfrist, Rückkaufswert und der Einordnung fürs Sozialamt."
-        pfad={[{ titel: 'Übersicht', href: '/heute' }, { titel: 'Verträge' }]}
-        aktionen={
-          schreiben && (
-            <Button asChild>
-              <Link href="/vertraege/neu">
-                <Plus aria-hidden="true" />
-                Vertrag anlegen
-              </Link>
-            </Button>
-          )
-        }
-      />
-
-      <KuendigungsUebersicht warnungen={warnungen} />
-
-      {vertraege.length === 0 ? (
-        <Leerzustand
-          titel="Noch kein Vertrag erfasst"
-          beschreibung="Nimm die Kontoauszüge des letzten Jahres zur Hand: Jede wiederkehrende Abbuchung ist ein Vertrag. Das ist der zuverlässigste Weg, nichts zu übersehen — Policen liegen selten vollständig im Ordner."
-          icon={Shield}
-          aktion={
-            schreiben && (
-              <Button asChild>
-                <Link href="/vertraege/neu">
-                  <Plus aria-hidden="true" />
-                  Vertrag anlegen
-                </Link>
-              </Button>
-            )
-          }
-        />
-      ) : (
-        <Card>
-          <CardHeader>
-            <CardTitle>Alle Verträge</CardTitle>
-            <CardDescription>
-              Jahresbeitrag der aktiven Verträge zusammen:{' '}
-              <strong className="text-foreground">
-                {formatCent(centZuZahl(jahresbeitragSumme))}
-              </strong>
-            </CardDescription>
-          </CardHeader>
-          <CardContent>
-            <Table>
-              <TableHeader>
-                <TableRow>
-                  <TableHead>Vertrag</TableHead>
-                  <TableHead>Art</TableHead>
-                  <TableHead className="text-right">Beitrag</TableHead>
-                  <TableHead className="text-right">Rückkaufswert</TableHead>
-                  <TableHead>Kündigung</TableHead>
-                  <TableHead>Sozialamt</TableHead>
-                  <TableHead>Status</TableHead>
-                </TableRow>
-              </TableHeader>
-              <TableBody>
-                {zeilen.map((zeile) => (
-                  <TableRow key={zeile.id}>
-                    <TableCell>
-                      <Link
-                        href={`/vertraege/${zeile.id}`}
-                        className="font-medium hover:underline"
-                      >
-                        {zeile.bezeichnung}
-                      </Link>
-                      <span className="block text-sm text-muted-foreground">
-                        {[zeile.gesellschaft, zeile.vertragsnummer].filter(Boolean).join(' · ') ||
-                          'Gesellschaft nicht erfasst'}
-                      </span>
-                    </TableCell>
-                    <TableCell className="text-sm">
-                      {VERTRAG_ART_BESCHRIFTUNG[zeile.art]}
-                    </TableCell>
-                    <TableCell className="text-right tabular-nums">
-                      {formatCent(zeile.beitragCent)}
-                      {zeile.rhythmus && (
-                        <span className="block text-xs text-muted-foreground">
-                          {RHYTHMUS_BESCHRIFTUNG[zeile.rhythmus]}
-                        </span>
-                      )}
-                    </TableCell>
-                    <TableCell className="text-right tabular-nums">
-                      {formatCent(zeile.rueckkaufswertCent)}
-                      {zeile.rueckkaufswertStichtag && (
-                        <span className="block text-xs text-muted-foreground">
-                          {formatDatum(zeile.rueckkaufswertStichtag)}
-                        </span>
-                      )}
-                    </TableCell>
-                    <TableCell>
-                      {zeile.ampel ? (
-                        <Badge variant={zeile.ampel.variante}>{zeile.ampel.text}</Badge>
-                      ) : (
-                        <span className="text-sm text-muted-foreground">nicht berechenbar</span>
-                      )}
-                    </TableCell>
-                    <TableCell>
-                      <Badge variant={BEWERTUNG_VARIANTE[zeile.bewertung]}>
-                        {BEWERTUNG_BESCHRIFTUNG[zeile.bewertung]}
-                      </Badge>
-                    </TableCell>
-                    <TableCell className="text-sm">
-                      {VERTRAG_STATUS_BESCHRIFTUNG[zeile.status]}
-                    </TableCell>
-                  </TableRow>
-                ))}
-              </TableBody>
-            </Table>
-          </CardContent>
-        </Card>
-      )}
-
-      <Rechtshinweis rechtsgrundlage="§ 90 SGB XII, § 1850 BGB" />
-      <p className="text-sm text-muted-foreground">
-        Kurz übersetzt: Ob ein Vertrag vor der Sozialhilfe einzusetzen ist, richtet sich nach
-        § 90 SGB XII — eine angemessene Bestattungsvorsorge bleibt regelmäßig geschützt. Und
-        bevor eine Lebens- oder Rentenversicherung verwertet wird, gehört die Frage nach der
-        Genehmigung des Betreuungsgerichts (§ 1850 BGB) an den Rechtspfleger, nicht an diese App.
-      </p>
-    </div>
-  )
-}
+import Link from 'next/link'
+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'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
+import { Rechtshinweis } from '@/components/rechtshinweis'
+import {
+  KuendigungsUebersicht,
+  type Kuendigungswarnung,
+} from '@/components/vertraege/kuendigungs-uebersicht'
+import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
+import { oeffnen } from '@/lib/crypto/feld'
+import { heuteAlsTag } from '@/lib/fristen/datum'
+import {
+  kuendigungsampel,
+  kuendigungsplan,
+  laufzeitAusVertrag,
+} from '@/lib/vertraege/kuendigung'
+import {
+  BEWERTUNG_BESCHRIFTUNG,
+  jahresbeitragCent,
+  RHYTHMUS_BESCHRIFTUNG,
+  VERTRAG_ART_BESCHRIFTUNG,
+  VERTRAG_STATUS_BESCHRIFTUNG,
+} from '@/lib/vertraege/konstanten'
+import { formatCent, formatDatum } from '@/lib/utils'
+
+export const dynamic = 'force-dynamic'
+
+const BEWERTUNG_VARIANTE = {
+  UNGEPRUEFT: 'outline',
+  VERWERTBAR: 'orange',
+  GESCHUETZT: 'gruen',
+  STRITTIG: 'gelb',
+} as const
+
+export default async function VertraegeUebersicht() {
+  const benutzer = await erfordereBenutzer('/vertraege')
+  const aktive = await aktiveBetreute(benutzer)
+  if (!aktive) return null
+
+  const { darfSchreiben } = await erfordereZugang(aktive.id, 'VERTRAEGE', 'lesen')
+  const schreiben = darfSchreiben('VERTRAEGE')
+
+  const vertraege = await db.vertrag.findMany({
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    include: {
+      vermoegensposten: {
+        where: { art: 'VERSICHERUNG', ...nichtGeloescht },
+        include: { wertstaende: { orderBy: { stichtag: 'desc' }, take: 1 } },
+      },
+    },
+    orderBy: [{ status: 'asc' }, { bezeichnung: 'asc' }],
+  })
+
+  const heute = heuteAlsTag()
+  const warnungen: Kuendigungswarnung[] = []
+  let jahresbeitragSumme = 0n
+
+  const zeilen = vertraege.map((vertrag) => {
+    const offen = oeffnen('Vertrag', vertrag)
+    const plan = kuendigungsplan({
+      beginnAm: vertrag.beginnAm,
+      endeAm: vertrag.endeAm,
+      laufzeitJahre: laufzeitAusVertrag(vertrag.beginnAm, vertrag.endeAm),
+      kuendigungsfristMonate: vertrag.kuendigungsfristMonate,
+      heute,
+    })
+    const ampel = kuendigungsampel(plan)
+
+    const jahr = jahresbeitragCent(vertrag.beitragCent, vertrag.rhythmus)
+    if (jahr && vertrag.status === 'AKTIV') jahresbeitragSumme += jahr
+
+    const laufend = vertrag.status === 'AKTIV' || vertrag.status === 'BEITRAGSFREI'
+    if (laufend && ampel && (ampel.variante === 'rot' || ampel.variante === 'orange')) {
+      warnungen.push({
+        vertragId: vertrag.id,
+        bezeichnung: vertrag.bezeichnung,
+        absendetag: plan.spaetesterAbsendetag?.toISOString() ?? null,
+        tageBisAbsendetag: plan.tageBisAbsendetag,
+        verpasst: plan.verpasst,
+        variante: ampel.variante,
+        text: ampel.text,
+      })
+    }
+
+    return {
+      id: vertrag.id,
+      bezeichnung: vertrag.bezeichnung,
+      gesellschaft: vertrag.gesellschaft,
+      art: vertrag.art,
+      status: vertrag.status,
+      vertragsnummer: offen.vertragsnummer,
+      beitragCent: centZuZahl(vertrag.beitragCent),
+      rhythmus: vertrag.rhythmus,
+      bewertung: vertrag.bewertungSozialhilfe,
+      rueckkaufswertCent: centZuZahl(
+        vertrag.vermoegensposten[0]?.wertstaende[0]?.wertCent ?? null,
+      ),
+      rueckkaufswertStichtag:
+        vertrag.vermoegensposten[0]?.wertstaende[0]?.stichtag.toISOString() ?? null,
+      ampel,
+    }
+  })
+
+  return (
+    <div className="space-y-6">
+      <SeitenKopf
+        titel="Versicherungen & Verträge"
+        beschreibung="Alle laufenden Verträge mit Beitrag, Kündigungsfrist, Rückkaufswert und der Einordnung fürs Sozialamt."
+        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>
+            </>
+          )
+        }
+      />
+
+      <KuendigungsUebersicht warnungen={warnungen} />
+
+      {vertraege.length === 0 ? (
+        <Leerzustand
+          titel="Noch kein Vertrag erfasst"
+          beschreibung="Nimm die Kontoauszüge des letzten Jahres zur Hand: Jede wiederkehrende Abbuchung ist ein Vertrag. Das ist der zuverlässigste Weg, nichts zu übersehen — Policen liegen selten vollständig im Ordner."
+          icon={Shield}
+          aktion={
+            schreiben && (
+              <Button asChild>
+                <Link href="/vertraege/neu">
+                  <Plus aria-hidden="true" />
+                  Vertrag anlegen
+                </Link>
+              </Button>
+            )
+          }
+        />
+      ) : (
+        <Card>
+          <CardHeader>
+            <CardTitle>Alle Verträge</CardTitle>
+            <CardDescription>
+              Jahresbeitrag der aktiven Verträge zusammen:{' '}
+              <strong className="text-foreground">
+                {formatCent(centZuZahl(jahresbeitragSumme))}
+              </strong>
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>Vertrag</TableHead>
+                  <TableHead>Art</TableHead>
+                  <TableHead className="text-right">Beitrag</TableHead>
+                  <TableHead className="text-right">Rückkaufswert</TableHead>
+                  <TableHead>Kündigung</TableHead>
+                  <TableHead>Sozialamt</TableHead>
+                  <TableHead>Status</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {zeilen.map((zeile) => (
+                  <TableRow key={zeile.id}>
+                    <TableCell>
+                      <Link
+                        href={`/vertraege/${zeile.id}`}
+                        className="font-medium hover:underline"
+                      >
+                        {zeile.bezeichnung}
+                      </Link>
+                      <span className="block text-sm text-muted-foreground">
+                        {[zeile.gesellschaft, zeile.vertragsnummer].filter(Boolean).join(' · ') ||
+                          'Gesellschaft nicht erfasst'}
+                      </span>
+                    </TableCell>
+                    <TableCell className="text-sm">
+                      {VERTRAG_ART_BESCHRIFTUNG[zeile.art]}
+                    </TableCell>
+                    <TableCell className="text-right tabular-nums">
+                      {formatCent(zeile.beitragCent)}
+                      {zeile.rhythmus && (
+                        <span className="block text-xs text-muted-foreground">
+                          {RHYTHMUS_BESCHRIFTUNG[zeile.rhythmus]}
+                        </span>
+                      )}
+                    </TableCell>
+                    <TableCell className="text-right tabular-nums">
+                      {formatCent(zeile.rueckkaufswertCent)}
+                      {zeile.rueckkaufswertStichtag && (
+                        <span className="block text-xs text-muted-foreground">
+                          {formatDatum(zeile.rueckkaufswertStichtag)}
+                        </span>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      {zeile.ampel ? (
+                        <Badge variant={zeile.ampel.variante}>{zeile.ampel.text}</Badge>
+                      ) : (
+                        <span className="text-sm text-muted-foreground">nicht berechenbar</span>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <Badge variant={BEWERTUNG_VARIANTE[zeile.bewertung]}>
+                        {BEWERTUNG_BESCHRIFTUNG[zeile.bewertung]}
+                      </Badge>
+                    </TableCell>
+                    <TableCell className="text-sm">
+                      {VERTRAG_STATUS_BESCHRIFTUNG[zeile.status]}
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </CardContent>
+        </Card>
+      )}
+
+      <Rechtshinweis rechtsgrundlage="§ 90 SGB XII, § 1850 BGB" />
+      <p className="text-sm text-muted-foreground">
+        Kurz übersetzt: Ob ein Vertrag vor der Sozialhilfe einzusetzen ist, richtet sich nach
+        § 90 SGB XII — eine angemessene Bestattungsvorsorge bleibt regelmäßig geschützt. Und
+        bevor eine Lebens- oder Rentenversicherung verwertet wird, gehört die Frage nach der
+        Genehmigung des Betreuungsgerichts (§ 1850 BGB) an den Rechtspfleger, nicht an diese App.
+      </p>
+    </div>
+  )
+}

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,379 +1,387 @@
-import { notFound } from 'next/navigation'
-import Link from 'next/link'
-import { ArrowLeft, Clock } from 'lucide-react'
-import type { VorgangStatus } from '@prisma/client'
-import { Badge } from '@/components/ui/badge'
-import { Button } from '@/components/ui/button'
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
-import { SeitenKopf } from '@/components/seiten-kopf'
-import { AufgabenListe, type AufgabenZeile } from '@/components/vorgaenge/aufgaben-liste'
-import { Faelligkeit } from '@/components/vorgaenge/faelligkeit'
-import { GenehmigungAnlegen } from '@/components/vorgaenge/genehmigung-anlegen'
-import {
-  GenehmigungsKette,
-  type GenehmigungsAnzeige,
-} from '@/components/vorgaenge/genehmigungs-kette'
-import { SachstandsanfrageKnopf } from '@/components/vorgaenge/sachstandsanfrage-knopf'
-import { StatusWechsler } from '@/components/vorgaenge/status-wechsler'
-import { VorgangLoeschen } from '@/components/vorgaenge/vorgang-loeschen'
-import { VorgangsFormular } from '@/components/vorgaenge/vorgangs-formular'
-import { ZeitstrahlAnzeige } from '@/components/vorgaenge/zeitstrahl-anzeige'
-import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
-import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
-import { entschluesselnWennMoeglich, oeffnen } from '@/lib/crypto/feld'
-import { KATEGORIE_BESCHRIFTUNG, PRIORITAET_BESCHRIFTUNG } from '@/lib/validierung/vorgaenge'
-import { sachstandsanfrageErzeugen } from '@/lib/vorgaenge/sachstandsanfrage'
-import {
-  VORGANG_STATUS_BESCHRIFTUNG,
-  zeitstrahlBauen,
-  type ZeitstrahlStatuswechsel,
-} from '@/lib/vorgaenge/zeitstrahl'
-import { formatDatum } from '@/lib/utils'
-
-/**
- * Die Fallakte.
- *
- * Kopf mit Status, Gegenstelle, Aktenzeichen und dem nächsten Handgriff;
- * darunter die Aufgabenliste, das Genehmigungsverfahren und der
- * Zeitstrahl, der alles zusammenführt, was in dieser Sache passiert ist.
- */
-export default async function VorgangSeite({ params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const benutzer = await erfordereBenutzer(`/vorgaenge/${id}`)
-  const aktive = await aktiveBetreute(benutzer)
-  if (!aktive) notFound()
-
-  const vorgang = await db.vorgang.findFirst({
-    where: { id, betreuteId: aktive.id, ...nichtGeloescht },
-    include: {
-      aufgaben: { orderBy: [{ reihenfolge: 'asc' }, { erstelltAm: 'asc' }] },
-      genehmigungen: {
-        where: nichtGeloescht,
-        include: { beschlussDokument: { select: { id: true, titel: true } } },
-        orderBy: { erstelltAm: 'asc' },
-      },
-      fristen: { where: nichtGeloescht, orderBy: { datum: 'asc' } },
-      buchungen: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
-      kontaktprotokolle: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
-      verknuepfungen: { include: { dokument: true } },
-    },
-  })
-  if (!vorgang) notFound()
-
-  const { darfSchreiben } = await erfordereZugang(aktive.id, 'VORGAENGE', 'lesen')
-  const schreiben = darfSchreiben('VORGAENGE')
-
-  const offen = oeffnen('Vorgang', vorgang)
-
-  // --- Statuswechsel aus dem Audit-Log --------------------------------------
-  // Das Log ist ohnehin der Nachweis gegenueber dem Gericht; daraus die
-  // Statuschronik zu lesen, spart eine zusaetzliche Tabelle.
-  const protokolle = await db.auditLog.findMany({
-    where: { entitaet: 'Vorgang', entitaetId: vorgang.id, aktion: 'GEAENDERT' },
-    orderBy: { zeitpunkt: 'asc' },
-    take: 200,
-  })
-
-  const statuswechsel: ZeitstrahlStatuswechsel[] = []
-  for (const eintrag of protokolle) {
-    const roh = entschluesselnWennMoeglich(
-      eintrag.aenderungVerschluesselt,
-      'aenderungVerschluesselt',
-    )
-    if (!roh) continue
-    try {
-      const gelesen = JSON.parse(roh) as Record<string, { alt: unknown; neu: unknown }>
-      const status = gelesen.status
-      if (!status || typeof status.neu !== 'string') continue
-      statuswechsel.push({
-        id: eintrag.id,
-        zeitpunkt: eintrag.zeitpunkt,
-        von: typeof status.alt === 'string' ? (status.alt as VorgangStatus) : null,
-        nach: status.neu as VorgangStatus,
-        wer: eintrag.userName,
-      })
-    } catch {
-      // Ein unlesbarer Protokolleintrag darf die Akte nicht blockieren.
-      continue
-    }
-  }
-
-  // --- Zeitstrahl -----------------------------------------------------------
-  const zeitstrahl = zeitstrahlBauen({
-    vorgang: {
-      titel: vorgang.titel,
-      erstelltAm: vorgang.erstelltAm,
-      erledigtAm: vorgang.erledigtAm,
-    },
-    dokumente: vorgang.verknuepfungen
-      .map((v) => v.dokument)
-      .filter((d) => d.geloeschtAm === null)
-      .map((d) => ({
-        id: d.id,
-        titel: d.titel,
-        eingangAm: d.eingangAm,
-        versandAm: d.versandAm,
-        erstelltAm: d.erstelltAm,
-        absender: d.absender,
-        empfaenger: d.empfaenger,
-      })),
-    kontaktprotokolle: vorgang.kontaktprotokolle.map((p) => {
-      const klar = oeffnen('Kontaktprotokoll', p)
-      return {
-        id: p.id,
-        datum: p.datum,
-        art: p.art,
-        gespraechspartner: p.gespraechspartner,
-        mitBetreuter: p.mitBetreuter,
-        inhalt: klar.inhalt ?? null,
-      }
-    }),
-    fristen: vorgang.fristen.map((f) => ({
-      id: f.id,
-      titel: f.titel,
-      datum: f.datum,
-      erledigtAm: f.erledigtAm,
-      ausschlussfrist: f.ausschlussfrist,
-      rechtsgrundlage: f.rechtsgrundlage,
-    })),
-    buchungen: vorgang.buchungen.map((b) => {
-      const klar = oeffnen('Buchung', b)
-      return {
-        id: b.id,
-        datum: b.datum,
-        betragCent: centZuZahl(b.betragCent) ?? 0,
-        richtung: b.richtung,
-        gegenstelle: b.gegenstelle,
-        verwendungszweck: klar.verwendungszweck ?? null,
-      }
-    }),
-    genehmigungen: vorgang.genehmigungen.map((g) => ({
-      id: g.id,
-      titel: g.titel,
-      rechtsgrundlage: g.rechtsgrundlage,
-      status: g.status,
-      mitteilungAm: g.mitteilungAm,
-      antragAm: g.antragAm,
-      anhoerungAm: g.anhoerungAm,
-      beschlussAm: g.beschlussAm,
-      rechtskraftAm: g.rechtskraftAm,
-      vollzugAm: g.vollzugAm,
-    })),
-    statuswechsel,
-  })
-
-  // --- Sachstandsanfrage ----------------------------------------------------
-  // Nur, wenn tatsaechlich auf jemanden gewartet wird - sonst waere der
-  // Knopf nur Zierde.
-  const wartetAufDritte = vorgang.status === 'WARTET_AUF_DRITTE'
-  const anfrage = wartetAufDritte
-    ? sachstandsanfrageErzeugen({
-        vorgangTitel: vorgang.titel,
-        gegenstelle: vorgang.gegenstelle,
-        aktenzeichen: vorgang.aktenzeichen,
-        letzterKontaktAm: vorgang.letzterKontaktAm,
-        betreute: {
-          vorname: aktive.vorname,
-          nachname: aktive.nachname,
-          geburtsdatum: aktive.geburtsdatum,
-        },
-        betreuer: {
-          name: benutzer.name,
-          aktenzeichenGericht: aktive.aktenzeichenGericht,
-          betreuungsgericht: aktive.betreuungsgericht,
-        },
-      })
-    : null
-
-  // Dokumente der betreuten Person - Auswahl fuer das Beschlussdokument.
-  const dokumente = vorgang.genehmigungen.length
-    ? await db.dokument.findMany({
-        where: { betreuteId: aktive.id, ...nichtGeloescht },
-        select: { id: true, titel: true },
-        orderBy: { erstelltAm: 'desc' },
-        take: 100,
-      })
-    : []
-
-  const aufgaben: AufgabenZeile[] = vorgang.aufgaben.map((a) => ({
-    id: a.id,
-    titel: a.titel,
-    beschreibung: a.beschreibung,
-    erledigt: a.erledigt,
-    faelligAm: a.faelligAm,
-  }))
-
-  const genehmigungen: GenehmigungsAnzeige[] = vorgang.genehmigungen.map((g) => ({
-    id: g.id,
-    titel: g.titel,
-    rechtsgrundlage: g.rechtsgrundlage,
-    status: g.status,
-    mitteilungAm: g.mitteilungAm,
-    antragAm: g.antragAm,
-    anhoerungAm: g.anhoerungAm,
-    beschlussAm: g.beschlussAm,
-    rechtskraftAm: g.rechtskraftAm,
-    vollzugAm: g.vollzugAm,
-    beschlussDokumentId: g.beschlussDokumentId,
-    beschlussDokumentTitel: g.beschlussDokument?.titel ?? null,
-    dokumente,
-  }))
-
-  return (
-    <div className="space-y-8">
-      <SeitenKopf
-        titel={vorgang.titel}
-        beschreibung={offen.beschreibung ?? undefined}
-        pfad={[
-          { titel: 'Start', href: '/heute' },
-          { titel: 'Vorgänge', href: '/vorgaenge' },
-          { titel: vorgang.titel },
-        ]}
-        aktionen={
-          <>
-            <Button variant="ghost" asChild>
-              <Link href="/vorgaenge">
-                <ArrowLeft aria-hidden="true" />
-                Zurück
-              </Link>
-            </Button>
-            {anfrage && (
-              <SachstandsanfrageKnopf
-                vorgangId={vorgang.id}
-                betreff={anfrage.betreff}
-                text={anfrage.text}
-                darfSchreiben={schreiben}
-              />
-            )}
-            {schreiben && <VorgangLoeschen vorgangId={vorgang.id} titel={vorgang.titel} />}
-          </>
-        }
-      />
-
-      {/* --- Kopf der Akte ---------------------------------------------- */}
-      <Card>
-        <CardContent className="grid gap-5 p-5 sm:grid-cols-2 lg:grid-cols-3">
-          <div className="space-y-1">
-            <p className="text-sm text-muted-foreground">Status</p>
-            <p className="font-medium">{VORGANG_STATUS_BESCHRIFTUNG[vorgang.status]}</p>
-            {schreiben && (
-              <StatusWechsler vorgangId={vorgang.id} status={vorgang.status} klein />
-            )}
-          </div>
-
-          <div className="space-y-1">
-            <p className="text-sm text-muted-foreground">Gegenstelle</p>
-            <p className="font-medium">{vorgang.gegenstelle ?? '–'}</p>
-            {vorgang.letzterKontaktAm && (
-              <p className="flex items-center gap-1.5 text-sm text-muted-foreground">
-                <Clock className="size-3.5" aria-hidden="true" />
-                Letzter Kontakt: {formatDatum(vorgang.letzterKontaktAm)}
-              </p>
-            )}
-          </div>
-
-          <div className="space-y-1">
-            <p className="text-sm text-muted-foreground">Aktenzeichen</p>
-            <p className="font-medium">{vorgang.aktenzeichen ?? '–'}</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">
-              {vorgang.naechsterSchritt ?? 'Kein offener Handgriff notiert.'}
-            </p>
-          </div>
-
-          <div className="space-y-2">
-            <p className="text-sm text-muted-foreground">Einordnung</p>
-            <div className="flex flex-wrap gap-2">
-              <Badge variant="outline">{KATEGORIE_BESCHRIFTUNG[vorgang.kategorie]}</Badge>
-              <Badge variant="secondary">
-                {PRIORITAET_BESCHRIFTUNG[vorgang.prioritaet] ?? 'Normal'}
-              </Badge>
-              <Faelligkeit datum={vorgang.faelligAm} />
-            </div>
-          </div>
-        </CardContent>
-      </Card>
-
-      {/* --- Aufgaben ----------------------------------------------------- */}
-      <section aria-labelledby="aufgaben" className="space-y-4">
-        <h2 id="aufgaben" className="text-xl font-semibold">
-          Aufgaben
-        </h2>
-        <AufgabenListe
-          vorgangId={vorgang.id}
-          aufgaben={aufgaben}
-          darfSchreiben={schreiben}
-        />
-      </section>
-
-      {/* --- Genehmigungen ------------------------------------------------ */}
-      {(vorgang.genehmigungspflichtig || genehmigungen.length > 0) && (
-        <section aria-labelledby="genehmigungen" className="space-y-6">
-          <h2 id="genehmigungen" className="text-xl font-semibold">
-            Genehmigung des Betreuungsgerichts
-          </h2>
-
-          {genehmigungen.map((genehmigung) => (
-            <GenehmigungsKette
-              key={genehmigung.id}
-              genehmigung={genehmigung}
-              darfSchreiben={schreiben}
-            />
-          ))}
-
-          {schreiben && genehmigungen.length === 0 && (
-            <GenehmigungAnlegen vorgangId={vorgang.id} />
-          )}
-        </section>
-      )}
-
-      {/* --- Zeitstrahl --------------------------------------------------- */}
-      <section aria-labelledby="zeitstrahl" className="space-y-4">
-        <h2 id="zeitstrahl" className="text-xl font-semibold">
-          Zeitstrahl
-        </h2>
-        <p className="text-sm text-muted-foreground">
-          Dokumente, Gespräche, Fristen, Zahlungen und Statuswechsel in einer Spalte - neueste
-          zuerst.
-        </p>
-        <ZeitstrahlAnzeige eintraege={zeitstrahl} />
-      </section>
-
-      {/* --- Bearbeiten --------------------------------------------------- */}
-      {schreiben && (
-        <section aria-labelledby="bearbeiten" className="space-y-4">
-          <Card>
-            <CardHeader>
-              <CardTitle id="bearbeiten">Angaben bearbeiten</CardTitle>
-            </CardHeader>
-            <CardContent>
-              <VorgangsFormular
-                modus="aendern"
-                betreuteId={aktive.id}
-                vorgangId={vorgang.id}
-                abbrechenHref={`/vorgaenge/${vorgang.id}`}
-                werte={{
-                  titel: vorgang.titel,
-                  kategorie: vorgang.kategorie,
-                  status: vorgang.status,
-                  prioritaet: vorgang.prioritaet,
-                  beschreibung: offen.beschreibung ?? null,
-                  gegenstelle: vorgang.gegenstelle,
-                  aktenzeichen: vorgang.aktenzeichen,
-                  verantwortlich: vorgang.verantwortlich,
-                  naechsterSchritt: vorgang.naechsterSchritt,
-                  faelligAm: vorgang.faelligAm,
-                  letzterKontaktAm: vorgang.letzterKontaktAm,
-                  genehmigungspflichtig: vorgang.genehmigungspflichtig,
-                }}
-              />
-            </CardContent>
-          </Card>
-        </section>
-      )}
-    </div>
-  )
-}
+import { notFound } from 'next/navigation'
+import Link from 'next/link'
+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'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import { SeitenKopf } from '@/components/seiten-kopf'
+import { AufgabenListe, type AufgabenZeile } from '@/components/vorgaenge/aufgaben-liste'
+import { Faelligkeit } from '@/components/vorgaenge/faelligkeit'
+import { GenehmigungAnlegen } from '@/components/vorgaenge/genehmigung-anlegen'
+import {
+  GenehmigungsKette,
+  type GenehmigungsAnzeige,
+} from '@/components/vorgaenge/genehmigungs-kette'
+import { SachstandsanfrageKnopf } from '@/components/vorgaenge/sachstandsanfrage-knopf'
+import { StatusWechsler } from '@/components/vorgaenge/status-wechsler'
+import { VorgangLoeschen } from '@/components/vorgaenge/vorgang-loeschen'
+import { VorgangsFormular } from '@/components/vorgaenge/vorgangs-formular'
+import { ZeitstrahlAnzeige } from '@/components/vorgaenge/zeitstrahl-anzeige'
+import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
+import { entschluesselnWennMoeglich, oeffnen } from '@/lib/crypto/feld'
+import { KATEGORIE_BESCHRIFTUNG, PRIORITAET_BESCHRIFTUNG } from '@/lib/validierung/vorgaenge'
+import { sachstandsanfrageErzeugen } from '@/lib/vorgaenge/sachstandsanfrage'
+import {
+  VORGANG_STATUS_BESCHRIFTUNG,
+  zeitstrahlBauen,
+  type ZeitstrahlStatuswechsel,
+} from '@/lib/vorgaenge/zeitstrahl'
+import { formatDatum } from '@/lib/utils'
+
+/**
+ * Die Fallakte.
+ *
+ * Kopf mit Status, Gegenstelle, Aktenzeichen und dem nächsten Handgriff;
+ * darunter die Aufgabenliste, das Genehmigungsverfahren und der
+ * Zeitstrahl, der alles zusammenführt, was in dieser Sache passiert ist.
+ */
+export default async function VorgangSeite({ params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const benutzer = await erfordereBenutzer(`/vorgaenge/${id}`)
+  const aktive = await aktiveBetreute(benutzer)
+  if (!aktive) notFound()
+
+  const vorgang = await db.vorgang.findFirst({
+    where: { id, betreuteId: aktive.id, ...nichtGeloescht },
+    include: {
+      aufgaben: { orderBy: [{ reihenfolge: 'asc' }, { erstelltAm: 'asc' }] },
+      genehmigungen: {
+        where: nichtGeloescht,
+        include: { beschlussDokument: { select: { id: true, titel: true } } },
+        orderBy: { erstelltAm: 'asc' },
+      },
+      fristen: { where: nichtGeloescht, orderBy: { datum: 'asc' } },
+      buchungen: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
+      kontaktprotokolle: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
+      verknuepfungen: { include: { dokument: true } },
+    },
+  })
+  if (!vorgang) notFound()
+
+  const { darfSchreiben } = await erfordereZugang(aktive.id, 'VORGAENGE', 'lesen')
+  const schreiben = darfSchreiben('VORGAENGE')
+
+  const offen = oeffnen('Vorgang', vorgang)
+
+  // --- Statuswechsel aus dem Audit-Log --------------------------------------
+  // Das Log ist ohnehin der Nachweis gegenueber dem Gericht; daraus die
+  // Statuschronik zu lesen, spart eine zusaetzliche Tabelle.
+  const protokolle = await db.auditLog.findMany({
+    where: { entitaet: 'Vorgang', entitaetId: vorgang.id, aktion: 'GEAENDERT' },
+    orderBy: { zeitpunkt: 'asc' },
+    take: 200,
+  })
+
+  const statuswechsel: ZeitstrahlStatuswechsel[] = []
+  for (const eintrag of protokolle) {
+    const roh = entschluesselnWennMoeglich(
+      eintrag.aenderungVerschluesselt,
+      'aenderungVerschluesselt',
+    )
+    if (!roh) continue
+    try {
+      const gelesen = JSON.parse(roh) as Record<string, { alt: unknown; neu: unknown }>
+      const status = gelesen.status
+      if (!status || typeof status.neu !== 'string') continue
+      statuswechsel.push({
+        id: eintrag.id,
+        zeitpunkt: eintrag.zeitpunkt,
+        von: typeof status.alt === 'string' ? (status.alt as VorgangStatus) : null,
+        nach: status.neu as VorgangStatus,
+        wer: eintrag.userName,
+      })
+    } catch {
+      // Ein unlesbarer Protokolleintrag darf die Akte nicht blockieren.
+      continue
+    }
+  }
+
+  // --- Zeitstrahl -----------------------------------------------------------
+  const zeitstrahl = zeitstrahlBauen({
+    vorgang: {
+      titel: vorgang.titel,
+      erstelltAm: vorgang.erstelltAm,
+      erledigtAm: vorgang.erledigtAm,
+    },
+    dokumente: vorgang.verknuepfungen
+      .map((v) => v.dokument)
+      .filter((d) => d.geloeschtAm === null)
+      .map((d) => ({
+        id: d.id,
+        titel: d.titel,
+        eingangAm: d.eingangAm,
+        versandAm: d.versandAm,
+        erstelltAm: d.erstelltAm,
+        absender: d.absender,
+        empfaenger: d.empfaenger,
+      })),
+    kontaktprotokolle: vorgang.kontaktprotokolle.map((p) => {
+      const klar = oeffnen('Kontaktprotokoll', p)
+      return {
+        id: p.id,
+        datum: p.datum,
+        art: p.art,
+        gespraechspartner: p.gespraechspartner,
+        mitBetreuter: p.mitBetreuter,
+        inhalt: klar.inhalt ?? null,
+      }
+    }),
+    fristen: vorgang.fristen.map((f) => ({
+      id: f.id,
+      titel: f.titel,
+      datum: f.datum,
+      erledigtAm: f.erledigtAm,
+      ausschlussfrist: f.ausschlussfrist,
+      rechtsgrundlage: f.rechtsgrundlage,
+    })),
+    buchungen: vorgang.buchungen.map((b) => {
+      const klar = oeffnen('Buchung', b)
+      return {
+        id: b.id,
+        datum: b.datum,
+        betragCent: centZuZahl(b.betragCent) ?? 0,
+        richtung: b.richtung,
+        gegenstelle: b.gegenstelle,
+        verwendungszweck: klar.verwendungszweck ?? null,
+      }
+    }),
+    genehmigungen: vorgang.genehmigungen.map((g) => ({
+      id: g.id,
+      titel: g.titel,
+      rechtsgrundlage: g.rechtsgrundlage,
+      status: g.status,
+      mitteilungAm: g.mitteilungAm,
+      antragAm: g.antragAm,
+      anhoerungAm: g.anhoerungAm,
+      beschlussAm: g.beschlussAm,
+      rechtskraftAm: g.rechtskraftAm,
+      vollzugAm: g.vollzugAm,
+    })),
+    statuswechsel,
+  })
+
+  // --- Sachstandsanfrage ----------------------------------------------------
+  // Nur, wenn tatsaechlich auf jemanden gewartet wird - sonst waere der
+  // Knopf nur Zierde.
+  const wartetAufDritte = vorgang.status === 'WARTET_AUF_DRITTE'
+  const anfrage = wartetAufDritte
+    ? sachstandsanfrageErzeugen({
+        vorgangTitel: vorgang.titel,
+        gegenstelle: vorgang.gegenstelle,
+        aktenzeichen: vorgang.aktenzeichen,
+        letzterKontaktAm: vorgang.letzterKontaktAm,
+        betreute: {
+          vorname: aktive.vorname,
+          nachname: aktive.nachname,
+          geburtsdatum: aktive.geburtsdatum,
+        },
+        betreuer: {
+          name: benutzer.name,
+          aktenzeichenGericht: aktive.aktenzeichenGericht,
+          betreuungsgericht: aktive.betreuungsgericht,
+        },
+      })
+    : null
+
+  // Dokumente der betreuten Person - Auswahl fuer das Beschlussdokument.
+  const dokumente = vorgang.genehmigungen.length
+    ? await db.dokument.findMany({
+        where: { betreuteId: aktive.id, ...nichtGeloescht },
+        select: { id: true, titel: true },
+        orderBy: { erstelltAm: 'desc' },
+        take: 100,
+      })
+    : []
+
+  const aufgaben: AufgabenZeile[] = vorgang.aufgaben.map((a) => ({
+    id: a.id,
+    titel: a.titel,
+    beschreibung: a.beschreibung,
+    erledigt: a.erledigt,
+    faelligAm: a.faelligAm,
+  }))
+
+  const genehmigungen: GenehmigungsAnzeige[] = vorgang.genehmigungen.map((g) => ({
+    id: g.id,
+    titel: g.titel,
+    rechtsgrundlage: g.rechtsgrundlage,
+    status: g.status,
+    mitteilungAm: g.mitteilungAm,
+    antragAm: g.antragAm,
+    anhoerungAm: g.anhoerungAm,
+    beschlussAm: g.beschlussAm,
+    rechtskraftAm: g.rechtskraftAm,
+    vollzugAm: g.vollzugAm,
+    beschlussDokumentId: g.beschlussDokumentId,
+    beschlussDokumentTitel: g.beschlussDokument?.titel ?? null,
+    dokumente,
+  }))
+
+  return (
+    <div className="space-y-8">
+      <SeitenKopf
+        titel={vorgang.titel}
+        beschreibung={offen.beschreibung ?? undefined}
+        pfad={[
+          { titel: 'Start', href: '/heute' },
+          { titel: 'Vorgänge', href: '/vorgaenge' },
+          { titel: vorgang.titel },
+        ]}
+        aktionen={
+          <>
+            <Button variant="ghost" asChild>
+              <Link href="/vorgaenge">
+                <ArrowLeft aria-hidden="true" />
+                Zurück
+              </Link>
+            </Button>
+            {anfrage && (
+              <SachstandsanfrageKnopf
+                vorgangId={vorgang.id}
+                betreff={anfrage.betreff}
+                text={anfrage.text}
+                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} />}
+          </>
+        }
+      />
+
+      {/* --- Kopf der Akte ---------------------------------------------- */}
+      <Card>
+        <CardContent className="grid gap-5 p-5 sm:grid-cols-2 lg:grid-cols-3">
+          <div className="space-y-1">
+            <p className="text-sm text-muted-foreground">Status</p>
+            <p className="font-medium">{VORGANG_STATUS_BESCHRIFTUNG[vorgang.status]}</p>
+            {schreiben && (
+              <StatusWechsler vorgangId={vorgang.id} status={vorgang.status} klein />
+            )}
+          </div>
+
+          <div className="space-y-1">
+            <p className="text-sm text-muted-foreground">Gegenstelle</p>
+            <p className="font-medium">{vorgang.gegenstelle ?? '–'}</p>
+            {vorgang.letzterKontaktAm && (
+              <p className="flex items-center gap-1.5 text-sm text-muted-foreground">
+                <Clock className="size-3.5" aria-hidden="true" />
+                Letzter Kontakt: {formatDatum(vorgang.letzterKontaktAm)}
+              </p>
+            )}
+          </div>
+
+          <div className="space-y-1">
+            <p className="text-sm text-muted-foreground">Aktenzeichen</p>
+            <p className="font-medium">{vorgang.aktenzeichen ?? '–'}</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">
+              {vorgang.naechsterSchritt ?? 'Kein offener Handgriff notiert.'}
+            </p>
+          </div>
+
+          <div className="space-y-2">
+            <p className="text-sm text-muted-foreground">Einordnung</p>
+            <div className="flex flex-wrap gap-2">
+              <Badge variant="outline">{KATEGORIE_BESCHRIFTUNG[vorgang.kategorie]}</Badge>
+              <Badge variant="secondary">
+                {PRIORITAET_BESCHRIFTUNG[vorgang.prioritaet] ?? 'Normal'}
+              </Badge>
+              <Faelligkeit datum={vorgang.faelligAm} />
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+
+      {/* --- Aufgaben ----------------------------------------------------- */}
+      <section aria-labelledby="aufgaben" className="space-y-4">
+        <h2 id="aufgaben" className="text-xl font-semibold">
+          Aufgaben
+        </h2>
+        <AufgabenListe
+          vorgangId={vorgang.id}
+          aufgaben={aufgaben}
+          darfSchreiben={schreiben}
+        />
+      </section>
+
+      {/* --- Genehmigungen ------------------------------------------------ */}
+      {(vorgang.genehmigungspflichtig || genehmigungen.length > 0) && (
+        <section aria-labelledby="genehmigungen" className="space-y-6">
+          <h2 id="genehmigungen" className="text-xl font-semibold">
+            Genehmigung des Betreuungsgerichts
+          </h2>
+
+          {genehmigungen.map((genehmigung) => (
+            <GenehmigungsKette
+              key={genehmigung.id}
+              genehmigung={genehmigung}
+              darfSchreiben={schreiben}
+            />
+          ))}
+
+          {schreiben && genehmigungen.length === 0 && (
+            <GenehmigungAnlegen vorgangId={vorgang.id} />
+          )}
+        </section>
+      )}
+
+      {/* --- Zeitstrahl --------------------------------------------------- */}
+      <section aria-labelledby="zeitstrahl" className="space-y-4">
+        <h2 id="zeitstrahl" className="text-xl font-semibold">
+          Zeitstrahl
+        </h2>
+        <p className="text-sm text-muted-foreground">
+          Dokumente, Gespräche, Fristen, Zahlungen und Statuswechsel in einer Spalte - neueste
+          zuerst.
+        </p>
+        <ZeitstrahlAnzeige eintraege={zeitstrahl} />
+      </section>
+
+      {/* --- Bearbeiten --------------------------------------------------- */}
+      {schreiben && (
+        <section aria-labelledby="bearbeiten" className="space-y-4">
+          <Card>
+            <CardHeader>
+              <CardTitle id="bearbeiten">Angaben bearbeiten</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <VorgangsFormular
+                modus="aendern"
+                betreuteId={aktive.id}
+                vorgangId={vorgang.id}
+                abbrechenHref={`/vorgaenge/${vorgang.id}`}
+                werte={{
+                  titel: vorgang.titel,
+                  kategorie: vorgang.kategorie,
+                  status: vorgang.status,
+                  prioritaet: vorgang.prioritaet,
+                  beschreibung: offen.beschreibung ?? null,
+                  gegenstelle: vorgang.gegenstelle,
+                  aktenzeichen: vorgang.aktenzeichen,
+                  verantwortlich: vorgang.verantwortlich,
+                  naechsterSchritt: vorgang.naechsterSchritt,
+                  faelligAm: vorgang.faelligAm,
+                  letzterKontaktAm: vorgang.letzterKontaktAm,
+                  genehmigungspflichtig: vorgang.genehmigungspflichtig,
+                }}
+              />
+            </CardContent>
+          </Card>
+        </section>
+      )}
+    </div>
+  )
+}

src/components/app-huelle.tsx

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

src/components/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/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/schreiben/schreiben-editor.tsx

@@ -0,0 +1,513 @@
+'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; 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('')
+  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/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,7 +1,8 @@
 '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 { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
@@ -149,6 +150,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/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: {
-      konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
-      beleg: { select: { id: true, titel: true } },
-    },
+    include: BUCHUNG_EINBEZUG,
     orderBy: [{ datum: 'asc' }, { erstelltAm: 'asc' }],
   })
 
-  return zeilen.map((zeile) => {
-    const offen = oeffnen('Buchung', zeile)
-    return {
-      id: zeile.id,
-      datum: zeile.datum,
-      betragCent: zeile.betragCent,
-      richtung: zeile.richtung,
-      kategorie: zeile.kategorie,
-      gegenstelle: zeile.gegenstelle,
-      verwendungszweck: offen.verwendungszweck,
-      kontoId: zeile.kontoId,
-      kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
-      belegId: zeile.belegId,
-      belegTitel: zeile.beleg?.titel ?? null,
-      belegFehltBegruendung: zeile.belegFehltBegruendung,
-      betrifftBetreute: zeile.betrifftBetreute,
-      vermoegenswirksam: zeile.vermoegenswirksam,
-      aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
-    }
-  })
+  return zeilen.map(zuBuchungEingabe)
 }
 
 /** 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/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/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)
-  return { gesamt, mitBeleg, begruendet, ohneNachweis, quoteProzent }
+    gesamt === 0 ? 100 : Math.round(((mitBeleg + durchVertrag + begruendet) / gesamt) * 100)
+  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/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/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}`
+}

src/lib/schreiben/docx.ts

@@ -0,0 +1,118 @@
+import 'server-only'
+import {
+  AlignmentType,
+  Document,
+  Packer,
+  Paragraph,
+  TextRun,
+  convertMillimetersToTwip,
+} from 'docx'
+
+/**
+ * Ein Brief als Word-Datei.
+ *
+ * Getrennt von src/lib/berichte/docx.ts, und das ist Absicht. Der dortige
+ * Satz baut einen BERICHT: Titel, Kopfzeilen mit betreuter Person,
+ * Aktenzeichen und Berichtszeitraum, am Ende ein Unterschriftenblock. Ein
+ * Brief braucht etwas anderes - Absender, Anschriftenfeld, Datumszeile
+ * rechts, Betreff, Anrede, Grussformel. Beides in eine Funktion zu zwingen
+ * haette beide Ausgaben schlechter gemacht.
+ *
+ * Warum ueberhaupt .docx und nicht nur PDF? Weil jeder Fall eine
+ * Besonderheit hat, die in den Brief gehoert. Wer das Schreiben vor dem
+ * Absenden noch anfassen will, braucht eine Datei, die sich anfassen
+ * laesst. Die Fassung fuer die Akte ist ein PDF - siehe
+ * src/lib/schreiben/pdf.tsx.
+ *
+ * Das Layout folgt DIN 5008 lose: Anschriftenfeld oben links, Datum
+ * rechts, Betreff fett. Nicht auf den Millimeter - der Brief geht in einen
+ * gewoehnlichen Umschlag, nicht in ein Fensterkuvert der Behoerde.
+ */
+
+const SCHRIFT = 'Arial'
+const GROESSE = 11
+
+/**
+ * Der Entwurfstext kommt als eine Zeichenkette mit Zeilenumbruechen.
+ *
+ * Er ist bereits vollstaendig gesetzt: Absender, Anschrift, Datum,
+ * Betreff, Anrede, Text, Gruss. Diese Funktion formatiert ihn nur - sie
+ * denkt sich nichts dazu und laesst nichts weg. Was der Benutzer im
+ * Browser gesehen hat, steht auch in der Datei.
+ */
+function absatz(
+  text: string,
+  optionen: { fett?: boolean; rechts?: boolean; abstandNach?: number } = {},
+): Paragraph {
+  return new Paragraph({
+    alignment: optionen.rechts ? AlignmentType.RIGHT : AlignmentType.LEFT,
+    spacing: { after: optionen.abstandNach ?? 0, line: 276 },
+    children: [
+      new TextRun({
+        text,
+        bold: optionen.fett ?? false,
+        size: GROESSE * 2, // docx rechnet in halben Punkten
+        font: SCHRIFT,
+      }),
+    ],
+  })
+}
+
+/**
+ * Erkennt die Betreffzeile, damit sie fett gesetzt werden kann.
+ *
+ * Die erzeugten Schreiben beginnen sie mit "Betreff:" - siehe
+ * betreffZeile() in src/lib/vertraege/anschreiben.ts. Steht dort einmal
+ * etwas anderes, wird die Zeile eben normal gesetzt; ein Brief mit
+ * unfettem Betreff ist immer noch ein brauchbarer Brief.
+ */
+function istBetreff(zeile: string): boolean {
+  return /^Betreff:/i.test(zeile.trim())
+}
+
+/**
+ * Die Datumszeile steht rechts, wie im deutschen Geschaeftsbrief.
+ * Erkennbar daran, dass sie mit einem Ort und Komma oder direkt mit einem
+ * Datum beginnt und sonst nichts enthaelt.
+ */
+function istDatumszeile(zeile: string): boolean {
+  return /^([A-Za-zÄÖÜäöüß .-]+,\s*)?\d{1,2}\.\d{1,2}\.\d{4}$/.test(zeile.trim())
+}
+
+export function briefAlsDocx(text: string): Document {
+  const zeilen = text.split('\n')
+
+  const inhalt: Paragraph[] = zeilen.map((zeile) => {
+    if (zeile.trim() === '') return absatz('', { abstandNach: 120 })
+    if (istBetreff(zeile)) return absatz(zeile, { fett: true, abstandNach: 120 })
+    if (istDatumszeile(zeile)) return absatz(zeile, { rechts: true })
+    return absatz(zeile)
+  })
+
+  return new Document({
+    creator: 'Betreuungs-Cockpit',
+    description: 'Schreiben aus der Betreuungsakte',
+    title: 'Schreiben',
+    sections: [
+      {
+        properties: {
+          page: {
+            margin: {
+              top: convertMillimetersToTwip(25),
+              right: convertMillimetersToTwip(20),
+              // Links etwas mehr: Da wird gelocht und abgeheftet.
+              left: convertMillimetersToTwip(25),
+              bottom: convertMillimetersToTwip(20),
+            },
+          },
+        },
+        children: inhalt,
+      },
+    ],
+  })
+}
+
+/** Fertige .docx-Datei als Buffer. */
+export async function briefDocxErzeugen(text: string): Promise<Buffer> {
+  return Packer.toBuffer(briefAlsDocx(text))
+}

src/lib/schreiben/email.ts

@@ -0,0 +1,137 @@
+/**
+ * Aus dem Brieftext eine E-Mail machen.
+ *
+ * Rein und ohne Datenbank, damit sich jede Regel einzeln testen laesst -
+ * und ohne "server-only", weil die mailto-Pruefung auch im Browser
+ * gebraucht wird.
+ *
+ * Der Kern ist emailFassung(): Sie nimmt den fertigen Brieftext und
+ * entfernt, was in einer E-Mail nichts verloren hat - Absenderblock,
+ * Anschriftenfeld, Datumszeile, Betreffzeile (der Betreff steht im
+ * Betrefffeld der Mail). Was bleibt, ist Anrede, Inhalt samt
+ * Bestellungsabsatz und Grussformel.
+ *
+ * Warum aus dem Brieftext ableiten statt getrennt erzeugen? Weil der
+ * Benutzer den Brief womoeglich schon bearbeitet hat. Eine getrennt
+ * erzeugte E-Mail wuerfe diese Aenderungen weg - und dann stuende im
+ * Brief etwas anderes als in der Mail, ohne dass es jemand merkt.
+ */
+
+/**
+ * Ab wann ist ein mailto-Link nicht mehr verlaesslich?
+ *
+ * mailto uebergibt den Text in der Adresszeile. Die Grenzen sind je nach
+ * Browser, Betriebssystem und Mailprogramm verschieden und nirgends
+ * zugesichert; ab etwa 2000 Zeichen wird es unzuverlaessig - unter
+ * Windows schneidet die Uebergabe an das Mailprogramm teils frueher ab.
+ *
+ * 1800 Zeichen NACH der URL-Kodierung lassen etwas Luft. Ein
+ * abgeschnittener Brief ist schlimmer als ein fehlender Knopf: Er faellt
+ * erst beim Empfaenger auf.
+ */
+export const MAILTO_HOECHSTLAENGE = 1800
+
+export type EmailFassung = {
+  betreff: string
+  text: string
+}
+
+/** Erkennt die Betreffzeile des Briefes. */
+function istBetreff(zeile: string): boolean {
+  return /^Betreff:/i.test(zeile.trim())
+}
+
+/** Erkennt die Datumszeile ("Ort, 23.08.2026" oder nur das Datum). */
+function istDatumszeile(zeile: string): boolean {
+  return /^([A-Za-zÄÖÜäöüß .-]+,\s*)?\d{1,2}\.\d{1,2}\.\d{4}$/.test(zeile.trim())
+}
+
+/** Erkennt den Beginn des eigentlichen Inhalts: die Anrede. */
+function istAnrede(zeile: string): boolean {
+  return /^Sehr geehrte/i.test(zeile.trim())
+}
+
+/**
+ * Leitet die E-Mail-Fassung aus dem Brieftext ab.
+ *
+ * Alles VOR der Anrede ist Briefkopf - Absender, Anschrift, Datum,
+ * Betreff - und faellt weg. Der Betreff wird dabei herausgelesen und
+ * getrennt zurueckgegeben; er gehoert ins Betrefffeld, nicht in den
+ * Rumpf.
+ *
+ * Findet sich keine Anrede (der Benutzer hat den Text frei umgebaut),
+ * wird NICHTS entfernt: Lieber ein Briefkopf zu viel in der Mail als
+ * stillschweigend verlorener Inhalt.
+ */
+export function emailFassung(brieftext: string, betreffVorgabe = ''): EmailFassung {
+  const zeilen = brieftext.split('\n')
+
+  let betreff = betreffVorgabe
+  const betreffZeile = zeilen.find(istBetreff)
+  if (betreffZeile) {
+    const roh = betreffZeile.replace(/^Betreff:\s*/i, '').trim()
+    if (roh) betreff = roh
+  }
+
+  const anredeIndex = zeilen.findIndex(istAnrede)
+  if (anredeIndex === -1) {
+    // Kein erkennbarer Aufbau - unveraendert lassen, nur den Betreff
+    // nicht doppelt fuehren.
+    const ohneBetreff = zeilen.filter((zeile) => !istBetreff(zeile))
+    return { betreff, text: bereinigen(ohneBetreff) }
+  }
+
+  // Ab der Anrede ist alles Inhalt. Datums- und Betreffzeilen davor sind
+  // damit automatisch draussen; zur Sicherheit filtern wir sie auch im
+  // Rumpf, falls der Text unueblich aufgebaut ist.
+  const rumpf = zeilen
+    .slice(anredeIndex)
+    .filter((zeile) => !istBetreff(zeile) && !istDatumszeile(zeile))
+
+  return { betreff, text: bereinigen(rumpf) }
+}
+
+/** Hoechstens eine Leerzeile am Stueck, keine am Anfang oder Ende. */
+function bereinigen(zeilen: string[]): string {
+  const ergebnis: string[] = []
+  for (const zeile of zeilen) {
+    if (zeile.trim() === '' && ergebnis[ergebnis.length - 1]?.trim() === '') continue
+    ergebnis.push(zeile.trimEnd())
+  }
+  while (ergebnis[0]?.trim() === '') ergebnis.shift()
+  while (ergebnis[ergebnis.length - 1]?.trim() === '') ergebnis.pop()
+  return ergebnis.join('\n')
+}
+
+/**
+ * Baut den mailto-Link - oder gibt null zurueck, wenn er zu lang wuerde.
+ *
+ * null heisst fuer die Oberflaeche: den Knopf gar nicht erst anbieten.
+ * Ein Knopf, der einen halben Brief uebergibt, waere schlimmer als
+ * keiner - der Verlust faellt erst beim Empfaenger auf.
+ */
+export function mailtoLink(
+  adresse: string,
+  fassung: EmailFassung,
+): string | null {
+  if (!adresse.trim()) return null
+
+  const link =
+    `mailto:${encodeURIComponent(adresse.trim())}` +
+    `?subject=${encodeURIComponent(fassung.betreff)}` +
+    `&body=${encodeURIComponent(fassung.text)}`
+
+  return link.length <= MAILTO_HOECHSTLAENGE ? link : null
+}
+
+/**
+ * Sehr grobe Formpruefung einer E-Mail-Adresse.
+ *
+ * Bewusst locker: Die Adresse kommt aus den eigenen Kontakten oder wird
+ * gleich im Mailprogramm sichtbar. Eine strenge Pruefung wuerde nur
+ * gueltige, aber ungewoehnliche Adressen abweisen.
+ */
+export function siehtAusWieEmail(wert: string | null | undefined): boolean {
+  if (!wert) return false
+  return /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(wert.trim())
+}

src/lib/schreiben/eml.ts

@@ -0,0 +1,95 @@
+import 'server-only'
+
+/**
+ * Eine .eml-Datei bauen - der E-Mail-Entwurf zum Oeffnen im Mailprogramm.
+ *
+ * Warum .eml zusaetzlich zu mailto? mailto uebergibt den Text in der
+ * Adresszeile, und deren Laenge ist nirgends zugesichert. Die Briefe hier
+ * sind lang (Bestellungsabsatz, sechs Auskunftspunkte) - eine .eml-Datei
+ * traegt den vollen Text garantiert, egal wie lang.
+ *
+ * Das Format ist RFC 5322: Kopfzeilen, Leerzeile, Rumpf. Die Kopfzeile
+ * "X-Unsent: 1" bittet das Mailprogramm, die Datei als ENTWURF zu oeffnen
+ * statt als empfangene Nachricht - Outlook und Thunderbird respektieren
+ * das. Ein Programm, das sie ignoriert, zeigt die Mail eben als Nachricht
+ * mit Antwort-Moeglichkeit; auch damit laesst sich arbeiten.
+ *
+ * Ohne Absenderadresse ("From"): Die traegt das Mailprogramm beim Senden
+ * selbst ein. Eine erfundene Adresse hier wuerde je nach Programm sogar
+ * uebernommen - und dann ginge die Mail mit falschem Absender hinaus.
+ */
+
+/**
+ * Kodiert Text als quoted-printable (RFC 2045).
+ *
+ * Noetig fuer die Umlaute: .eml ist ein Textformat mit ASCII-Erwartung.
+ * Base64 ginge auch, aber quoted-printable bleibt lesbar, wenn jemand die
+ * Datei im Editor oeffnet - und bei einem Schreiben in einer
+ * Betreuungssache ist Nachvollziehbarkeit ein Wert fuer sich.
+ */
+export function quotedPrintable(text: string): string {
+  const bytes = Buffer.from(text.replace(/\r?\n/g, '\r\n'), 'utf8')
+  let ergebnis = ''
+  let zeilenlaenge = 0
+
+  for (const byte of bytes) {
+    let stueck: string
+
+    if (byte === 0x0d || byte === 0x0a) {
+      // Zeilenumbruch unkodiert - er strukturiert die Mail.
+      ergebnis += String.fromCharCode(byte)
+      zeilenlaenge = 0
+      continue
+    }
+
+    const istDruckbar =
+      (byte >= 33 && byte <= 126 && byte !== 61) || byte === 32 || byte === 9
+    if (istDruckbar) {
+      stueck = String.fromCharCode(byte)
+    } else {
+      stueck = `=${byte.toString(16).toUpperCase().padStart(2, '0')}`
+    }
+
+    // RFC 2045: hoechstens 76 Zeichen je Zeile, weiche Umbrueche mit "=".
+    if (zeilenlaenge + stueck.length > 75) {
+      ergebnis += '=\r\n'
+      zeilenlaenge = 0
+    }
+    ergebnis += stueck
+    zeilenlaenge += stueck.length
+  }
+
+  return ergebnis
+}
+
+/**
+ * Kodiert eine Kopfzeile mit Umlauten (RFC 2047, "encoded word").
+ *
+ * "Betreff: Rückkaufswert" wuerde als rohe Kopfzeile von manchen
+ * Programmen verstuemmelt. ASCII-Betreffs bleiben unkodiert - lesbarer.
+ */
+export function kopfzeileKodieren(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  if (!/[^\x20-\x7E]/.test(text)) return text
+  return `=?UTF-8?B?${Buffer.from(text, 'utf8').toString('base64')}?=`
+}
+
+export type EmlEingabe = {
+  an: string
+  betreff: string
+  text: string
+}
+
+/** Baut die .eml-Datei als Buffer. */
+export function emlErzeugen(eingabe: EmlEingabe): Buffer {
+  const kopf = [
+    `To: ${kopfzeileKodieren(eingabe.an)}`,
+    `Subject: ${kopfzeileKodieren(eingabe.betreff)}`,
+    'X-Unsent: 1',
+    'MIME-Version: 1.0',
+    'Content-Type: text/plain; charset=UTF-8',
+    'Content-Transfer-Encoding: quoted-printable',
+  ].join('\r\n')
+
+  return Buffer.from(`${kopf}\r\n\r\n${quotedPrintable(eingabe.text)}\r\n`, 'utf8')
+}

src/lib/schreiben/entwurf.ts

@@ -0,0 +1,242 @@
+import 'server-only'
+import { db, nichtGeloescht } from '@/lib/db'
+import { oeffnen } from '@/lib/crypto/feld'
+import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
+import {
+  absenderBlock,
+  anschriftBlock,
+  betreffZeile,
+  bestellungsAbsatz,
+  datumsZeile,
+  grussformel,
+  type Briefkopf,
+  type Empfaenger,
+} from '@/lib/vertraege/anschreiben'
+import { rueckkaufswertAnschreiben } from '@/lib/vertraege/rueckkaufswert'
+import { kuendigungsassistent } from '@/lib/vertraege/kuendigungsassistent'
+import { sachstandsanfrageErzeugen } from '@/lib/vorgaenge/sachstandsanfrage'
+import { laufzeitAusVertrag } from '@/lib/vertraege/kuendigung'
+import { VERTRAG_ART_BESCHRIFTUNG } from '@/lib/vertraege/konstanten'
+import { heuteAlsTag } from '@/lib/fristen/datum'
+import { SCHREIBEN_EIGENSCHAFTEN, type SchreibenArt } from '@/lib/schreiben/arten'
+
+/**
+ * Baut den Entwurf eines Schreibens - Text, Betreff, Empfaenger.
+ *
+ * Hier laufen die vorhandenen Erzeuger zusammen (Rueckkaufswert,
+ * Kuendigung, Sachstandsanfrage). Sie bleiben unveraendert: Ihr Wortlaut
+ * ist getestet und in der Praxis erprobt, und ihn fuer eine neue
+ * Ausgabeform umzuschreiben waere ein Risiko ohne Gewinn.
+ *
+ * Was hier dazukommt, ist der vierte Fall: das freie Schreiben an eine
+ * Stelle, zu der es noch keinen Datensatz gibt. Am Anfang einer Betreuung
+ * ist das der Normalfall - man fragt ja gerade an, um zu erfahren, ob dort
+ * ueberhaupt etwas besteht.
+ */
+
+export type SchreibenEntwurf = {
+  art: SchreibenArt
+  betreff: string
+  /** Vollstaendiger Brieftext, bearbeitbar. */
+  text: string
+  empfaengerName: string
+  empfaengerAnschrift: string
+  /** Vorgeschlagenes Datum der Wiedervorlage, ISO-Tag oder leer. */
+  wiedervorlageAm: string
+  /** Woran haengt das Schreiben? */
+  vertragId: string | null
+  vorgangId: string | null
+  /** Was vor dem Abschicken zu klaeren ist - aus dem Kuendigungsassistenten. */
+  warnungen: string[]
+}
+
+function tagAlsIsoText(datum: Date): string {
+  return datum.toISOString().slice(0, 10)
+}
+
+function wiedervorlageVorschlag(art: SchreibenArt, heute: Date): string {
+  const tage = SCHREIBEN_EIGENSCHAFTEN[art].wiedervorlageTage
+  if (tage === null) return ''
+  const ziel = new Date(heute)
+  ziel.setUTCDate(ziel.getUTCDate() + tage)
+  return tagAlsIsoText(ziel)
+}
+
+/**
+ * Der Rumpf eines freien Schreibens.
+ *
+ * Bewusst kurz und mit sichtbaren Luecken in eckigen Klammern. Ein
+ * vorformulierter Text, der fast passt, wird abgeschickt, ohne gelesen zu
+ * werden; eine offensichtliche Luecke nicht.
+ *
+ * Der Bestellungsabsatz steht drin und nicht zur Wahl: Ohne den Nachweis
+ * der Vertretungsmacht kommt die Auskunft nicht, und das faellt erst nach
+ * vier Wochen auf.
+ */
+function freierEntwurf(kopf: Briefkopf, empfaenger: Empfaenger, heute: Date): string {
+  return [
+    absenderBlock(kopf),
+    '',
+    anschriftBlock(empfaenger),
+    '',
+    datumsZeile(kopf.betreuerOrt, heute),
+    '',
+    betreffZeile('[Betreff eintragen]', null, kopf.betreuteName, kopf.betreuteGeburtsdatum),
+    '',
+    'Sehr geehrte Damen und Herren,',
+    '',
+    bestellungsAbsatz(kopf),
+    '',
+    '[Hier steht dein Anliegen.]',
+    '',
+    'Für Rückfragen stehe ich gerne zur Verfügung.',
+    '',
+    grussformel(kopf.betreuerName),
+    '',
+    'Anlage: Kopie der Bestellungsurkunde',
+  ].join('\n')
+}
+
+/** Zieht die Betreffzeile aus einem fertigen Brieftext. */
+export function betreffAusText(text: string): string {
+  const zeile = text.split('\n').find((z) => /^Betreff:/i.test(z.trim()))
+  return zeile ? zeile.replace(/^Betreff:\s*/i, '').trim() : ''
+}
+
+export type EntwurfEingabe = {
+  betreuteId: string
+  benutzerName: string
+  art: SchreibenArt
+  vertragId?: string | null
+  vorgangId?: string | null
+  /** Fuer den Test ueberschreibbar. */
+  heute?: Date
+}
+
+export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEntwurf> {
+  const heute = eingabe.heute ?? heuteAlsTag()
+
+  const betreute = await db.betreute.findFirst({
+    where: { id: eingabe.betreuteId, ...nichtGeloescht },
+  })
+  if (!betreute) throw new Error('Die betreute Person gibt es nicht (mehr).')
+
+  const kopf = briefkopfBauen({
+    betreute: oeffnen('Betreute', betreute),
+    benutzer: { name: eingabe.benutzerName },
+  })
+
+  const gemeinsam = {
+    art: eingabe.art,
+    wiedervorlageAm: wiedervorlageVorschlag(eingabe.art, heute),
+    vertragId: eingabe.vertragId ?? null,
+    vorgangId: eingabe.vorgangId ?? null,
+    warnungen: [] as string[],
+  }
+
+  // --- Vertragsbezogene Schreiben -------------------------------------------
+  if (eingabe.art === 'RUECKKAUFSWERT' || eingabe.art === 'KUENDIGUNG') {
+    if (!eingabe.vertragId) throw new Error('Für dieses Schreiben fehlt der Vertrag.')
+
+    const vertrag = await db.vertrag.findFirst({
+      where: { id: eingabe.vertragId, betreuteId: eingabe.betreuteId, ...nichtGeloescht },
+    })
+    if (!vertrag) throw new Error('Diesen Vertrag gibt es nicht (mehr).')
+
+    const offen = oeffnen('Vertrag', vertrag)
+    const empfaenger: Empfaenger = { gesellschaft: vertrag.gesellschaft, anschrift: null }
+    const bezeichnung = `${VERTRAG_ART_BESCHRIFTUNG[vertrag.art]} — ${vertrag.bezeichnung}`
+
+    if (eingabe.art === 'RUECKKAUFSWERT') {
+      const text = rueckkaufswertAnschreiben({
+        kopf,
+        empfaenger,
+        vertragsbezeichnung: bezeichnung,
+        vertragsnummer: offen.vertragsnummer,
+        stichtag: heute,
+        heute,
+      })
+      return {
+        ...gemeinsam,
+        text,
+        betreff: betreffAusText(text),
+        empfaengerName: vertrag.gesellschaft ?? '',
+        empfaengerAnschrift: '',
+      }
+    }
+
+    const paket = kuendigungsassistent({
+      kopf,
+      empfaenger,
+      vertragsbezeichnung: bezeichnung,
+      vertragsnummer: offen.vertragsnummer,
+      art: vertrag.art,
+      laufzeit: {
+        beginnAm: vertrag.beginnAm,
+        endeAm: vertrag.endeAm,
+        laufzeitJahre: laufzeitAusVertrag(vertrag.beginnAm, vertrag.endeAm),
+        kuendigungsfristMonate: vertrag.kuendigungsfristMonate,
+      },
+      kuendigungZum: vertrag.kuendigungZum,
+      heute,
+    })
+
+    return {
+      ...gemeinsam,
+      text: paket.schreiben,
+      betreff: betreffAusText(paket.schreiben),
+      empfaengerName: vertrag.gesellschaft ?? '',
+      empfaengerAnschrift: '',
+      warnungen: paket.warnungen,
+    }
+  }
+
+  // --- Sachstandsanfrage zum Vorgang ----------------------------------------
+  if (eingabe.art === 'SACHSTAND') {
+    if (!eingabe.vorgangId) throw new Error('Für dieses Schreiben fehlt der Vorgang.')
+
+    const vorgang = await db.vorgang.findFirst({
+      where: { id: eingabe.vorgangId, betreuteId: eingabe.betreuteId, ...nichtGeloescht },
+      include: {
+        kontakte: { select: { name: true, organisation: true }, take: 1 },
+      },
+    })
+    if (!vorgang) throw new Error('Diesen Vorgang gibt es nicht (mehr).')
+
+    const anfrage = sachstandsanfrageErzeugen({
+      vorgangTitel: vorgang.titel,
+      gegenstelle: vorgang.gegenstelle,
+      aktenzeichen: vorgang.aktenzeichen,
+      letzterKontaktAm: vorgang.letzterKontaktAm,
+      betreute: {
+        vorname: betreute.vorname,
+        nachname: betreute.nachname,
+        geburtsdatum: betreute.geburtsdatum,
+      },
+      betreuer: {
+        name: eingabe.benutzerName,
+        aktenzeichenGericht: betreute.aktenzeichenGericht,
+        betreuungsgericht: betreute.betreuungsgericht,
+      },
+      heute,
+    })
+
+    return {
+      ...gemeinsam,
+      text: anfrage.text,
+      betreff: anfrage.betreff,
+      empfaengerName: vorgang.gegenstelle ?? '',
+      empfaengerAnschrift: '',
+    }
+  }
+
+  // --- Freies Schreiben ------------------------------------------------------
+  const text = freierEntwurf(kopf, { gesellschaft: null, anschrift: null }, heute)
+  return {
+    ...gemeinsam,
+    text,
+    betreff: '',
+    empfaengerName: '',
+    empfaengerAnschrift: '',
+  }
+}

src/lib/schreiben/pdf.tsx

@@ -0,0 +1,104 @@
+import 'server-only'
+import * as React from 'react'
+import { Document, Page, StyleSheet, Text, View } from '@react-pdf/renderer'
+import { fuerStandardschrift, pdfErzeugen } from '@/lib/pdf/erzeugen'
+
+/**
+ * Das Schreiben als PDF - die Fassung, die in die Akte geht.
+ *
+ * Warum PDF und nicht die Word-Datei?
+ *
+ * Erstens der Ablageschutz: src/lib/speicher/dateityp.ts laesst nur PDF und
+ * Bilder in den Objektspeicher, und zwar nach den Magic Bytes, nicht nach
+ * Endung oder gemeldetem Typ. Eine .docx ist ein ZIP-Archiv; sie
+ * durchzulassen hiesse, jedes ZIP durchzulassen. Diese Pruefung ist eine
+ * bewusste Zusage der Anwendung, und sie fuer eine Bequemlichkeit
+ * aufzuweichen waere der falsche Handel.
+ *
+ * Zweitens die Sache selbst: In der Akte liegt der Nachweis, was
+ * hinausgegangen ist. Dafuer ist ein Format, das sich nicht mehr aendert,
+ * das richtige. Die .docx ist die Arbeitsfassung zum Ausdrucken und
+ * Unterschreiben - sie liegt beim Benutzer, nicht in der Akte.
+ *
+ * Zu beachten: Abgelegt wird der Text, wie er beim Ablegen im Browser
+ * stand. Wer die Word-Datei danach noch aendert, hat in der Akte eine
+ * andere Fassung als im Briefkasten. Die Oberflaeche sagt das dazu.
+ */
+
+const stile = StyleSheet.create({
+  seite: {
+    paddingTop: 70,
+    paddingBottom: 56,
+    paddingLeft: 71, // 25 mm - da wird gelocht
+    paddingRight: 57,
+    fontSize: 10.5,
+    lineHeight: 1.45,
+    fontFamily: 'Helvetica',
+    color: '#111111',
+  },
+  zeile: { marginBottom: 0 },
+  leer: { height: 9 },
+  betreff: { fontFamily: 'Helvetica-Bold', marginBottom: 4 },
+  datum: { textAlign: 'right' },
+  fuss: {
+    position: 'absolute',
+    bottom: 28,
+    left: 71,
+    right: 57,
+    fontSize: 7.5,
+    color: '#777777',
+    textAlign: 'center',
+  },
+})
+
+function istBetreff(zeile: string): boolean {
+  return /^Betreff:/i.test(zeile.trim())
+}
+
+function istDatumszeile(zeile: string): boolean {
+  return /^([A-Za-zÄÖÜäöüß .-]+,\s*)?\d{1,2}\.\d{1,2}\.\d{4}$/.test(zeile.trim())
+}
+
+export function Briefdokument({
+  text,
+  erzeugtAm,
+}: {
+  text: string
+  erzeugtAm: Date
+}): React.JSX.Element {
+  const zeilen = text.split('\n')
+
+  return (
+    <Document>
+      <Page size="A4" style={stile.seite}>
+        {zeilen.map((zeile, i) => {
+          if (zeile.trim() === '') return <View key={i} style={stile.leer} />
+
+          const stil = istBetreff(zeile)
+            ? [stile.zeile, stile.betreff]
+            : istDatumszeile(zeile)
+              ? [stile.zeile, stile.datum]
+              : stile.zeile
+
+          return (
+            <Text key={i} style={stil}>
+              {fuerStandardschrift(zeile)}
+            </Text>
+          )
+        })}
+
+        <Text style={stile.fuss} fixed>
+          {fuerStandardschrift(
+            `Aus dem Betreuungs-Cockpit erzeugt am ${erzeugtAm.toLocaleDateString('de-DE')}. ` +
+              'Diese Fassung liegt in der Akte.',
+          )}
+        </Text>
+      </Page>
+    </Document>
+  )
+}
+
+/** Fertiges PDF als Buffer, fuer die Ablage im Objektspeicher. */
+export async function briefPdfErzeugen(text: string, erzeugtAm: Date): Promise<Buffer> {
+  return pdfErzeugen(<Briefdokument text={text} erzeugtAm={erzeugtAm} />)
+}

src/lib/validierung/finanzen.ts

@@ -229,6 +229,7 @@ export const buchungSchema = z
     verwendungszweck: optionalerText(500),
     belegId: optionaleId,
     belegFehltBegruendung: optionalerText(300),
+    vertragId: optionaleId,
     betrifftBetreute: schalter,
     vermoegenswirksam: schalter,
   })

src/lib/version.ts

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

src/lib/vertraege/serienabfrage.ts

@@ -0,0 +1,139 @@
+import type { VertragArt, VertragStatus } from '@prisma/client'
+import { kannRueckkaufswertHaben } from '@/lib/vertraege/konstanten'
+import { RUECKKAUFSWERT_WIEDERVORLAGE_TAGE } from '@/lib/vertraege/rueckkaufswert'
+import { heuteAlsTag, tageZwischen } from '@/lib/fristen/datum'
+
+/**
+ * Die Serienabfrage der Rueckkaufswerte - Auswahllogik.
+ *
+ * Rein und ohne Datenbank: Welche Vertraege kommen in Frage, welche sind
+ * vorausgewaehlt, welche gesperrt? Das sind die Entscheidungen, die
+ * hinterher niemand mehr nachvollziehen kann, wenn sie in einer
+ * Datenbankabfrage stecken. Hier stehen sie einzeln und mit Begruendung.
+ *
+ * Der Anlass: Vor dem Vermoegensverzeichnis und vor jedem Jahresbericht
+ * braucht es von jeder Lebens- und Rentenversicherung den Rueckkaufswert
+ * zum Stichtag. Das sind jedes Mal dieselben fuenf bis zehn Briefe.
+ */
+
+export type SerienKandidat = {
+  id: string
+  bezeichnung: string
+  gesellschaft: string | null
+  art: VertragArt
+  status: VertragStatus
+  rueckkaufswertAngefragtAm: Date | null
+}
+
+export type KandidatBewertung = {
+  vertrag: SerienKandidat
+  /** Kommt der Vertrag ueberhaupt in Frage? */
+  moeglich: boolean
+  /** Warum nicht? Steht in der Liste, statt den Vertrag stumm auszublenden. */
+  hindernis: string | null
+  /** Vorausgewaehlt? Nur moegliche Vertraege ohne frische Anfrage. */
+  vorausgewaehlt: boolean
+  /** Tage seit der letzten Anfrage, falls eine lief. */
+  tageSeitAnfrage: number | null
+}
+
+/**
+ * Sperrfrist: Wer in den letzten 28 Tagen schon gefragt hat, fragt nicht
+ * gleich noch einmal - die Antwort ist schlicht noch unterwegs. Dieselbe
+ * Zahl wie die Wiedervorlage; ein Test haelt beide zusammen.
+ */
+export const SPERRFRIST_TAGE = RUECKKAUFSWERT_WIEDERVORLAGE_TAGE
+
+/**
+ * Bewertet einen Vertrag fuer die Serienabfrage.
+ *
+ * Grundsatz: Nicht stumm ausblenden, sondern begruenden. Ein Vertrag, der
+ * fehlt, wirft die Frage auf "und wo ist der?"; ein Vertrag mit dem
+ * Vermerk "gekuendigt" beantwortet sie gleich mit.
+ */
+export function bewerten(vertrag: SerienKandidat, heute: Date = heuteAlsTag()): KandidatBewertung {
+  const tageSeitAnfrage = vertrag.rueckkaufswertAngefragtAm
+    ? tageZwischen(vertrag.rueckkaufswertAngefragtAm, heute)
+    : null
+
+  if (!kannRueckkaufswertHaben(vertrag.art)) {
+    return {
+      vertrag,
+      moeglich: false,
+      hindernis: 'Diese Vertragsart bildet keinen Rückkaufswert.',
+      vorausgewaehlt: false,
+      tageSeitAnfrage,
+    }
+  }
+
+  // Verwertet oder abgelaufen: Da gibt es nichts mehr anzufragen. GEKUENDIGT
+  // bleibt dagegen moeglich - bis zum Wirksamwerden der Kuendigung besteht
+  // der Vertrag, und genau dann will der Sozialhilfetraeger den Wert sehen.
+  if (vertrag.status === 'VERWERTET' || vertrag.status === 'ABGELAUFEN') {
+    return {
+      vertrag,
+      moeglich: false,
+      hindernis:
+        vertrag.status === 'VERWERTET'
+          ? 'Der Vertrag ist bereits verwertet.'
+          : 'Der Vertrag ist abgelaufen.',
+      vorausgewaehlt: false,
+      tageSeitAnfrage,
+    }
+  }
+
+  if (!vertrag.gesellschaft?.trim()) {
+    return {
+      vertrag,
+      moeglich: false,
+      hindernis: 'Ohne Gesellschaft fehlt der Empfänger — bitte am Vertrag nachtragen.',
+      vorausgewaehlt: false,
+      tageSeitAnfrage,
+    }
+  }
+
+  // Frisch angefragt: moeglich, aber nicht vorausgewaehlt. Wer trotzdem
+  // will (etwa weil der Brief verloren ging), waehlt von Hand an.
+  if (tageSeitAnfrage !== null && tageSeitAnfrage < SPERRFRIST_TAGE) {
+    return {
+      vertrag,
+      moeglich: true,
+      hindernis: `Vor ${tageSeitAnfrage} Tag${tageSeitAnfrage === 1 ? '' : 'en'} bereits angefragt — die Antwort ist vermutlich noch unterwegs.`,
+      vorausgewaehlt: false,
+      tageSeitAnfrage,
+    }
+  }
+
+  return { vertrag, moeglich: true, hindernis: null, vorausgewaehlt: true, tageSeitAnfrage }
+}
+
+export function kandidatenBewerten(
+  vertraege: SerienKandidat[],
+  heute: Date = heuteAlsTag(),
+): KandidatBewertung[] {
+  return vertraege
+    .map((vertrag) => bewerten(vertrag, heute))
+    .sort((a, b) => {
+      // Vorausgewaehlte zuerst, dann die moeglichen, dann der Rest -
+      // jeweils alphabetisch. Was zu tun ist, steht oben.
+      const rang = (k: KandidatBewertung) => (k.vorausgewaehlt ? 0 : k.moeglich ? 1 : 2)
+      if (rang(a) !== rang(b)) return rang(a) - rang(b)
+      return a.vertrag.bezeichnung.localeCompare(b.vertrag.bezeichnung, 'de')
+    })
+}
+
+/**
+ * Wurde heute schon angefragt? Der Dublettenschutz fuer den zweiten Lauf.
+ *
+ * Bewusst tagesgenau und nicht "innerhalb der Sperrfrist": Wer denselben
+ * Lauf versehentlich zweimal startet, soll keine doppelten Dokumente
+ * bekommen. Wer nach einer Woche bewusst erneut anfragt (Brief verloren),
+ * soll es duerfen.
+ */
+export function heuteSchonAngefragt(
+  angefragtAm: Date | null,
+  heute: Date = heuteAlsTag(),
+): boolean {
+  if (!angefragtAm) return false
+  return tageZwischen(angefragtAm, heute) === 0
+}

src/lib/vertraege/serienlauf.ts

@@ -0,0 +1,254 @@
+import 'server-only'
+import archiver from 'archiver'
+import { db, nichtGeloescht } from '@/lib/db'
+import { oeffnen } from '@/lib/crypto/feld'
+import { protokollieren } from '@/lib/audit'
+import { ablegenMitTyp } from '@/lib/speicher'
+import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
+import {
+  RUECKKAUFSWERT_WIEDERVORLAGE_TAGE,
+  rueckkaufswertAnschreiben,
+  wiedervorlageAm,
+} from '@/lib/vertraege/rueckkaufswert'
+import { VERTRAG_ART_BESCHRIFTUNG } from '@/lib/vertraege/konstanten'
+import { heuteSchonAngefragt } from '@/lib/vertraege/serienabfrage'
+import { briefDocxErzeugen } from '@/lib/schreiben/docx'
+import { briefPdfErzeugen } from '@/lib/schreiben/pdf'
+import { dateinameFuerSchreiben } from '@/lib/schreiben/arten'
+import { betreffAusText } from '@/lib/schreiben/entwurf'
+import { heuteAlsTag } from '@/lib/fristen/datum'
+
+/**
+ * Der Serienlauf: Rueckkaufswerte aller gewaehlten Vertraege anfragen.
+ *
+ * Je Vertrag entsteht das volle Paket aus Issue #4 - Word-Datei fuers
+ * ZIP, PDF in die Akte, rueckkaufswertAngefragtAm, Wiedervorlage,
+ * Protokolleintrag. Der Unterschied: alles in einem Lauf, und ein
+ * gescheiterter Vertrag reisst die uebrigen nicht mit.
+ *
+ * Kein Alles-oder-nichts heisst konkret: Jeder Vertrag laeuft fuer sich.
+ * Was gelingt, gilt; was scheitert, steht mit Grund im Ergebnis und im
+ * Begleitblatt des ZIP. Eine Transaktion ueber alle Vertraege waere die
+ * falsche Zusage - wenn der neunte Brief am Objektspeicher scheitert,
+ * sollen die acht fertigen nicht verworfen werden.
+ */
+
+export type SerienErgebnisZeile = {
+  vertragId: string
+  bezeichnung: string
+  gesellschaft: string | null
+  /** 'erzeugt' | 'uebersprungen' | 'fehlgeschlagen' */
+  ausgang: 'erzeugt' | 'uebersprungen' | 'fehlgeschlagen'
+  grund: string | null
+}
+
+export type SerienErgebnis = {
+  zip: Buffer
+  dateiname: string
+  zeilen: SerienErgebnisZeile[]
+  erzeugt: number
+}
+
+export async function serienlaufDurchfuehren(eingabe: {
+  betreuteId: string
+  vertragIds: string[]
+  stichtag: Date
+  benutzer: { id: string; name: string; email: string }
+}): Promise<SerienErgebnis> {
+  const heute = heuteAlsTag()
+  const { betreuteId, benutzer } = eingabe
+
+  const betreute = await db.betreute.findFirst({
+    where: { id: betreuteId, ...nichtGeloescht },
+  })
+  if (!betreute) throw new Error('Die betreute Person gibt es nicht (mehr).')
+
+  const kopf = briefkopfBauen({
+    betreute: oeffnen('Betreute', betreute),
+    benutzer: { name: benutzer.name },
+  })
+
+  // Nur Vertraege dieser betreuten Person - fremde IDs laufen ins Leere.
+  const vertraege = await db.vertrag.findMany({
+    where: { id: { in: eingabe.vertragIds }, betreuteId, ...nichtGeloescht },
+  })
+
+  const zeilen: SerienErgebnisZeile[] = []
+  const dateien: { name: string; inhalt: Buffer }[] = []
+
+  for (const vertrag of vertraege) {
+    const basis = {
+      vertragId: vertrag.id,
+      bezeichnung: vertrag.bezeichnung,
+      gesellschaft: vertrag.gesellschaft,
+    }
+
+    try {
+      // Dublettenschutz: Der zweite Lauf am selben Tag erzeugt nichts
+      // Neues, sondern sagt, dass es heute schon lief.
+      if (heuteSchonAngefragt(vertrag.rueckkaufswertAngefragtAm, heute)) {
+        zeilen.push({
+          ...basis,
+          ausgang: 'uebersprungen',
+          grund: 'Heute bereits angefragt — kein zweites Schreiben erzeugt.',
+        })
+        continue
+      }
+
+      const offen = oeffnen('Vertrag', vertrag)
+      const text = rueckkaufswertAnschreiben({
+        kopf,
+        empfaenger: { gesellschaft: vertrag.gesellschaft, anschrift: null },
+        vertragsbezeichnung: `${VERTRAG_ART_BESCHRIFTUNG[vertrag.art]} — ${vertrag.bezeichnung}`,
+        vertragsnummer: offen.vertragsnummer,
+        stichtag: eingabe.stichtag,
+        heute,
+      })
+      const betreff = betreffAusText(text) || `Rückkaufswert ${vertrag.bezeichnung}`
+
+      // --- Word-Datei fuers ZIP ------------------------------------------
+      const docx = await briefDocxErzeugen(text)
+      dateien.push({
+        name: dateinameFuerSchreiben('RUECKKAUFSWERT', vertrag.gesellschaft, heute, 'docx'),
+        inhalt: docx,
+      })
+
+      // --- PDF in die Akte -----------------------------------------------
+      const pdf = await briefPdfErzeugen(text, heute)
+      const ablage = await ablegenMitTyp(
+        betreuteId,
+        'dokumente',
+        dateinameFuerSchreiben('RUECKKAUFSWERT', vertrag.gesellschaft, heute, 'pdf'),
+        pdf,
+        'application/pdf',
+      )
+
+      const dokument = await db.dokument.create({
+        data: {
+          betreuteId,
+          titel: betreff.slice(0, 200),
+          art: 'SCHREIBEN',
+          richtung: 'AUSGANG',
+          schreibenVom: heute,
+          versandAm: heute,
+          empfaenger: vertrag.gesellschaft,
+          objektSchluessel: ablage.schluessel,
+          dateiname: ablage.dateiname,
+          mimeTyp: ablage.typ.mimeTyp,
+          groesseBytes: ablage.groesseBytes,
+          pruefsumme: ablage.pruefsumme,
+          ocrStatus: 'nicht_verfuegbar',
+          posteingangStatus: 'ZUGEORDNET',
+          verknuepfungen: { create: [{ betreuteId, vertragId: vertrag.id }] },
+        },
+        select: { id: true },
+      })
+
+      // --- Wiedervorlage und Anfragedatum --------------------------------
+      await db.frist.create({
+        data: {
+          betreuteId,
+          titel: `Antwort abwarten: Rückkaufswert ${vertrag.bezeichnung}`.slice(0, 200),
+          beschreibung:
+            `Am ${heute.toLocaleDateString('de-DE')} an ${vertrag.gesellschaft ?? 'die Gesellschaft'} ` +
+            `geschickt (Stichtag ${eingabe.stichtag.toLocaleDateString('de-DE')}). ` +
+            'Kommt bis zu diesem Tag nichts, nachfassen.',
+          datum: wiedervorlageAm(heute),
+          typ: 'WIEDERVORLAGE',
+          verknuepfungen: { create: [{ betreuteId, dokumentId: dokument.id }] },
+        },
+      })
+
+      await db.vertrag.update({
+        where: { id: vertrag.id },
+        data: { rueckkaufswertAngefragtAm: heute },
+      })
+
+      await protokollieren({
+        aktion: 'ERSTELLT',
+        entitaet: 'Dokument',
+        entitaetId: dokument.id,
+        bezeichnung: `Serienabfrage Rückkaufswert: ${vertrag.bezeichnung}`,
+        betreuteId,
+        userId: benutzer.id,
+        userEmail: benutzer.email,
+        userName: benutzer.name,
+      })
+
+      zeilen.push({ ...basis, ausgang: 'erzeugt', grund: null })
+    } catch (ausnahme) {
+      // Ein Vertrag scheitert, die uebrigen laufen weiter. Der Grund
+      // steht im Ergebnis - nichts verschwindet stumm.
+      console.error(`[serienlauf] Vertrag ${vertrag.id} fehlgeschlagen:`, ausnahme)
+      zeilen.push({
+        ...basis,
+        ausgang: 'fehlgeschlagen',
+        grund: ausnahme instanceof Error ? ausnahme.message : 'Unbekannter Fehler.',
+      })
+    }
+  }
+
+  // IDs, die zu keinem Vertrag der Person gehoeren - auch das wird
+  // benannt statt verschluckt.
+  const gefunden = new Set(vertraege.map((v) => v.id))
+  for (const id of eingabe.vertragIds) {
+    if (!gefunden.has(id)) {
+      zeilen.push({
+        vertragId: id,
+        bezeichnung: '(unbekannt)',
+        gesellschaft: null,
+        ausgang: 'fehlgeschlagen',
+        grund: 'Diesen Vertrag gibt es nicht (mehr).',
+      })
+    }
+  }
+
+  const erzeugt = zeilen.filter((z) => z.ausgang === 'erzeugt').length
+
+  // --- Begleitblatt und ZIP ----------------------------------------------
+  const begleitblatt = [
+    `Serienabfrage Rückkaufswerte vom ${heute.toLocaleDateString('de-DE')}`,
+    `Stichtag der Anfragen: ${eingabe.stichtag.toLocaleDateString('de-DE')}`,
+    `Wiedervorlage: ${wiedervorlageAm(heute).toLocaleDateString('de-DE')} (${RUECKKAUFSWERT_WIEDERVORLAGE_TAGE} Tage)`,
+    '',
+    ...zeilen.map((zeile) => {
+      const stand =
+        zeile.ausgang === 'erzeugt'
+          ? 'erzeugt'
+          : zeile.ausgang === 'uebersprungen'
+            ? `übersprungen: ${zeile.grund}`
+            : `FEHLGESCHLAGEN: ${zeile.grund}`
+      return `- ${zeile.bezeichnung}${zeile.gesellschaft ? ` (${zeile.gesellschaft})` : ''} — ${stand}`
+    }),
+    '',
+    'Jedes erzeugte Schreiben liegt zusätzlich als PDF in der Akte (Dokumente, Richtung Ausgang).',
+  ].join('\n')
+
+  const zip = await zipBauen([
+    { name: 'UEBERSICHT.txt', inhalt: Buffer.from(begleitblatt, 'utf8') },
+    ...dateien,
+  ])
+
+  return {
+    zip,
+    dateiname: `${heute.toISOString().slice(0, 10)}_Rueckkaufswert-Anfragen.zip`,
+    zeilen,
+    erzeugt,
+  }
+}
+
+/** Packt die Dateien in ein ZIP im Speicher. Bei einer Handvoll Word-Dateien
+ *  ist Streamen unnoetig - Einfachheit schlaegt hier Durchsatz. */
+function zipBauen(dateien: { name: string; inhalt: Buffer }[]): Promise<Buffer> {
+  return new Promise((erfuellen, verwerfen) => {
+    const archiv = archiver('zip', { zlib: { level: 9 } })
+    const teile: Buffer[] = []
+    archiv.on('data', (teil: Buffer) => teile.push(teil))
+    archiv.on('error', verwerfen)
+    archiv.on('end', () => erfuellen(Buffer.concat(teile)))
+    for (const datei of dateien) {
+      archiv.append(datei.inhalt, { name: datei.name })
+    }
+    void archiv.finalize()
+  })
+}

src/server/actions/finanzen.ts

@@ -11,6 +11,7 @@ import { blindindex } from '@/lib/crypto/hash'
 import { alsTag } from '@/lib/finanzen/datum'
 import { csvTextLesen, csvZuBuchungen, dublettenMarkieren } from '@/lib/finanzen/import'
 import { camtZuBuchungen } from '@/lib/finanzen/camt'
+import { eindeutigerVertrag } from '@/lib/finanzen/wiederkehrend'
 import {
   buchungSchema,
   fehlerAuflisten,
@@ -349,6 +350,10 @@ export async function buchungSpeichern(
       kategorie: werte.kategorie,
       gegenstelle: werte.gegenstelle,
       belegId: werte.belegId,
+      vertragId: werte.vertragId,
+      // Von Hand gesetzt heisst: nicht mehr "automatisch". Wer die
+      // Zuordnung anfasst, uebernimmt sie.
+      vertragAutomatisch: false,
       belegFehltBegruendung: werte.belegId ? null : werte.belegFehltBegruendung,
       betrifftBetreute: werte.betrifftBetreute,
       vermoegenswirksam: werte.vermoegenswirksam,
@@ -515,8 +520,18 @@ export async function importAusfuehren(
 
     const anzulegen = zeilen.filter((z) => werte.dublettenUebernehmen || !z.dublette)
 
+    // Vertraege einmal holen, nicht je Zeile. Zugeordnet wird nur, wo die
+    // Gegenstelle zu genau EINEM Vertrag passt - bei Mehrdeutigkeit
+    // geschieht nichts.
+    const vertraege = await db.vertrag.findMany({
+      where: { betreuteId, ...nichtGeloescht },
+      select: { id: true, bezeichnung: true, gesellschaft: true },
+    })
+
     let angelegt = 0
+    let zugeordnet = 0
     for (const zeile of anzulegen) {
+      const passenderVertrag = eindeutigerVertrag(zeile.gegenstelle, vertraege)
       try {
         await db.buchung.create({
           data: {
@@ -530,10 +545,17 @@ export async function importAusfuehren(
             gegenstelle: zeile.gegenstelle,
             betrifftBetreute: werte.betrifftBetreute,
             importReferenz: werte.dublettenUebernehmen && zeile.dublette ? null : zeile.importReferenz,
+            // Nur bei Ausgaben: Eine Gutschrift der Versicherung ist keine
+            // Praemienzahlung und darf nicht als "durch Vertrag belegt"
+            // gelten.
+            ...(zeile.richtung === 'AUSGABE' && passenderVertrag
+              ? { vertragId: passenderVertrag.id, vertragAutomatisch: true }
+              : {}),
             ...sealen('Buchung', { verwendungszweck: zeile.verwendungszweck }),
           },
         })
         angelegt++
+        if (zeile.richtung === 'AUSGABE' && passenderVertrag) zugeordnet++
       } catch (ausnahme) {
         // Die Eindeutigkeit auf (kontoId, importReferenz) faengt Reste ab,
         // die zwischen Lesen und Schreiben dazugekommen sind.
@@ -563,6 +585,13 @@ export async function importAusfuehren(
         ? [`${gelesen.fehler.length} Zeile(n) konnten nicht gelesen werden:`]
         : []),
       ...gelesen.fehler.slice(0, 10).map((f) => `Zeile ${f.zeilennummer}: ${f.meldung}`),
+      ...(zugeordnet > 0
+        ? [
+            `${zugeordnet} Buchung(en) wurden automatisch einem Vertrag zugeordnet und gelten ` +
+              'damit als belegt. Sie sind in der Liste als automatisch zugeordnet erkennbar – ' +
+              'bitte einmal durchsehen.',
+          ]
+        : []),
       'Alle importierten Buchungen stehen zunächst in „Sonstige Einnahmen“ bzw. „Sonstige Ausgaben“. ' +
         'Bitte die Kategorien nachtragen – danach stimmen die Berichte.',
     ]
@@ -821,3 +850,172 @@ export async function wertstandLoeschen(
   revalidatePath('/finanzen/vermoegen')
   return { erfolg: 'Wert gelöscht.' }
 }
+
+// -----------------------------------------------------------------------------
+// Wiederkehrende Zahlungen
+// -----------------------------------------------------------------------------
+
+/**
+ * Hakt eine Gruppe wiederkehrender Zahlungen als "kein Vertrag" ab.
+ *
+ * Der Schluessel kommt aus normalisieren() und wird hier NICHT noch einmal
+ * gebildet: Was der Benutzer auf dem Bildschirm gesehen hat, soll auch
+ * abgehakt werden. Bildeten Anzeige und Aktion den Schluessel getrennt,
+ * koennten sie auseinanderlaufen - und dann verschwaende eine andere
+ * Gruppe als die angeklickte.
+ */
+export async function zahlungsgruppeAbhaken(
+  _zustand: Formularzustand,
+  daten: FormData,
+): Promise<Formularzustand> {
+  const betreuteId = String(daten.get('betreuteId') ?? '')
+  const schluessel = String(daten.get('schluessel') ?? '').trim()
+  const anzeigename = String(daten.get('anzeigename') ?? '').trim()
+  const begruendung = String(daten.get('begruendung') ?? '').trim()
+
+  if (!schluessel || !anzeigename) {
+    return { fehler: 'Diese Zahlungsgruppe lässt sich nicht zuordnen.' }
+  }
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'FINANZEN', 'schreiben')
+
+    await db.zahlungsgruppeGeklaert.upsert({
+      where: { betreuteId_schluessel: { betreuteId, schluessel } },
+      create: {
+        betreuteId,
+        schluessel,
+        anzeigename,
+        begruendung: begruendung === '' ? null : begruendung,
+      },
+      update: { begruendung: begruendung === '' ? null : begruendung },
+    })
+
+    await protokollieren({
+      aktion: 'ERSTELLT',
+      entitaet: 'ZahlungsgruppeGeklaert',
+      bezeichnung: `${anzeigename} — kein Vertrag`,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[finanzen] Zahlungsgruppe konnte nicht abgehakt werden:', ausnahme)
+    return { fehler: 'Die Zahlungsgruppe konnte nicht abgehakt werden.' }
+  }
+
+  revalidatePath('/finanzen/wiederkehrend')
+  revalidatePath('/heute')
+  return { erfolg: `„${anzeigename}“ gilt als geklärt.` }
+}
+
+/** Holt eine abgehakte Gruppe zurueck in die Liste. */
+export async function zahlungsgruppeZurueckholen(
+  _zustand: Formularzustand,
+  daten: FormData,
+): Promise<Formularzustand> {
+  const betreuteId = String(daten.get('betreuteId') ?? '')
+  const eintragId = String(daten.get('eintragId') ?? '')
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'FINANZEN', 'schreiben')
+
+    // Zeilenweise Pruefung: Die ID muss zu DIESER betreuten Person gehoeren.
+    const eintrag = await db.zahlungsgruppeGeklaert.findFirst({
+      where: { id: eintragId, betreuteId },
+      select: { id: true, anzeigename: true },
+    })
+    if (!eintrag) return { fehler: 'Diesen Eintrag gibt es nicht (mehr).' }
+
+    await db.zahlungsgruppeGeklaert.delete({ where: { id: eintrag.id } })
+
+    await protokollieren({
+      aktion: 'GELOESCHT',
+      entitaet: 'ZahlungsgruppeGeklaert',
+      entitaetId: eintrag.id,
+      bezeichnung: `${eintrag.anzeigename} — wieder offen`,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[finanzen] Zahlungsgruppe konnte nicht zurückgeholt werden:', ausnahme)
+    return { fehler: 'Der Eintrag konnte nicht zurückgeholt werden.' }
+  }
+
+  revalidatePath('/finanzen/wiederkehrend')
+  revalidatePath('/heute')
+  return { erfolg: 'Die Gruppe steht wieder in der Liste.' }
+}
+
+/**
+ * Ordnet mehrere Buchungen auf einmal einem Vertrag zu.
+ *
+ * Der Weg dorthin fuehrt ueber "Wiederkehrende Zahlungen": Dort steht eine
+ * Gruppe gleichartiger Abbuchungen beisammen, und wenn dazu ein Vertrag in
+ * der Akte liegt, sind es genau die Buchungen, die er belegt. Sie einzeln
+ * anzuklicken waere die Arbeit, die dieses Issue abschaffen soll.
+ *
+ * Die IDs kommen aus dem Formular und werden NICHT geglaubt: Geschrieben
+ * wird nur, was zu dieser betreuten Person gehoert.
+ */
+export async function zahlungenVertragZuordnen(
+  _zustand: Formularzustand,
+  daten: FormData,
+): Promise<Formularzustand> {
+  const betreuteId = String(daten.get('betreuteId') ?? '')
+  const vertragId = String(daten.get('vertragId') ?? '')
+  const buchungIds = String(daten.get('buchungIds') ?? '')
+    .split(',')
+    .map((id) => id.trim())
+    .filter(Boolean)
+
+  if (!vertragId || buchungIds.length === 0) {
+    return { fehler: 'Es ist nichts zum Zuordnen ausgewählt.' }
+  }
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'FINANZEN', 'schreiben')
+
+    const vertrag = await db.vertrag.findFirst({
+      where: { id: vertragId, betreuteId, ...nichtGeloescht },
+      select: { id: true, bezeichnung: true },
+    })
+    if (!vertrag) return { fehler: 'Diesen Vertrag gibt es nicht (mehr).' }
+
+    // betreuteId im WHERE ist der eigentliche Schutz: Eine fremde
+    // Buchungs-ID trifft dann auf null Zeilen.
+    const { count } = await db.buchung.updateMany({
+      where: { id: { in: buchungIds }, betreuteId, ...nichtGeloescht },
+      data: { vertragId: vertrag.id, vertragAutomatisch: false },
+    })
+
+    await protokollieren({
+      aktion: 'GEAENDERT',
+      entitaet: 'Buchung',
+      bezeichnung: `${count} Buchung(en) als Dauerzahlung zu „${vertrag.bezeichnung}“`,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+
+    revalidatePath('/finanzen')
+    revalidatePath('/finanzen/buchungen')
+    revalidatePath('/finanzen/wiederkehrend')
+    revalidatePath('/heute')
+
+    return { erfolg: `${count} Buchung(en) gelten jetzt als durch den Vertrag belegt.` }
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[finanzen] Sammelzuordnung fehlgeschlagen:', ausnahme)
+    return { fehler: 'Die Zuordnung konnte nicht gespeichert werden.' }
+  }
+}

src/server/actions/schreiben.ts

@@ -0,0 +1,310 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+import { db, nichtGeloescht } from '@/lib/db'
+import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
+import { protokollieren } from '@/lib/audit'
+import { ablegenMitTyp } from '@/lib/speicher'
+import { heuteAlsTag } from '@/lib/fristen/datum'
+import { tagAusText } from '@/lib/finanzen/datum'
+import {
+  SCHREIBEN_EIGENSCHAFTEN,
+  dateinameFuerSchreiben,
+  istSchreibenArt,
+  type SchreibenArt,
+} from '@/lib/schreiben/arten'
+import { briefPdfErzeugen } from '@/lib/schreiben/pdf'
+import { emailFassung } from '@/lib/schreiben/email'
+
+/**
+ * Server Actions rund um erzeugte Schreiben.
+ *
+ * Der Kern ist "In die Akte legen". Bisher endete ein Schreiben beim Text
+ * zum Kopieren; alles danach - ausdrucken, abschicken, als Dokument
+ * nachtragen, Wiedervorlage setzen - war Handarbeit, und der letzte
+ * Schritt wurde am haeufigsten vergessen. Dann fehlt der Nachweis genau
+ * dort, wo er gebraucht wird: im Bericht ans Gericht.
+ *
+ * Hier passiert alles in einem Zug, und zwar so, dass ein Abbruch nichts
+ * Halbes hinterlaesst.
+ */
+
+export type SchreibenZustand = {
+  fehler?: string
+  erfolg?: string
+  /** Kurze Aufzaehlung dessen, was angelegt wurde. */
+  meldung?: string[]
+}
+
+function zugriffsfehler(ausnahme: unknown): SchreibenZustand | null {
+  if (ausnahme instanceof ZugriffVerweigert) return { fehler: ausnahme.message }
+  return null
+}
+
+const ablegenSchema = z.object({
+  betreuteId: z.string().min(1),
+  art: z.string().refine(istSchreibenArt, 'Unbekannte Art von Schreiben.'),
+  betreff: z.string().trim().min(1, 'Bitte einen Betreff eintragen.').max(200),
+  text: z.string().trim().min(30, 'Der Text ist zu kurz für ein Schreiben.').max(50_000),
+  empfaengerName: z.string().trim().max(200).default(''),
+  versandAm: z.string().trim().default(''),
+  wiedervorlageAm: z.string().trim().default(''),
+  vertragId: z.string().trim().default(''),
+  vorgangId: z.string().trim().default(''),
+  /** "BRIEF" oder "EMAIL" - bestimmt Fassung und Kennzeichnung. */
+  versandweg: z.enum(['BRIEF', 'EMAIL']).default('BRIEF'),
+  empfaengerEmail: z.string().trim().max(200).default(''),
+})
+
+/**
+ * Legt das Schreiben als Ausgangsdokument in die Akte und setzt die
+ * Wiedervorlage.
+ *
+ * Reihenfolge mit Absicht: Erst die Datei in den Objektspeicher, dann der
+ * Datensatz. Bricht das Ablegen ab, gibt es keinen Dokumentdatensatz, der
+ * auf eine Datei zeigt, die es nicht gibt. Umgekehrt bliebe im
+ * schlimmsten Fall eine verwaiste Datei liegen - die kostet Platz, aber
+ * sie luegt niemanden an.
+ */
+export async function schreibenAblegen(
+  _zustand: SchreibenZustand,
+  daten: FormData,
+): Promise<SchreibenZustand> {
+  const gelesen = ablegenSchema.safeParse({
+    betreuteId: daten.get('betreuteId'),
+    art: daten.get('art'),
+    betreff: daten.get('betreff'),
+    text: daten.get('text'),
+    empfaengerName: daten.get('empfaengerName') ?? '',
+    versandweg: daten.get('versandweg') ?? 'BRIEF',
+    empfaengerEmail: daten.get('empfaengerEmail') ?? '',
+    versandAm: daten.get('versandAm') ?? '',
+    wiedervorlageAm: daten.get('wiedervorlageAm') ?? '',
+    vertragId: daten.get('vertragId') ?? '',
+    vorgangId: daten.get('vorgangId') ?? '',
+  })
+
+  if (!gelesen.success) {
+    return { fehler: gelesen.error.issues[0]?.message ?? 'Bitte prüfe deine Eingaben.' }
+  }
+
+  const werte = gelesen.data
+  const art = werte.art as SchreibenArt
+  const betreuteId = werte.betreuteId
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'DOKUMENTE', 'schreiben')
+
+    const versandAm = tagAusText(werte.versandAm) ?? heuteAlsTag()
+
+    // --- Bezuege pruefen, bevor irgendetwas geschrieben wird ---------------
+    const vertrag = werte.vertragId
+      ? await db.vertrag.findFirst({
+          where: { id: werte.vertragId, betreuteId, ...nichtGeloescht },
+          select: { id: true, bezeichnung: true },
+        })
+      : null
+    if (werte.vertragId && !vertrag) return { fehler: 'Diesen Vertrag gibt es nicht (mehr).' }
+
+    const vorgang = werte.vorgangId
+      ? await db.vorgang.findFirst({
+          where: { id: werte.vorgangId, betreuteId, ...nichtGeloescht },
+          select: { id: true, titel: true },
+        })
+      : null
+    if (werte.vorgangId && !vorgang) return { fehler: 'Diesen Vorgang gibt es nicht (mehr).' }
+
+    // --- Datei zuerst -------------------------------------------------------
+    // Bei einer E-Mail wird die E-Mail-Fassung abgelegt, nicht der
+    // Brieftext: In der Akte soll stehen, was tatsaechlich hinausging -
+    // samt Empfaengeradresse im Kopf der PDF.
+    const istEmail = werte.versandweg === 'EMAIL'
+    const fassung = istEmail ? emailFassung(werte.text, werte.betreff) : null
+    const ablageText = fassung
+      ? [
+          `E-Mail an: ${werte.empfaengerEmail || werte.empfaengerName || '[Adresse]'}`,
+          `Betreff: ${fassung.betreff}`,
+          '',
+          fassung.text,
+        ].join('\n')
+      : werte.text
+    const pdf = await briefPdfErzeugen(ablageText, versandAm)
+    const dateiname = dateinameFuerSchreiben(art, werte.empfaengerName || null, versandAm, 'pdf')
+    const ablage = await ablegenMitTyp(betreuteId, 'dokumente', dateiname, pdf, 'application/pdf')
+
+    // --- Dann der Datensatz -------------------------------------------------
+    const dokument = await db.dokument.create({
+      data: {
+        betreuteId,
+        titel: (istEmail ? `E-Mail: ${werte.betreff}` : werte.betreff).slice(0, 200),
+        art: 'SCHREIBEN',
+        richtung: 'AUSGANG',
+        schreibenVom: versandAm,
+        versandAm,
+        empfaenger: werte.empfaengerName || null,
+        objektSchluessel: ablage.schluessel,
+        dateiname: ablage.dateiname,
+        mimeTyp: ablage.typ.mimeTyp,
+        groesseBytes: ablage.groesseBytes,
+        pruefsumme: ablage.pruefsumme,
+        // Was wir selbst gesetzt haben, muss nicht erkannt werden.
+        ocrStatus: 'nicht_verfuegbar',
+        // Ein eigenes Schreiben gehoert nicht in den Posteingang - es ist
+        // ja nichts angekommen, das noch zuzuordnen waere.
+        posteingangStatus: 'ZUGEORDNET',
+        ...(vertrag || vorgang
+          ? {
+              verknuepfungen: {
+                create: [
+                  {
+                    betreuteId,
+                    ...(vertrag ? { vertragId: vertrag.id } : {}),
+                    ...(vorgang ? { vorgangId: vorgang.id } : {}),
+                  },
+                ],
+              },
+            }
+          : {}),
+      },
+      select: { id: true, titel: true },
+    })
+
+    const meldung = [`Als Ausgangsdokument abgelegt: „${dokument.titel}“.`]
+
+    // --- Wiedervorlage ------------------------------------------------------
+    const wiedervorlage = tagAusText(werte.wiedervorlageAm)
+    if (wiedervorlage) {
+      const frist = await db.frist.create({
+        data: {
+          betreuteId,
+          vorgangId: vorgang?.id ?? null,
+          titel: `Antwort abwarten: ${werte.betreff}`.slice(0, 200),
+          beschreibung:
+            `Am ${versandAm.toLocaleDateString('de-DE')} verschickt` +
+            (werte.empfaengerName ? ` an ${werte.empfaengerName}` : '') +
+            '. Kommt bis zu diesem Tag nichts, nachfassen.',
+          datum: wiedervorlage,
+          typ: 'WIEDERVORLAGE',
+          verknuepfungen: { create: [{ betreuteId, dokumentId: dokument.id }] },
+        },
+        select: { id: true },
+      })
+      meldung.push(
+        `Wiedervorlage zum ${wiedervorlage.toLocaleDateString('de-DE')} angelegt.`,
+      )
+      void frist
+    } else if (SCHREIBEN_EIGENSCHAFTEN[art].wiedervorlageTage !== null) {
+      meldung.push('Ohne Wiedervorlage abgelegt — es erinnert dich also nichts daran.')
+    }
+
+    // --- Beim Vorgang festhalten, dass wir gerade geschrieben haben --------
+    if (vorgang) {
+      await db.vorgang.update({
+        where: { id: vorgang.id },
+        data: { letzterKontaktAm: versandAm },
+      })
+    }
+
+    await protokollieren({
+      aktion: 'ERSTELLT',
+      entitaet: 'Dokument',
+      entitaetId: dokument.id,
+      bezeichnung: `Schreiben ausgegangen: ${dokument.titel}`,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+
+    revalidatePath('/dokumente')
+    revalidatePath('/fristen')
+    revalidatePath('/heute')
+    if (vertrag) revalidatePath(`/vertraege/${vertrag.id}`)
+    if (vorgang) revalidatePath(`/vorgaenge/${vorgang.id}`)
+
+    return { erfolg: 'Das Schreiben liegt in der Akte.', meldung }
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[schreiben] Ablegen fehlgeschlagen:', ausnahme)
+    return { fehler: 'Das Schreiben konnte nicht abgelegt werden.' }
+  }
+}
+
+const kontaktSchema = z.object({
+  betreuteId: z.string().min(1),
+  name: z.string().trim().min(1, 'Bitte einen Namen eintragen.').max(200),
+  anschrift: z.string().trim().max(500).default(''),
+})
+
+/**
+ * Legt aus einer frei eingegebenen Anschrift einen Kontakt an.
+ *
+ * Damit man dieselbe Stelle beim naechsten Mal aus der Liste waehlen kann,
+ * statt sie erneut abzutippen. Genau so waechst das Adressbuch einer
+ * Betreuung: nicht durch Pflege, sondern nebenbei beim Schreiben.
+ */
+export async function kontaktAusAnschrift(
+  _zustand: SchreibenZustand,
+  daten: FormData,
+): Promise<SchreibenZustand> {
+  const gelesen = kontaktSchema.safeParse({
+    betreuteId: daten.get('betreuteId'),
+    name: daten.get('empfaengerName'),
+    anschrift: daten.get('empfaengerAnschrift') ?? '',
+  })
+
+  if (!gelesen.success) {
+    return { fehler: gelesen.error.issues[0]?.message ?? 'Bitte prüfe deine Eingaben.' }
+  }
+
+  const { betreuteId, name, anschrift } = gelesen.data
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'KONTAKTE', 'schreiben')
+
+    // Die freie Anschrift kommt als Block; die erste Zeile ist die Strasse,
+    // die zweite PLZ und Ort. Mehr wird nicht geraten - was nicht sicher
+    // zuzuordnen ist, landet in den Notizen.
+    const zeilen = anschrift
+      .split('\n')
+      .map((z) => z.trim())
+      .filter(Boolean)
+    const strasse = zeilen[0] ?? null
+    const ortszeile = zeilen[1] ?? ''
+    const treffer = ortszeile.match(/^(\d{5})\s+(.+)$/)
+
+    const kontakt = await db.kontakt.create({
+      data: {
+        betreuteId,
+        name: name.slice(0, 200),
+        organisation: name.slice(0, 200),
+        rolle: 'SONSTIGES',
+        strasse,
+        plz: treffer?.[1] ?? null,
+        ort: treffer?.[2] ?? (treffer ? null : ortszeile || null),
+      },
+      select: { id: true, name: true },
+    })
+
+    await protokollieren({
+      aktion: 'ERSTELLT',
+      entitaet: 'Kontakt',
+      entitaetId: kontakt.id,
+      bezeichnung: kontakt.name,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+
+    revalidatePath('/kontakte')
+    return { erfolg: `„${kontakt.name}“ steht jetzt in den Kontakten.` }
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[schreiben] Kontakt konnte nicht angelegt werden:', ausnahme)
+    return { fehler: 'Der Kontakt konnte nicht angelegt werden.' }
+  }
+}

tests/dauerzahlung.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, it } from 'vitest'
+import {
+  BETRAGS_TOLERANZ_PROZENT,
+  belegBegruendet,
+  belegDurchVertrag,
+  belegFehlt,
+  belegquote,
+  betragPasstZumVertrag,
+  betragPruefen,
+  type BuchungEingabe,
+} from '@/lib/finanzen/kassenbuch'
+
+/**
+ * Dauerzahlungen zu einem Vertrag.
+ *
+ * Bei einem Dauerschuldverhältnis ist der Vertrag der Beleg — für zwölf
+ * gleiche Lastschriften gibt es keine zwölf Quittungen, sondern eine Police.
+ *
+ * Der gefährliche Fehler wäre hier nicht ein zu strenges Urteil, sondern ein
+ * zu mildes: Wenn eine verdreifachte Prämie als „belegt" durchgeht, ist die
+ * Zuordnung eine Hintertür geworden. Die Hälfte dieser Prüfungen zielt
+ * deshalb darauf, dass die Anerkennung auch wirklich **wegfällt**.
+ */
+
+function buchung(teile: Partial<BuchungEingabe> = {}): BuchungEingabe {
+  return {
+    id: 'b1',
+    datum: new Date('2026-03-01T00:00:00Z'),
+    betragCent: 4250n,
+    richtung: 'AUSGABE',
+    kategorie: 'VERSICHERUNG',
+    gegenstelle: 'Allianz',
+    verwendungszweck: null,
+    kontoId: 'k1',
+    belegId: null,
+    belegFehltBegruendung: null,
+    betrifftBetreute: true,
+    vermoegenswirksam: false,
+    ...teile,
+  }
+}
+
+/** Monatlicher Vertrag über 42,50 EUR. */
+const MONATLICH = { vertragId: 'v1', vertragBeitragCent: 4250n, vertragRhythmus: 'MONATLICH' as const }
+
+describe('Betrag gegen den hinterlegten Beitrag', () => {
+  it('erkennt die passende monatliche Rate', () => {
+    expect(betragPasstZumVertrag(4250n, 4250n, 'MONATLICH')).toBe(true)
+  })
+
+  it('lässt eine Beitragsanpassung durchgehen', () => {
+    // 46,00 statt 42,50 - knapp acht Prozent, das ist eine normale Anpassung.
+    expect(betragPasstZumVertrag(4600n, 4250n, 'MONATLICH')).toBe(true)
+  })
+
+  it('meldet die Prämie, die von 42 auf 420 springt', () => {
+    expect(betragPasstZumVertrag(42_000n, 4250n, 'MONATLICH')).toBe(false)
+  })
+
+  it('meldet auch die Zahlweise, die nicht zum Vertrag passt', () => {
+    // Am Vertrag steht die Monatsrate, die Bank bucht jährlich ab
+    // (12 x 42,50 = 510,00). Das gilt bewusst NICHT als in Ordnung: Dann
+    // stimmen die Vertragsdaten nicht, und das soll auffallen.
+    //
+    // Ein früherer Entwurf hat solche Umrechnungen zugelassen — und damit
+    // ein Toleranzband mit vier Löchern geschaffen. 420 EUR wären als
+    // "nahe am Jahresbetrag von 510" durchgegangen, also ausgerechnet der
+    // Fall, den diese Prüfung fangen soll.
+    expect(betragPasstZumVertrag(51_000n, 4250n, 'MONATLICH')).toBe(false)
+  })
+
+  it('akzeptiert die Rate, sobald die Zahlweise am Vertrag stimmt', () => {
+    // Derselbe Fall, nachdem die Zahlweise berichtigt wurde.
+    expect(betragPasstZumVertrag(51_000n, 51_000n, 'JAEHRLICH')).toBe(true)
+  })
+
+  it('antwortet „unbekannt“, wenn kein Beitrag hinterlegt ist', () => {
+    // Nicht "in Ordnung". Es soll nicht so aussehen, als wäre geprüft worden.
+    expect(betragPasstZumVertrag(4250n, null, 'MONATLICH')).toBeNull()
+    expect(betragPasstZumVertrag(4250n, 0n, 'MONATLICH')).toBeNull()
+  })
+
+  it('antwortet „unbekannt“ ohne Zahlweise und bei EINMALIG', () => {
+    expect(betragPasstZumVertrag(4250n, 4250n, null)).toBeNull()
+    // Zu einer Einmalzahlung gibt es keine wiederkehrende Rate.
+    expect(betragPasstZumVertrag(4250n, 4250n, 'EINMALIG')).toBeNull()
+  })
+
+  it('rechnet mit dem Betrag, nicht mit dem Vorzeichen', () => {
+    expect(betragPasstZumVertrag(-4250n, 4250n, 'MONATLICH')).toBe(true)
+  })
+
+  it('hält die dokumentierte Toleranz ein', () => {
+    expect(BETRAGS_TOLERANZ_PROZENT).toBe(20n)
+    // Genau an der Grenze: 42,50 + 20 % = 51,00.
+    expect(betragPasstZumVertrag(5100n, 4250n, 'MONATLICH')).toBe(true)
+    // Knapp darüber nicht mehr.
+    expect(betragPasstZumVertrag(5200n, 4250n, 'MONATLICH')).toBe(false)
+  })
+})
+
+describe('Belegzustand', () => {
+  it('zählt eine Dauerzahlung als belegt', () => {
+    const b = buchung(MONATLICH)
+    expect(belegDurchVertrag(b)).toBe(true)
+    expect(belegFehlt(b)).toBe(false)
+    expect(belegBegruendet(b)).toBe(false)
+  })
+
+  it('lässt die Anerkennung bei abweichendem Betrag wegfallen', () => {
+    // Der wichtigste Test: Sonst wäre die Zuordnung eine Hintertür.
+    const b = buchung({ ...MONATLICH, betragCent: 42_000n })
+    expect(belegDurchVertrag(b)).toBe(false)
+    expect(betragPruefen(b)).toBe(true)
+    expect(belegFehlt(b)).toBe(true)
+  })
+
+  it('erkennt eine Zuordnung an, wenn am Vertrag kein Beitrag steht', () => {
+    // Zuordnung gilt, aber es wird nicht behauptet, sie sei geprüft.
+    const b = buchung({ vertragId: 'v1', vertragBeitragCent: null, vertragRhythmus: null })
+    expect(belegDurchVertrag(b)).toBe(true)
+    expect(betragPruefen(b)).toBe(false)
+  })
+
+  it('lässt einen echten Beleg vorgehen', () => {
+    const b = buchung({ ...MONATLICH, belegId: 'd1' })
+    expect(belegDurchVertrag(b)).toBe(false)
+    expect(belegFehlt(b)).toBe(false)
+  })
+
+  it('bleibt ohne Zuordnung beim alten Verhalten', () => {
+    expect(belegFehlt(buchung())).toBe(true)
+    expect(belegBegruendet(buchung({ belegFehltBegruendung: 'Barzahlung' }))).toBe(true)
+    expect(belegFehlt(buchung({ belegFehltBegruendung: 'Barzahlung' }))).toBe(false)
+  })
+
+  it('lässt eine Begründung nicht neben den Vertrag treten', () => {
+    // Der Vertrag ist die stärkere Aussage; doppelt gezählt würde die
+    // Summe der Kategorien die Gesamtzahl übersteigen.
+    const b = buchung({ ...MONATLICH, belegFehltBegruendung: 'Dauerauftrag' })
+    expect(belegDurchVertrag(b)).toBe(true)
+    expect(belegBegruendet(b)).toBe(false)
+  })
+})
+
+describe('Belegquote', () => {
+  it('weist die drei Fälle getrennt aus', () => {
+    const quote = belegquote([
+      buchung({ id: '1', belegId: 'd1' }),
+      buchung({ id: '2', ...MONATLICH }),
+      buchung({ id: '3', belegFehltBegruendung: 'Barzahlung' }),
+      buchung({ id: '4' }),
+    ])
+
+    expect(quote.gesamt).toBe(4)
+    expect(quote.mitBeleg).toBe(1)
+    expect(quote.durchVertrag).toBe(1)
+    expect(quote.begruendet).toBe(1)
+    expect(quote.ohneNachweis).toBe(1)
+    expect(quote.quoteProzent).toBe(75)
+  })
+
+  it('rechnet die Kategorien überschneidungsfrei', () => {
+    // Jede Buchung zählt in genau eine Kategorie - sonst ergäbe die Summe
+    // mehr als das Ganze.
+    const buchungen = [
+      buchung({ id: '1', belegId: 'd1' }),
+      buchung({ id: '2', ...MONATLICH }),
+      buchung({ id: '3', ...MONATLICH, belegFehltBegruendung: 'egal' }),
+      buchung({ id: '4', belegFehltBegruendung: 'Barzahlung' }),
+      buchung({ id: '5' }),
+      buchung({ id: '6', ...MONATLICH, betragCent: 99_000n }),
+    ]
+    const q = belegquote(buchungen)
+    expect(q.mitBeleg + q.durchVertrag + q.begruendet + q.ohneNachweis).toBe(q.gesamt)
+  })
+
+  it('zählt eine abweichende Zahlung als zu prüfen und nicht als belegt', () => {
+    const quote = belegquote([buchung({ ...MONATLICH, betragCent: 42_000n })])
+    expect(quote.durchVertrag).toBe(0)
+    expect(quote.zuPruefen).toBe(1)
+    expect(quote.ohneNachweis).toBe(1)
+    expect(quote.quoteProzent).toBe(0)
+  })
+
+  it('bleibt bei null Buchungen bei 100 Prozent', () => {
+    expect(belegquote([]).quoteProzent).toBe(100)
+  })
+})

tests/email.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, it } from 'vitest'
+import {
+  MAILTO_HOECHSTLAENGE,
+  emailFassung,
+  mailtoLink,
+  siehtAusWieEmail,
+} from '@/lib/schreiben/email'
+import { emlErzeugen, kopfzeileKodieren, quotedPrintable } from '@/lib/schreiben/eml'
+
+/**
+ * Schreiben als E-Mail.
+ *
+ * Zwei Gefahren stehen im Mittelpunkt: dass beim Umbau vom Brief zur Mail
+ * stillschweigend Inhalt verloren geht (vor allem der Bestellungsabsatz),
+ * und dass ein mailto-Link einen halben Brief übergibt, ohne dass es
+ * jemand merkt.
+ */
+
+const BRIEF = [
+  'Florian Wilde',
+  'Musterstraße 1',
+  '96450 Coburg',
+  '',
+  'Allianz Lebensversicherungs-AG',
+  '[Straße und Hausnummer]',
+  '[PLZ und Ort]',
+  '',
+  '23.08.2026',
+  '',
+  'Betreff: Auskunft über Rückkaufswert — Franziska Wilde, geb. 23.09.1963',
+  '',
+  'Sehr geehrte Damen und Herren,',
+  '',
+  'ich bin durch Beschluss des Amtsgerichts Lichtenfels (Az. XVII 355/25) ' +
+    'zum rechtlichen Betreuer bestellt.',
+  '',
+  'für ein laufendes Verfahren benötige ich folgende Auskünfte.',
+  '',
+  'Mit freundlichen Grüßen',
+  'Florian Wilde',
+].join('\n')
+
+describe('E-Mail-Fassung aus dem Brief', () => {
+  it('entfernt Absender, Anschrift, Datum und Betreffzeile', () => {
+    const fassung = emailFassung(BRIEF)
+    expect(fassung.text).not.toContain('Musterstraße')
+    expect(fassung.text).not.toContain('[Straße und Hausnummer]')
+    expect(fassung.text).not.toContain('23.08.2026')
+    expect(fassung.text).not.toContain('Betreff:')
+  })
+
+  it('beginnt mit der Anrede und behält den Bestellungsabsatz', () => {
+    // Der Absatz ist der Grund, warum überhaupt geantwortet wird.
+    const fassung = emailFassung(BRIEF)
+    expect(fassung.text.startsWith('Sehr geehrte Damen und Herren,')).toBe(true)
+    expect(fassung.text).toContain('Amtsgerichts Lichtenfels')
+    expect(fassung.text).toContain('Mit freundlichen Grüßen')
+  })
+
+  it('zieht den Betreff aus der Betreffzeile', () => {
+    const fassung = emailFassung(BRIEF)
+    expect(fassung.betreff).toContain('Auskunft über Rückkaufswert')
+    expect(fassung.betreff).toContain('Franziska Wilde')
+  })
+
+  it('lässt einen frei umgebauten Text unangetastet', () => {
+    // Ohne erkennbare Anrede wird nichts entfernt: Lieber ein Briefkopf zu
+    // viel in der Mail als stillschweigend verlorener Inhalt.
+    const frei = 'Hallo Frau Maier,\nhier die gewünschten Unterlagen.\nViele Grüße'
+    const fassung = emailFassung(frei, 'Unterlagen')
+    expect(fassung.text).toContain('Hallo Frau Maier,')
+    expect(fassung.text).toContain('Viele Grüße')
+    expect(fassung.betreff).toBe('Unterlagen')
+  })
+
+  it('faltet mehrfache Leerzeilen zusammen', () => {
+    const fassung = emailFassung(BRIEF)
+    expect(fassung.text).not.toContain('\n\n\n')
+  })
+})
+
+describe('mailto-Link', () => {
+  const fassung = { betreff: 'Kurzer Betreff', text: 'Kurzer Text.' }
+
+  it('baut den Link mit Adresse, Betreff und Text', () => {
+    const link = mailtoLink('service@allianz.de', fassung)
+    expect(link).not.toBeNull()
+    expect(link).toContain('mailto:service%40allianz.de')
+    expect(link).toContain('subject=Kurzer%20Betreff')
+    expect(link).toContain('body=Kurzer%20Text.')
+  })
+
+  it('verweigert den Link bei zu langem Text, statt abzuschneiden', () => {
+    // Der Kern der Beides-Entscheidung: Ein Knopf, der einen halben Brief
+    // übergibt, wäre schlimmer als keiner.
+    const lang = { betreff: 'B', text: 'ä'.repeat(MAILTO_HOECHSTLAENGE) }
+    expect(mailtoLink('a@b.de', lang)).toBeNull()
+  })
+
+  it('verweigert den Link ohne Adresse', () => {
+    expect(mailtoLink('', fassung)).toBeNull()
+    expect(mailtoLink('   ', fassung)).toBeNull()
+  })
+
+  it('rechnet die Grenze nach der Kodierung, nicht davor', () => {
+    // 900 Umlaute sind roh unter der Grenze, kodiert (je 3 Byte -> %C3%A4,
+    // 6 Zeichen) weit darüber.
+    const umlaute = { betreff: 'B', text: 'ä'.repeat(900) }
+    expect(mailtoLink('a@b.de', umlaute)).toBeNull()
+  })
+})
+
+describe('Adressprüfung', () => {
+  it('erkennt gewöhnliche Adressen', () => {
+    expect(siehtAusWieEmail('service@allianz.de')).toBe(true)
+    expect(siehtAusWieEmail('info@stadt-coburg.bayern.de')).toBe(true)
+  })
+
+  it('weist Offensichtliches ab', () => {
+    expect(siehtAusWieEmail('')).toBe(false)
+    expect(siehtAusWieEmail(null)).toBe(false)
+    expect(siehtAusWieEmail('kein-at-zeichen.de')).toBe(false)
+    expect(siehtAusWieEmail('zwei @ leerzeichen@x.de')).toBe(false)
+  })
+})
+
+describe('.eml-Datei', () => {
+  it('trägt Empfänger, Betreff und den vollen Text', () => {
+    const eml = emlErzeugen({
+      an: 'service@allianz.de',
+      betreff: 'Testbetreff',
+      text: 'Zeile eins.\nZeile zwei.',
+    }).toString('utf8')
+
+    expect(eml).toContain('To: service@allianz.de')
+    expect(eml).toContain('Subject: Testbetreff')
+    expect(eml).toContain('Zeile eins.')
+    expect(eml).toContain('Zeile zwei.')
+  })
+
+  it('bittet das Mailprogramm um einen Entwurf', () => {
+    const eml = emlErzeugen({ an: 'a@b.de', betreff: 'B', text: 'T' }).toString('utf8')
+    expect(eml).toContain('X-Unsent: 1')
+  })
+
+  it('erfindet keinen Absender', () => {
+    // Ein erfundener From-Kopf würde je nach Programm übernommen - und
+    // dann ginge die Mail mit falschem Absender hinaus.
+    const eml = emlErzeugen({ an: 'a@b.de', betreff: 'B', text: 'T' }).toString('utf8')
+    expect(eml).not.toMatch(/^From:/m)
+  })
+
+  it('kodiert Umlaute im Betreff nach RFC 2047', () => {
+    const eml = emlErzeugen({ an: 'a@b.de', betreff: 'Rückkaufswert', text: 'T' }).toString('utf8')
+    expect(eml).toContain('Subject: =?UTF-8?B?')
+    // Und zurückgerechnet stimmt der Inhalt.
+    const treffer = eml.match(/Subject: =\?UTF-8\?B\?([A-Za-z0-9+/=]+)\?=/)
+    expect(Buffer.from(treffer![1]!, 'base64').toString('utf8')).toBe('Rückkaufswert')
+  })
+
+  it('lässt einen ASCII-Betreff lesbar', () => {
+    const eml = emlErzeugen({ an: 'a@b.de', betreff: 'Anfrage', text: 'T' }).toString('utf8')
+    expect(eml).toContain('Subject: Anfrage')
+  })
+})
+
+describe('quoted-printable', () => {
+  it('kodiert Umlaute und lässt ASCII lesbar', () => {
+    const kodiert = quotedPrintable('Grüße')
+    expect(kodiert).toContain('Gr')
+    expect(kodiert).toContain('=C3=BC')
+    expect(kodiert).toContain('=C3=9F')
+  })
+
+  it('kodiert das Gleichheitszeichen', () => {
+    expect(quotedPrintable('a=b')).toBe('a=3Db')
+  })
+
+  it('hält die 76-Zeichen-Grenze je Zeile ein', () => {
+    const kodiert = quotedPrintable('ä'.repeat(200))
+    for (const zeile of kodiert.split('\r\n')) {
+      expect(zeile.length).toBeLessThanOrEqual(76)
+    }
+  })
+
+  it('lässt Kopfzeilen ohne Sonderzeichen unkodiert', () => {
+    expect(kopfzeileKodieren('Anfrage 2026')).toBe('Anfrage 2026')
+  })
+})

tests/schreiben.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest'
+import {
+  SCHREIBEN_ARTEN,
+  SCHREIBEN_EIGENSCHAFTEN,
+  dateinameFuerSchreiben,
+  istSchreibenArt,
+} from '@/lib/schreiben/arten'
+import { RUECKKAUFSWERT_WIEDERVORLAGE_TAGE } from '@/lib/vertraege/rueckkaufswert'
+import { NACHFASSEN_AB_TAGEN } from '@/lib/vorgaenge/sachstandsanfrage'
+
+/**
+ * Schreiben erzeugen — die Teile ohne Datenbank.
+ *
+ * Der Schwerpunkt liegt auf zwei Dingen, die sonst still auseinanderlaufen:
+ * den Wiedervorlagefristen (sie stehen an zwei Stellen) und dem Dateinamen
+ * (er landet im Objektspeicher und im Download).
+ */
+
+describe('Arten von Schreiben', () => {
+  it('erkennt bekannte Arten und weist alles andere ab', () => {
+    expect(istSchreibenArt('RUECKKAUFSWERT')).toBe(true)
+    expect(istSchreibenArt('FREI')).toBe(true)
+    expect(istSchreibenArt('etwas-anderes')).toBe(false)
+    expect(istSchreibenArt(null)).toBe(false)
+    expect(istSchreibenArt(undefined)).toBe(false)
+  })
+
+  it('beschreibt jede Art vollständig', () => {
+    for (const art of SCHREIBEN_ARTEN) {
+      const eigenschaft = SCHREIBEN_EIGENSCHAFTEN[art]
+      expect(eigenschaft.beschriftung.length, art).toBeGreaterThan(3)
+      // Wo es eine Frist gibt, muss auch dastehen, warum sie so lang ist.
+      if (eigenschaft.wiedervorlageTage !== null) {
+        expect(eigenschaft.fristBegruendung, art).toBeTruthy()
+      }
+    }
+  })
+
+  it('schlägt für ein freies Schreiben KEINE Frist vor', () => {
+    // Bei einem freien Schreiben weiß niemand, ob und wann eine Antwort
+    // kommt. Eine erfundene Frist wäre schlechter als keine.
+    expect(SCHREIBEN_EIGENSCHAFTEN.FREI.wiedervorlageTage).toBeNull()
+  })
+})
+
+describe('Wiedervorlagefristen bleiben mit den Modulen im Gleichschritt', () => {
+  it('nimmt beim Rückkaufswert dieselbe Zahl wie das Vertragsmodul', () => {
+    // Sie steht dort für die Anzeige am Vertrag, hier für die erzeugte
+    // Frist. Laufen sie auseinander, mahnt die Anwendung zu zwei
+    // verschiedenen Terminen — und man glaubt keinem mehr.
+    expect(SCHREIBEN_EIGENSCHAFTEN.RUECKKAUFSWERT.wiedervorlageTage).toBe(
+      RUECKKAUFSWERT_WIEDERVORLAGE_TAGE,
+    )
+  })
+
+  it('nimmt bei der Sachstandsanfrage dieselbe Zahl wie das Vorgangsmodul', () => {
+    expect(SCHREIBEN_EIGENSCHAFTEN.SACHSTAND.wiedervorlageTage).toBe(NACHFASSEN_AB_TAGEN)
+  })
+})
+
+describe('Dateiname', () => {
+  const tag = new Date('2026-08-23T00:00:00.000Z')
+
+  it('beginnt mit dem Datum, damit die Dateien sortierbar bleiben', () => {
+    const name = dateinameFuerSchreiben('KUENDIGUNG', 'Allianz', tag, 'docx')
+    expect(name.startsWith('2026-08-23_')).toBe(true)
+    expect(name.endsWith('.docx')).toBe(true)
+  })
+
+  it('nennt Art und Empfänger', () => {
+    const name = dateinameFuerSchreiben('KUENDIGUNG', 'Allianz', tag, 'pdf')
+    expect(name).toContain('Kuendigung')
+    expect(name).toContain('Allianz')
+    expect(name.endsWith('.pdf')).toBe(true)
+  })
+
+  it('löst Umlaute auf und wirft Sonderzeichen heraus', () => {
+    // Der Name geht in den Objektspeicher und über einen HTTP-Kopf. Beides
+    // verträgt keine Umlaute und keine Anführungszeichen.
+    const name = dateinameFuerSchreiben('FREI', 'Müller & Co. "Süd"', tag, 'docx')
+    // Nur der Namensteil — der Punkt vor der Endung gehört dazu.
+    const ohneEndung = name.replace(/\.docx$/, '')
+
+    expect(name).not.toMatch(/[^\x20-\x7E]/)
+    expect(ohneEndung).not.toMatch(/["&.]/)
+    expect(name).toContain('Mueller')
+    expect(name).toContain('Sued')
+  })
+
+  it('kommt ohne Empfänger aus', () => {
+    const name = dateinameFuerSchreiben('FREI', null, tag, 'docx')
+    expect(name).toBe('2026-08-23_Freies-Schreiben.docx')
+  })
+
+  it('kürzt einen sehr langen Empfänger, statt den Namen ausufern zu lassen', () => {
+    const lang = 'Sehr Lange Versicherungsgesellschaft auf Gegenseitigkeit in Oberfranken'
+    const name = dateinameFuerSchreiben('FREI', lang, tag, 'pdf')
+    expect(name.length).toBeLessThan(90)
+  })
+})

tests/serienabfrage.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest'
+import {
+  SPERRFRIST_TAGE,
+  bewerten,
+  heuteSchonAngefragt,
+  kandidatenBewerten,
+  type SerienKandidat,
+} from '@/lib/vertraege/serienabfrage'
+import { RUECKKAUFSWERT_WIEDERVORLAGE_TAGE } from '@/lib/vertraege/rueckkaufswert'
+
+/**
+ * Serienabfrage der Rückkaufswerte — die Auswahllogik.
+ *
+ * Der teuerste Fehler wäre hier ein Brief zu viel an der falschen Stelle
+ * (die Gesellschaft antwortet auf die zweite Anfrage mit Verwirrung) oder
+ * ein stumm fehlender Vertrag (der Wert fehlt dann im Vermögensverzeichnis).
+ * Beides wird geprüft.
+ */
+
+const HEUTE = new Date('2026-08-23T00:00:00.000Z')
+
+function vertrag(teile: Partial<SerienKandidat> = {}): SerienKandidat {
+  return {
+    id: 'v1',
+    bezeichnung: 'Lebensversicherung',
+    gesellschaft: 'Allianz',
+    art: 'LEBENSVERSICHERUNG',
+    status: 'AKTIV',
+    rueckkaufswertAngefragtAm: null,
+    ...teile,
+  }
+}
+
+function vorTagen(tage: number): Date {
+  const d = new Date(HEUTE)
+  d.setUTCDate(d.getUTCDate() - tage)
+  return d
+}
+
+describe('Bewertung eines Vertrags', () => {
+  it('wählt eine unbefragte Lebensversicherung vor', () => {
+    const b = bewerten(vertrag(), HEUTE)
+    expect(b.moeglich).toBe(true)
+    expect(b.vorausgewaehlt).toBe(true)
+    expect(b.hindernis).toBeNull()
+  })
+
+  it('schließt Vertragsarten ohne Rückkaufswert aus — mit Begründung', () => {
+    const b = bewerten(vertrag({ art: 'HAFTPFLICHT' }), HEUTE)
+    expect(b.moeglich).toBe(false)
+    expect(b.hindernis).toContain('keinen Rückkaufswert')
+  })
+
+  it('schließt verwertete und abgelaufene Verträge aus', () => {
+    expect(bewerten(vertrag({ status: 'VERWERTET' }), HEUTE).moeglich).toBe(false)
+    expect(bewerten(vertrag({ status: 'ABGELAUFEN' }), HEUTE).moeglich).toBe(false)
+  })
+
+  it('lässt einen gekündigten Vertrag zu', () => {
+    // Bis zum Wirksamwerden besteht der Vertrag - und genau dann will der
+    // Sozialhilfeträger den Wert sehen.
+    const b = bewerten(vertrag({ status: 'GEKUENDIGT' }), HEUTE)
+    expect(b.moeglich).toBe(true)
+  })
+
+  it('verlangt eine Gesellschaft und sagt, was zu tun ist', () => {
+    const b = bewerten(vertrag({ gesellschaft: null }), HEUTE)
+    expect(b.moeglich).toBe(false)
+    expect(b.hindernis).toContain('nachtragen')
+  })
+
+  it('wählt einen frisch angefragten Vertrag NICHT vor, lässt ihn aber wählbar', () => {
+    // Der Brief könnte verloren gegangen sein - dann wählt man von Hand an.
+    const b = bewerten(vertrag({ rueckkaufswertAngefragtAm: vorTagen(10) }), HEUTE)
+    expect(b.moeglich).toBe(true)
+    expect(b.vorausgewaehlt).toBe(false)
+    expect(b.hindernis).toContain('bereits angefragt')
+    expect(b.tageSeitAnfrage).toBe(10)
+  })
+
+  it('wählt nach Ablauf der Sperrfrist wieder vor', () => {
+    const b = bewerten(vertrag({ rueckkaufswertAngefragtAm: vorTagen(SPERRFRIST_TAGE) }), HEUTE)
+    expect(b.vorausgewaehlt).toBe(true)
+  })
+
+  it('hält die Sperrfrist mit der Wiedervorlage im Gleichschritt', () => {
+    // Beide 28 Tage: Solange die Wiedervorlage läuft, ist die Antwort
+    // unterwegs - eine zweite Anfrage davor wäre nur Verwirrung.
+    expect(SPERRFRIST_TAGE).toBe(RUECKKAUFSWERT_WIEDERVORLAGE_TAGE)
+  })
+})
+
+describe('Sortierung der Kandidaten', () => {
+  it('stellt Vorausgewählte nach oben, Unmögliche ans Ende', () => {
+    const bewertet = kandidatenBewerten(
+      [
+        vertrag({ id: 'a', bezeichnung: 'Zulassung', art: 'HAFTPFLICHT' }),
+        vertrag({ id: 'b', bezeichnung: 'Beitragsfrei' }),
+        vertrag({ id: 'c', bezeichnung: 'Angefragt', rueckkaufswertAngefragtAm: vorTagen(5) }),
+      ],
+      HEUTE,
+    )
+
+    expect(bewertet[0]!.vertrag.id).toBe('b')
+    expect(bewertet[1]!.vertrag.id).toBe('c')
+    expect(bewertet[2]!.vertrag.id).toBe('a')
+  })
+})
+
+describe('Dublettenschutz', () => {
+  it('erkennt die Anfrage vom selben Tag', () => {
+    expect(heuteSchonAngefragt(HEUTE, HEUTE)).toBe(true)
+  })
+
+  it('lässt eine bewusste zweite Anfrage nach einer Woche zu', () => {
+    // Tagesgenau, nicht sperrfristgenau: Der Doppelklick soll abgefangen
+    // werden, die bewusste Wiederholung (Brief verloren) nicht.
+    expect(heuteSchonAngefragt(vorTagen(7), HEUTE)).toBe(false)
+  })
+
+  it('meldet ohne Anfrage nichts', () => {
+    expect(heuteSchonAngefragt(null, HEUTE)).toBe(false)
+  })
+})

tests/skripte.test.ts

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

tests/wiederkehrend.test.ts

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