Merge #33: Ein Jahr Kontobewegungen im Beispielfall

Behebt Issue #22: 107 Buchungen ueber zwoelf Monate im Demofall, mit
gerechnetem Kontostand. Dazu behoben: gGmbH fehlte in der Rechtsformliste
beim Zusammenfassen wiederkehrender Zahlungen.

Closes #22

CHANGELOG.md

@@ -26,6 +26,364 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [1.10.1] – 2026-08-23
+
+### Geändert
+
+- **Der Beispielfall hat jetzt ein Jahr Kontobewegungen**
+  ([#22](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/22)).
+  Bisher brachte er Konten und Kontostände mit, aber keine einzige
+  Buchung — Kassenbuch, Belegpflicht, Dauerzahlungen und die Erkennung
+  wiederkehrender Zahlungen liefen darin also leer. Wer die Anwendung zum
+  ersten Mal ansah, musste erst eine CSV importieren.
+
+  Neu sind 107 Buchungen über zwölf Monate: Rente, Betriebsrente und
+  Pflegekasse als Einnahmen, Heimentgelt, Barbetrag, Sterbegeldbeitrag,
+  Telefon und Kontoführung als monatliche Ausgaben, dazu Rundfunkbeitrag
+  und Grundsteuer vierteljährlich sowie eine Handvoll Einzelposten.
+
+  Das betrifft nur neue Installationen mit `SEED_DEMO=true` — an einem
+  bestehenden Bestand ändert sich nichts.
+
+### Behoben
+
+- **„gGmbH" wurde nicht als Rechtsform erkannt.** Beim Zusammenfassen
+  wiederkehrender Zahlungen galten „Seniorenzentrum St. Katharina" und
+  „Seniorenzentrum St. Katharina gGmbH" als zwei verschiedene Empfänger —
+  und damit zerfiel die Gruppe genau dort, wo sie am meisten zählt: Heime,
+  Sozialdienste und Träger sind fast durchweg gGmbH.
+
+### Was der Beispielfall jetzt zeigt
+
+- Das Heimentgelt steht in **drei Schreibweisen** auf dem Auszug und wird
+  trotzdem als eine monatliche Zahlung von 2.489 € geführt.
+- Genau **eine** Buchung hat weder Quittung noch Begründung — damit die
+  Belegpflicht etwas zu zeigen hat, aber die Liste nicht rot leuchtet.
+- Die Sterbegeld-Lastschriften sind bewusst **nicht** zugeordnet: So lässt
+  sich der Handgriff „zwölf Zahlungen als belegt zuordnen" ausprobieren.
+  Der Beitrag steigt im Mai von 18,40 € auf 19,80 €, damit auch die
+  Abweichungsprüfung sichtbar wird.
+- Der Kontostand zum 31.07.2026 wird aus dem Anfangsstand und den
+  Buchungen **gerechnet**, nicht behauptet. Ein Beispielfall, der sich
+  selbst widerspricht, wäre schlimmer als einer ohne Buchungen.
+
+### Geprüft
+
+- Ein Einheitstest für die gGmbH-Erkennung.
+- Vier End-to-End-Tests am Beispielfall: Umfang und Zeitraum der
+  Buchungen, die Übereinstimmung von Kontostand und Buchungssumme, die
+  erkannten Zahlungsgruppen und das Kassenbuch.
+
+## [1.10.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Deine Anschrift steht jetzt in jedem Schreiben**
+  ([#21](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/21)).
+  Bisher ging jeder Brief ohne Rücksendeadresse hinaus — im
+  Absenderblock stand nur dein Name, und in der Datumszeile fehlte der
+  Ort. Bei einer Versicherung oder Behörde wirkt das unseriös und macht
+  es der Gegenstelle unnötig schwer zu antworten.
+
+  Unter **Mein Konto → Meine Anschrift** einmal Straße, PLZ und Ort
+  hinterlegen. Ab da stehen sie im Absenderblock jedes erzeugten
+  Schreibens, und die Datumszeile lautet „Bayreuth, den 23.08.2026".
+  Betroffen ist alles: Rückkaufswert-Anfrage, Serienabfrage, Kündigung,
+  Sachstandsanfrage und die eigenen Vorlagen.
+
+- **Zwei neue Platzhalter** für eigene Vorlagen: `{{betreuer_anschrift}}`
+  und `{{betreuer_ort}}`.
+
+### Eine Zusage
+
+**Was fehlt, bleibt weg.** Jede der drei Angaben ist einzeln freiwillig.
+Hinterlegst du nur den Ort, bekommst du die Datumszeile mit Ort und einen
+Absenderblock, der weiterhin nur aus deinem Namen besteht — keine leeren
+Zeilen, kein Komma ohne Ort. Eine halb ausgefüllte Adresse sieht nach
+Fehler aus, ein bloßer Name nach Absicht.
+
+### Datenbank
+
+Eine Migration: drei Felder am Benutzer. Die Anschrift hängt an dir und
+nicht an der betreuten Person — sie gilt für alle Akten.
+
+### Geprüft
+
+- Sieben Einheitstests für den Absenderblock, darunter jede
+  Teilbefüllung und die Gegenprobe, dass nie die Heimadresse der
+  betreuten Person im Absender landet.
+- Vier End-to-End-Tests: der Brief ohne hinterlegte Anschrift, das
+  Speichern unter *Mein Konto*, der Brief danach und die Gegenprobe am
+  Rückkaufswert-Schreiben.
+
+## [1.9.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Ansprechpartner am Vorgang**
+  ([#9](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/9)).
+  Ein namentlich adressiertes Schreiben landet bei der Person, die den
+  Vorgang kennt, statt in der Poststelle — beim Bezirk ist das der
+  Unterschied zwischen zwei Wochen und zwei Monaten. Am Vorgang lässt
+  sich jetzt ein Kontakt aus dem Verzeichnis als Ansprechpartner
+  benennen.
+
+- **Die Sachstandsanfrage redet ihn an.** Aus „Sehr geehrte Damen und
+  Herren" wird „Sehr geehrte Frau Sachs" — und der Name steht über der
+  Behörde, damit die Poststelle den Brief zur Person sortiert. Auch das
+  Schreiben aus dem Editor übernimmt Anrede, Empfänger und Anschrift,
+  sodass nichts abgetippt werden muss.
+
+- **Anrede am Kontakt.** Damit die Briefanrede stimmt, trägt ein Kontakt
+  wahlweise „Frau" oder „Herr". **Geraten wird nie:** Ohne Angabe wird
+  mit vollem Namen angeredet („Sehr geehrte(r) Kim Berger,"). Eine
+  falsch geratene Anrede fällt dem Empfänger sofort auf und kostet genau
+  die Aufmerksamkeit, die man gewinnen wollte.
+
+- **Vor dem Anruf weiß man, wen man fragt.** Auf der Vorgangsseite steht
+  der Ansprechpartner mit Organisation, Durchwahl und E-Mail, verlinkt
+  auf den Kontakt.
+
+### Zwei Zusagen
+
+**Ohne Ansprechpartner ändert sich nichts.** Ist keiner benannt, bleibt
+es bei „Sehr geehrte Damen und Herren" — und die Vorgangsseite sagt das
+auch, statt ein leeres Feld zu zeigen. Ein halb gefüllter Name führt nie
+zu einer verstümmelten Anrede wie „Sehr geehrte Frau ,".
+
+**Der Wechsel bleibt nachvollziehbar.** Wer den Ansprechpartner
+austauscht, findet den Vorgänger im Protokoll — mit **Namen**, nicht mit
+der internen Kennung. Zwei Kennungen nebeneinander wären protokolliert,
+aber nicht nachvollziehbar.
+
+### Datenbank
+
+Eine Migration: `ansprechpartnerId` am Vorgang und `anrede` am Kontakt.
+Wird ein Kontakt gelöscht, bleibt der Vorgang bestehen und verliert nur
+den Verweis — ein Vorgang darf nicht daran hängen, dass es den Kontakt
+noch gibt.
+
+### Geprüft
+
+- Neun Einheitstests für die Anrede, darunter der Nachname aus „Dr. Anna
+  Maria Schmitt", der Doppelname und der Fall, der nie passieren darf:
+  leerer Name mit gesetzter Anrede.
+- Fünf End-to-End-Tests: die allgemeine Anrede ohne Ansprechpartner, das
+  Benennen samt Anzeige mit Durchwahl, die namentliche Anrede in der
+  Sachstandsanfrage, die vorbelegte Anschrift im Schreiben und der
+  Wechsel im Protokoll.
+
+## [1.8.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Der Rückkaufswert steht jetzt beim Vertrag**
+  ([#8](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/8)).
+  Am Telefon mit der Gesellschaft braucht man die Zahl dort, wo man sie
+  gefragt hat — nicht nach einem Umweg über das Vermögensverzeichnis.
+  Auf der Vertragsseite steht deshalb oben der zuletzt mitgeteilte Wert
+  mit Stichtag und Quelle, darunter die vollständige Historie.
+
+- **Ein alter Wert sagt, dass er alt ist.** Ist der jüngste Wert älter
+  als ein Jahr, steht „über ein Jahr alt" daneben — in der
+  Vertragsübersicht wie auf der Vertragsseite. Ein veralteter Betrag
+  ohne erkennbares Alter ist schlimmer als kein Betrag: Man rechnet mit
+  ihm weiter und merkt es erst, wenn der Bezirk nachfragt. Die Grenze von
+  einem Jahr gilt jetzt überall dieselbe; im Vermögensverzeichnis stand
+  sie schon, am Vertrag fehlte sie.
+
+- **Verträge ohne Wert bleiben nicht stumm.** Wo ein Rückkaufswert zu
+  erwarten wäre, aber keiner erfasst ist, steht „noch nicht erfasst"
+  statt einer leeren Zelle.
+
+### Behoben
+
+- **Ein Vertrag hatte unter Umständen zwei Wertreihen.** Vertrag und
+  Vermögensposten wurden über die *Art* des Postens zusammengeführt.
+  Wer einen Posten von Hand anlegte und ihn als etwas anderes als
+  „Versicherung" führte, bekam beim ersten Eintragen am Vertrag
+  klammheimlich einen zweiten Posten — und damit zwei Wahrheiten, von
+  denen der Bericht die eine und der Vertrag die andere zeigte.
+  Maßgeblich ist jetzt die Verknüpfung mit dem Vertrag, nicht die Art.
+
+- **Fehlende Prüfung bei Verweisen auf Vertrag und Immobilie.** Beim
+  Speichern eines Vermögenspostens wurde geprüft, ob das verknüpfte
+  *Konto* zur betreuten Person gehört — bei Vertrag und Immobilie fehlte
+  dieselbe Prüfung, ebenso beim Vertragsverweis einer Buchung. Bei
+  mehreren betreuten Personen hätte ein manipuliertes Formular eine
+  Verknüpfung über Aktengrenzen hinweg anlegen können. Jetzt wird jeder
+  der drei Verweise gleich behandelt.
+
+### Geprüft
+
+- Zehn Einheitstests: die Ein-Jahres-Grenze (auch der Tag davor und
+  danach), das Alter taggenau und ohne Uhrzeiteinfluss, ein künftiger
+  Stichtag, und die Zusammenführung mehrerer Posten zu einer Historie.
+- Vier End-to-End-Tests: Wert und Stichtag in der Übersicht, das
+  Abzeichen am alten Wert, die Historie am Vertrag, und ein neu
+  eingetragener Wert, der unverändert im Vermögensverzeichnis
+  wiederauftaucht.
+
+## [1.7.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Eigene Vorlagen für Anschreiben**
+  ([#7](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/7)).
+  Wer zum dritten Mal denselben Brief tippt, tippt ihn beim vierten Mal
+  falsch. Neu unter **Einstellungen → Schreibvorlagen**: eigene Texte
+  hinterlegen, beim freien Schreiben auswählen — der Rest füllt sich aus
+  den Daten, die ohnehin im System stehen.
+
+- **Platzhalter, die sich selbst erklären.** Neben dem Editor steht die
+  vollständige Liste — Name, wofür er steht, woher der Wert kommt. Ein
+  Klick setzt ihn an die Cursorstelle; niemand muss `{{…}}`-Namen raten
+  oder abtippen. Verfügbar sind unter anderem Name und Geburtsdatum der
+  betreuten Person, ihre Anschrift, Betreuungsgericht und Aktenzeichen,
+  das Bestellungsdatum, der Stichtag und das heutige Datum.
+
+- **Vier mitgelieferte Vorlagen** als Ausgangspunkt: Auskunftsersuchen an
+  eine noch unbekannte Stelle, Adressänderung nach Heimeinzug, Nachweis
+  der Vertretungsmacht (wenn eine Stelle die Auskunft verweigert) und die
+  Kurzfassung der Rückkaufswert-Anfrage. Sie lassen sich nicht kaputt
+  bearbeiten — „Als Kopie übernehmen" legt eine eigene Fassung an, das
+  Original bleibt liegen. Für Rückkaufswert und Kündigung führt die
+  Oberfläche weiter zuerst zu den fallbezogenen Erzeugern: Die rechnen
+  Kündigungstermine aus, was eine Vorlage nicht kann.
+
+### Zwei Zusagen
+
+**Nichts geht stillschweigend schief.** Fehlt ein Wert (etwa das
+Aktenzeichen), steht im Brief eine sichtbare Lücke `[Aktenzeichen des
+Gerichts]` — kein Leerraum, den erst der Empfänger bemerkt. Ein
+Tippfehler im Platzhalternamen bricht nicht ab, sondern wird im Text
+markiert und über dem Editor benannt.
+
+**Der Bestellungsabsatz wird nicht vergessen.** Ohne den Nachweis der
+Vertretungsmacht kommt keine Auskunft — und das fällt erst nach vier
+Wochen auf. Beim Speichern einer Vorlage ohne Bestellungsabsatz kommt
+deshalb eine Rückfrage. Wer ihn bewusst weglässt (etwa für die zweite
+Mail an eine Stelle, die den Nachweis schon hat), bestätigt einmal und
+wird nicht weiter gefragt. Ein ausformulierter Absatz zählt genauso wie
+der Platzhalter.
+
+### Geändert
+
+- Gelöschte Vorlagen liegen wie alles andere **30 Tage im Papierkorb**
+  und lassen sich zurückholen. Beim Vollexport der Akte sind sie mit
+  dabei.
+
+### Geprüft
+
+- Dreizehn Einheitstests für die Platzhalter-Ersetzung, darunter jeder
+  der drei Fälle (Wert einsetzen, sichtbare Lücke, unbekannter
+  Platzhalter) und die Bestellungsabsatz-Erkennung, die sich nicht von
+  einem halben Nachweis („Beschluss der Eigentümerversammlung") täuschen
+  lässt.
+- Sechs End-to-End-Tests: die zweistufige Warnung, das Übernehmen einer
+  mitgelieferten Vorlage, die Auflösung im Editor samt markierter
+  Tippfehler und der Weg durch den Papierkorb.
+
+## [1.6.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Rückkaufswerte aller Versicherungen in einem Zug anfragen**
+  ([#6](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/6)).
+  Vor dem Vermögensverzeichnis und vor jedem Jahresbericht braucht es von
+  jeder Lebens- und Rentenversicherung den Rückkaufswert zum Stichtag —
+  jedes Mal dieselben fünf bis zehn Briefe. Das war der Handgriff, der im
+  Jahr am meisten Zeit gekostet hat.
+
+  Neu unter **Verträge → Rückkaufswerte anfragen**: Stichtag wählen, Liste
+  prüfen, ein Klick. Heraus kommt ein **ZIP mit einer Word-Datei je
+  Gesellschaft** plus Begleitblatt — und je Vertrag entsteht nebenbei die
+  PDF-Fassung in der Akte, die Wiedervorlage nach 28 Tagen und der
+  Vermerk, dass angefragt wurde. Auf „Heute" steht danach unter *Wartet
+  auf andere*, worauf gewartet wird und seit wann.
+
+- **Die Auswahl begründet sich selbst.** Vorausgewählt ist nur, was in
+  Frage kommt. Was nicht in Frage kommt, wird nicht stumm ausgeblendet,
+  sondern steht mit Grund in der Liste: „Ohne Gesellschaft fehlt der
+  Empfänger", „bereits vor 10 Tagen angefragt". Nur Vertragsarten, die
+  nie einen Rückkaufswert bilden (Strom, Haftpflicht), bleiben draußen.
+  Gekündigte Verträge bleiben anfragbar — bis zum Wirksamwerden besteht
+  der Vertrag, und genau dann will der Sozialhilfeträger den Wert sehen.
+
+- **Die Zahl steht vor dem Klick auf dem Knopf** („4 Schreiben erzeugen").
+  Einen Fehlgriff soll man bemerken, bevor zehn Briefe entstehen — nicht
+  danach beim Aufräumen.
+
+### Zwei Zusagen
+
+**Kein Alles-oder-nichts.** Jeder Vertrag läuft für sich. Scheitert einer
+(etwa am Objektspeicher), steht er mit Grund im Begleitblatt des ZIP —
+die übrigen laufen durch. Eine Transaktion über alle wäre die falsche
+Zusage: Wenn der neunte Brief scheitert, sollen die acht fertigen nicht
+verworfen werden.
+
+**Der Doppelklick kostet nichts.** Ein zweiter Lauf am selben Tag
+überspringt bereits angefragte Verträge und sagt es im Begleitblatt —
+keine doppelten Dokumente, keine doppelten Wiedervorlagen. Eine bewusste
+zweite Anfrage nach einer Woche (Brief verloren) bleibt möglich: von Hand
+anwählen genügt.
+
+### Geprüft
+
+- Zwölf Einheitstests für die Auswahllogik, darunter der Gleichschritt
+  von Sperrfrist und Wiedervorlage (beide 28 Tage — liefen sie
+  auseinander, würde gemahnt und zugleich neu angefragt).
+- Drei End-to-End-Tests: Vorauswahl samt Begründungen, der volle Lauf mit
+  allen Nebenwirkungen in der Datenbank, und der Dublettenschutz beim
+  zweiten Lauf.
+
+## [1.5.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Schreiben als E-Mail übernehmen**
+  ([#5](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/5)).
+  Vieles geht heute per E-Mail hinaus, nicht per Brief. Im Schreiben-Editor
+  gibt es jetzt den Umschalter **Als Brief / Als E-Mail**.
+
+  Die E-Mail-Fassung wird aus dem — womöglich schon bearbeiteten —
+  Brieftext abgeleitet: ohne Absenderblock, Anschrift und Datumszeile, die
+  gehören in den Brief und nicht in die Mail. **Der Bestellungsabsatz
+  bleibt drin** — ohne ihn kommt die Auskunft nicht. Betreff und Text sind
+  einzeln kopierbar.
+
+- **Zwei Wege ins Mailprogramm.** Die offene Entscheidung aus dem Issue
+  (mailto oder .eml) ist mit *beides* beantwortet:
+
+  **„Im Mailprogramm öffnen"** (mailto) für kurze Texte — der Knopf
+  verschwindet, sobald der kodierte Link 1800 Zeichen übersteigt. mailto
+  übergibt den Text in der Adresszeile, deren Länge nirgends zugesichert
+  ist; ein stillschweigend halbierter Brief fällt erst beim Empfänger auf.
+
+  **„Als E-Mail-Entwurf (.eml)"** immer: eine Datei, die sich im
+  Mailprogramm als fertiger Entwurf öffnet — Adresse, Betreff und voller
+  Text garantiert vollständig, mit korrekt kodierten Umlauten. Die Datei
+  erfindet bewusst keinen Absender: den trägt das Mailprogramm beim
+  Senden selbst ein.
+
+  Beide Knöpfe erscheinen nur, wenn eine E-Mail-Adresse da ist — aus dem
+  gewählten Kontakt übernommen oder von Hand eingetragen. Ohne Adresse
+  bleibt das Kopieren.
+
+- **Die Ablage kennt den Unterschied.** Eine als E-Mail abgelegte
+  Nachricht heißt in der Akte „E-Mail: …" und die PDF-Fassung trägt die
+  Empfängeradresse im Kopf — abgelegt wird die E-Mail-Fassung, nicht der
+  Brieftext. In der Akte soll stehen, was tatsächlich hinausging.
+
+### Geprüft
+
+- 20 Einheitstests: die Ableitung der E-Mail-Fassung (nichts geht
+  stillschweigend verloren, der Bestellungsabsatz bleibt), die
+  mailto-Längengrenze **nach** der Kodierung, das .eml-Format samt
+  Umlauten nach RFC 2047 und quoted-printable.
+- Vier End-to-End-Tests: Fassung ohne Briefkopf, .eml-Download, kein
+  Mailknopf ohne Adresse, Ablage als gekennzeichnete E-Mail.
+
 ## [1.4.0] – 2026-08-23
 
 ### Hinzugefügt
@@ -768,7 +1126,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.4.0...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.10.1...HEAD
+[1.10.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.10.0...v1.10.1
+[1.10.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.9.0...v1.10.0
+[1.9.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.8.0...v1.9.0
+[1.8.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.7.0...v1.8.0
+[1.7.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.6.0...v1.7.0
+[1.6.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.5.0...v1.6.0
+[1.5.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.4.0...v1.5.0
 [1.4.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.3.0...v1.4.0
 [1.3.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.2.0...v1.3.0
 [1.2.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.2...v1.2.0

README.md

@@ -97,11 +97,12 @@ DATABASE_URL="postgresql://cockpit:entwicklung@localhost:5433/betreuungs_cockpit
 **3. Datenbank einrichten:**
 
 ```bash
-npx prisma migrate dev --name fundament
+npm run setup             # Migrationen, Volltextsuche, Audit-Schutz, Beispieldaten
-npm run db:sql            # Volltextsuche und Audit-Schutz
-npm run db:seed
 ```
 
+Das ist die Kurzform für `db:deploy`, `db:sql` und `db:seed` — die drei
+Schritte laufen ohne Rückfrage durch.
+
 **4. Starten:**
 
 ```bash
@@ -513,6 +514,35 @@ npm run protokoll        # Bauprotokoll aus der Git-Historie
 npm run version -- patch # Version anheben, Changelog vorbereiten
 ```
 
+### Die Datenbankbefehle
+
+Welcher Befehl wofür — und welcher am Terminal Rückfragen stellt. Nur
+`db:migrate` ist interaktiv; alle anderen laufen in Skripten, in der CI
+und im Container durch.
+
+| Befehl | Wofür | Rückfragen? |
+|---|---|---|
+| `npm run setup` | Ersteinrichtung: Migrationen, SQL-Skripte, Beispieldaten | nein |
+| `npm run db:migration -- <name>` | Schemaänderung während der Entwicklung — erzeugt die Migration und nimmt die `DROP INDEX`-Zeilen zur Volltextsuche heraus | nein |
+| `npm run db:deploy` | Vorhandene Migrationen anwenden (Server, CI, Container) | nein |
+| `npm run db:migrate` | `prisma migrate dev` — fragt nach dem Namen und bietet an, die Datenbank zurückzusetzen | **ja** |
+| `npm run db:sql` | Volltextsuche und Audit-Schutz; läuft nicht mit den Migrationen mit | nein |
+| `npm run db:pruefen` | Nachsehen, ob die Trigramm-Indizes noch stehen | nein |
+| `npm run db:seed` | Beispieldaten einspielen | nein |
+
+Der übliche Weg für eine Schemaänderung:
+
+```bash
+# Schema in prisma/schema.prisma ändern, dann
+npm run db:migration -- ansprechpartner   # erzeugen und lesen
+npm run db:deploy                          # anwenden
+npm run db:pruefen                         # Indizes nachsehen
+```
+
+`db:migrate` braucht man dafür nicht mehr. Es bleibt für die Fälle, in
+denen man wirklich den interaktiven Prisma-Ablauf will — etwa um eine
+verkorkste Entwicklungsdatenbank zurückzusetzen.
+
 Konventionen — verbindlich für alle Beiträge:
 [`docs/KONVENTIONEN.md`](docs/KONVENTIONEN.md).
 Schnittstellen zwischen den Modulen:
@@ -545,7 +575,8 @@ Produktion.
   über den Abschnitt `environment:`.
 - Beim ersten Start eines Containers laufen die Migrationen automatisch
   mit. Die beiden SQL-Skripte (Volltextsuche, Audit-Schutz) sind
-  **einmalig von Hand** anzustoßen, siehe oben.
+  **einmalig von Hand** anzustoßen, siehe oben. Beim Aktualisieren
+  erledigt das `scripts/update.sh` mit — beide Skripte sind idempotent.
 
 ### Technische Grundlage
 
@@ -580,11 +611,11 @@ Fehler, die während des Baus aufgefallen sind.
 
 | | | nachzuzählen mit |
 |---|---:|---|
-| Zeilen TypeScript/TSX | 76.610 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
+| Zeilen TypeScript/TSX | 79.102 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
 | Prisma-Modelle | 34 | `grep -c '^model ' prisma/schema.prisma` |
-| Seiten | 81 | `find src/app -name page.tsx \| wc -l` |
+| Seiten | 82 | `find src/app -name page.tsx \| wc -l` |
-| Unit-Tests (Vitest) | 570 | `npm test` |
+| Unit-Tests (Vitest) | 602 | `npm test` |
-| End-to-End-Tests (Playwright) | 73 | `npm run test:e2e` — 40 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
+| 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.4.0
+git checkout v1.10.1
 ```
 
 ### Kontrolle
 
 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.4.0
+git describe --tags                              # v1.10.1
 ```
 
 ---
@@ -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.4.0","commit":"..."}
+# {"status":"bereit","version":"1.10.1","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.4.0",...}
+# {"status":"bereit","version":"1.10.1",...}
 ```
 
 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.4.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.10.1 · <commit>`.
 
 ---
 
@@ -875,7 +875,7 @@ alles so vor wie zuvor.
 | Aufruf | Wirkung |
 |---|---|
 | `./scripts/update.sh` | auf die neueste veröffentlichte Fassung |
-| `./scripts/update.sh v1.4.0` | auf eine bestimmte Fassung |
+| `./scripts/update.sh v1.10.1` | 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 |
@@ -913,7 +913,7 @@ git fetch --tags
 git log --oneline HEAD..origin/main
 
 # 3. Umschalten
-git checkout v1.4.0
+git checkout v1.10.1
 
 # 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: 23.08.2026 · Aktuelle Fassung: **1.4.0** ([CHANGELOG](../CHANGELOG.md))
+Stand: 23.08.2026 · Aktuelle Fassung: **1.10.1** ([CHANGELOG](../CHANGELOG.md))
 
 ---
 

e2e/absenderanschrift.spec.ts

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

e2e/ansprechpartner.spec.ts

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

e2e/demofall.spec.ts

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

e2e/email.spec.ts

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

e2e/rueckkaufswert-vertrag.spec.ts

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

e2e/serienabfrage.spec.ts

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

e2e/vorlagen.spec.ts

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "betreuungs-cockpit",
-  "version": "1.4.0",
+  "version": "1.10.1",
   "private": true,
   "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
   "engines": {
@@ -17,6 +17,8 @@
     "db:generate": "prisma generate",
     "db:migrate": "prisma migrate dev",
     "db:deploy": "prisma migrate deploy",
+    "db:migration": "node scripts/migration-erzeugen.mjs",
+    "db:pruefen": "node -e \"import('./scripts/migration-erzeugen.mjs').then(m => m.indizesPruefen())\"",
     "db:volltext": "prisma db execute --schema prisma/schema.prisma --file prisma/sql/volltextsuche.sql",
     "db:seed": "prisma db seed",
     "db:studio": "prisma studio",

prisma/migrations/20260822160000_passkey_anmeldung/migration.sql

@@ -2,10 +2,11 @@
 --
 -- ACHTUNG beim Erzeugen weiterer Migrationen: "prisma migrate diff" wollte
 -- hier zusaetzlich die Trigramm-Indizes "dokument_absender_trgm" und
--- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/suche.sql und
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/volltextsuche.sql und
 -- sind Prisma unbekannt - ein DROP haette die unscharfe Suche stillgelegt,
 -- ohne dass irgendetwas fehlgeschlagen waere. Solche Zeilen gehoeren aus
 -- jeder erzeugten Migration entfernt.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- CreateEnum
 CREATE TYPE "PasskeyAnfrageArt" AS ENUM ('REGISTRIERUNG', 'ANMELDUNG');

prisma/migrations/20260823000500_zahlungsgruppe_geklaert/migration.sql

@@ -2,10 +2,11 @@
 --
 -- 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
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/volltextsuche.sql und
 -- sind Prisma unbekannt; ein DROP haette die unscharfe Suche stillgelegt,
 -- ohne dass irgendetwas fehlgeschlagen waere. Die Zeilen sind entfernt.
 -- Wer die naechste Migration erzeugt: nachsehen und wieder herausnehmen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- CreateTable
 CREATE TABLE "zahlungsgruppe_geklaert" (

prisma/migrations/20260823062000_buchung_vertragszahlung/migration.sql

@@ -2,10 +2,11 @@
 --
 -- 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
+-- loeschen. Sie stammen aus prisma/sql/volltextsuche.sql und sind Prisma
 -- unbekannt; ein DROP legt die unscharfe Suche stumm, ohne dass etwas
 -- fehlschlaegt. Zeilen entfernt. Wer die naechste Migration erzeugt:
 -- nachsehen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- AlterTable
 ALTER TABLE "buchung" ADD COLUMN     "vertragAutomatisch" BOOLEAN NOT NULL DEFAULT false,

prisma/migrations/20260823102500_schreibvorlage/migration.sql

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

prisma/migrations/20260823153000_ansprechpartner/migration.sql

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

prisma/migrations/20260823193832_betreuer_anschrift/migration.sql

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

prisma/schema.prisma

@@ -81,6 +81,13 @@ model User {
   // (Passwortwechsel, Rollenaenderung, Verdacht auf Kompromittierung).
   sitzungsGeneration Int @default(0)
 
+  /// Die eigene Anschrift - Absenderblock und Ort in der Datumszeile
+  /// jedes erzeugten Schreibens. Sie gehoert zum Betreuer und nicht zur
+  /// betreuten Person: Sie gilt fuer alle Akten.
+  strasse String?
+  plz     String?
+  ort     String?
+
   // Oberflaechen-Einstellungen
   theme String @default("system") // "system" | "hell" | "dunkel"
 
@@ -313,6 +320,7 @@ model Betreute {
   konten                Konto[]
   buchungen             Buchung[]
   zahlungsgruppen       ZahlungsgruppeGeklaert[]
+  schreibvorlagen       Schreibvorlage[]
   vermoegensposten      Vermoegensposten[]
   immobilien            Immobilie[]
   vertraege             Vertrag[]
@@ -372,6 +380,14 @@ model Vorgang {
   gegenstelle  String?
   aktenzeichen String?
 
+  /// Die Person bei der Gegenstelle, die den Vorgang bearbeitet. Ein
+  /// namentlich adressiertes Schreiben landet bei ihr statt in der
+  /// Poststelle - beim Bezirk ist das der Unterschied zwischen zwei
+  /// Wochen und zwei Monaten. SetNull: Ein Vorgang darf nicht daran
+  /// haengen, dass es den Kontakt noch gibt.
+  ansprechpartnerId String?
+  ansprechpartner   Kontakt? @relation("VorgangAnsprechpartner", fields: [ansprechpartnerId], references: [id], onDelete: SetNull)
+
   verantwortlich String?
   angelegtVonId  String?
   angelegtVon    User?   @relation("VorgangAngelegtVon", fields: [angelegtVonId], references: [id], onDelete: SetNull)
@@ -842,6 +858,39 @@ enum BuchungKategorie {
 /// wieder auf. Das ist unangenehm, aber ungefaehrlich - schlimmer waere,
 /// eine Gruppe stillschweigend weiter zu verbergen, die inzwischen anders
 /// zugeschnitten ist.
+/// Eine eigene Schreibvorlage.
+///
+/// Die mitgelieferten Vorlagen (Rueckkaufswert, Kuendigung,
+/// Sachstandsanfrage) stehen bewusst NICHT in dieser Tabelle - sie sind
+/// Code, getestet und unveraenderlich. "Wiederherstellen" heisst: die
+/// mitgelieferte Fassung als neue Kopie hierher holen.
+///
+/// Der Text traegt Platzhalter im Format {{name}} - aufgeloest in
+/// src/lib/schreiben/platzhalter.ts. Er ist bewusst NICHT verschluesselt:
+/// Eine Vorlage ist ein Textbaustein ohne Fallbezug; die Fachdaten kommen
+/// erst beim Erzeugen hinein.
+model Schreibvorlage {
+  id String @id @default(cuid())
+
+  betreuteId String
+  betreute   Betreute @relation(fields: [betreuteId], references: [id], onDelete: Cascade)
+
+  name    String
+  betreff String @default("")
+  text    String
+
+  /// Beim Speichern bestaetigt, dass der fehlende Bestellungsabsatz
+  /// Absicht ist - dann wird nicht bei jedem Bearbeiten erneut gewarnt.
+  ohneBestellungsabsatz Boolean @default(false)
+
+  erstelltAm     DateTime  @default(now())
+  aktualisiertAm DateTime  @updatedAt
+  geloeschtAm    DateTime?
+
+  @@index([betreuteId])
+  @@map("schreibvorlage")
+}
+
 model ZahlungsgruppeGeklaert {
   id String @id @default(cuid())
 
@@ -1199,6 +1248,13 @@ model Vertrag {
 // Kontakte und Kontaktprotokoll
 // =============================================================================
 
+/// Anrede fuer die Briefanrede eines Kontakts.
+enum KontaktAnrede {
+  OHNE
+  FRAU
+  HERR
+}
+
 enum KontaktRolle {
   RECHTSPFLEGER
   RICHTER
@@ -1233,7 +1289,10 @@ model Kontakt {
 
   name         String
   organisation String?
-  rolle        KontaktRolle @default(SONSTIGES)
+  rolle        KontaktRolle  @default(SONSTIGES)
+  /// Fuer die Briefanrede. Ohne Angabe wird mit vollem Namen angeredet -
+  /// nie geraten, das faellt dem Empfaenger sofort auf.
+  anrede       KontaktAnrede @default(OHNE)
 
   telefon      String?
   mobil        String?
@@ -1251,9 +1310,10 @@ model Kontakt {
   aktualisiertAm DateTime  @updatedAt
   geloeschtAm    DateTime?
 
-  protokolle     Kontaktprotokoll[]
+  protokolle        Kontaktprotokoll[]
-  vorgaenge      Vorgang[]              @relation("VorgangKontakte")
+  vorgaenge         Vorgang[]              @relation("VorgangKontakte")
-  verknuepfungen DokumentVerknuepfung[]
+  betreuteVorgaenge Vorgang[]              @relation("VorgangAnsprechpartner")
+  verknuepfungen    DokumentVerknuepfung[]
 
   @@index([betreuteId, rolle])
   @@map("kontakt")

prisma/seed.ts

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

scripts/migration-erzeugen.d.mts

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

scripts/migration-erzeugen.mjs

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import type { Metadata } from 'next'
 import Link from 'next/link'
-import { Fingerprint, KeyRound, ShieldCheck } from 'lucide-react'
+import { Fingerprint, KeyRound, MapPin, ShieldCheck } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
@@ -11,6 +11,7 @@ import { PasskeyVerwaltung } from '@/components/konto/passkey-verwaltung'
 import { ROLLEN_BESCHRIFTUNG, ROLLEN_ERKLAERUNG } from '@/lib/auth/rollen'
 import { formatDatumZeit } from '@/lib/utils'
 import { PasswortFormular } from './passwort-formular'
+import { AnschriftFormular } from './anschrift-formular'
 
 export const metadata: Metadata = { title: 'Mein Konto' }
 export const dynamic = 'force-dynamic'
@@ -22,7 +23,10 @@ export default async function KontoSeite() {
 
   return (
     <div className="max-w-2xl space-y-6">
-      <SeitenKopf titel="Mein Konto" beschreibung="Zugangsdaten, zweiter Faktor und Passkeys." />
+      <SeitenKopf
+        titel="Mein Konto"
+        beschreibung="Zugangsdaten, eigene Anschrift, zweiter Faktor und Passkeys."
+      />
 
       <Card>
         <CardHeader className="pb-3">
@@ -55,6 +59,27 @@ export default async function KontoSeite() {
         </CardContent>
       </Card>
 
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="flex items-center gap-2 text-base">
+            <MapPin className="size-5" aria-hidden="true" />
+            Meine Anschrift
+          </CardTitle>
+          <CardDescription>
+            Steht im Absenderblock jedes Schreibens, das hier entsteht, und liefert den Ort für
+            die Datumszeile. Ohne sie geht ein förmlicher Brief ohne Rücksendeadresse hinaus.
+            Jede Angabe ist einzeln freiwillig — was fehlt, bleibt im Brief einfach weg.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <AnschriftFormular
+            strasse={benutzer.strasse}
+            plz={benutzer.plz}
+            ort={benutzer.ort}
+          />
+        </CardContent>
+      </Card>
+
       <Card>
         <CardHeader className="pb-3">
           <CardTitle className="flex items-center gap-2 text-base">

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

@@ -8,6 +8,7 @@ import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/s
 import { db, nichtGeloescht } from '@/lib/db'
 import { entwurfBauen } from '@/lib/schreiben/entwurf'
 import { SCHREIBEN_EIGENSCHAFTEN, istSchreibenArt } from '@/lib/schreiben/arten'
+import { VorlagenWahl } from '@/components/schreiben/vorlagen-wahl'
 
 export const metadata: Metadata = { title: 'Schreiben' }
 export const dynamic = 'force-dynamic'
@@ -49,10 +50,11 @@ export default async function SchreibenSeite({
   try {
     entwurf = await entwurfBauen({
       betreuteId: aktive.id,
-      benutzerName: benutzer.name,
+      benutzer,
       art,
       vertragId: text('vertragId') || null,
       vorgangId: text('vorgangId') || null,
+      vorlageId: text('vorlageId') || null,
     })
   } catch (ausnahme) {
     // Fehlender oder fremder Bezug: Das ist kein Absturz, sondern eine
@@ -77,9 +79,26 @@ export default async function SchreibenSeite({
     )
   }
 
+  const vorlagen =
+    art === 'FREI'
+      ? await db.schreibvorlage.findMany({
+          where: { betreuteId: aktive.id, ...nichtGeloescht },
+          select: { id: true, name: true },
+          orderBy: { name: 'asc' },
+        })
+      : []
+
   const kontakte = await db.kontakt.findMany({
     where: { betreuteId: aktive.id, ...nichtGeloescht },
-    select: { id: true, name: true, organisation: true, strasse: true, plz: true, ort: true },
+    select: {
+      id: true,
+      name: true,
+      organisation: true,
+      strasse: true,
+      plz: true,
+      ort: true,
+      email: true,
+    },
     orderBy: [{ organisation: 'asc' }, { name: 'asc' }],
     take: 200,
   })
@@ -92,13 +111,22 @@ export default async function SchreibenSeite({
         pfad={[{ titel: 'Dokumente', href: '/dokumente' }, { titel: 'Schreiben' }]}
       />
 
+      {art === 'FREI' && vorlagen.length > 0 && (
+        <VorlagenWahl vorlagen={vorlagen} aktiveVorlageId={text('vorlageId') || null} />
+      )}
+
       <SchreibenEditor
+        // Der Editor haelt den Text als eigenen State. Wechselt die Vorlage,
+        // muss er neu aufsetzen - sonst ueberlebt der alte Entwurf die
+        // Navigation und die Vorlage kommt nie im Textfeld an.
+        key={text('vorlageId') || 'ohne-vorlage'}
         betreuteId={aktive.id}
         art={art}
         entwurf={{
           betreff: entwurf.betreff,
           text: entwurf.text,
           empfaengerName: entwurf.empfaengerName,
+          empfaengerAnschrift: entwurf.empfaengerAnschrift,
           wiedervorlageAm: entwurf.wiedervorlageAm,
         }}
         kontakte={kontakte}

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

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

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

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

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

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

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

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

src/components/einstellungen/vorlagen-verwaltung.tsx

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

src/components/kontakte/kontakt-formular.tsx

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

src/components/schreiben/schreiben-editor.tsx

@@ -10,6 +10,7 @@ import {
   FileDown,
   FolderInput,
   Info,
+  Mail,
   UserPlus,
 } from 'lucide-react'
 import { Alert, AlertDescription } from '@/components/ui/alert'
@@ -26,6 +27,7 @@ import {
   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
@@ -34,6 +36,7 @@ export type KontaktAuswahl = {
   strasse: string | null
   plz: string | null
   ort: string | null
+  email: string | null
 }
 
 /**
@@ -56,7 +59,13 @@ export function SchreibenEditor({
 }: {
   betreuteId: string
   art: SchreibenArt
-  entwurf: { betreff: string; text: string; empfaengerName: string; wiedervorlageAm: string }
+  entwurf: {
+    betreff: string
+    text: string
+    empfaengerName: string
+    empfaengerAnschrift: string
+    wiedervorlageAm: string
+  }
   kontakte: KontaktAuswahl[]
   vertragId: string | null
   vorgangId: string | null
@@ -66,7 +75,13 @@ export function SchreibenEditor({
   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 [empfaengerAnschrift, setEmpfaengerAnschrift] = React.useState(
+    entwurf.empfaengerAnschrift,
+  )
+  const [empfaengerEmail, setEmpfaengerEmail] = React.useState('')
+  const [versandweg, setVersandweg] = React.useState<'BRIEF' | 'EMAIL'>('BRIEF')
+  const [betreffKopiert, setBetreffKopiert] = React.useState(false)
+  const [mailKopiert, setMailKopiert] = React.useState(false)
   const [versandAm, setVersandAm] = React.useState(new Date().toISOString().slice(0, 10))
   const [wiedervorlageAm, setWiedervorlageAm] = React.useState(entwurf.wiedervorlageAm)
   const [kopiert, setKopiert] = React.useState(false)
@@ -94,6 +109,8 @@ export function SchreibenEditor({
         <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} />
       </>
     )
   }
@@ -107,6 +124,7 @@ export function SchreibenEditor({
         .filter(Boolean)
         .join('\n'),
     )
+    setEmpfaengerEmail(kontakt.email ?? '')
   }
 
   async function textKopieren() {
@@ -121,6 +139,109 @@ export function SchreibenEditor({
 
   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 && (
@@ -193,6 +314,21 @@ export function SchreibenEditor({
             />
           </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 />
@@ -263,8 +399,32 @@ export function SchreibenEditor({
       <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"
@@ -293,26 +453,31 @@ export function SchreibenEditor({
             </Feld>
           </div>
 
-          {/* Word-Datei: eigene Route, damit der Browser einen echten
+          {versandweg === 'BRIEF' && (
-              Download bekommt. */}
+            <>
-          <form action="/schreiben/docx" method="post" className="inline">
+              {/* Word-Datei: eigene Route, damit der Browser einen echten
-            <VersteckteFelder />
+                  Download bekommt. */}
-            <Button type="submit" variant="outline">
+              <form action="/schreiben/docx" method="post" className="inline">
-              <FileDown aria-hidden="true" />
+                <VersteckteFelder />
-              Als Word-Datei
+                <Button type="submit" variant="outline">
-            </Button>
+                  <FileDown aria-hidden="true" />
-          </form>
+                  Als Word-Datei
+                </Button>
+              </form>
 
-          <Alert variant="hinweis">
+              <Alert variant="hinweis">
-            <Info aria-hidden="true" />
+                <Info aria-hidden="true" />
-            <AlertDescription>
+                <AlertDescription>
-              In die Akte kommt eine <strong>PDF-Fassung</strong> dieses Textes — sie ist der
+                  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
+                  Nachweis, was hinausgegangen ist, und lässt sich nicht mehr ändern. Die
-              ist die Arbeitsfassung zum Ausdrucken und Unterschreiben.{' '}
+                  Word-Datei ist die Arbeitsfassung zum Ausdrucken und Unterschreiben.{' '}
-              <strong>Änderst du sie danach noch in Word</strong>, weicht die Akte davon ab — dann
+                  <strong>Änderst du sie danach noch in Word</strong>, weicht die Akte davon ab —
-              lieber erst dort fertig schreiben, den Text hierher zurückkopieren und dann ablegen.
+                  dann lieber erst dort fertig schreiben, den Text hierher zurückkopieren und dann
-            </AlertDescription>
+                  ablegen.
-          </Alert>
+                </AlertDescription>
+              </Alert>
+            </>
+          )}
 
           {ablageZustand.fehler && (
             <Alert variant="fehler">

src/components/schreiben/vorlagen-wahl.tsx

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

src/components/vertraege/rueckkaufswert.tsx

@@ -4,6 +4,7 @@ import Link from 'next/link'
 import { useActionState, useState } from 'react'
 import { Coins, FileDown, Mail, Plus } from 'lucide-react'
 import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Input } from '@/components/ui/input'
@@ -36,6 +37,7 @@ export function Rueckkaufswert({
   anschreiben,
   stichtagVorschlag,
   darfSchreiben,
+  alterHinweis,
 }: {
   betreuteId: string
   vertragId: string
@@ -46,6 +48,8 @@ export function Rueckkaufswert({
   anschreiben: string
   stichtagVorschlag: string
   darfSchreiben: boolean
+  /** Kurztext, wenn der juengste Wert zu alt ist - sonst null. */
+  alterHinweis: string | null
 }) {
   const [erfassen, erfassenAktion] = useActionState<Formularzustand, FormData>(
     rueckkaufswertErfassen,
@@ -55,6 +59,9 @@ export function Rueckkaufswert({
     rueckkaufswertAnfordern,
     {},
   )
+  // Die Liste kommt bereits juengster Wert zuerst von der Seite.
+  const letzter = werte[0] ?? null
+
   const [briefOffen, setBriefOffen] = useState(false)
   const [erfassenOffen, setErfassenOffen] = useState(false)
 
@@ -88,7 +95,7 @@ export function Rueckkaufswert({
           </Alert>
         )}
 
-        {werte.length === 0 ? (
+        {!letzter ? (
           <Leerzustand
             titel="Noch kein Rückkaufswert erfasst"
             beschreibung="Fordere ihn bei der Gesellschaft an. Frag im selben Schreiben nach der beitragsfreien Versicherungssumme — sonst musst du für den Vergleich ein zweites Mal schreiben."
@@ -103,7 +110,26 @@ export function Rueckkaufswert({
             }
           />
         ) : (
-          <Table>
+          <>
+            {/* Der zuletzt mitgeteilte Wert gehoert nach oben: Wer beim
+                Telefonat mit der Gesellschaft danach gefragt wird, hat
+                keine Zeit, eine Historie zu lesen. */}
+            <div className="rounded-md border p-4">
+              <p className="text-sm text-muted-foreground">Zuletzt mitgeteilt</p>
+              <p className="text-2xl font-semibold tabular-nums">
+                {formatCent(letzter.wertCent)}
+              </p>
+              <p className="text-sm text-muted-foreground">
+                zum Stichtag {formatDatum(letzter.stichtag)} · {letzter.wertquelle}
+              </p>
+              {alterHinweis && (
+                <Badge variant="gelb" className="mt-2">
+                  {alterHinweis} — vor dem nächsten Bericht neu anfragen
+                </Badge>
+              )}
+            </div>
+
+            <Table>
             <TableHeader>
               <TableRow>
                 <TableHead>Stichtag</TableHead>
@@ -126,7 +152,8 @@ export function Rueckkaufswert({
                 </TableRow>
               ))}
             </TableBody>
-          </Table>
+            </Table>
+          </>
         )}
 
         {darfSchreiben && (

src/components/vertraege/serienabfrage-formular.tsx

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

src/components/vorgaenge/vorgangs-formular.tsx

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

src/lib/berichte/vollexport.ts

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

src/lib/finanzen/wertalter.ts

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

src/lib/finanzen/wiederkehrend.ts

@@ -122,6 +122,10 @@ export type Zahlungsgruppe = {
 const RECHTSFORMEN = [
   'gmbh & co kg',
   'gmbh und co kg',
+  // Die haeufigste Rechtsform in diesem Fachgebiet ueberhaupt: Heime,
+  // Sozialdienste und Traeger sind fast durchweg gGmbH. Fehlte sie,
+  // zerfiele die Zusammenfassung genau dort, wo sie gebraucht wird.
+  'ggmbh',
   'gmbh',
   'mbh',
   'ohg',

src/lib/kontakte/anrede.ts

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

src/lib/schreiben/arten.ts

@@ -88,7 +88,7 @@ export function dateinameFuerSchreiben(
   art: SchreibenArt,
   empfaenger: string | null,
   datum: Date,
-  endung: 'docx' | 'pdf',
+  endung: 'docx' | 'pdf' | 'eml',
 ): string {
   const tag = datum.toISOString().slice(0, 10)
 

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

@@ -1,7 +1,7 @@
 import 'server-only'
 import { db, nichtGeloescht } from '@/lib/db'
 import { oeffnen } from '@/lib/crypto/feld'
-import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
+import { briefkopfBauen, type Absender } from '@/lib/vertraege/briefkopf'
 import {
   absenderBlock,
   anschriftBlock,
@@ -19,6 +19,8 @@ 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'
+import { platzhalterErsetzen, type PlatzhalterWerte } from '@/lib/schreiben/platzhalter'
+import { formatDatum } from '@/lib/utils'
 
 /**
  * Baut den Entwurf eines Schreibens - Text, Betreff, Empfaenger.
@@ -105,10 +107,13 @@ export function betreffAusText(text: string): string {
 
 export type EntwurfEingabe = {
   betreuteId: string
-  benutzerName: string
+  /** Wer schreibt - mit Anschrift, wenn hinterlegt. */
+  benutzer: Absender
   art: SchreibenArt
   vertragId?: string | null
   vorgangId?: string | null
+  /** Eigene Vorlage als Grundlage des freien Schreibens. */
+  vorlageId?: string | null
   /** Fuer den Test ueberschreibbar. */
   heute?: Date
 }
@@ -123,7 +128,7 @@ export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEn
 
   const kopf = briefkopfBauen({
     betreute: oeffnen('Betreute', betreute),
-    benutzer: { name: eingabe.benutzerName },
+    benutzer: eingabe.benutzer,
   })
 
   const gemeinsam = {
@@ -197,8 +202,19 @@ export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEn
 
     const vorgang = await db.vorgang.findFirst({
       where: { id: eingabe.vorgangId, betreuteId: eingabe.betreuteId, ...nichtGeloescht },
+      // Der benannte Ansprechpartner, nicht irgendeiner der verknuepften
+      // Kontakte: Wer angeredet wird, ist eine Entscheidung und kein Zufall.
       include: {
-        kontakte: { select: { name: true, organisation: true }, take: 1 },
+        ansprechpartner: {
+          select: {
+            name: true,
+            anrede: true,
+            organisation: true,
+            strasse: true,
+            plz: true,
+            ort: true,
+          },
+        },
       },
     })
     if (!vorgang) throw new Error('Diesen Vorgang gibt es nicht (mehr).')
@@ -214,23 +230,101 @@ export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEn
         geburtsdatum: betreute.geburtsdatum,
       },
       betreuer: {
-        name: eingabe.benutzerName,
+        name: eingabe.benutzer.name,
         aktenzeichenGericht: betreute.aktenzeichenGericht,
         betreuungsgericht: betreute.betreuungsgericht,
       },
+      ansprechpartner: vorgang.ansprechpartner,
       heute,
     })
 
+    // Ist ein Ansprechpartner benannt, kommt seine Anschrift gleich mit -
+    // sie steht im Kontaktverzeichnis und muesste sonst abgetippt werden.
+    const anschrift = vorgang.ansprechpartner
+      ? [
+          vorgang.ansprechpartner.strasse,
+          [vorgang.ansprechpartner.plz, vorgang.ansprechpartner.ort]
+            .filter(Boolean)
+            .join(' ')
+            .trim() || null,
+        ]
+          .filter(Boolean)
+          .join('\n')
+      : ''
+
     return {
       ...gemeinsam,
       text: anfrage.text,
       betreff: anfrage.betreff,
-      empfaengerName: vorgang.gegenstelle ?? '',
+      empfaengerName:
+        vorgang.ansprechpartner?.name ?? vorgang.gegenstelle ?? '',
+      empfaengerAnschrift: anschrift,
+    }
+  }
+
+  // --- Freies Schreiben, wahlweise aus eigener Vorlage -----------------------
+  if (eingabe.vorlageId) {
+    const vorlage = await db.schreibvorlage.findFirst({
+      where: { id: eingabe.vorlageId, betreuteId: eingabe.betreuteId, ...nichtGeloescht },
+    })
+    if (!vorlage) throw new Error('Diese Vorlage gibt es nicht (mehr).')
+
+    // Die Werte, die eine Vorlage kennen kann. Vertragsbezogene bleiben
+    // hier leer und erscheinen als sichtbare Luecke - ein freies Schreiben
+    // hat keinen Vertrag.
+    const werte: PlatzhalterWerte = {
+      betreute_name: kopf.betreuteName,
+      betreute_geburtsdatum: kopf.betreuteGeburtsdatum
+        ? formatDatum(kopf.betreuteGeburtsdatum)
+        : null,
+      betreute_anschrift: kopf.betreuteAnschrift,
+      betreuer_name: kopf.betreuerName,
+      betreuer_anschrift:
+        [kopf.betreuerStrasse, [kopf.betreuerPlz, kopf.betreuerOrt].filter(Boolean).join(' ')]
+          .filter((zeile) => zeile && zeile.trim() !== '')
+          .join('\n') || null,
+      betreuer_ort: kopf.betreuerOrt,
+      betreuungsgericht: kopf.betreuungsgericht,
+      aktenzeichen_gericht: kopf.aktenzeichenGericht,
+      bestellung_datum: kopf.bestellungAm ? formatDatum(kopf.bestellungAm) : null,
+      bestellungsabsatz: bestellungsAbsatz(kopf),
+      stichtag: formatDatum(heute),
+      datum_heute: formatDatum(heute),
+    }
+
+    const rumpf = platzhalterErsetzen(vorlage.text, werte)
+    const betreffErsetzt = platzhalterErsetzen(vorlage.betreff, werte)
+
+    // Der Briefrahmen kommt dazu - die Vorlage traegt nur den Inhalt.
+    const text = [
+      absenderBlock(kopf),
+      '',
+      anschriftBlock({ gesellschaft: null, anschrift: null }),
+      '',
+      datumsZeile(kopf.betreuerOrt, heute),
+      '',
+      betreffErsetzt.text ? `Betreff: ${betreffErsetzt.text}` : 'Betreff: [Betreff eintragen]',
+      '',
+      rumpf.text,
+    ].join('\n')
+
+    return {
+      ...gemeinsam,
+      text,
+      betreff: betreffErsetzt.text,
+      empfaengerName: '',
       empfaengerAnschrift: '',
+      warnungen:
+        rumpf.unbekannte.length > 0
+          ? [
+              `Die Vorlage enthält unbekannte Platzhalter: ${rumpf.unbekannte
+                .map((name) => `{{${name}}}`)
+                .join(', ')}. Sie sind im Text markiert - bitte vor dem Absenden ersetzen.`,
+            ]
+          : [],
     }
   }
 
-  // --- Freies Schreiben ------------------------------------------------------
   const text = freierEntwurf(kopf, { gesellschaft: null, anschrift: null }, heute)
   return {
     ...gemeinsam,

src/lib/schreiben/mitgelieferte-vorlagen.ts

@@ -0,0 +1,123 @@
+/**
+ * Die mitgelieferten Schreibvorlagen - als Platzhalter-Fassung.
+ *
+ * Sie sind Code und damit unveraenderlich; "wiederherstellen" heisst,
+ * sie erneut als Kopie in die eigenen Vorlagen zu holen.
+ *
+ * Bewusst NICHT dieselben Texte wie die fest verdrahteten Erzeuger in
+ * rueckkaufswert.ts und kuendigungsassistent.ts: Die dortigen bauen
+ * fallbezogene Saetze (Kuendigungstermin, Warnungen), die eine Vorlage
+ * nicht leisten kann. Diese hier sind der gemeinsame Kern als
+ * Ausgangspunkt fuer eigene Fassungen - die Spezialerzeuger bleiben der
+ * bessere Weg, wo es sie gibt, und die Oberflaeche fuehrt weiter zuerst
+ * dorthin.
+ */
+
+export type MitgelieferteVorlage = {
+  schluessel: string
+  name: string
+  beschreibung: string
+  betreff: string
+  text: string
+}
+
+export const MITGELIEFERTE_VORLAGEN: readonly MitgelieferteVorlage[] = [
+  {
+    schluessel: 'auskunftsersuchen',
+    name: 'Auskunftsersuchen',
+    beschreibung: 'Bestehen bei Ihnen Verträge? Der erste Brief an eine unbekannte Stelle.',
+    betreff: 'Auskunftsersuchen — {{betreute_name}}, geb. {{betreute_geburtsdatum}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'zur Ordnung der Vermögensangelegenheiten bitte ich um Auskunft, ob bei',
+      'Ihnen Verträge, Konten oder sonstige Geschäftsbeziehungen für die von mir',
+      'vertretene Person bestehen oder in den letzten Jahren bestanden haben.',
+      '',
+      'Falls ja, bitte ich um eine Aufstellung mit Vertragsnummern, aktuellem',
+      'Stand und den jährlichen Beiträgen bzw. Leistungen.',
+      '',
+      'Für Rückfragen stehe ich gerne zur Verfügung.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+  {
+    schluessel: 'adressaenderung',
+    name: 'Adressänderung',
+    beschreibung: 'Neue Anschrift nach Heimeinzug mitteilen.',
+    betreff: 'Anschriftenänderung — {{betreute_name}}, geb. {{betreute_geburtsdatum}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'die Anschrift der von mir vertretenen Person hat sich geändert. Die neue',
+      'Anschrift lautet:',
+      '',
+      '{{betreute_anschrift}}',
+      '',
+      'Bitte stellen Sie künftige Post zu dieser Sache außerdem an mich als',
+      'rechtlichen Betreuer zu.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+  {
+    schluessel: 'vollmachtsnachweis',
+    name: 'Nachweis der Vertretungsmacht',
+    beschreibung: 'Wenn eine Stelle die Auskunft verweigert: der Nachweis, förmlich.',
+    betreff: 'Nachweis der Vertretungsmacht — {{betreute_name}}, geb. {{betreute_geburtsdatum}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      'auf Ihr Schreiben, in dem Sie um einen Nachweis meiner Vertretungsmacht',
+      'bitten, teile ich mit:',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'Eine Kopie der Bestellungsurkunde liegt bei. Das Original stelle ich bei',
+      'Bedarf zur Einsicht — bitte nennen Sie mir dafür einen Termin.',
+      '',
+      'Ich bitte nunmehr um Bearbeitung meines Anliegens vom {{datum_heute}}.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+  {
+    schluessel: 'rueckkaufswert_kurz',
+    name: 'Rückkaufswert (Kurzfassung)',
+    beschreibung:
+      'Die Kurzfassung der Rückkaufswert-Anfrage. Für den vollen Fragenkatalog nimm den Weg über den Vertrag.',
+    betreff:
+      'Auskunft über Rückkaufswert — {{vertrag_bezeichnung}}, Nr. {{vertrag_nummer}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'zu dem oben genannten Vertrag bei {{vertrag_gesellschaft}} bitte ich um',
+      'Mitteilung des Rückkaufswertes einschließlich Überschussanteilen zum',
+      'Stichtag {{stichtag}}, außerdem der beitragsfreien Versicherungssumme.',
+      '',
+      'Da im Verfahren beim Sozialhilfeträger eine Frist läuft, bitte ich um',
+      'Antwort innerhalb von vier Wochen.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+]

src/lib/schreiben/platzhalter.ts

@@ -0,0 +1,151 @@
+/**
+ * Platzhalter in Schreibvorlagen.
+ *
+ * Rein und ohne Datenbank. Der Vertrag ist einfach: {{name}} wird ersetzt,
+ * und zwar nach drei Regeln, die alle demselben Grundsatz folgen -
+ * NICHTS geht stillschweigend schief:
+ *
+ * 1. Bekannter Platzhalter, Daten vorhanden  -> Wert eingesetzt.
+ * 2. Bekannter Platzhalter, Daten fehlen     -> sichtbare Luecke
+ *    "[Aktenzeichen]". Eine stille Leerstelle wuerde erst der Empfaenger
+ *    bemerken - oder niemand.
+ * 3. Unbekannter Platzhalter                 -> markiert als
+ *    "[Unbekannter Platzhalter: {{xyz}}]". Kein Abbruch: Ein Tippfehler
+ *    in einer Vorlage darf das Schreiben nicht verhindern, aber er muss
+ *    ins Auge springen. Falsch ausgefuellt ist schlimmer als
+ *    offensichtlich leer.
+ */
+
+export type PlatzhalterName =
+  | 'betreute_name'
+  | 'betreute_geburtsdatum'
+  | 'betreute_anschrift'
+  | 'betreuer_name'
+  | 'betreuer_anschrift'
+  | 'betreuer_ort'
+  | 'betreuungsgericht'
+  | 'aktenzeichen_gericht'
+  | 'bestellung_datum'
+  | 'bestellungsabsatz'
+  | 'vertrag_gesellschaft'
+  | 'vertrag_nummer'
+  | 'vertrag_bezeichnung'
+  | 'stichtag'
+  | 'datum_heute'
+
+export type PlatzhalterBeschreibung = {
+  name: PlatzhalterName
+  beschriftung: string
+  /** Woher der Wert kommt - steht in der Hilfe neben dem Editor. */
+  quelle: string
+}
+
+/**
+ * Die verfuegbaren Platzhalter, in der Reihenfolge der Anzeige.
+ *
+ * Diese Liste steht beim Bearbeiten NEBEN dem Editor - niemand soll
+ * Platzhalternamen raten muessen.
+ */
+export const PLATZHALTER: readonly PlatzhalterBeschreibung[] = [
+  { name: 'betreute_name', beschriftung: 'Name der betreuten Person', quelle: 'Stammdaten' },
+  { name: 'betreute_geburtsdatum', beschriftung: 'Geburtsdatum', quelle: 'Stammdaten' },
+  { name: 'betreute_anschrift', beschriftung: 'Anschrift (Heim)', quelle: 'Stammdaten' },
+  { name: 'betreuer_name', beschriftung: 'Dein Name', quelle: 'Dein Zugang' },
+  {
+    name: 'betreuer_anschrift',
+    beschriftung: 'Deine Anschrift',
+    quelle: 'Mein Konto',
+  },
+  { name: 'betreuer_ort', beschriftung: 'Dein Ort', quelle: 'Mein Konto' },
+  { name: 'betreuungsgericht', beschriftung: 'Betreuungsgericht', quelle: 'Stammdaten' },
+  { name: 'aktenzeichen_gericht', beschriftung: 'Aktenzeichen des Gerichts', quelle: 'Stammdaten' },
+  { name: 'bestellung_datum', beschriftung: 'Datum der Bestellung', quelle: 'Stammdaten' },
+  {
+    name: 'bestellungsabsatz',
+    beschriftung: 'Der ganze Bestellungsabsatz',
+    quelle: 'Aus Gericht, Aktenzeichen und Bestellungsdatum gebaut',
+  },
+  { name: 'vertrag_gesellschaft', beschriftung: 'Gesellschaft', quelle: 'Vertrag, falls gewählt' },
+  { name: 'vertrag_nummer', beschriftung: 'Vertragsnummer', quelle: 'Vertrag, falls gewählt' },
+  { name: 'vertrag_bezeichnung', beschriftung: 'Vertragsbezeichnung', quelle: 'Vertrag, falls gewählt' },
+  { name: 'stichtag', beschriftung: 'Stichtag', quelle: 'Beim Erzeugen gewählt' },
+  { name: 'datum_heute', beschriftung: 'Heutiges Datum', quelle: 'Beim Erzeugen' },
+]
+
+const BEKANNT = new Set<string>(PLATZHALTER.map((p) => p.name))
+
+/** Die sichtbare Luecke, wenn Daten fehlen: "[Aktenzeichen des Gerichts]". */
+function luecke(name: PlatzhalterName): string {
+  const eintrag = PLATZHALTER.find((p) => p.name === name)
+  return `[${eintrag?.beschriftung ?? name}]`
+}
+
+export type PlatzhalterWerte = Partial<Record<PlatzhalterName, string | null>>
+
+export type ErsetzungsErgebnis = {
+  text: string
+  /** Bekannte Platzhalter ohne Daten - als Luecke eingesetzt. */
+  luecken: PlatzhalterName[]
+  /** Unbekannte Platzhalter - markiert im Text. */
+  unbekannte: string[]
+}
+
+/** Findet alle {{...}}-Vorkommen. Grosszuegig beim Namen: auch Tippfehler
+ *  sollen gefunden (und dann markiert) werden. */
+const MUSTER = /\{\{\s*([a-zA-Z0-9_äöüÄÖÜß-]+)\s*\}\}/g
+
+export function platzhalterErsetzen(
+  vorlage: string,
+  werte: PlatzhalterWerte,
+): ErsetzungsErgebnis {
+  const luecken = new Set<PlatzhalterName>()
+  const unbekannte = new Set<string>()
+
+  const text = vorlage.replace(MUSTER, (treffer, roh: string) => {
+    const name = roh.trim()
+
+    if (!BEKANNT.has(name)) {
+      unbekannte.add(name)
+      return `[Unbekannter Platzhalter: {{${name}}}]`
+    }
+
+    const wert = werte[name as PlatzhalterName]
+    if (wert === null || wert === undefined || wert.trim() === '') {
+      luecken.add(name as PlatzhalterName)
+      return luecke(name as PlatzhalterName)
+    }
+
+    return wert
+  })
+
+  return { text, luecken: [...luecken], unbekannte: [...unbekannte] }
+}
+
+/** Welche Platzhalter benutzt eine Vorlage? Fuer die Anzeige in der Liste. */
+export function benutztePlatzhalter(vorlage: string): string[] {
+  const gefunden = new Set<string>()
+  for (const treffer of vorlage.matchAll(MUSTER)) {
+    gefunden.add(treffer[1]!.trim())
+  }
+  return [...gefunden]
+}
+
+/**
+ * Fehlt der Bestellungsabsatz?
+ *
+ * Erfuellt ist die Pruefung durch den Platzhalter {{bestellungsabsatz}}
+ * ODER durch einen von Hand geschriebenen Absatz, der erkennbar die
+ * Bestellung nachweist (Beschluss + Betreuer im selben Text). Wer den
+ * Absatz ausformuliert hat, soll nicht gegaengelt werden.
+ *
+ * Die Warnung ist eine Warnung, kein Verbot: Ein Schreiben an die eigene
+ * Hausverwaltung braucht keinen Bestellungsnachweis. Aber wer ihn
+ * weglaesst, soll es wissentlich tun.
+ */
+export function bestellungsabsatzFehlt(vorlage: string): boolean {
+  if (/\{\{\s*bestellungsabsatz\s*\}\}/.test(vorlage)) return false
+  const klein = vorlage.toLowerCase()
+  const nennBestellung =
+    klein.includes('beschluss') && (klein.includes('betreuer') || klein.includes('betreuung'))
+  return !nennBestellung
+}

src/lib/validierung/kontakte.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import type { KontaktArt, KontaktRolle } from '@prisma/client'
+import type { KontaktAnrede, KontaktArt, KontaktRolle } from '@prisma/client'
 
 /**
  * Eingabepruefung fuer Kontakte und Kontaktprotokolle.
@@ -101,6 +101,13 @@ export const KONTAKT_ROLLEN = [
   'SONSTIGES',
 ] as const satisfies readonly KontaktRolle[]
 
+/** Anreden fuer die Briefanrede - Reihenfolge der Auswahlliste. */
+export const KONTAKT_ANREDEN = [
+  'OHNE',
+  'FRAU',
+  'HERR',
+] as const satisfies readonly KontaktAnrede[]
+
 export const KONTAKT_ROLLE_BESCHRIFTUNG: Record<KontaktRolle, string> = {
   RECHTSPFLEGER: 'Rechtspfleger',
   RICHTER: 'Richter',
@@ -177,6 +184,7 @@ export const KontaktSchema = z.object({
   rolle: z.enum(KONTAKT_ROLLEN, {
     errorMap: () => ({ message: 'Bitte eine Rolle aus der Liste wählen.' }),
   }),
+  anrede: z.enum(KONTAKT_ANREDEN).default('OHNE'),
   telefon: optionalerText(50),
   mobil: optionalerText(50),
   fax: optionalerText(50),
@@ -198,6 +206,7 @@ export function kontaktFormularLesen(formular: FormData): Record<string, unknown
   for (const feld of [
     'name',
     'organisation',
+    'anrede',
     'rolle',
     'telefon',
     'mobil',

src/lib/validierung/vorgaenge.ts

@@ -19,6 +19,14 @@ const optionalerText = (max = 200) =>
     .transform((wert) => (wert === '' ? null : wert))
     .nullable()
 
+/** Ein Verweis auf einen anderen Datensatz - leer heisst "keiner". */
+const optionaleId = z
+  .string()
+  .trim()
+  .transform((wert) => (wert === '' ? null : wert))
+  .nullable()
+  .default(null)
+
 const optionalesDatum = z
   .string()
   .trim()
@@ -90,6 +98,7 @@ export const VorgangSchema = z.object({
   beschreibung: optionalerText(4000),
   gegenstelle: optionalerText(150),
   aktenzeichen: optionalerText(80),
+  ansprechpartnerId: optionaleId,
   verantwortlich: optionalerText(120),
   naechsterSchritt: optionalerText(300),
   faelligAm: optionalesDatum,

src/lib/version.ts

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

src/lib/vertraege/briefkopf.ts

@@ -3,11 +3,20 @@ import type { Briefkopf } from '@/lib/vertraege/anschreiben'
 /**
  * Baut den Briefkopf aus Stammdaten und angemeldetem Benutzer.
  *
- * Die Anschrift des Betreuers steht im Datenmodell nicht - der Benutzer
+ * Die Anschrift des Betreuers haengt am Benutzer, nicht an der betreuten
- * hat nur Name und E-Mail. Sie bleibt deshalb leer; im erzeugten Text
+ * Person: Sie gehoert zu mir und gilt fuer alle Akten. Ist sie nicht
- * fehlen dann schlicht die beiden Zeilen, und wer den Entwurf kopiert,
+ * hinterlegt, bleiben die Zeilen weg - ein Absenderblock mit leeren
- * ergaenzt sie im Briefkopf seines Textverarbeitungsprogramms ohnehin.
+ * Zeilen sieht schlimmer aus als einer, der nur aus dem Namen besteht.
  */
+
+/** Wer schreibt - Name und, wenn hinterlegt, die eigene Anschrift. */
+export type Absender = {
+  name: string
+  strasse?: string | null
+  plz?: string | null
+  ort?: string | null
+}
+
 export type BriefkopfQuelle = {
   betreute: {
     vorname: string
@@ -22,7 +31,7 @@ export type BriefkopfQuelle = {
     aktenzeichenGericht: string | null
     bestellungAm: Date | null
   }
-  benutzer: { name: string }
+  benutzer: Absender
 }
 
 export function briefkopfBauen(quelle: BriefkopfQuelle): Briefkopf {
@@ -37,11 +46,11 @@ export function briefkopfBauen(quelle: BriefkopfQuelle): Briefkopf {
 
   return {
     betreuerName: quelle.benutzer.name,
-    betreuerStrasse: null,
+    betreuerStrasse: quelle.benutzer.strasse ?? null,
-    betreuerPlz: null,
+    betreuerPlz: quelle.benutzer.plz ?? null,
-    // Der Ort in der Datumszeile ist der Ort des Betreuers, nicht der des
+    // Der Ort in der Datumszeile ist der Ort des Betreuers, nicht der
-    // Heims - er steht nirgends im Datenmodell und bleibt deshalb leer.
+    // des Heims.
-    betreuerOrt: null,
+    betreuerOrt: quelle.benutzer.ort ?? null,
     betreuteName: `${b.anrede ? `${b.anrede} ` : ''}${b.vorname} ${b.nachname}`.trim(),
     betreuteGeburtsdatum: b.geburtsdatum,
     betreuteAnschrift: anschrift || null,

src/lib/vertraege/rueckkaufswert.ts

@@ -114,3 +114,31 @@ export function anfrageStatus(
     tageSeitAnfrage: tage,
   }
 }
+
+/**
+ * Die Rueckkaufswert-Historie eines Vertrags, juengster Wert zuerst.
+ *
+ * Der Wert lebt nicht am Vertrag, sondern als Wertstand am
+ * Vermoegensposten - genau derselbe, aus dem das Vermoegensverzeichnis
+ * rechnet. Es gibt also keine zweite Zahl, die abweichen koennte, und
+ * der Vertrag zeigt nur an, was ohnehin schon in der Akte steht.
+ *
+ * Verknuepft wird ueber die Vertrags-Id, nicht ueber die Art des Postens.
+ * Wer einen Posten von Hand als "Sonstiges" anlegt und mit dem Vertrag
+ * verknuepft, meint denselben Vertrag - er darf dadurch nicht eine
+ * zweite, unsichtbare Wahrheit bekommen.
+ */
+export function wertHistorie<T extends { stichtag: Date }>(
+  posten: { wertstaende: T[] }[],
+): T[] {
+  return posten
+    .flatMap((p) => p.wertstaende)
+    .sort((a, b) => b.stichtag.getTime() - a.stichtag.getTime())
+}
+
+/** Der zuletzt mitgeteilte Wert, oder null, wenn noch keiner vorliegt. */
+export function juengsterWert<T extends { stichtag: Date }>(
+  posten: { wertstaende: T[] }[],
+): T | null {
+  return wertHistorie(posten)[0] ?? null
+}

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, type Absender } 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 } & Absender
+}): 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,
+  })
+
+  // 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/lib/vorgaenge/sachstandsanfrage.ts

@@ -1,4 +1,5 @@
 import { differenceInCalendarDays } from 'date-fns'
+import { anredeZeile, type Ansprechpartner } from '@/lib/kontakte/anrede'
 import { formatDatum } from '@/lib/utils'
 
 /**
@@ -36,8 +37,12 @@ export type SachstandsanfrageEingabe = {
     aktenzeichenGericht?: string | null
     betreuungsgericht?: string | null
   }
-  /** Ansprechpartner bei der Gegenstelle, wenn bekannt. */
+  /**
-  ansprechpartner?: string | null
+   * Ansprechpartner bei der Gegenstelle, wenn am Vorgang benannt.
+   * Bestimmt die Anrede - ohne ihn bleibt es bei "Sehr geehrte Damen
+   * und Herren".
+   */
+  ansprechpartner?: Ansprechpartner | null
   /** Für den Test überschreibbar. */
   heute?: Date
 }
@@ -69,13 +74,15 @@ export function sachstandsanfrageErzeugen(
       .filter(Boolean)
       .join(' · ')
 
-  const anrede = eingabe.ansprechpartner
+  const anrede = anredeZeile(eingabe.ansprechpartner ?? null)
-    ? `Sehr geehrte(r) ${eingabe.ansprechpartner},`
-    : 'Sehr geehrte Damen und Herren,'
 
   const zeilen: string[] = []
 
-  if (eingabe.gegenstelle) zeilen.push(eingabe.gegenstelle, '')
+  // Der Name steht ueber der Stelle, nicht darunter: So sortiert die
+  // Poststelle den Brief zur Person und nicht ins allgemeine Fach.
+  if (eingabe.ansprechpartner?.name.trim()) zeilen.push(eingabe.ansprechpartner.name.trim())
+  if (eingabe.gegenstelle) zeilen.push(eingabe.gegenstelle)
+  if (eingabe.ansprechpartner?.name.trim() || eingabe.gegenstelle) zeilen.push('')
   zeilen.push(formatDatum(heute), '')
   zeilen.push(`Betreff: ${betreff}`, '')
   zeilen.push(anrede, '')

src/lib/wartung.ts

@@ -50,6 +50,7 @@ const PAPIERKORB_TABELLEN = [
   'bescheid',
   'leistung',
   'bericht',
+  'schreibvorlage',
   'betreute',
 ] as const
 

src/server/actions/finanzen.ts

@@ -332,6 +332,15 @@ export async function buchungSpeichern(
       })
       if (!konto) return { fehler: 'Dieses Konto gehört nicht zu dieser betreuten Person.' }
     }
+
+    // Wie beim Konto: Der Vertrag muss zu dieser Akte gehoeren.
+    if (werte.vertragId) {
+      const vertrag = await db.vertrag.findFirst({
+        where: { id: werte.vertragId, betreuteId, ...nichtGeloescht },
+        select: { id: true },
+      })
+      if (!vertrag) return { fehler: 'Dieser Vertrag gehört nicht zu dieser betreuten Person.' }
+    }
     if (werte.belegId) {
       const beleg = await db.dokument.findFirst({
         where: { id: werte.belegId, betreuteId, ...nichtGeloescht },
@@ -634,6 +643,27 @@ export async function vermoegenspostenSpeichern(
       if (!konto) return { fehler: 'Dieses Konto gehört nicht zu dieser betreuten Person.' }
     }
 
+    // Dieselbe Pruefung fuer die beiden anderen Verweise. Sie fehlte:
+    // An der Verknuepfung zum Vertrag haengt dessen Rueckkaufswert, und
+    // die darf nicht in eine fremde Akte zeigen.
+    if (werte.vertragId) {
+      const vertrag = await db.vertrag.findFirst({
+        where: { id: werte.vertragId, betreuteId, ...nichtGeloescht },
+        select: { id: true },
+      })
+      if (!vertrag) return { fehler: 'Dieser Vertrag gehört nicht zu dieser betreuten Person.' }
+    }
+
+    if (werte.immobilieId) {
+      const immobilie = await db.immobilie.findFirst({
+        where: { id: werte.immobilieId, betreuteId, ...nichtGeloescht },
+        select: { id: true },
+      })
+      if (!immobilie) {
+        return { fehler: 'Diese Immobilie gehört nicht zu dieser betreuten Person.' }
+      }
+    }
+
     const felder = {
       bezeichnung: werte.bezeichnung,
       art: werte.art,

src/server/actions/konto.ts

@@ -1,5 +1,6 @@
 'use server'
 
+import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
 import { db } from '@/lib/db'
 import { erfordereBenutzer } from '@/lib/auth/sitzung'
@@ -102,3 +103,82 @@ export async function passwortAendern(
   await aufMindestdauerWarten(begonnen)
   return { erfolg: true }
 }
+
+/**
+ * Die eigene Anschrift.
+ *
+ * Sie steht im Absenderblock jedes erzeugten Schreibens und liefert den
+ * Ort fuer die Datumszeile. Angaben sind einzeln freiwillig: Wer nur den
+ * Ort hinterlegt, bekommt "Bayreuth, den 23.08.2026" und keinen
+ * Absenderblock mit leeren Zeilen.
+ */
+const AnschriftSchema = z.object({
+  strasse: z.string().trim().max(150, 'Bitte höchstens 150 Zeichen.'),
+  plz: z.string().trim().max(10, 'Bitte höchstens 10 Zeichen.'),
+  ort: z.string().trim().max(100, 'Bitte höchstens 100 Zeichen.'),
+})
+
+export type AnschriftZustand = {
+  fehler?: string
+  felder?: Partial<Record<'strasse' | 'plz' | 'ort', string>>
+  erfolg?: string
+}
+
+export async function anschriftSpeichern(
+  _vorher: AnschriftZustand,
+  formular: FormData,
+): Promise<AnschriftZustand> {
+  const benutzer = await erfordereBenutzer()
+
+  const gelesen = AnschriftSchema.safeParse({
+    strasse: formular.get('strasse') ?? '',
+    plz: formular.get('plz') ?? '',
+    ort: formular.get('ort') ?? '',
+  })
+
+  if (!gelesen.success) {
+    const felder = gelesen.error.flatten().fieldErrors
+    return {
+      fehler: 'Bitte prüfe die Eingaben.',
+      felder: {
+        strasse: felder.strasse?.[0],
+        plz: felder.plz?.[0],
+        ort: felder.ort?.[0],
+      },
+    }
+  }
+
+  // Leer heisst "nicht hinterlegt", nicht "leere Zeichenkette" - sonst
+  // stuende im Brief eine Zeile aus Leerzeichen.
+  const leerZuNull = (wert: string) => (wert === '' ? null : wert)
+
+  await db.user.update({
+    where: { id: benutzer.id },
+    data: {
+      strasse: leerZuNull(gelesen.data.strasse),
+      plz: leerZuNull(gelesen.data.plz),
+      ort: leerZuNull(gelesen.data.ort),
+    },
+  })
+
+  await protokollieren({
+    aktion: 'GEAENDERT',
+    entitaet: 'User',
+    entitaetId: benutzer.id,
+    bezeichnung: benutzer.name,
+    userId: benutzer.id,
+    userEmail: benutzer.email,
+    userName: benutzer.name,
+    aenderung: {
+      anschrift: {
+        alt: [benutzer.strasse, benutzer.plz, benutzer.ort].filter(Boolean).join(', ') || null,
+        neu:
+          [gelesen.data.strasse, gelesen.data.plz, gelesen.data.ort].filter(Boolean).join(', ') ||
+          null,
+      },
+    },
+  })
+
+  revalidatePath('/konto')
+  return { erfolg: 'Deine Anschrift ist gespeichert.' }
+}

src/server/actions/papierkorb.ts

@@ -105,6 +105,14 @@ function eintragsarten(): Record<string, Eintragsart> {
     ),
     Immobilie: einfach('Immobilie', 'Immobilie', 'Immobilien', 'IMMOBILIE', z.immobilie, 'bezeichnung'),
     Vertrag: einfach('Vertrag', 'Vertrag', 'Verträge', 'VERTRAEGE', z.vertrag, 'bezeichnung'),
+    Schreibvorlage: einfach(
+      'Schreibvorlage',
+      'Vorlage',
+      'Vorlagen',
+      'DOKUMENTE',
+      z.schreibvorlage,
+      'name',
+    ),
     Kontakt: einfach('Kontakt', 'Kontakt', 'Kontakte', 'KONTAKTE', z.kontakt, 'name'),
     Kontaktprotokoll: einfach(
       'Kontaktprotokoll',

src/server/actions/schreiben.ts

@@ -15,6 +15,7 @@ import {
   type SchreibenArt,
 } from '@/lib/schreiben/arten'
 import { briefPdfErzeugen } from '@/lib/schreiben/pdf'
+import { emailFassung } from '@/lib/schreiben/email'
 
 /**
  * Server Actions rund um erzeugte Schreiben.
@@ -51,6 +52,9 @@ const ablegenSchema = z.object({
   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(''),
 })
 
 /**
@@ -73,6 +77,8 @@ export async function schreibenAblegen(
     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') ?? '',
@@ -110,7 +116,20 @@ export async function schreibenAblegen(
     if (werte.vorgangId && !vorgang) return { fehler: 'Diesen Vorgang gibt es nicht (mehr).' }
 
     // --- Datei zuerst -------------------------------------------------------
-    const pdf = await briefPdfErzeugen(werte.text, versandAm)
+    // 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')
 
@@ -118,7 +137,7 @@ export async function schreibenAblegen(
     const dokument = await db.dokument.create({
       data: {
         betreuteId,
-        titel: werte.betreff.slice(0, 200),
+        titel: (istEmail ? `E-Mail: ${werte.betreff}` : werte.betreff).slice(0, 200),
         art: 'SCHREIBEN',
         richtung: 'AUSGANG',
         schreibenVom: versandAm,

src/server/actions/vertraege.ts

@@ -145,8 +145,13 @@ export async function vertragLoeschen(betreuteId: string, vertragId: string): Pr
 // -----------------------------------------------------------------------------
 
 async function vermoegenspostenZumVertrag(betreuteId: string, vertragId: string, bezeichnung: string) {
+  // Gesucht wird ueber die Verknuepfung, nicht ueber die Art. Sonst
+  // entsteht neben einem von Hand als "Sonstiges" angelegten Posten ein
+  // zweiter - und derselbe Vertrag haette zwei Wertreihen, von denen der
+  // Bericht die eine und der Vertrag die andere zeigt.
   const vorhanden = await db.vermoegensposten.findFirst({
-    where: { betreuteId, vertragId, art: 'VERSICHERUNG', ...nichtGeloescht },
+    where: { betreuteId, vertragId, ...nichtGeloescht },
+    orderBy: { erstelltAm: 'asc' },
   })
   if (vorhanden) return vorhanden
   return db.vermoegensposten.create({

src/server/actions/vorgaenge.ts

@@ -5,7 +5,7 @@ import { redirect } from 'next/navigation'
 import type { Prisma } from '@prisma/client'
 import { db, nichtGeloescht } from '@/lib/db'
 import { erfordereZugang } from '@/lib/auth/sitzung'
-import { aenderungErmitteln, protokollieren } from '@/lib/audit'
+import { aenderungErmitteln, protokollieren, type Aenderung } from '@/lib/audit'
 import { oeffnen, sealen } from '@/lib/crypto/feld'
 import {
   AufgabeAbhakenSchema,
@@ -58,6 +58,45 @@ function pfadeAuffrischen(vorgangId?: string): void {
 // Anlegen
 // -----------------------------------------------------------------------------
 
+/** Der Name eines Kontakts fuers Protokoll - null bleibt null. */
+async function kontaktnameZu(kontaktId: string | null): Promise<string | null> {
+  if (!kontaktId) return null
+  const kontakt = await db.kontakt.findUnique({
+    where: { id: kontaktId },
+    select: { name: true, organisation: true },
+  })
+  if (!kontakt) return null
+  return [kontakt.name, kontakt.organisation].filter(Boolean).join(', ')
+}
+
+/**
+ * Gehoert der Ansprechpartner zu dieser Akte?
+ *
+ * Ohne die Pruefung koennte ein veraendertes Formular einen Kontakt aus
+ * einer fremden Akte an den Vorgang haengen - und sein Name stuende
+ * anschliessend im Briefkopf.
+ */
+async function ansprechpartnerPruefen(
+  betreuteId: string,
+  ansprechpartnerId: string | null,
+): Promise<{ ok: true } | { ok: false; zustand: Formularzustand }> {
+  if (!ansprechpartnerId) return { ok: true }
+
+  const kontakt = await db.kontakt.findFirst({
+    where: { id: ansprechpartnerId, betreuteId, geloeschtAm: null },
+    select: { id: true },
+  })
+  if (kontakt) return { ok: true }
+
+  return {
+    ok: false,
+    zustand: {
+      fehler: 'Diesen Kontakt gibt es nicht (mehr).',
+      felder: { ansprechpartnerId: 'Bitte einen Kontakt aus dem Verzeichnis wählen.' },
+    },
+  }
+}
+
 export async function vorgangAnlegen(
   _vorher: Formularzustand,
   formular: FormData,
@@ -79,6 +118,10 @@ export async function vorgangAnlegen(
   }
 
   const eingabe = gelesen.data
+
+  const geprueft = await ansprechpartnerPruefen(betreuteId, eingabe.ansprechpartnerId)
+  if (!geprueft.ok) return geprueft.zustand
+
   const jetzt = new Date()
 
   // Aus der Vorlage entstehen Aufgaben und Fristen in einem Rutsch. Alles
@@ -101,6 +144,7 @@ export async function vorgangAnlegen(
         prioritaet: eingabe.prioritaet,
         gegenstelle: eingabe.gegenstelle,
         aktenzeichen: eingabe.aktenzeichen,
+        ansprechpartnerId: eingabe.ansprechpartnerId,
         verantwortlich: eingabe.verantwortlich ?? benutzer.name,
         naechsterSchritt:
           eingabe.naechsterSchritt ?? ergebnis?.aufgaben[0]?.titel ?? null,
@@ -205,6 +249,10 @@ export async function vorgangAendern(
   }
 
   const eingabe = gelesen.data
+
+  const geprueft = await ansprechpartnerPruefen(vorgang.betreuteId, eingabe.ansprechpartnerId)
+  if (!geprueft.ok) return geprueft.zustand
+
   const vorherOffen = oeffnen('Vorgang', vorgang)
 
   const daten: Prisma.VorgangUpdateInput = {
@@ -214,6 +262,11 @@ export async function vorgangAendern(
     prioritaet: eingabe.prioritaet,
     gegenstelle: eingabe.gegenstelle,
     aktenzeichen: eingabe.aktenzeichen,
+    // Ueber die Beziehung, nicht ueber das Feld: connect/disconnect ist
+    // das, was Prisma bei einer Update-Eingabe erwartet.
+    ansprechpartner: eingabe.ansprechpartnerId
+      ? { connect: { id: eingabe.ansprechpartnerId } }
+      : { disconnect: true },
     verantwortlich: eingabe.verantwortlich,
     naechsterSchritt: eingabe.naechsterSchritt,
     faelligAm: eingabe.faelligAm,
@@ -227,6 +280,19 @@ export async function vorgangAendern(
 
   const geaendert = await db.vorgang.update({ where: { id: vorgang.id }, data: daten })
 
+  // Der Wechsel des Ansprechpartners gehoert mit NAMEN ins Protokoll.
+  // Zwei cuids nebeneinander sind protokolliert, aber nicht
+  // nachvollziehbar - und nachvollziehbar war die Anforderung.
+  const ansprechpartnerWechsel: Aenderung =
+    vorgang.ansprechpartnerId !== geaendert.ansprechpartnerId
+      ? {
+          ansprechpartner: {
+            alt: await kontaktnameZu(vorgang.ansprechpartnerId),
+            neu: await kontaktnameZu(geaendert.ansprechpartnerId),
+          },
+        }
+      : {}
+
   await protokollieren({
     aktion: 'GEAENDERT',
     entitaet: 'Vorgang',
@@ -238,6 +304,7 @@ export async function vorgangAendern(
     userName: kontext.benutzer.name,
     aenderung: {
       ...aenderungErmitteln(vorgang, geaendert),
+      ...ansprechpartnerWechsel,
       ...(vorherOffen.beschreibung !== (eingabe.beschreibung ?? null)
         ? { beschreibung: { alt: vorherOffen.beschreibung, neu: eingabe.beschreibung } }
         : {}),

src/server/actions/vorlagen.ts

@@ -0,0 +1,187 @@
+'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, aenderungErmitteln } from '@/lib/audit'
+import { bestellungsabsatzFehlt } from '@/lib/schreiben/platzhalter'
+
+/**
+ * Server Actions fuer eigene Schreibvorlagen.
+ *
+ * Die Warnung beim fehlenden Bestellungsabsatz ist zweistufig: Der erste
+ * Speicherversuch ohne ihn kommt mit einer Warnung zurueck; erst die
+ * ausdrueckliche Bestaetigung ("ohneBestellungsabsatz") speichert. So
+ * laesst sich der Absatz weglassen - aber nur wissentlich. Ohne den
+ * Nachweis der Bestellung antwortet keine Versicherung, und das faellt
+ * erst nach vier Wochen auf.
+ */
+
+export type VorlagenZustand = {
+  fehler?: string
+  /** Die Bestellungsabsatz-Warnung - Speichern erst nach Bestaetigung. */
+  warnung?: string
+  erfolg?: string
+  felder?: Record<string, string>
+}
+
+function zugriffsfehler(ausnahme: unknown): VorlagenZustand | null {
+  if (ausnahme instanceof ZugriffVerweigert) return { fehler: ausnahme.message }
+  return null
+}
+
+const vorlageSchema = z.object({
+  betreuteId: z.string().min(1),
+  vorlageId: z.string().trim().default(''),
+  name: z.string().trim().min(1, 'Bitte einen Namen vergeben.').max(120),
+  betreff: z.string().trim().max(200).default(''),
+  text: z.string().trim().min(10, 'Der Text ist zu kurz für eine Vorlage.').max(50_000),
+  ohneBestellungsabsatz: z.string().default(''),
+})
+
+export async function vorlageSpeichern(
+  _zustand: VorlagenZustand,
+  daten: FormData,
+): Promise<VorlagenZustand> {
+  const gelesen = vorlageSchema.safeParse({
+    betreuteId: daten.get('betreuteId'),
+    vorlageId: daten.get('vorlageId') ?? '',
+    name: daten.get('name'),
+    betreff: daten.get('betreff') ?? '',
+    text: daten.get('text'),
+    ohneBestellungsabsatz: daten.get('ohneBestellungsabsatz') ?? '',
+  })
+
+  if (!gelesen.success) {
+    const felder = gelesen.error.flatten().fieldErrors
+    return {
+      fehler: 'Bitte prüfe die Eingaben.',
+      felder: Object.fromEntries(
+        Object.entries(felder).map(([name, meldungen]) => [name, meldungen?.[0] ?? '']),
+      ),
+    }
+  }
+
+  const werte = gelesen.data
+  const bestaetigt = werte.ohneBestellungsabsatz === 'ja'
+
+  try {
+    const { benutzer } = await erfordereZugang(werte.betreuteId, 'DOKUMENTE', 'schreiben')
+
+    // Die zweistufige Warnung: erst warnen, dann - bestaetigt - speichern.
+    if (bestellungsabsatzFehlt(werte.text) && !bestaetigt) {
+      return {
+        warnung:
+          'In dieser Vorlage fehlt der Bestellungsabsatz — der Nachweis, dass du zur Vertretung ' +
+          'befugt bist. Ohne ihn antworten Versicherungen und Behörden mit „aus ' +
+          'datenschutzrechtlichen Gründen keine Auskunft", und das fällt erst nach Wochen auf. ' +
+          'Füge {{bestellungsabsatz}} ein — oder speichere bewusst ohne.',
+      }
+    }
+
+    if (werte.vorlageId) {
+      const vorhanden = await db.schreibvorlage.findFirst({
+        where: { id: werte.vorlageId, betreuteId: werte.betreuteId, ...nichtGeloescht },
+      })
+      if (!vorhanden) return { fehler: 'Diese Vorlage gibt es nicht (mehr).' }
+
+      const nachher = await db.schreibvorlage.update({
+        where: { id: vorhanden.id },
+        data: {
+          name: werte.name,
+          betreff: werte.betreff,
+          text: werte.text,
+          ohneBestellungsabsatz: bestaetigt,
+        },
+      })
+
+      await protokollieren({
+        aktion: 'GEAENDERT',
+        entitaet: 'Schreibvorlage',
+        entitaetId: nachher.id,
+        bezeichnung: nachher.name,
+        betreuteId: werte.betreuteId,
+        userId: benutzer.id,
+        userEmail: benutzer.email,
+        userName: benutzer.name,
+        aenderung: aenderungErmitteln(
+          { name: vorhanden.name, betreff: vorhanden.betreff, text: vorhanden.text },
+          { name: nachher.name, betreff: nachher.betreff, text: nachher.text },
+        ),
+      })
+    } else {
+      const neu = await db.schreibvorlage.create({
+        data: {
+          betreuteId: werte.betreuteId,
+          name: werte.name,
+          betreff: werte.betreff,
+          text: werte.text,
+          ohneBestellungsabsatz: bestaetigt,
+        },
+      })
+
+      await protokollieren({
+        aktion: 'ERSTELLT',
+        entitaet: 'Schreibvorlage',
+        entitaetId: neu.id,
+        bezeichnung: neu.name,
+        betreuteId: werte.betreuteId,
+        userId: benutzer.id,
+        userEmail: benutzer.email,
+        userName: benutzer.name,
+      })
+    }
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[vorlagen] Speichern fehlgeschlagen:', ausnahme)
+    return { fehler: 'Die Vorlage konnte nicht gespeichert werden.' }
+  }
+
+  revalidatePath('/einstellungen/vorlagen')
+  return { erfolg: `„${werte.name}“ ist gespeichert.` }
+}
+
+/** Papierkorb: geloeschtAm setzen, 30 Tage rueckholbar wie ueberall. */
+export async function vorlageLoeschen(
+  _zustand: VorlagenZustand,
+  daten: FormData,
+): Promise<VorlagenZustand> {
+  const betreuteId = String(daten.get('betreuteId') ?? '')
+  const vorlageId = String(daten.get('vorlageId') ?? '')
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'DOKUMENTE', 'schreiben')
+
+    const vorlage = await db.schreibvorlage.findFirst({
+      where: { id: vorlageId, betreuteId, ...nichtGeloescht },
+      select: { id: true, name: true },
+    })
+    if (!vorlage) return { fehler: 'Diese Vorlage gibt es nicht (mehr).' }
+
+    await db.schreibvorlage.update({
+      where: { id: vorlage.id },
+      data: { geloeschtAm: new Date() },
+    })
+
+    await protokollieren({
+      aktion: 'GELOESCHT',
+      entitaet: 'Schreibvorlage',
+      entitaetId: vorlage.id,
+      bezeichnung: vorlage.name,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[vorlagen] Löschen fehlgeschlagen:', ausnahme)
+    return { fehler: 'Die Vorlage konnte nicht gelöscht werden.' }
+  }
+
+  revalidatePath('/einstellungen/vorlagen')
+  return { erfolg: 'In den Papierkorb gelegt — 30 Tage rückholbar.' }
+}

tests/anrede.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest'
+import { ALLGEMEINE_ANREDE, anredeZeile, nachnameAus } from '@/lib/kontakte/anrede'
+
+/**
+ * Die Briefanrede.
+ *
+ * Zwei Zusagen werden hier gepruft: Es wird nie geraten, und ein halb
+ * gefuellter Name fuehrt nie zu einer verstuemmelten Anrede.
+ */
+
+describe('Nachname', () => {
+  it('nimmt das letzte Wort', () => {
+    expect(nachnameAus('Anna Schmitt')).toBe('Schmitt')
+  })
+
+  it('lässt Titel und Vornamen weg', () => {
+    expect(nachnameAus('Dr. Anna Maria Schmitt')).toBe('Schmitt')
+  })
+
+  it('hält einen Doppelnamen zusammen', () => {
+    expect(nachnameAus('Anna Schmitt-Berger')).toBe('Schmitt-Berger')
+  })
+
+  it('verträgt überzählige Leerzeichen', () => {
+    expect(nachnameAus('  Anna   Schmitt  ')).toBe('Schmitt')
+  })
+})
+
+describe('Anredezeile', () => {
+  it('redet eine Frau mit Nachnamen an', () => {
+    expect(anredeZeile({ name: 'Anna Schmitt', anrede: 'FRAU' })).toBe(
+      'Sehr geehrte Frau Schmitt,',
+    )
+  })
+
+  it('redet einen Herrn mit Nachnamen an', () => {
+    expect(anredeZeile({ name: 'Peter Vogel', anrede: 'HERR' })).toBe(
+      'Sehr geehrter Herr Vogel,',
+    )
+  })
+
+  it('rät nicht, wenn die Anrede fehlt', () => {
+    // Lieber die etwas steife Form als ein falsch geratenes "Frau".
+    expect(anredeZeile({ name: 'Kim Berger', anrede: 'OHNE' })).toBe(
+      'Sehr geehrte(r) Kim Berger,',
+    )
+  })
+
+  it('bleibt ohne Ansprechpartner allgemein', () => {
+    expect(anredeZeile(null)).toBe(ALLGEMEINE_ANREDE)
+  })
+
+  it('wird bei leerem Namen nicht verstümmelt', () => {
+    // Der Fehler, der hier nie passieren darf: "Sehr geehrte Frau ,".
+    expect(anredeZeile({ name: '   ', anrede: 'FRAU' })).toBe(ALLGEMEINE_ANREDE)
+  })
+})

tests/briefkopf.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
+import { absenderBlock, datumsZeile } from '@/lib/vertraege/anschreiben'
+
+/**
+ * Der Absenderblock.
+ *
+ * Ein foermliches Schreiben ohne Ruecksendeadresse wirkt unserioes und
+ * macht es der Gegenstelle schwer zu antworten. Umgekehrt gilt: Lieber
+ * nur der Name als ein Block mit leeren Zeilen - eine halb ausgefuellte
+ * Adresse sieht nach Fehler aus, ein blosser Name nach Absicht.
+ */
+
+const BETREUTE = {
+  vorname: 'Erika',
+  nachname: 'Musterfrau',
+  anrede: 'Frau',
+  geburtsdatum: new Date(Date.UTC(1943, 3, 17)),
+  heimName: 'Seniorenheim Sonnenhof',
+  heimStrasse: 'Heimweg 3',
+  heimPlz: '95445',
+  heimOrt: 'Bayreuth',
+  betreuungsgericht: 'Amtsgericht Bayreuth',
+  aktenzeichenGericht: 'XVII 412/25',
+  bestellungAm: new Date(Date.UTC(2026, 1, 14)),
+}
+
+const VOLLSTAENDIG = {
+  name: 'Florian Wilde',
+  strasse: 'Cottenbacher Str. 23',
+  plz: '95445',
+  ort: 'Bayreuth',
+}
+
+describe('Absenderblock', () => {
+  it('nennt Name, Straße und Ort', () => {
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: VOLLSTAENDIG })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde\nCottenbacher Str. 23\n95445 Bayreuth')
+  })
+
+  it('bleibt beim Namen, wenn keine Anschrift hinterlegt ist', () => {
+    // Kein Block mit leeren Zeilen - das sieht nach Fehler aus.
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: { name: 'Florian Wilde' } })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde')
+  })
+
+  it('lässt die Straße weg, wenn nur der Ort bekannt ist', () => {
+    const kopf = briefkopfBauen({
+      betreute: BETREUTE,
+      benutzer: { name: 'Florian Wilde', plz: '95445', ort: 'Bayreuth' },
+    })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde\n95445 Bayreuth')
+  })
+
+  it('verträgt einen Ort ohne PLZ', () => {
+    const kopf = briefkopfBauen({
+      betreute: BETREUTE,
+      benutzer: { name: 'Florian Wilde', ort: 'Bayreuth' },
+    })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde\nBayreuth')
+  })
+
+  it('nimmt die Anschrift vom Betreuer, nicht vom Heim', () => {
+    // Die Heimadresse ist die der betreuten Person und gehört in den
+    // Anschriftenblock, nie in den Absender.
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: VOLLSTAENDIG })
+    expect(absenderBlock(kopf)).not.toContain('Heimweg')
+    expect(kopf.betreuteAnschrift).toContain('Heimweg 3')
+  })
+})
+
+describe('Datumszeile', () => {
+  const heute = new Date(Date.UTC(2026, 7, 23))
+
+  it('stellt den Ort des Betreuers voran', () => {
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: VOLLSTAENDIG })
+    expect(datumsZeile(kopf.betreuerOrt, heute)).toBe('Bayreuth, den 23.08.2026')
+  })
+
+  it('lässt ohne Ort das Komma weg', () => {
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: { name: 'Florian Wilde' } })
+    expect(datumsZeile(kopf.betreuerOrt, heute)).toBe('23.08.2026')
+  })
+})

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/migration-erzeugen.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest'
+import {
+  dropZeilenEntfernen,
+  hatAnweisungen,
+  kopfBauen,
+  ordnernameBauen,
+} from '../scripts/migration-erzeugen.mjs'
+
+/**
+ * Der Migrations-Wrapper.
+ *
+ * Die eine Sache, die hier schiefgehen darf und nicht schiefgehen soll:
+ * zu viel entfernen. Ein DROP INDEX, das Prisma zu Recht schreibt, muss
+ * stehen bleiben - sonst repariert das Skript die Suche und zerlegt
+ * dafuer das Schema.
+ */
+
+const GESCHUETZT = [
+  { name: 'dokument_absender_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+  { name: 'vorgang_titel_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+]
+
+describe('DROP-Zeilen entfernen', () => {
+  it('nimmt die geschützte Anweisung samt Überschrift heraus', () => {
+    const roh = [
+      '-- DropIndex',
+      'DROP INDEX "dokument_absender_trgm";',
+      '',
+      '-- AlterTable',
+      'ALTER TABLE "kontakt" ADD COLUMN "anrede" TEXT;',
+    ].join('\n')
+
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+
+    expect(entfernt).toEqual(['dokument_absender_trgm'])
+    expect(sql).not.toContain('DROP INDEX')
+    expect(sql).not.toContain('DropIndex')
+    expect(sql).toContain('ALTER TABLE "kontakt"')
+  })
+
+  it('lässt ein DROP INDEX auf einen Prisma-eigenen Index stehen', () => {
+    // Der Kern der Sache: Das Skript darf nicht alles wegräumen, was nach
+    // DROP INDEX aussieht - manche sollen wirklich weg.
+    const roh = ['-- DropIndex', 'DROP INDEX "vertrag_betreuteId_status_idx";'].join('\n')
+
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+
+    expect(entfernt).toEqual([])
+    expect(sql).toContain('DROP INDEX "vertrag_betreuteId_status_idx";')
+    expect(sql).toContain('-- DropIndex')
+  })
+
+  it('entfernt mehrere geschützte Anweisungen und meldet beide', () => {
+    const roh = [
+      '-- DropIndex',
+      'DROP INDEX "dokument_absender_trgm";',
+      '',
+      '-- DropIndex',
+      'DROP INDEX "vorgang_titel_trgm";',
+      '',
+      '-- CreateTable',
+      'CREATE TABLE "schreibvorlage" ();',
+    ].join('\n')
+
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+
+    expect(entfernt).toEqual(['dokument_absender_trgm', 'vorgang_titel_trgm'])
+    expect(sql.startsWith('-- CreateTable')).toBe(true)
+  })
+
+  it('verträgt IF EXISTS und abweichende Schreibweise', () => {
+    const roh = 'drop index if exists "vorgang_titel_trgm";'
+    expect(dropZeilenEntfernen(roh, GESCHUETZT).entfernt).toEqual(['vorgang_titel_trgm'])
+  })
+
+  it('lässt eine Migration ohne Treffer unverändert', () => {
+    const roh = ['-- AlterTable', 'ALTER TABLE "vorgang" ADD COLUMN "x" TEXT;'].join('\n')
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+    expect(entfernt).toEqual([])
+    expect(sql).toBe(roh)
+  })
+
+  it('greift nicht bei einem bloßen Vorkommen des Namens im Text', () => {
+    // Ein Kommentar, der den Index nennt, ist keine Anweisung.
+    const roh = '-- dokument_absender_trgm bleibt bestehen'
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+    expect(entfernt).toEqual([])
+    expect(sql).toBe(roh)
+  })
+})
+
+describe('Leere Migration erkennen', () => {
+  it('sieht eine echte Anweisung', () => {
+    expect(hatAnweisungen('-- AlterTable\nALTER TABLE "x" ADD COLUMN "y" TEXT;')).toBe(true)
+  })
+
+  it('hält reinen Kommentartext für leer', () => {
+    // Der Normalfall: Schema und Datenbank stimmen überein, der ganze
+    // Diff bestand aus den zwei bekannten DROP-Zeilen. Dann darf keine
+    // Migration entstehen — eine leere in der Historie ist schlimmer als
+    // keine.
+    expect(hatAnweisungen('-- nur ein Kommentar\n\n-- noch einer')).toBe(false)
+  })
+
+  it('hält Leerraum für leer', () => {
+    expect(hatAnweisungen('   \n\n  ')).toBe(false)
+  })
+})
+
+describe('Kopfkommentar', () => {
+  it('benennt die entfernten Indizes und ihre Quelle', () => {
+    const kopf = kopfBauen('ansprechpartner', ['vorgang_titel_trgm'], GESCHUETZT)
+    expect(kopf).toContain('vorgang_titel_trgm')
+    expect(kopf).toContain('prisma/sql/volltextsuche.sql')
+  })
+
+  it('sagt auch, wenn nichts zu entfernen war', () => {
+    expect(kopfBauen('leer', [], GESCHUETZT)).toContain('Nichts zu entfernen')
+  })
+})
+
+describe('Ordnername', () => {
+  it('baut den Zeitstempel im Prisma-Format', () => {
+    expect(ordnernameBauen('anrede', new Date(2026, 7, 23, 9, 5, 3))).toBe(
+      '20260823090503_anrede',
+    )
+  })
+})

tests/platzhalter.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest'
+import {
+  PLATZHALTER,
+  benutztePlatzhalter,
+  bestellungsabsatzFehlt,
+  platzhalterErsetzen,
+} from '@/lib/schreiben/platzhalter'
+
+/**
+ * Platzhalter in Schreibvorlagen.
+ *
+ * Der Grundsatz, den jede Prüfung hier absichert: NICHTS geht
+ * stillschweigend schief. Fehlende Daten werden zur sichtbaren Lücke,
+ * unbekannte Platzhalter zur Markierung — nie zu einer leeren Stelle, die
+ * erst der Empfänger bemerkt.
+ */
+
+describe('Ersetzen', () => {
+  it('setzt bekannte Werte ein', () => {
+    const ergebnis = platzhalterErsetzen('Sehr geehrte Damen und Herren, {{betreuer_name}} hier.', {
+      betreuer_name: 'Florian Wilde',
+    })
+    expect(ergebnis.text).toBe('Sehr geehrte Damen und Herren, Florian Wilde hier.')
+    expect(ergebnis.luecken).toHaveLength(0)
+    expect(ergebnis.unbekannte).toHaveLength(0)
+  })
+
+  it('macht aus fehlenden Daten eine sichtbare Lücke', () => {
+    const ergebnis = platzhalterErsetzen('Az. {{aktenzeichen_gericht}}', {})
+    expect(ergebnis.text).toBe('Az. [Aktenzeichen des Gerichts]')
+    expect(ergebnis.luecken).toEqual(['aktenzeichen_gericht'])
+  })
+
+  it('behandelt leere Zeichenketten wie fehlende Daten', () => {
+    const ergebnis = platzhalterErsetzen('{{betreuungsgericht}}', { betreuungsgericht: '  ' })
+    expect(ergebnis.text).toContain('[Betreuungsgericht]')
+  })
+
+  it('markiert unbekannte Platzhalter, statt abzubrechen', () => {
+    // Ein Tippfehler in der Vorlage darf das Schreiben nicht verhindern —
+    // aber er muss ins Auge springen.
+    const ergebnis = platzhalterErsetzen('Hallo {{betreur_name}}!', {})
+    expect(ergebnis.text).toBe('Hallo [Unbekannter Platzhalter: {{betreur_name}}]!')
+    expect(ergebnis.unbekannte).toEqual(['betreur_name'])
+  })
+
+  it('verträgt Leerzeichen in den Klammern', () => {
+    const ergebnis = platzhalterErsetzen('{{ betreuer_name }}', { betreuer_name: 'F. Wilde' })
+    expect(ergebnis.text).toBe('F. Wilde')
+  })
+
+  it('ersetzt mehrere Vorkommen und meldet jede Lücke nur einmal', () => {
+    const ergebnis = platzhalterErsetzen('{{stichtag}} und nochmal {{stichtag}}', {})
+    expect(ergebnis.luecken).toEqual(['stichtag'])
+    expect(ergebnis.text.match(/\[Stichtag\]/g)).toHaveLength(2)
+  })
+
+  it('lässt Text ohne Platzhalter unangetastet', () => {
+    const text = 'Ein Brief ohne alles. Auch { einzelne } Klammern bleiben.'
+    expect(platzhalterErsetzen(text, {}).text).toBe(text)
+  })
+})
+
+describe('Platzhalterliste', () => {
+  it('beschreibt jeden Platzhalter mit Beschriftung und Quelle', () => {
+    // Die Liste steht neben dem Editor - niemand soll Namen raten müssen.
+    for (const platzhalter of PLATZHALTER) {
+      expect(platzhalter.beschriftung.length, platzhalter.name).toBeGreaterThan(3)
+      expect(platzhalter.quelle.length, platzhalter.name).toBeGreaterThan(3)
+    }
+  })
+
+  it('findet die benutzten Platzhalter einer Vorlage', () => {
+    expect(
+      benutztePlatzhalter('{{betreuer_name}} an {{vertrag_gesellschaft}}, nochmal {{betreuer_name}}'),
+    ).toEqual(['betreuer_name', 'vertrag_gesellschaft'])
+  })
+})
+
+describe('Bestellungsabsatz-Warnung', () => {
+  it('ist zufrieden mit dem Platzhalter', () => {
+    expect(bestellungsabsatzFehlt('Text mit {{bestellungsabsatz}} darin.')).toBe(false)
+  })
+
+  it('ist zufrieden mit einem von Hand geschriebenen Nachweis', () => {
+    // Wer den Absatz ausformuliert hat, wird nicht gegängelt.
+    expect(
+      bestellungsabsatzFehlt(
+        'Durch Beschluss des Amtsgerichts bin ich zum Betreuer bestellt.',
+      ),
+    ).toBe(false)
+  })
+
+  it('warnt bei einer Vorlage ohne jeden Nachweis', () => {
+    expect(bestellungsabsatzFehlt('Sehr geehrte Damen und Herren, bitte um Auskunft.')).toBe(true)
+  })
+
+  it('lässt sich nicht von einem halben Nachweis täuschen', () => {
+    // "Beschluss" allein (etwa der Beschluss der Eigentümerversammlung)
+    // ist kein Bestellungsnachweis.
+    expect(bestellungsabsatzFehlt('Zum Beschluss der Eigentümerversammlung...')).toBe(true)
+  })
+})

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/vertraege.test.ts

@@ -11,7 +11,9 @@ import {
 import { kuendigungsassistent, genehmigungsfrage } from '@/lib/vertraege/kuendigungsassistent'
 import {
   anfrageStatus,
+  juengsterWert,
   rueckkaufswertAnschreiben,
+  wertHistorie,
   wiedervorlageAm,
 } from '@/lib/vertraege/rueckkaufswert'
 import { jahresbeitragCent, kannRueckkaufswertHaben } from '@/lib/vertraege/konstanten'
@@ -313,3 +315,29 @@ describe('Vertragsdauer aus Beginn und Ende', () => {
     expect(plan.naechsterTermin).toEqual(tag(2027, 1, 1))
   })
 })
+
+describe('Rückkaufswert-Historie am Vertrag', () => {
+  const wert = (jahr: number, cent: number) => ({ stichtag: tag(jahr, 3, 1), wertCent: cent })
+
+  it('sortiert über alle verknüpften Posten hinweg, jüngster zuerst', () => {
+    // Zwei Posten am selben Vertrag: einer von Hand angelegt, einer beim
+    // ersten Erfassen entstanden. Der Vertrag zeigt beide Reihen als eine.
+    const historie = wertHistorie([
+      { wertstaende: [wert(2024, 4000)] },
+      { wertstaende: [wert(2026, 5200), wert(2025, 4600)] },
+    ])
+
+    expect(historie.map((w) => w.wertCent)).toEqual([5200, 4600, 4000])
+  })
+
+  it('nennt den zuletzt mitgeteilten Wert', () => {
+    expect(juengsterWert([{ wertstaende: [wert(2025, 4600), wert(2026, 5200)] }])?.wertCent).toBe(
+      5200,
+    )
+  })
+
+  it('gibt ohne jeden Wert null zurück, statt eine Null zu behaupten', () => {
+    expect(juengsterWert([{ wertstaende: [] }])).toBeNull()
+    expect(juengsterWert([])).toBeNull()
+  })
+})

tests/vorgaenge.test.ts

@@ -481,8 +481,20 @@ describe('Sachstandsanfrage', () => {
   })
 
   it('spricht einen bekannten Ansprechpartner direkt an', () => {
-    const anfrage = sachstandsanfrageErzeugen({ ...eingabe, ansprechpartner: 'Frau Schmidt' })
+    const anfrage = sachstandsanfrageErzeugen({
-    expect(anfrage.text).toContain('Sehr geehrte(r) Frau Schmidt,')
+      ...eingabe,
+      ansprechpartner: { name: 'Petra Schmidt', anrede: 'FRAU' },
+    })
+    expect(anfrage.text).toContain('Sehr geehrte Frau Schmidt,')
+    // Der Name steht ueber der Stelle - so landet der Brief bei ihr.
+    const zeilen = anfrage.text.split('\n')
+    expect(zeilen[0]).toBe('Petra Schmidt')
+    expect(zeilen[1]).toBe('Bezirk Oberfranken')
+  })
+
+  it('bleibt ohne Ansprechpartner bei der allgemeinen Anrede', () => {
+    const anfrage = sachstandsanfrageErzeugen(eingabe)
+    expect(anfrage.text).toContain('Sehr geehrte Damen und Herren,')
   })
 
   it('hält Nachfassen erst nach sechs Wochen für angebracht', () => {

tests/wertalter.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+import {
+  WERT_VERALTET_TAGE,
+  wertalterBestimmen,
+  wertVeraltet,
+} from '@/lib/finanzen/wertalter'
+
+/**
+ * Das Alter eines Rueckkaufswerts.
+ *
+ * Die Grenze ist eine fachliche Aussage, keine Zierde: Ein Wert, der den
+ * letzten Jahresbericht ueberlebt hat, gehoert erneuert.
+ */
+
+const tag = (iso: string) => new Date(`${iso}T00:00:00.000Z`)
+
+describe('Grenze', () => {
+  it('liegt bei einem Jahr', () => {
+    expect(WERT_VERALTET_TAGE).toBe(365)
+  })
+
+  it('ist am 365. Tag noch nicht ueberschritten', () => {
+    expect(wertVeraltet(365)).toBe(false)
+    expect(wertVeraltet(366)).toBe(true)
+  })
+})
+
+describe('Alter bestimmen', () => {
+  it('rechnet in Kalendertagen', () => {
+    const alter = wertalterBestimmen(tag('2026-01-01'), tag('2026-01-31'))
+    expect(alter?.alterTage).toBe(30)
+    expect(alter?.veraltet).toBe(false)
+    expect(alter?.hinweis).toBeNull()
+  })
+
+  it('meldet einen Wert von vor zwei Jahren als veraltet', () => {
+    const alter = wertalterBestimmen(tag('2024-03-01'), tag('2026-03-01'))
+    expect(alter?.veraltet).toBe(true)
+    expect(alter?.hinweis).toBe('über ein Jahr alt')
+  })
+
+  it('behauptet ohne Stichtag kein Alter', () => {
+    // Kein Datum heisst nicht "heute" - es heisst "unbekannt".
+    expect(wertalterBestimmen(null, tag('2026-03-01'))).toBeNull()
+  })
+
+  it('zaehlt einen kuenftigen Stichtag negativ und nicht als veraltet', () => {
+    // Kommt vor: Der Wert wird zum Quartalsende angefragt und vorab erfasst.
+    const alter = wertalterBestimmen(tag('2026-06-30'), tag('2026-06-01'))
+    expect(alter?.alterTage).toBe(-29)
+    expect(alter?.veraltet).toBe(false)
+  })
+
+  it('ist taggenau und nicht uhrzeitabhaengig', () => {
+    const spaetAmTag = new Date('2026-03-01T23:30:00.000Z')
+    expect(wertalterBestimmen(tag('2026-03-01'), spaetAmTag)?.alterTage).toBe(0)
+  })
+})

tests/wiederkehrend.test.ts

@@ -75,6 +75,17 @@ describe('Schreibweisen vergleichbar machen', () => {
     expect(normalisieren('Debeka AG')).toBe(normalisieren('Debeka'))
   })
 
+  it('kennt die gGmbH', () => {
+    // Heime, Sozialdienste und Träger sind fast durchweg gGmbH — ohne
+    // sie zerfiele die Zusammenfassung genau dort, wo sie zählt.
+    expect(normalisieren('Seniorenzentrum St. Katharina gGmbH')).toBe(
+      normalisieren('Seniorenzentrum St. Katharina'),
+    )
+    expect(normalisieren('SENIORENZENTRUM ST KATHARINA GGMBH')).toBe(
+      normalisieren('Seniorenzentrum St. Katharina'),
+    )
+  })
+
   it('entfernt auch mehrteilige Rechtsformen', () => {
     expect(normalisieren('Stadtwerke Bamberg GmbH & Co KG')).toBe(
       normalisieren('Stadtwerke Bamberg'),