Merge #17: Rueckkaufswerte in einem Zug anfragen

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

Closes #6

CHANGELOG.md

@@ -26,6 +26,106 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [1.6.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Rückkaufswerte aller Versicherungen in einem Zug anfragen**
+  ([#6](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/6)).
+  Vor dem Vermögensverzeichnis und vor jedem Jahresbericht braucht es von
+  jeder Lebens- und Rentenversicherung den Rückkaufswert zum Stichtag —
+  jedes Mal dieselben fünf bis zehn Briefe. Das war der Handgriff, der im
+  Jahr am meisten Zeit gekostet hat.
+
+  Neu unter **Verträge → Rückkaufswerte anfragen**: Stichtag wählen, Liste
+  prüfen, ein Klick. Heraus kommt ein **ZIP mit einer Word-Datei je
+  Gesellschaft** plus Begleitblatt — und je Vertrag entsteht nebenbei die
+  PDF-Fassung in der Akte, die Wiedervorlage nach 28 Tagen und der
+  Vermerk, dass angefragt wurde. Auf „Heute" steht danach unter *Wartet
+  auf andere*, worauf gewartet wird und seit wann.
+
+- **Die Auswahl begründet sich selbst.** Vorausgewählt ist nur, was in
+  Frage kommt. Was nicht in Frage kommt, wird nicht stumm ausgeblendet,
+  sondern steht mit Grund in der Liste: „Ohne Gesellschaft fehlt der
+  Empfänger", „bereits vor 10 Tagen angefragt". Nur Vertragsarten, die
+  nie einen Rückkaufswert bilden (Strom, Haftpflicht), bleiben draußen.
+  Gekündigte Verträge bleiben anfragbar — bis zum Wirksamwerden besteht
+  der Vertrag, und genau dann will der Sozialhilfeträger den Wert sehen.
+
+- **Die Zahl steht vor dem Klick auf dem Knopf** („4 Schreiben erzeugen").
+  Einen Fehlgriff soll man bemerken, bevor zehn Briefe entstehen — nicht
+  danach beim Aufräumen.
+
+### Zwei Zusagen
+
+**Kein Alles-oder-nichts.** Jeder Vertrag läuft für sich. Scheitert einer
+(etwa am Objektspeicher), steht er mit Grund im Begleitblatt des ZIP —
+die übrigen laufen durch. Eine Transaktion über alle wäre die falsche
+Zusage: Wenn der neunte Brief scheitert, sollen die acht fertigen nicht
+verworfen werden.
+
+**Der Doppelklick kostet nichts.** Ein zweiter Lauf am selben Tag
+überspringt bereits angefragte Verträge und sagt es im Begleitblatt —
+keine doppelten Dokumente, keine doppelten Wiedervorlagen. Eine bewusste
+zweite Anfrage nach einer Woche (Brief verloren) bleibt möglich: von Hand
+anwählen genügt.
+
+### Geprüft
+
+- Zwölf Einheitstests für die Auswahllogik, darunter der Gleichschritt
+  von Sperrfrist und Wiedervorlage (beide 28 Tage — liefen sie
+  auseinander, würde gemahnt und zugleich neu angefragt).
+- Drei End-to-End-Tests: Vorauswahl samt Begründungen, der volle Lauf mit
+  allen Nebenwirkungen in der Datenbank, und der Dublettenschutz beim
+  zweiten Lauf.
+
+## [1.5.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Schreiben als E-Mail übernehmen**
+  ([#5](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/5)).
+  Vieles geht heute per E-Mail hinaus, nicht per Brief. Im Schreiben-Editor
+  gibt es jetzt den Umschalter **Als Brief / Als E-Mail**.
+
+  Die E-Mail-Fassung wird aus dem — womöglich schon bearbeiteten —
+  Brieftext abgeleitet: ohne Absenderblock, Anschrift und Datumszeile, die
+  gehören in den Brief und nicht in die Mail. **Der Bestellungsabsatz
+  bleibt drin** — ohne ihn kommt die Auskunft nicht. Betreff und Text sind
+  einzeln kopierbar.
+
+- **Zwei Wege ins Mailprogramm.** Die offene Entscheidung aus dem Issue
+  (mailto oder .eml) ist mit *beides* beantwortet:
+
+  **„Im Mailprogramm öffnen"** (mailto) für kurze Texte — der Knopf
+  verschwindet, sobald der kodierte Link 1800 Zeichen übersteigt. mailto
+  übergibt den Text in der Adresszeile, deren Länge nirgends zugesichert
+  ist; ein stillschweigend halbierter Brief fällt erst beim Empfänger auf.
+
+  **„Als E-Mail-Entwurf (.eml)"** immer: eine Datei, die sich im
+  Mailprogramm als fertiger Entwurf öffnet — Adresse, Betreff und voller
+  Text garantiert vollständig, mit korrekt kodierten Umlauten. Die Datei
+  erfindet bewusst keinen Absender: den trägt das Mailprogramm beim
+  Senden selbst ein.
+
+  Beide Knöpfe erscheinen nur, wenn eine E-Mail-Adresse da ist — aus dem
+  gewählten Kontakt übernommen oder von Hand eingetragen. Ohne Adresse
+  bleibt das Kopieren.
+
+- **Die Ablage kennt den Unterschied.** Eine als E-Mail abgelegte
+  Nachricht heißt in der Akte „E-Mail: …" und die PDF-Fassung trägt die
+  Empfängeradresse im Kopf — abgelegt wird die E-Mail-Fassung, nicht der
+  Brieftext. In der Akte soll stehen, was tatsächlich hinausging.
+
+### Geprüft
+
+- 20 Einheitstests: die Ableitung der E-Mail-Fassung (nichts geht
+  stillschweigend verloren, der Bestellungsabsatz bleibt), die
+  mailto-Längengrenze **nach** der Kodierung, das .eml-Format samt
+  Umlauten nach RFC 2047 und quoted-printable.
+- Vier End-to-End-Tests: Fassung ohne Briefkopf, .eml-Download, kein
+  Mailknopf ohne Adresse, Ablage als gekennzeichnete E-Mail.
+
 ## [1.4.0] – 2026-08-23
 
 ### Hinzugefügt
@@ -768,7 +868,9 @@ 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.6.0...HEAD
+[1.6.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.5.0...v1.6.0
+[1.5.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.4.0...v1.5.0
 [1.4.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.3.0...v1.4.0
 [1.3.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.2.0...v1.3.0
 [1.2.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.2...v1.2.0

README.md

@@ -580,11 +580,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.6.0
 ```
 
 ### Kontrolle
 
 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.4.0
+git describe --tags                              # v1.6.0
 ```
 
 ---
@@ -299,7 +299,7 @@ betreuungs-cockpit-sicherung-1  Up
 ```bash
 # Antwortet die Anwendung? (Port anpassen, falls du APP_PORT gesetzt hast)
 curl -s http://127.0.0.1:3000/api/gesundheit
-# {"status":"bereit","version":"1.4.0","commit":"..."}
+# {"status":"bereit","version":"1.6.0","commit":"..."}
 ```
 
 Kommt hier nichts, sieh in die Logs:
@@ -649,7 +649,7 @@ Erst **vom Proxy-Server aus** — kommt er überhaupt an?
 
 ```bash
 curl -s http://10.0.0.5:3000/api/gesundheit
-# {"status":"bereit","version":"1.4.0",...}
+# {"status":"bereit","version":"1.6.0",...}
 ```
 
 Kommt hier nichts, liegt es an 7a: falsche `APP_BIND`, Firewall, oder der
@@ -700,7 +700,7 @@ Zum Schluss: **Fristen → Pflichtfristen ableiten**.
 - Du kommst mit E-Mail, Passwort und dem Code aus der App herein.
 - Unter **Fristen** stehen Einträge mit Paragraphenbezug.
 - Unter **Protokoll** siehst du deine eigene Anmeldung.
-- Unten links in der Seitenleiste steht `Version 1.4.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.6.0 · <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.6.0` | auf eine bestimmte Fassung |
 | `./scripts/update.sh --pruefen` | nur nachsehen, nichts ändern |
 | `./scripts/update.sh --ja` | ohne Rückfrage (für cron) |
 | `./scripts/update.sh --verwerfen` | eigene Änderungen wegwerfen statt beiseitelegen |
@@ -913,7 +913,7 @@ git fetch --tags
 git log --oneline HEAD..origin/main
 
 # 3. Umschalten
-git checkout v1.4.0
+git checkout v1.6.0
 
 # 4. Neu bauen und starten
 GIT_COMMIT=$(git rev-parse --short HEAD) BUILD_ZEIT=$(date -Iseconds) docker compose up -d --build

docs/ROADMAP.md

@@ -9,7 +9,7 @@ Zeit spart. Er steht weit unten, wenn er nur schön wäre.
 Diese Datei ist eine Absichtserklärung, kein Vertrag. Was sich im Betrieb
 als wichtiger herausstellt, rutscht nach oben.
 
-Stand: 23.08.2026 · Aktuelle Fassung: **1.4.0** ([CHANGELOG](../CHANGELOG.md))
+Stand: 23.08.2026 · Aktuelle Fassung: **1.6.0** ([CHANGELOG](../CHANGELOG.md))
 
 ---
 

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

package.json

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

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

@@ -79,7 +79,15 @@ export default async function SchreibenSeite({
 
   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,
   })

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

@@ -1,235 +1,243 @@
-import Link from 'next/link'
+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 { Badge } from '@/components/ui/badge'
-import { Button } from '@/components/ui/button'
+import { Button } from '@/components/ui/button'
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
-import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
-import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
+import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
-import { Rechtshinweis } from '@/components/rechtshinweis'
+import { Rechtshinweis } from '@/components/rechtshinweis'
-import {
+import {
-  KuendigungsUebersicht,
+  KuendigungsUebersicht,
-  type Kuendigungswarnung,
+  type Kuendigungswarnung,
-} from '@/components/vertraege/kuendigungs-uebersicht'
+} from '@/components/vertraege/kuendigungs-uebersicht'
-import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
-import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
+import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
-import { oeffnen } from '@/lib/crypto/feld'
+import { oeffnen } from '@/lib/crypto/feld'
-import { heuteAlsTag } from '@/lib/fristen/datum'
+import { heuteAlsTag } from '@/lib/fristen/datum'
-import {
+import {
-  kuendigungsampel,
+  kuendigungsampel,
-  kuendigungsplan,
+  kuendigungsplan,
-  laufzeitAusVertrag,
+  laufzeitAusVertrag,
-} from '@/lib/vertraege/kuendigung'
+} from '@/lib/vertraege/kuendigung'
-import {
+import {
-  BEWERTUNG_BESCHRIFTUNG,
+  BEWERTUNG_BESCHRIFTUNG,
-  jahresbeitragCent,
+  jahresbeitragCent,
-  RHYTHMUS_BESCHRIFTUNG,
+  RHYTHMUS_BESCHRIFTUNG,
-  VERTRAG_ART_BESCHRIFTUNG,
+  VERTRAG_ART_BESCHRIFTUNG,
-  VERTRAG_STATUS_BESCHRIFTUNG,
+  VERTRAG_STATUS_BESCHRIFTUNG,
-} from '@/lib/vertraege/konstanten'
+} from '@/lib/vertraege/konstanten'
-import { formatCent, formatDatum } from '@/lib/utils'
+import { formatCent, formatDatum } from '@/lib/utils'
-
+
-export const dynamic = 'force-dynamic'
+export const dynamic = 'force-dynamic'
-
+
-const BEWERTUNG_VARIANTE = {
+const BEWERTUNG_VARIANTE = {
-  UNGEPRUEFT: 'outline',
+  UNGEPRUEFT: 'outline',
-  VERWERTBAR: 'orange',
+  VERWERTBAR: 'orange',
-  GESCHUETZT: 'gruen',
+  GESCHUETZT: 'gruen',
-  STRITTIG: 'gelb',
+  STRITTIG: 'gelb',
-} as const
+} as const
-
+
-export default async function VertraegeUebersicht() {
+export default async function VertraegeUebersicht() {
-  const benutzer = await erfordereBenutzer('/vertraege')
+  const benutzer = await erfordereBenutzer('/vertraege')
-  const aktive = await aktiveBetreute(benutzer)
+  const aktive = await aktiveBetreute(benutzer)
-  if (!aktive) return null
+  if (!aktive) return null
-
+
-  const { darfSchreiben } = await erfordereZugang(aktive.id, 'VERTRAEGE', 'lesen')
+  const { darfSchreiben } = await erfordereZugang(aktive.id, 'VERTRAEGE', 'lesen')
-  const schreiben = darfSchreiben('VERTRAEGE')
+  const schreiben = darfSchreiben('VERTRAEGE')
-
+
-  const vertraege = await db.vertrag.findMany({
+  const vertraege = await db.vertrag.findMany({
-    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
-    include: {
+    include: {
-      vermoegensposten: {
+      vermoegensposten: {
-        where: { art: 'VERSICHERUNG', ...nichtGeloescht },
+        where: { art: 'VERSICHERUNG', ...nichtGeloescht },
-        include: { wertstaende: { orderBy: { stichtag: 'desc' }, take: 1 } },
+        include: { wertstaende: { orderBy: { stichtag: 'desc' }, take: 1 } },
-      },
+      },
-    },
+    },
-    orderBy: [{ status: 'asc' }, { bezeichnung: 'asc' }],
+    orderBy: [{ status: 'asc' }, { bezeichnung: 'asc' }],
-  })
+  })
-
+
-  const heute = heuteAlsTag()
+  const heute = heuteAlsTag()
-  const warnungen: Kuendigungswarnung[] = []
+  const warnungen: Kuendigungswarnung[] = []
-  let jahresbeitragSumme = 0n
+  let jahresbeitragSumme = 0n
-
+
-  const zeilen = vertraege.map((vertrag) => {
+  const zeilen = vertraege.map((vertrag) => {
-    const offen = oeffnen('Vertrag', vertrag)
+    const offen = oeffnen('Vertrag', vertrag)
-    const plan = kuendigungsplan({
+    const plan = kuendigungsplan({
-      beginnAm: vertrag.beginnAm,
+      beginnAm: vertrag.beginnAm,
-      endeAm: vertrag.endeAm,
+      endeAm: vertrag.endeAm,
-      laufzeitJahre: laufzeitAusVertrag(vertrag.beginnAm, vertrag.endeAm),
+      laufzeitJahre: laufzeitAusVertrag(vertrag.beginnAm, vertrag.endeAm),
-      kuendigungsfristMonate: vertrag.kuendigungsfristMonate,
+      kuendigungsfristMonate: vertrag.kuendigungsfristMonate,
-      heute,
+      heute,
-    })
+    })
-    const ampel = kuendigungsampel(plan)
+    const ampel = kuendigungsampel(plan)
-
+
-    const jahr = jahresbeitragCent(vertrag.beitragCent, vertrag.rhythmus)
+    const jahr = jahresbeitragCent(vertrag.beitragCent, vertrag.rhythmus)
-    if (jahr && vertrag.status === 'AKTIV') jahresbeitragSumme += jahr
+    if (jahr && vertrag.status === 'AKTIV') jahresbeitragSumme += jahr
-
+
-    const laufend = vertrag.status === 'AKTIV' || vertrag.status === 'BEITRAGSFREI'
+    const laufend = vertrag.status === 'AKTIV' || vertrag.status === 'BEITRAGSFREI'
-    if (laufend && ampel && (ampel.variante === 'rot' || ampel.variante === 'orange')) {
+    if (laufend && ampel && (ampel.variante === 'rot' || ampel.variante === 'orange')) {
-      warnungen.push({
+      warnungen.push({
-        vertragId: vertrag.id,
+        vertragId: vertrag.id,
-        bezeichnung: vertrag.bezeichnung,
+        bezeichnung: vertrag.bezeichnung,
-        absendetag: plan.spaetesterAbsendetag?.toISOString() ?? null,
+        absendetag: plan.spaetesterAbsendetag?.toISOString() ?? null,
-        tageBisAbsendetag: plan.tageBisAbsendetag,
+        tageBisAbsendetag: plan.tageBisAbsendetag,
-        verpasst: plan.verpasst,
+        verpasst: plan.verpasst,
-        variante: ampel.variante,
+        variante: ampel.variante,
-        text: ampel.text,
+        text: ampel.text,
-      })
+      })
-    }
+    }
-
+
-    return {
+    return {
-      id: vertrag.id,
+      id: vertrag.id,
-      bezeichnung: vertrag.bezeichnung,
+      bezeichnung: vertrag.bezeichnung,
-      gesellschaft: vertrag.gesellschaft,
+      gesellschaft: vertrag.gesellschaft,
-      art: vertrag.art,
+      art: vertrag.art,
-      status: vertrag.status,
+      status: vertrag.status,
-      vertragsnummer: offen.vertragsnummer,
+      vertragsnummer: offen.vertragsnummer,
-      beitragCent: centZuZahl(vertrag.beitragCent),
+      beitragCent: centZuZahl(vertrag.beitragCent),
-      rhythmus: vertrag.rhythmus,
+      rhythmus: vertrag.rhythmus,
-      bewertung: vertrag.bewertungSozialhilfe,
+      bewertung: vertrag.bewertungSozialhilfe,
-      rueckkaufswertCent: centZuZahl(
+      rueckkaufswertCent: centZuZahl(
-        vertrag.vermoegensposten[0]?.wertstaende[0]?.wertCent ?? null,
+        vertrag.vermoegensposten[0]?.wertstaende[0]?.wertCent ?? null,
-      ),
+      ),
-      rueckkaufswertStichtag:
+      rueckkaufswertStichtag:
-        vertrag.vermoegensposten[0]?.wertstaende[0]?.stichtag.toISOString() ?? null,
+        vertrag.vermoegensposten[0]?.wertstaende[0]?.stichtag.toISOString() ?? null,
-      ampel,
+      ampel,
-    }
+    }
-  })
+  })
-
+
-  return (
+  return (
-    <div className="space-y-6">
+    <div className="space-y-6">
-      <SeitenKopf
+      <SeitenKopf
-        titel="Versicherungen & Verträge"
+        titel="Versicherungen & Verträge"
-        beschreibung="Alle laufenden Verträge mit Beitrag, Kündigungsfrist, Rückkaufswert und der Einordnung fürs Sozialamt."
+        beschreibung="Alle laufenden Verträge mit Beitrag, Kündigungsfrist, Rückkaufswert und der Einordnung fürs Sozialamt."
-        pfad={[{ titel: 'Übersicht', href: '/heute' }, { titel: 'Verträge' }]}
+        pfad={[{ titel: 'Übersicht', href: '/heute' }, { titel: 'Verträge' }]}
-        aktionen={
+        aktionen={
-          schreiben && (
+          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" />
-      <KuendigungsUebersicht warnungen={warnungen} />
+                  Vertrag anlegen
-
+                </Link>
-      {vertraege.length === 0 ? (
+              </Button>
-        <Leerzustand
+            </>
-          titel="Noch kein Vertrag erfasst"
+          )
-          beschreibung="Nimm die Kontoauszüge des letzten Jahres zur Hand: Jede wiederkehrende Abbuchung ist ein Vertrag. Das ist der zuverlässigste Weg, nichts zu übersehen — Policen liegen selten vollständig im Ordner."
+        }
-          icon={Shield}
+      />
-          aktion={
+
-            schreiben && (
+      <KuendigungsUebersicht warnungen={warnungen} />
-              <Button asChild>
+
-                <Link href="/vertraege/neu">
+      {vertraege.length === 0 ? (
-                  <Plus aria-hidden="true" />
+        <Leerzustand
-                  Vertrag anlegen
+          titel="Noch kein Vertrag erfasst"
-                </Link>
+          beschreibung="Nimm die Kontoauszüge des letzten Jahres zur Hand: Jede wiederkehrende Abbuchung ist ein Vertrag. Das ist der zuverlässigste Weg, nichts zu übersehen — Policen liegen selten vollständig im Ordner."
-              </Button>
+          icon={Shield}
-            )
+          aktion={
-          }
+            schreiben && (
-        />
+              <Button asChild>
-      ) : (
+                <Link href="/vertraege/neu">
-        <Card>
+                  <Plus aria-hidden="true" />
-          <CardHeader>
+                  Vertrag anlegen
-            <CardTitle>Alle Verträge</CardTitle>
+                </Link>
-            <CardDescription>
+              </Button>
-              Jahresbeitrag der aktiven Verträge zusammen:{' '}
+            )
-              <strong className="text-foreground">
+          }
-                {formatCent(centZuZahl(jahresbeitragSumme))}
+        />
-              </strong>
+      ) : (
-            </CardDescription>
+        <Card>
-          </CardHeader>
+          <CardHeader>
-          <CardContent>
+            <CardTitle>Alle Verträge</CardTitle>
-            <Table>
+            <CardDescription>
-              <TableHeader>
+              Jahresbeitrag der aktiven Verträge zusammen:{' '}
-                <TableRow>
+              <strong className="text-foreground">
-                  <TableHead>Vertrag</TableHead>
+                {formatCent(centZuZahl(jahresbeitragSumme))}
-                  <TableHead>Art</TableHead>
+              </strong>
-                  <TableHead className="text-right">Beitrag</TableHead>
+            </CardDescription>
-                  <TableHead className="text-right">Rückkaufswert</TableHead>
+          </CardHeader>
-                  <TableHead>Kündigung</TableHead>
+          <CardContent>
-                  <TableHead>Sozialamt</TableHead>
+            <Table>
-                  <TableHead>Status</TableHead>
+              <TableHeader>
-                </TableRow>
+                <TableRow>
-              </TableHeader>
+                  <TableHead>Vertrag</TableHead>
-              <TableBody>
+                  <TableHead>Art</TableHead>
-                {zeilen.map((zeile) => (
+                  <TableHead className="text-right">Beitrag</TableHead>
-                  <TableRow key={zeile.id}>
+                  <TableHead className="text-right">Rückkaufswert</TableHead>
-                    <TableCell>
+                  <TableHead>Kündigung</TableHead>
-                      <Link
+                  <TableHead>Sozialamt</TableHead>
-                        href={`/vertraege/${zeile.id}`}
+                  <TableHead>Status</TableHead>
-                        className="font-medium hover:underline"
+                </TableRow>
-                      >
+              </TableHeader>
-                        {zeile.bezeichnung}
+              <TableBody>
-                      </Link>
+                {zeilen.map((zeile) => (
-                      <span className="block text-sm text-muted-foreground">
+                  <TableRow key={zeile.id}>
-                        {[zeile.gesellschaft, zeile.vertragsnummer].filter(Boolean).join(' · ') ||
+                    <TableCell>
-                          'Gesellschaft nicht erfasst'}
+                      <Link
-                      </span>
+                        href={`/vertraege/${zeile.id}`}
-                    </TableCell>
+                        className="font-medium hover:underline"
-                    <TableCell className="text-sm">
+                      >
-                      {VERTRAG_ART_BESCHRIFTUNG[zeile.art]}
+                        {zeile.bezeichnung}
-                    </TableCell>
+                      </Link>
-                    <TableCell className="text-right tabular-nums">
+                      <span className="block text-sm text-muted-foreground">
-                      {formatCent(zeile.beitragCent)}
+                        {[zeile.gesellschaft, zeile.vertragsnummer].filter(Boolean).join(' · ') ||
-                      {zeile.rhythmus && (
+                          'Gesellschaft nicht erfasst'}
-                        <span className="block text-xs text-muted-foreground">
+                      </span>
-                          {RHYTHMUS_BESCHRIFTUNG[zeile.rhythmus]}
+                    </TableCell>
-                        </span>
+                    <TableCell className="text-sm">
-                      )}
+                      {VERTRAG_ART_BESCHRIFTUNG[zeile.art]}
-                    </TableCell>
+                    </TableCell>
-                    <TableCell className="text-right tabular-nums">
+                    <TableCell className="text-right tabular-nums">
-                      {formatCent(zeile.rueckkaufswertCent)}
+                      {formatCent(zeile.beitragCent)}
-                      {zeile.rueckkaufswertStichtag && (
+                      {zeile.rhythmus && (
-                        <span className="block text-xs text-muted-foreground">
+                        <span className="block text-xs text-muted-foreground">
-                          {formatDatum(zeile.rueckkaufswertStichtag)}
+                          {RHYTHMUS_BESCHRIFTUNG[zeile.rhythmus]}
-                        </span>
+                        </span>
-                      )}
+                      )}
-                    </TableCell>
+                    </TableCell>
-                    <TableCell>
+                    <TableCell className="text-right tabular-nums">
-                      {zeile.ampel ? (
+                      {formatCent(zeile.rueckkaufswertCent)}
-                        <Badge variant={zeile.ampel.variante}>{zeile.ampel.text}</Badge>
+                      {zeile.rueckkaufswertStichtag && (
-                      ) : (
+                        <span className="block text-xs text-muted-foreground">
-                        <span className="text-sm text-muted-foreground">nicht berechenbar</span>
+                          {formatDatum(zeile.rueckkaufswertStichtag)}
-                      )}
+                        </span>
-                    </TableCell>
+                      )}
-                    <TableCell>
+                    </TableCell>
-                      <Badge variant={BEWERTUNG_VARIANTE[zeile.bewertung]}>
+                    <TableCell>
-                        {BEWERTUNG_BESCHRIFTUNG[zeile.bewertung]}
+                      {zeile.ampel ? (
-                      </Badge>
+                        <Badge variant={zeile.ampel.variante}>{zeile.ampel.text}</Badge>
-                    </TableCell>
+                      ) : (
-                    <TableCell className="text-sm">
+                        <span className="text-sm text-muted-foreground">nicht berechenbar</span>
-                      {VERTRAG_STATUS_BESCHRIFTUNG[zeile.status]}
+                      )}
-                    </TableCell>
+                    </TableCell>
-                  </TableRow>
+                    <TableCell>
-                ))}
+                      <Badge variant={BEWERTUNG_VARIANTE[zeile.bewertung]}>
-              </TableBody>
+                        {BEWERTUNG_BESCHRIFTUNG[zeile.bewertung]}
-            </Table>
+                      </Badge>
-          </CardContent>
+                    </TableCell>
-        </Card>
+                    <TableCell className="text-sm">
-      )}
+                      {VERTRAG_STATUS_BESCHRIFTUNG[zeile.status]}
-
+                    </TableCell>
-      <Rechtshinweis rechtsgrundlage="§ 90 SGB XII, § 1850 BGB" />
+                  </TableRow>
-      <p className="text-sm text-muted-foreground">
+                ))}
-        Kurz übersetzt: Ob ein Vertrag vor der Sozialhilfe einzusetzen ist, richtet sich nach
+              </TableBody>
-        § 90 SGB XII — eine angemessene Bestattungsvorsorge bleibt regelmäßig geschützt. Und
+            </Table>
-        bevor eine Lebens- oder Rentenversicherung verwertet wird, gehört die Frage nach der
+          </CardContent>
-        Genehmigung des Betreuungsgerichts (§ 1850 BGB) an den Rechtspfleger, nicht an diese App.
+        </Card>
-      </p>
+      )}
-    </div>
+
-  )
+      <Rechtshinweis rechtsgrundlage="§ 90 SGB XII, § 1850 BGB" />
-}
+      <p className="text-sm text-muted-foreground">
+        Kurz übersetzt: Ob ein Vertrag vor der Sozialhilfe einzusetzen ist, richtet sich nach
+        § 90 SGB XII — eine angemessene Bestattungsvorsorge bleibt regelmäßig geschützt. Und
+        bevor eine Lebens- oder Rentenversicherung verwertet wird, gehört die Frage nach der
+        Genehmigung des Betreuungsgerichts (§ 1850 BGB) an den Rechtspfleger, nicht an diese App.
+      </p>
+    </div>
+  )
+}

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

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

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

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

src/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
 }
 
 /**
@@ -67,6 +70,10 @@ export function SchreibenEditor({
   const [betreff, setBetreff] = React.useState(entwurf.betreff)
   const [empfaengerName, setEmpfaengerName] = React.useState(entwurf.empfaengerName)
   const [empfaengerAnschrift, setEmpfaengerAnschrift] = React.useState('')
+  const [empfaengerEmail, setEmpfaengerEmail] = React.useState('')
+  const [versandweg, setVersandweg] = React.useState<'BRIEF' | 'EMAIL'>('BRIEF')
+  const [betreffKopiert, setBetreffKopiert] = React.useState(false)
+  const [mailKopiert, setMailKopiert] = React.useState(false)
   const [versandAm, setVersandAm] = React.useState(new Date().toISOString().slice(0, 10))
   const [wiedervorlageAm, setWiedervorlageAm] = React.useState(entwurf.wiedervorlageAm)
   const [kopiert, setKopiert] = React.useState(false)
@@ -94,6 +101,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 +116,7 @@ export function SchreibenEditor({
         .filter(Boolean)
         .join('\n'),
     )
+    setEmpfaengerEmail(kontakt.email ?? '')
   }
 
   async function textKopieren() {
@@ -121,6 +131,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 +306,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 +391,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 +445,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/vertraege/serienabfrage-formular.tsx

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

src/lib/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/version.ts

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

src/lib/vertraege/serienabfrage.ts

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

src/lib/vertraege/serienlauf.ts

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

src/server/actions/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,

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