Merge #18 : Eigene Vorlagen fuer Anschreiben

Behebt Issue #7: eigene Schreibvorlagen unter Einstellungen, Platzhalter mit sichtbaren Luecken, zweistufige Bestellungsabsatz-Warnung, vier mitgelieferte Vorlagen als Kopiervorlage, Auswahl beim freien Schreiben. Closes #7
Eigene Vorlagen fuer Anschreiben
2026-08-23 11:59:44 +00:00 · 2026-08-23 13:41:51 +02:00 · 2026-08-23 10:18:02 +00:00 · 2026-08-23 12:10:32 +02:00
30 changed files with 2777 additions and 252 deletions
@@ -26,6 +26,119 @@ Wiederherstellung*.

 _Noch nichts._

+## [1.7.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Eigene Vorlagen für Anschreiben**
+  ([#7](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/7)).
+  Wer zum dritten Mal denselben Brief tippt, tippt ihn beim vierten Mal
+  falsch. Neu unter **Einstellungen → Schreibvorlagen**: eigene Texte
+  hinterlegen, beim freien Schreiben auswählen — der Rest füllt sich aus
+  den Daten, die ohnehin im System stehen.
+
+- **Platzhalter, die sich selbst erklären.** Neben dem Editor steht die
+  vollständige Liste — Name, wofür er steht, woher der Wert kommt. Ein
+  Klick setzt ihn an die Cursorstelle; niemand muss `{{…}}`-Namen raten
+  oder abtippen. Verfügbar sind unter anderem Name und Geburtsdatum der
+  betreuten Person, ihre Anschrift, Betreuungsgericht und Aktenzeichen,
+  das Bestellungsdatum, der Stichtag und das heutige Datum.
+
+- **Vier mitgelieferte Vorlagen** als Ausgangspunkt: Auskunftsersuchen an
+  eine noch unbekannte Stelle, Adressänderung nach Heimeinzug, Nachweis
+  der Vertretungsmacht (wenn eine Stelle die Auskunft verweigert) und die
+  Kurzfassung der Rückkaufswert-Anfrage. Sie lassen sich nicht kaputt
+  bearbeiten — „Als Kopie übernehmen" legt eine eigene Fassung an, das
+  Original bleibt liegen. Für Rückkaufswert und Kündigung führt die
+  Oberfläche weiter zuerst zu den fallbezogenen Erzeugern: Die rechnen
+  Kündigungstermine aus, was eine Vorlage nicht kann.
+
+### Zwei Zusagen
+
+**Nichts geht stillschweigend schief.** Fehlt ein Wert (etwa das
+Aktenzeichen), steht im Brief eine sichtbare Lücke `[Aktenzeichen des
+Gerichts]` — kein Leerraum, den erst der Empfänger bemerkt. Ein
+Tippfehler im Platzhalternamen bricht nicht ab, sondern wird im Text
+markiert und über dem Editor benannt.
+
+**Der Bestellungsabsatz wird nicht vergessen.** Ohne den Nachweis der
+Vertretungsmacht kommt keine Auskunft — und das fällt erst nach vier
+Wochen auf. Beim Speichern einer Vorlage ohne Bestellungsabsatz kommt
+deshalb eine Rückfrage. Wer ihn bewusst weglässt (etwa für die zweite
+Mail an eine Stelle, die den Nachweis schon hat), bestätigt einmal und
+wird nicht weiter gefragt. Ein ausformulierter Absatz zählt genauso wie
+der Platzhalter.
+
+### Geändert
+
+- Gelöschte Vorlagen liegen wie alles andere **30 Tage im Papierkorb**
+  und lassen sich zurückholen. Beim Vollexport der Akte sind sie mit
+  dabei.
+
+### Geprüft
+
+- Dreizehn Einheitstests für die Platzhalter-Ersetzung, darunter jeder
+  der drei Fälle (Wert einsetzen, sichtbare Lücke, unbekannter
+  Platzhalter) und die Bestellungsabsatz-Erkennung, die sich nicht von
+  einem halben Nachweis („Beschluss der Eigentümerversammlung") täuschen
+  lässt.
+- Sechs End-to-End-Tests: die zweistufige Warnung, das Übernehmen einer
+  mitgelieferten Vorlage, die Auflösung im Editor samt markierter
+  Tippfehler und der Weg durch den Papierkorb.
+
+## [1.6.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Rückkaufswerte aller Versicherungen in einem Zug anfragen**
+  ([#6](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/6)).
+  Vor dem Vermögensverzeichnis und vor jedem Jahresbericht braucht es von
+  jeder Lebens- und Rentenversicherung den Rückkaufswert zum Stichtag —
+  jedes Mal dieselben fünf bis zehn Briefe. Das war der Handgriff, der im
+  Jahr am meisten Zeit gekostet hat.
+
+  Neu unter **Verträge → Rückkaufswerte anfragen**: Stichtag wählen, Liste
+  prüfen, ein Klick. Heraus kommt ein **ZIP mit einer Word-Datei je
+  Gesellschaft** plus Begleitblatt — und je Vertrag entsteht nebenbei die
+  PDF-Fassung in der Akte, die Wiedervorlage nach 28 Tagen und der
+  Vermerk, dass angefragt wurde. Auf „Heute" steht danach unter *Wartet
+  auf andere*, worauf gewartet wird und seit wann.
+
+- **Die Auswahl begründet sich selbst.** Vorausgewählt ist nur, was in
+  Frage kommt. Was nicht in Frage kommt, wird nicht stumm ausgeblendet,
+  sondern steht mit Grund in der Liste: „Ohne Gesellschaft fehlt der
+  Empfänger", „bereits vor 10 Tagen angefragt". Nur Vertragsarten, die
+  nie einen Rückkaufswert bilden (Strom, Haftpflicht), bleiben draußen.
+  Gekündigte Verträge bleiben anfragbar — bis zum Wirksamwerden besteht
+  der Vertrag, und genau dann will der Sozialhilfeträger den Wert sehen.
+
+- **Die Zahl steht vor dem Klick auf dem Knopf** („4 Schreiben erzeugen").
+  Einen Fehlgriff soll man bemerken, bevor zehn Briefe entstehen — nicht
+  danach beim Aufräumen.
+
+### Zwei Zusagen
+
+**Kein Alles-oder-nichts.** Jeder Vertrag läuft für sich. Scheitert einer
+(etwa am Objektspeicher), steht er mit Grund im Begleitblatt des ZIP —
+die übrigen laufen durch. Eine Transaktion über alle wäre die falsche
+Zusage: Wenn der neunte Brief scheitert, sollen die acht fertigen nicht
+verworfen werden.
+
+**Der Doppelklick kostet nichts.** Ein zweiter Lauf am selben Tag
+überspringt bereits angefragte Verträge und sagt es im Begleitblatt —
+keine doppelten Dokumente, keine doppelten Wiedervorlagen. Eine bewusste
+zweite Anfrage nach einer Woche (Brief verloren) bleibt möglich: von Hand
+anwählen genügt.
+
+### Geprüft
+
+- Zwölf Einheitstests für die Auswahllogik, darunter der Gleichschritt
+  von Sperrfrist und Wiedervorlage (beide 28 Tage — liefen sie
+  auseinander, würde gemahnt und zugleich neu angefragt).
+- Drei End-to-End-Tests: Vorauswahl samt Begründungen, der volle Lauf mit
+  allen Nebenwirkungen in der Datenbank, und der Dublettenschutz beim
+  zweiten Lauf.
+
 ## [1.5.0] – 2026-08-23

 ### Hinzugefügt
@@ -815,7 +928,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.5.0...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.7.0...HEAD
+[1.7.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.6.0...v1.7.0
+[1.6.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.5.0...v1.6.0
 [1.5.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.4.0...v1.5.0
 [1.4.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.3.0...v1.4.0
 [1.3.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.2.0...v1.3.0
@@ -580,11 +580,11 @@ Fehler, die während des Baus aufgefallen sind.

 | | | nachzuzählen mit |
 |---|---:|---|
-| Zeilen TypeScript/TSX | 78.486 | `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` |
-| Unit-Tests (Vitest) | 590 | `npm test` |
-| End-to-End-Tests (Playwright) | 81 | `npm run test:e2e` — 44 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
+| Seiten | 82 | `find src/app -name page.tsx \| wc -l` |
+| Unit-Tests (Vitest) | 602 | `npm test` |
+| End-to-End-Tests (Playwright) | 87 | `npm run test:e2e` — 47 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
 | TypeScript-Fehler | 0 | `npm run typecheck` |

 Die Befehle stehen dabei, weil die Zahlen sonst altern, ohne dass es
@@ -131,14 +131,14 @@ cd /opt/betreuungs-cockpit

 # Auf die letzte veröffentlichte Fassung wechseln,
 # nicht auf den laufenden Entwicklungsstand
-git checkout v1.5.0
+git checkout v1.7.0
 ```

 ### Kontrolle

 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.5.0
+git describe --tags                              # v1.7.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.5.0","commit":"..."}
+# {"status":"bereit","version":"1.7.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.5.0",...}
+# {"status":"bereit","version":"1.7.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.5.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.7.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.5.0` | auf eine bestimmte Fassung |
+| `./scripts/update.sh v1.7.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.5.0
+git checkout v1.7.0

 # 4. Neu bauen und starten
 GIT_COMMIT=$(git rev-parse --short HEAD) BUILD_ZEIT=$(date -Iseconds) docker compose up -d --build
@@ -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.5.0** ([CHANGELOG](../CHANGELOG.md))
+Stand: 23.08.2026 · Aktuelle Fassung: **1.7.0** ([CHANGELOG](../CHANGELOG.md))

 ---

@@ -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)
+  })
+})
@@ -0,0 +1,157 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Eigene Schreibvorlagen — gegen die echte Anwendung.
+ *
+ * Der Weg über die Oberfläche: Vorlage anlegen (mit der zweistufigen
+ * Bestellungsabsatz-Warnung), aus einer mitgelieferten kopieren, beim
+ * Schreiben auswählen und die Platzhalter-Auflösung sehen.
+ */
+
+const VORLAGE = 'Prüfhausen Testvorlage'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.schreibvorlage.deleteMany({ where: { name: { contains: 'Prüfhausen' } } })
+    await db.schreibvorlage.deleteMany({ where: { name: { contains: '(eigene Fassung)' } } })
+  })
+}
+
+test.describe('Schreibvorlagen', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('warnt ohne Bestellungsabsatz und speichert erst nach Bestätigung', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    await page.getByRole('button', { name: 'Neue Vorlage' }).click()
+    await page.locator('input[name="name"]').fill(VORLAGE)
+    await page
+      .locator('textarea[name="text"]')
+      .fill('Sehr geehrte Damen und Herren,\n\nbitte um Auskunft zu {{betreute_name}}.\n\nMfG')
+
+    // Erster Versuch: Warnung, nicht gespeichert.
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(/fehlt der Bestellungsabsatz/)).toBeVisible()
+
+    // Bestätigen und erneut speichern.
+    await page.getByText('Bewusst ohne Bestellungsabsatz speichern').click()
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(`„${VORLAGE}“ ist gespeichert.`)).toBeVisible()
+  })
+
+  test('speichert mit Platzhalter ohne Warnung', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    await page.getByRole('button', { name: 'Neue Vorlage' }).click()
+    await page.locator('input[name="name"]').fill(`${VORLAGE} mit Absatz`)
+    await page
+      .locator('textarea[name="text"]')
+      .fill('Sehr geehrte Damen und Herren,\n\n{{bestellungsabsatz}}\n\nbitte um Auskunft.\n\nMfG')
+
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(`„${VORLAGE} mit Absatz“ ist gespeichert.`)).toBeVisible()
+  })
+
+  test('übernimmt eine mitgelieferte Vorlage als Kopie', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    await page
+      .locator('li', { hasText: 'Auskunftsersuchen' })
+      .getByRole('button', { name: 'Als Kopie übernehmen' })
+      .click()
+
+    // Der Editor öffnet mit den kopierten Inhalten.
+    await expect(page.locator('input[name="name"]')).toHaveValue(/eigene Fassung/)
+    const text = await page.locator('textarea[name="text"]').inputValue()
+    expect(text).toContain('{{bestellungsabsatz}}')
+
+    await page.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText(/ist gespeichert/)).toBeVisible()
+  })
+
+  test('löst die Platzhalter beim Erzeugen auf — mit sichtbaren Lücken', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    // Die gespeicherte Vorlage steht zur Wahl.
+    const wahl = page.locator('select#vorlageWahl')
+    await expect(wahl).toBeVisible()
+    await wahl.selectOption({ label: `${VORLAGE} mit Absatz` })
+
+    await page.waitForURL(/vorlageId=/)
+    const text = await page.locator('textarea#text').inputValue()
+
+    // Der Bestellungsabsatz ist aufgelöst (kein Platzhalter mehr) …
+    expect(text).not.toContain('{{bestellungsabsatz}}')
+    expect(text).toMatch(/Beschluss|bestellt/)
+    // … und der Rest des Textes steht drin.
+    expect(text).toContain('bitte um Auskunft.')
+  })
+
+  test('markiert unbekannte Platzhalter im Text und warnt', async ({ page }) => {
+    await mitDb(async (db) => {
+      const betreute = await db.betreute.findMany({
+        where: { geloeschtAm: null },
+        select: { id: true },
+      })
+      for (const person of betreute) {
+        await db.schreibvorlage.create({
+          data: {
+            betreuteId: person.id,
+            name: `${VORLAGE} kaputt`,
+            text: 'Sehr geehrte Damen und Herren,\n\n{{bestellungsabsatz}}\n\nHallo {{gibt_es_nicht}}.',
+          },
+        })
+      }
+    })
+
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+    await page.locator('select#vorlageWahl').selectOption({ label: `${VORLAGE} kaputt` })
+    await page.waitForURL(/vorlageId=/)
+
+    // Markiert im Text, benannt in der Warnung — kein Abbruch.
+    const text = await page.locator('textarea#text').inputValue()
+    expect(text).toContain('[Unbekannter Platzhalter: {{gibt_es_nicht}}]')
+    await expect(page.getByText(/unbekannte Platzhalter/)).toBeVisible()
+  })
+
+  test('gelöschte Vorlage liegt im Papierkorb und kommt zurück', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen/vorlagen')
+
+    // Zweistufig - Loeschen fragt erst nach.
+    const eintrag = page.locator('li', { hasText: `${VORLAGE} mit Absatz` })
+    await eintrag.getByRole('button', { name: 'Löschen' }).click()
+    await eintrag.getByRole('button', { name: 'In den Papierkorb' }).click()
+    await expect(page.getByText(`${VORLAGE} mit Absatz`)).toHaveCount(0)
+
+    await page.goto('/einstellungen/papierkorb')
+    const zeile = page.locator('li', { hasText: `${VORLAGE} mit Absatz` })
+    await expect(zeile).toBeVisible()
+
+    await zeile.getByRole('button', { name: 'Wiederherstellen' }).click()
+    await page.goto('/einstellungen/vorlagen')
+    await expect(page.getByText(`${VORLAGE} mit Absatz`)).toBeVisible()
+  })
+})
@@ -1,6 +1,6 @@
 {
  "name": "betreuungs-cockpit",
-  "version": "1.5.0",
+  "version": "1.7.0",
  "private": true,
  "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
  "engines": {
@@ -0,0 +1,27 @@
+-- Eigene Schreibvorlagen.
+--
+-- ACHTUNG, zum vierten Mal: "prisma migrate diff" wollte wieder die
+-- Trigramm-Indizes aus prisma/sql/suche.sql loeschen. Zeilen entfernt.
+-- Wer die naechste Migration erzeugt: nachsehen.
+
+-- CreateTable
+CREATE TABLE "schreibvorlage" (
+    "id" TEXT NOT NULL,
+    "betreuteId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "betreff" TEXT NOT NULL DEFAULT '',
+    "text" TEXT NOT NULL,
+    "ohneBestellungsabsatz" BOOLEAN NOT NULL DEFAULT false,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+    "geloeschtAm" TIMESTAMP(3),
+
+    CONSTRAINT "schreibvorlage_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "schreibvorlage_betreuteId_idx" ON "schreibvorlage"("betreuteId");
+
+-- AddForeignKey
+ALTER TABLE "schreibvorlage" ADD CONSTRAINT "schreibvorlage_betreuteId_fkey" FOREIGN KEY ("betreuteId") REFERENCES "betreute"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
@@ -313,6 +313,7 @@ model Betreute {
  konten                Konto[]
  buchungen             Buchung[]
  zahlungsgruppen       ZahlungsgruppeGeklaert[]
+  schreibvorlagen       Schreibvorlage[]
  vermoegensposten      Vermoegensposten[]
  immobilien            Immobilie[]
  vertraege             Vertrag[]
@@ -842,6 +843,39 @@ enum BuchungKategorie {
 /// wieder auf. Das ist unangenehm, aber ungefaehrlich - schlimmer waere,
 /// eine Gruppe stillschweigend weiter zu verbergen, die inzwischen anders
 /// zugeschnitten ist.
+/// Eine eigene Schreibvorlage.
+///
+/// Die mitgelieferten Vorlagen (Rueckkaufswert, Kuendigung,
+/// Sachstandsanfrage) stehen bewusst NICHT in dieser Tabelle - sie sind
+/// Code, getestet und unveraenderlich. "Wiederherstellen" heisst: die
+/// mitgelieferte Fassung als neue Kopie hierher holen.
+///
+/// Der Text traegt Platzhalter im Format {{name}} - aufgeloest in
+/// src/lib/schreiben/platzhalter.ts. Er ist bewusst NICHT verschluesselt:
+/// Eine Vorlage ist ein Textbaustein ohne Fallbezug; die Fachdaten kommen
+/// erst beim Erzeugen hinein.
+model Schreibvorlage {
+  id String @id @default(cuid())
+
+  betreuteId String
+  betreute   Betreute @relation(fields: [betreuteId], references: [id], onDelete: Cascade)
+
+  name    String
+  betreff String @default("")
+  text    String
+
+  /// Beim Speichern bestaetigt, dass der fehlende Bestellungsabsatz
+  /// Absicht ist - dann wird nicht bei jedem Bearbeiten erneut gewarnt.
+  ohneBestellungsabsatz Boolean @default(false)
+
+  erstelltAm     DateTime  @default(now())
+  aktualisiertAm DateTime  @updatedAt
+  geloeschtAm    DateTime?
+
+  @@index([betreuteId])
+  @@map("schreibvorlage")
+}
+
 model ZahlungsgruppeGeklaert {
  id String @id @default(cuid())

@@ -1,5 +1,5 @@
 import Link from 'next/link'
-import { KeyRound, Trash2, Users } from 'lucide-react'
+import { KeyRound, FileText, Trash2, Users } from 'lucide-react'
 import { SeitenKopf } from '@/components/seiten-kopf'
 import { Card, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { Badge } from '@/components/ui/badge'
@@ -69,6 +69,23 @@ export default async function EinstellungenSeite() {
          </CardHeader>
        </Card>

+        <Card>
+          <CardHeader className="flex flex-row items-start gap-3 space-y-0">
+            <FileText className="mt-0.5 size-5 shrink-0 text-primary" aria-hidden="true" />
+            <div>
+              <CardTitle className="text-lg">
+                <Link href="/einstellungen/vorlagen" className="underline-offset-4 hover:underline">
+                  Schreibvorlagen
+                </Link>
+              </CardTitle>
+              <CardDescription className="mt-1">
+                Bewährte Formulierungen mit Platzhaltern hinterlegen – beim Erzeugen eines
+                Schreibens wählbar.
+              </CardDescription>
+            </div>
+          </CardHeader>
+        </Card>
+
        <Card>
          <CardHeader className="flex flex-row items-start gap-3 space-y-0">
            <Trash2 className="mt-0.5 size-5 shrink-0 text-primary" aria-hidden="true" />
@@ -0,0 +1,51 @@
+import type { Metadata } from 'next'
+import { redirect } from 'next/navigation'
+import { SeitenKopf } from '@/components/seiten-kopf'
+import { VorlagenVerwaltung } from '@/components/einstellungen/vorlagen-verwaltung'
+import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
+import { db, nichtGeloescht } from '@/lib/db'
+import { MITGELIEFERTE_VORLAGEN } from '@/lib/schreiben/mitgelieferte-vorlagen'
+
+export const metadata: Metadata = { title: 'Vorlagen' }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Einstellungen → Vorlagen.
+ *
+ * Vorlagen hängen an der betreuten Person, nicht am Benutzer: Die
+ * Formulierungen beziehen sich auf ihren Fall, und beim Vollexport ihrer
+ * Akte gehören sie mit hinein.
+ */
+export default async function VorlagenSeite() {
+  const benutzer = await erfordereBenutzer('/einstellungen/vorlagen')
+  const aktive = await aktiveBetreute(benutzer)
+  if (!aktive) redirect('/ersteinrichtung')
+
+  const { darfSchreiben } = await erfordereZugang(aktive.id, 'DOKUMENTE', 'lesen')
+  if (!darfSchreiben('DOKUMENTE')) redirect('/einstellungen')
+
+  const eigene = await db.schreibvorlage.findMany({
+    where: { betreuteId: aktive.id, ...nichtGeloescht },
+    select: { id: true, name: true, betreff: true, text: true },
+    orderBy: { name: 'asc' },
+  })
+
+  return (
+    <div className="max-w-5xl space-y-6">
+      <SeitenKopf
+        titel="Schreibvorlagen"
+        beschreibung="Bewährte Formulierungen einmal hinterlegen, beim Schreiben auswählen. Platzhalter füllen sich aus den Daten, die ohnehin im System stehen."
+        pfad={[
+          { titel: 'Einstellungen', href: '/einstellungen' },
+          { titel: 'Vorlagen' },
+        ]}
+      />
+
+      <VorlagenVerwaltung
+        betreuteId={aktive.id}
+        eigene={eigene}
+        mitgelieferte={[...MITGELIEFERTE_VORLAGEN]}
+      />
+    </div>
+  )
+}
@@ -8,6 +8,7 @@ import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/s
 import { db, nichtGeloescht } from '@/lib/db'
 import { entwurfBauen } from '@/lib/schreiben/entwurf'
 import { SCHREIBEN_EIGENSCHAFTEN, istSchreibenArt } from '@/lib/schreiben/arten'
+import { VorlagenWahl } from '@/components/schreiben/vorlagen-wahl'

 export const metadata: Metadata = { title: 'Schreiben' }
 export const dynamic = 'force-dynamic'
@@ -53,6 +54,7 @@ export default async function SchreibenSeite({
      art,
      vertragId: text('vertragId') || null,
      vorgangId: text('vorgangId') || null,
+      vorlageId: text('vorlageId') || null,
    })
  } catch (ausnahme) {
    // Fehlender oder fremder Bezug: Das ist kein Absturz, sondern eine
@@ -77,6 +79,15 @@ export default async function SchreibenSeite({
    )
  }

+  const vorlagen =
+    art === 'FREI'
+      ? await db.schreibvorlage.findMany({
+          where: { betreuteId: aktive.id, ...nichtGeloescht },
+          select: { id: true, name: true },
+          orderBy: { name: 'asc' },
+        })
+      : []
+
  const kontakte = await db.kontakt.findMany({
    where: { betreuteId: aktive.id, ...nichtGeloescht },
    select: {
@@ -100,7 +111,15 @@ export default async function SchreibenSeite({
        pfad={[{ titel: 'Dokumente', href: '/dokumente' }, { titel: 'Schreiben' }]}
      />

+      {art === 'FREI' && vorlagen.length > 0 && (
+        <VorlagenWahl vorlagen={vorlagen} aktiveVorlageId={text('vorlageId') || null} />
+      )}
+
      <SchreibenEditor
+        // Der Editor haelt den Text als eigenen State. Wechselt die Vorlage,
+        // muss er neu aufsetzen - sonst ueberlebt der alte Entwurf die
+        // Navigation und die Vorlage kommt nie im Textfeld an.
+        key={text('vorlageId') || 'ohne-vorlage'}
        betreuteId={aktive.id}
        art={art}
        entwurf={{
@@ -1,5 +1,5 @@
 import Link from 'next/link'
-import { Plus, Shield } from 'lucide-react'
+import { FileArchive, Plus, Shield } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
@@ -114,12 +114,20 @@ export default async function VertraegeUebersicht() {
        pfad={[{ titel: 'Übersicht', href: '/heute' }, { titel: 'Verträge' }]}
        aktionen={
          schreiben && (
-            <Button asChild>
-              <Link href="/vertraege/neu">
-                <Plus aria-hidden="true" />
-                Vertrag anlegen
-              </Link>
-            </Button>
+            <>
+              <Button asChild variant="outline">
+                <Link href="/vertraege/serienabfrage/seite">
+                  <FileArchive aria-hidden="true" />
+                  Rückkaufswerte anfragen
+                </Link>
+              </Button>
+              <Button asChild>
+                <Link href="/vertraege/neu">
+                  <Plus aria-hidden="true" />
+                  Vertrag anlegen
+                </Link>
+              </Button>
+            </>
          )
        }
      />
@@ -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',
+    },
+  })
+}
@@ -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>
+  )
+}
@@ -0,0 +1,374 @@
+'use client'
+
+import * as React from 'react'
+import { useActionState } from 'react'
+import { AlertCircle, AlertTriangle, CheckCircle2, Copy, Pencil, Plus, Trash2 } from 'lucide-react'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Input } from '@/components/ui/input'
+import { Textarea } from '@/components/ui/textarea'
+import { Feld } from '@/components/feld'
+import { Absendeknopf } from '@/components/finanzen/eingaben'
+import {
+  vorlageLoeschen,
+  vorlageSpeichern,
+  type VorlagenZustand,
+} from '@/server/actions/vorlagen'
+import { PLATZHALTER, benutztePlatzhalter } from '@/lib/schreiben/platzhalter'
+
+export type VorlagenZeile = {
+  id: string
+  name: string
+  betreff: string
+  text: string
+}
+
+export type MitgelieferteVorlage = {
+  schluessel: string
+  name: string
+  beschreibung: string
+  betreff: string
+  text: string
+}
+
+/**
+ * Verwaltung der eigenen Schreibvorlagen.
+ *
+ * Zwei Listen, ein Editor. Die mitgelieferten Vorlagen sind Code und
+ * unveränderlich — von ihnen führt nur ein Weg hierher: „Als Kopie
+ * übernehmen". Damit kann nichts kaputtgehen, was die Anwendung braucht,
+ * und „wiederherstellen" ist schlicht: noch einmal kopieren.
+ */
+export function VorlagenVerwaltung({
+  betreuteId,
+  eigene,
+  mitgelieferte,
+}: {
+  betreuteId: string
+  eigene: VorlagenZeile[]
+  mitgelieferte: MitgelieferteVorlage[]
+}) {
+  const [offen, setOffen] = React.useState(false)
+  const [bearbeitet, setBearbeitet] = React.useState<VorlagenZeile | null>(null)
+  const [name, setName] = React.useState('')
+  const [betreff, setBetreff] = React.useState('')
+  const [text, setText] = React.useState('')
+
+  function neuBeginnen(vorlage?: Partial<VorlagenZeile>) {
+    setBearbeitet(null)
+    setName(vorlage?.name ?? '')
+    setBetreff(vorlage?.betreff ?? '')
+    setText(vorlage?.text ?? '')
+    setOffen(true)
+  }
+
+  function bearbeiten(vorlage: VorlagenZeile) {
+    setBearbeitet(vorlage)
+    setName(vorlage.name)
+    setBetreff(vorlage.betreff)
+    setText(vorlage.text)
+    setOffen(true)
+  }
+
+  return (
+    <div className="space-y-6">
+      {/* --- Eigene Vorlagen ---------------------------------------------- */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">Eigene Vorlagen</CardTitle>
+          <CardDescription>
+            Formulierungen, die sich bewährt haben — einmal hinterlegt, beim Schreiben wählbar.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          {eigene.length === 0 ? (
+            <p className="text-sm text-muted-foreground">
+              Noch keine eigene Vorlage. Fang mit einer Kopie einer mitgelieferten an — oder mit
+              einem leeren Blatt.
+            </p>
+          ) : (
+            <ul className="divide-y rounded-md border">
+              {eigene.map((vorlage) => (
+                <li key={vorlage.id} className="flex flex-wrap items-center gap-2 p-3">
+                  <div className="min-w-0 flex-1">
+                    <p className="font-medium">{vorlage.name}</p>
+                    <p className="text-xs text-muted-foreground">
+                      {benutztePlatzhalter(vorlage.text).length} Platzhalter
+                      {vorlage.betreff ? ` · Betreff: ${vorlage.betreff}` : ''}
+                    </p>
+                  </div>
+                  <Button type="button" variant="ghost" size="sm" onClick={() => bearbeiten(vorlage)}>
+                    <Pencil aria-hidden="true" />
+                    Bearbeiten
+                  </Button>
+                  <VorlageLoeschKnopf betreuteId={betreuteId} vorlage={vorlage} />
+                </li>
+              ))}
+            </ul>
+          )}
+
+          <Button type="button" variant="outline" onClick={() => neuBeginnen()}>
+            <Plus aria-hidden="true" />
+            Neue Vorlage
+          </Button>
+        </CardContent>
+      </Card>
+
+      {/* --- Mitgelieferte ------------------------------------------------- */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">Mitgelieferte Vorlagen</CardTitle>
+          <CardDescription>
+            Unveränderlich — sie sind Teil der Anwendung und lassen sich nicht kaputtmachen. Als
+            Grundlage für eigene Fassungen: kopieren und anpassen.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <ul className="divide-y rounded-md border">
+            {mitgelieferte.map((vorlage) => (
+              <li key={vorlage.schluessel} className="flex flex-wrap items-center gap-2 p-3">
+                <div className="min-w-0 flex-1">
+                  <p className="font-medium">{vorlage.name}</p>
+                  <p className="text-xs text-muted-foreground">{vorlage.beschreibung}</p>
+                </div>
+                <Badge variant="secondary">mitgeliefert</Badge>
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="sm"
+                  onClick={() =>
+                    neuBeginnen({
+                      name: `${vorlage.name} (eigene Fassung)`,
+                      betreff: vorlage.betreff,
+                      text: vorlage.text,
+                    })
+                  }
+                >
+                  <Copy aria-hidden="true" />
+                  Als Kopie übernehmen
+                </Button>
+              </li>
+            ))}
+          </ul>
+        </CardContent>
+      </Card>
+
+      {/* --- Editor --------------------------------------------------------- */}
+      {offen && (
+        <VorlagenEditor
+          betreuteId={betreuteId}
+          vorlageId={bearbeitet?.id ?? ''}
+          name={name}
+          betreff={betreff}
+          text={text}
+          onName={setName}
+          onBetreff={setBetreff}
+          onText={setText}
+          onSchliessen={() => setOffen(false)}
+        />
+      )}
+    </div>
+  )
+}
+
+function VorlageLoeschKnopf({
+  betreuteId,
+  vorlage,
+}: {
+  betreuteId: string
+  vorlage: VorlagenZeile
+}) {
+  const [zustand, absenden] = useActionState<VorlagenZustand, FormData>(vorlageLoeschen, {})
+  const [gefragt, setGefragt] = React.useState(false)
+
+  if (!gefragt) {
+    return (
+      <>
+        {zustand.fehler && <span className="text-xs text-destructive">{zustand.fehler}</span>}
+        <Button type="button" variant="ghost" size="sm" onClick={() => setGefragt(true)}>
+          <Trash2 aria-hidden="true" />
+          Löschen
+        </Button>
+      </>
+    )
+  }
+
+  return (
+    <form action={absenden} className="flex items-center gap-2">
+      <input type="hidden" name="betreuteId" value={betreuteId} />
+      <input type="hidden" name="vorlageId" value={vorlage.id} />
+      <Absendeknopf variant="destructive" size="sm" wartetext="…">
+        In den Papierkorb
+      </Absendeknopf>
+      <Button type="button" variant="ghost" size="sm" onClick={() => setGefragt(false)}>
+        Abbrechen
+      </Button>
+    </form>
+  )
+}
+
+/**
+ * Der Editor mit der Platzhalterliste daneben.
+ *
+ * Die Warnung zum Bestellungsabsatz kommt vom Server (zweistufig): Der
+ * erste Speicherversuch ohne ihn liefert die Warnung zurück, erst die
+ * Bestätigung speichert wirklich. So bleibt die Prüfung an EINER Stelle —
+ * eine zweite Prüfung im Browser könnte von der Serverfassung abweichen.
+ */
+function VorlagenEditor({
+  betreuteId,
+  vorlageId,
+  name,
+  betreff,
+  text,
+  onName,
+  onBetreff,
+  onText,
+  onSchliessen,
+}: {
+  betreuteId: string
+  vorlageId: string
+  name: string
+  betreff: string
+  text: string
+  onName: (wert: string) => void
+  onBetreff: (wert: string) => void
+  onText: (wert: string) => void
+  onSchliessen: () => void
+}) {
+  const [zustand, absenden] = useActionState<VorlagenZustand, FormData>(vorlageSpeichern, {})
+  const [trotzdem, setTrotzdem] = React.useState(false)
+
+  const textfeld = React.useRef<HTMLTextAreaElement>(null)
+
+  function platzhalterEinfuegen(platzhalterName: string) {
+    const feld = textfeld.current
+    const einschub = `{{${platzhalterName}}}`
+    if (!feld) {
+      onText(`${text}${einschub}`)
+      return
+    }
+    const start = feld.selectionStart ?? text.length
+    const ende = feld.selectionEnd ?? text.length
+    onText(`${text.slice(0, start)}${einschub}${text.slice(ende)}`)
+  }
+
+  return (
+    <Card>
+      <CardHeader className="pb-3">
+        <CardTitle className="text-base">
+          {vorlageId ? 'Vorlage bearbeiten' : 'Neue Vorlage'}
+        </CardTitle>
+      </CardHeader>
+      <CardContent>
+        <form action={absenden} className="grid gap-6 lg:grid-cols-[1fr_260px]">
+          <div className="space-y-4">
+            <input type="hidden" name="betreuteId" value={betreuteId} />
+            <input type="hidden" name="vorlageId" value={vorlageId} />
+            <input type="hidden" name="ohneBestellungsabsatz" value={trotzdem ? 'ja' : ''} />
+
+            {zustand.fehler && (
+              <Alert variant="fehler">
+                <AlertCircle aria-hidden="true" />
+                <AlertDescription>{zustand.fehler}</AlertDescription>
+              </Alert>
+            )}
+
+            {zustand.warnung && (
+              <Alert variant="warnung">
+                <AlertTriangle aria-hidden="true" />
+                <AlertDescription>
+                  <p>{zustand.warnung}</p>
+                  <label className="mt-2 flex items-center gap-2 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={trotzdem}
+                      onChange={(ereignis) => setTrotzdem(ereignis.target.checked)}
+                    />
+                    Bewusst ohne Bestellungsabsatz speichern
+                  </label>
+                </AlertDescription>
+              </Alert>
+            )}
+
+            {zustand.erfolg && (
+              <Alert variant="erfolg">
+                <CheckCircle2 aria-hidden="true" />
+                <AlertDescription>{zustand.erfolg}</AlertDescription>
+              </Alert>
+            )}
+
+            <Feld id="name" beschriftung="Name der Vorlage" fehler={zustand.felder?.name} pflicht>
+              <Input
+                name="name"
+                value={name}
+                onChange={(ereignis) => onName(ereignis.target.value)}
+                maxLength={120}
+                placeholder="z. B. Auskunftsersuchen Krankenkasse"
+              />
+            </Feld>
+
+            <Feld
+              id="betreff"
+              beschriftung="Betreff"
+              erklaerung="Darf Platzhalter enthalten. Wird beim Erzeugen zum Betreff des Schreibens."
+            >
+              <Input
+                name="betreff"
+                value={betreff}
+                onChange={(ereignis) => onBetreff(ereignis.target.value)}
+                maxLength={200}
+              />
+            </Feld>
+
+            <Feld id="text" beschriftung="Text der Vorlage" fehler={zustand.felder?.text} pflicht>
+              <Textarea
+                ref={textfeld}
+                name="text"
+                value={text}
+                onChange={(ereignis) => onText(ereignis.target.value)}
+                rows={18}
+                className="font-mono text-sm leading-relaxed"
+              />
+            </Feld>
+
+            <div className="flex gap-2">
+              <Absendeknopf wartetext="Wird gespeichert …">Speichern</Absendeknopf>
+              <Button type="button" variant="ghost" onClick={onSchliessen}>
+                Schließen
+              </Button>
+            </div>
+          </div>
+
+          {/* Die Platzhalterliste - niemand soll Namen raten muessen. */}
+          <aside className="space-y-2 rounded-md border p-3">
+            <p className="text-sm font-medium">Platzhalter</p>
+            <p className="text-xs text-muted-foreground">
+              Klick fügt an der Schreibmarke ein. Fehlt beim Erzeugen der Wert, bleibt eine
+              sichtbare Lücke — nichts verschwindet still.
+            </p>
+            <ul className="space-y-1">
+              {PLATZHALTER.map((platzhalter) => (
+                <li key={platzhalter.name}>
+                  <button
+                    type="button"
+                    onClick={() => platzhalterEinfuegen(platzhalter.name)}
+                    className="w-full rounded px-2 py-1 text-left text-xs hover:bg-accent"
+                    title={platzhalter.quelle}
+                  >
+                    <code className="text-primary">{'{{'}{platzhalter.name}{'}}'}</code>
+                    <span className="block text-muted-foreground">
+                      {platzhalter.beschriftung}
+                    </span>
+                  </button>
+                </li>
+              ))}
+            </ul>
+          </aside>
+        </form>
+      </CardContent>
+    </Card>
+  )
+}
@@ -0,0 +1,57 @@
+'use client'
+
+import { useRouter, useSearchParams } from 'next/navigation'
+import { FileText } from 'lucide-react'
+import { Select } from '@/components/ui/select'
+import { Feld } from '@/components/feld'
+
+/**
+ * Vorlagenauswahl über dem Schreiben-Editor.
+ *
+ * Die Wahl lädt die Seite mit ?vorlageId neu — der Entwurf entsteht
+ * serverseitig, wo die Platzhalter aufgelöst werden. Ein Wechsel wirft
+ * damit auch bewusst den bearbeiteten Text weg; deshalb steht die Auswahl
+ * VOR dem Editor, nicht darin.
+ */
+export function VorlagenWahl({
+  vorlagen,
+  aktiveVorlageId,
+}: {
+  vorlagen: { id: string; name: string }[]
+  aktiveVorlageId: string | null
+}) {
+  const router = useRouter()
+  const parameter = useSearchParams()
+
+  function wechseln(vorlageId: string) {
+    const neu = new URLSearchParams(parameter.toString())
+    if (vorlageId) neu.set('vorlageId', vorlageId)
+    else neu.delete('vorlageId')
+    router.push(`/schreiben/neu?${neu.toString()}`)
+  }
+
+  return (
+    <div className="flex items-start gap-2.5 rounded-md border bg-muted/30 p-3">
+      <FileText className="mt-8 size-4 shrink-0 text-muted-foreground" aria-hidden="true" />
+      <Feld
+        id="vorlageWahl"
+        beschriftung="Aus eigener Vorlage"
+        erklaerung="Ersetzt den Entwurf unten — was dort schon steht, geht dabei verloren."
+        className="flex-1"
+      >
+        <Select
+          id="vorlageWahl"
+          value={aktiveVorlageId ?? ''}
+          onChange={(ereignis) => wechseln(ereignis.target.value)}
+        >
+          <option value="">– leerer Entwurf –</option>
+          {vorlagen.map((vorlage) => (
+            <option key={vorlage.id} value={vorlage.id}>
+              {vorlage.name}
+            </option>
+          ))}
+        </Select>
+      </Feld>
+    </div>
+  )
+}
@@ -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>
+  )
+}
@@ -157,6 +157,13 @@ function tabellen(betreuteId: string, optionen: VollexportOptionen): Tabelle[] {
      laden: () => db.genehmigung.findMany({ where: { betreuteId } }),
    },
    { name: 'frist', modell: null, laden: () => db.frist.findMany({ where: { betreuteId } }) },
+    {
+      // Eigene Schreibvorlagen gehoeren zur Akte: Sie tragen die im Fall
+      // bewaehrten Formulierungen und waeren beim Umzug sonst verloren.
+      name: 'schreibvorlage',
+      modell: null,
+      laden: () => db.schreibvorlage.findMany({ where: { betreuteId } }),
+    },
    {
      name: 'dokument',
      modell: 'Dokument',
@@ -19,6 +19,8 @@ import { laufzeitAusVertrag } from '@/lib/vertraege/kuendigung'
 import { VERTRAG_ART_BESCHRIFTUNG } from '@/lib/vertraege/konstanten'
 import { heuteAlsTag } from '@/lib/fristen/datum'
 import { SCHREIBEN_EIGENSCHAFTEN, type SchreibenArt } from '@/lib/schreiben/arten'
+import { platzhalterErsetzen, type PlatzhalterWerte } from '@/lib/schreiben/platzhalter'
+import { formatDatum } from '@/lib/utils'

 /**
 * Baut den Entwurf eines Schreibens - Text, Betreff, Empfaenger.
@@ -109,6 +111,8 @@ export type EntwurfEingabe = {
  art: SchreibenArt
  vertragId?: string | null
  vorgangId?: string | null
+  /** Eigene Vorlage als Grundlage des freien Schreibens. */
+  vorlageId?: string | null
  /** Fuer den Test ueberschreibbar. */
  heute?: Date
 }
@@ -230,7 +234,64 @@ export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEn
    }
  }

-  // --- Freies Schreiben ------------------------------------------------------
+  // --- Freies Schreiben, wahlweise aus eigener Vorlage -----------------------
+  if (eingabe.vorlageId) {
+    const vorlage = await db.schreibvorlage.findFirst({
+      where: { id: eingabe.vorlageId, betreuteId: eingabe.betreuteId, ...nichtGeloescht },
+    })
+    if (!vorlage) throw new Error('Diese Vorlage gibt es nicht (mehr).')
+
+    // Die Werte, die eine Vorlage kennen kann. Vertragsbezogene bleiben
+    // hier leer und erscheinen als sichtbare Luecke - ein freies Schreiben
+    // hat keinen Vertrag.
+    const werte: PlatzhalterWerte = {
+      betreute_name: kopf.betreuteName,
+      betreute_geburtsdatum: kopf.betreuteGeburtsdatum
+        ? formatDatum(kopf.betreuteGeburtsdatum)
+        : null,
+      betreute_anschrift: kopf.betreuteAnschrift,
+      betreuer_name: kopf.betreuerName,
+      betreuungsgericht: kopf.betreuungsgericht,
+      aktenzeichen_gericht: kopf.aktenzeichenGericht,
+      bestellung_datum: kopf.bestellungAm ? formatDatum(kopf.bestellungAm) : null,
+      bestellungsabsatz: bestellungsAbsatz(kopf),
+      stichtag: formatDatum(heute),
+      datum_heute: formatDatum(heute),
+    }
+
+    const rumpf = platzhalterErsetzen(vorlage.text, werte)
+    const betreffErsetzt = platzhalterErsetzen(vorlage.betreff, werte)
+
+    // Der Briefrahmen kommt dazu - die Vorlage traegt nur den Inhalt.
+    const text = [
+      absenderBlock(kopf),
+      '',
+      anschriftBlock({ gesellschaft: null, anschrift: null }),
+      '',
+      datumsZeile(kopf.betreuerOrt, heute),
+      '',
+      betreffErsetzt.text ? `Betreff: ${betreffErsetzt.text}` : 'Betreff: [Betreff eintragen]',
+      '',
+      rumpf.text,
+    ].join('\n')
+
+    return {
+      ...gemeinsam,
+      text,
+      betreff: betreffErsetzt.text,
+      empfaengerName: '',
+      empfaengerAnschrift: '',
+      warnungen:
+        rumpf.unbekannte.length > 0
+          ? [
+              `Die Vorlage enthält unbekannte Platzhalter: ${rumpf.unbekannte
+                .map((name) => `{{${name}}}`)
+                .join(', ')}. Sie sind im Text markiert - bitte vor dem Absenden ersetzen.`,
+            ]
+          : [],
+    }
+  }
+
  const text = freierEntwurf(kopf, { gesellschaft: null, anschrift: null }, heute)
  return {
    ...gemeinsam,
@@ -0,0 +1,123 @@
+/**
+ * Die mitgelieferten Schreibvorlagen - als Platzhalter-Fassung.
+ *
+ * Sie sind Code und damit unveraenderlich; "wiederherstellen" heisst,
+ * sie erneut als Kopie in die eigenen Vorlagen zu holen.
+ *
+ * Bewusst NICHT dieselben Texte wie die fest verdrahteten Erzeuger in
+ * rueckkaufswert.ts und kuendigungsassistent.ts: Die dortigen bauen
+ * fallbezogene Saetze (Kuendigungstermin, Warnungen), die eine Vorlage
+ * nicht leisten kann. Diese hier sind der gemeinsame Kern als
+ * Ausgangspunkt fuer eigene Fassungen - die Spezialerzeuger bleiben der
+ * bessere Weg, wo es sie gibt, und die Oberflaeche fuehrt weiter zuerst
+ * dorthin.
+ */
+
+export type MitgelieferteVorlage = {
+  schluessel: string
+  name: string
+  beschreibung: string
+  betreff: string
+  text: string
+}
+
+export const MITGELIEFERTE_VORLAGEN: readonly MitgelieferteVorlage[] = [
+  {
+    schluessel: 'auskunftsersuchen',
+    name: 'Auskunftsersuchen',
+    beschreibung: 'Bestehen bei Ihnen Verträge? Der erste Brief an eine unbekannte Stelle.',
+    betreff: 'Auskunftsersuchen — {{betreute_name}}, geb. {{betreute_geburtsdatum}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'zur Ordnung der Vermögensangelegenheiten bitte ich um Auskunft, ob bei',
+      'Ihnen Verträge, Konten oder sonstige Geschäftsbeziehungen für die von mir',
+      'vertretene Person bestehen oder in den letzten Jahren bestanden haben.',
+      '',
+      'Falls ja, bitte ich um eine Aufstellung mit Vertragsnummern, aktuellem',
+      'Stand und den jährlichen Beiträgen bzw. Leistungen.',
+      '',
+      'Für Rückfragen stehe ich gerne zur Verfügung.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+  {
+    schluessel: 'adressaenderung',
+    name: 'Adressänderung',
+    beschreibung: 'Neue Anschrift nach Heimeinzug mitteilen.',
+    betreff: 'Anschriftenänderung — {{betreute_name}}, geb. {{betreute_geburtsdatum}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'die Anschrift der von mir vertretenen Person hat sich geändert. Die neue',
+      'Anschrift lautet:',
+      '',
+      '{{betreute_anschrift}}',
+      '',
+      'Bitte stellen Sie künftige Post zu dieser Sache außerdem an mich als',
+      'rechtlichen Betreuer zu.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+  {
+    schluessel: 'vollmachtsnachweis',
+    name: 'Nachweis der Vertretungsmacht',
+    beschreibung: 'Wenn eine Stelle die Auskunft verweigert: der Nachweis, förmlich.',
+    betreff: 'Nachweis der Vertretungsmacht — {{betreute_name}}, geb. {{betreute_geburtsdatum}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      'auf Ihr Schreiben, in dem Sie um einen Nachweis meiner Vertretungsmacht',
+      'bitten, teile ich mit:',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'Eine Kopie der Bestellungsurkunde liegt bei. Das Original stelle ich bei',
+      'Bedarf zur Einsicht — bitte nennen Sie mir dafür einen Termin.',
+      '',
+      'Ich bitte nunmehr um Bearbeitung meines Anliegens vom {{datum_heute}}.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+  {
+    schluessel: 'rueckkaufswert_kurz',
+    name: 'Rückkaufswert (Kurzfassung)',
+    beschreibung:
+      'Die Kurzfassung der Rückkaufswert-Anfrage. Für den vollen Fragenkatalog nimm den Weg über den Vertrag.',
+    betreff:
+      'Auskunft über Rückkaufswert — {{vertrag_bezeichnung}}, Nr. {{vertrag_nummer}}',
+    text: [
+      'Sehr geehrte Damen und Herren,',
+      '',
+      '{{bestellungsabsatz}}',
+      '',
+      'zu dem oben genannten Vertrag bei {{vertrag_gesellschaft}} bitte ich um',
+      'Mitteilung des Rückkaufswertes einschließlich Überschussanteilen zum',
+      'Stichtag {{stichtag}}, außerdem der beitragsfreien Versicherungssumme.',
+      '',
+      'Da im Verfahren beim Sozialhilfeträger eine Frist läuft, bitte ich um',
+      'Antwort innerhalb von vier Wochen.',
+      '',
+      'Mit freundlichen Grüßen',
+      '{{betreuer_name}}',
+      '',
+      'Anlage: Kopie der Bestellungsurkunde',
+    ].join('\n'),
+  },
+]
@@ -0,0 +1,143 @@
+/**
+ * Platzhalter in Schreibvorlagen.
+ *
+ * Rein und ohne Datenbank. Der Vertrag ist einfach: {{name}} wird ersetzt,
+ * und zwar nach drei Regeln, die alle demselben Grundsatz folgen -
+ * NICHTS geht stillschweigend schief:
+ *
+ * 1. Bekannter Platzhalter, Daten vorhanden  -> Wert eingesetzt.
+ * 2. Bekannter Platzhalter, Daten fehlen     -> sichtbare Luecke
+ *    "[Aktenzeichen]". Eine stille Leerstelle wuerde erst der Empfaenger
+ *    bemerken - oder niemand.
+ * 3. Unbekannter Platzhalter                 -> markiert als
+ *    "[Unbekannter Platzhalter: {{xyz}}]". Kein Abbruch: Ein Tippfehler
+ *    in einer Vorlage darf das Schreiben nicht verhindern, aber er muss
+ *    ins Auge springen. Falsch ausgefuellt ist schlimmer als
+ *    offensichtlich leer.
+ */
+
+export type PlatzhalterName =
+  | 'betreute_name'
+  | 'betreute_geburtsdatum'
+  | 'betreute_anschrift'
+  | 'betreuer_name'
+  | 'betreuungsgericht'
+  | 'aktenzeichen_gericht'
+  | 'bestellung_datum'
+  | 'bestellungsabsatz'
+  | 'vertrag_gesellschaft'
+  | 'vertrag_nummer'
+  | 'vertrag_bezeichnung'
+  | 'stichtag'
+  | 'datum_heute'
+
+export type PlatzhalterBeschreibung = {
+  name: PlatzhalterName
+  beschriftung: string
+  /** Woher der Wert kommt - steht in der Hilfe neben dem Editor. */
+  quelle: string
+}
+
+/**
+ * Die verfuegbaren Platzhalter, in der Reihenfolge der Anzeige.
+ *
+ * Diese Liste steht beim Bearbeiten NEBEN dem Editor - niemand soll
+ * Platzhalternamen raten muessen.
+ */
+export const PLATZHALTER: readonly PlatzhalterBeschreibung[] = [
+  { name: 'betreute_name', beschriftung: 'Name der betreuten Person', quelle: 'Stammdaten' },
+  { name: 'betreute_geburtsdatum', beschriftung: 'Geburtsdatum', quelle: 'Stammdaten' },
+  { name: 'betreute_anschrift', beschriftung: 'Anschrift (Heim)', quelle: 'Stammdaten' },
+  { name: 'betreuer_name', beschriftung: 'Dein Name', quelle: 'Dein Zugang' },
+  { name: 'betreuungsgericht', beschriftung: 'Betreuungsgericht', quelle: 'Stammdaten' },
+  { name: 'aktenzeichen_gericht', beschriftung: 'Aktenzeichen des Gerichts', quelle: 'Stammdaten' },
+  { name: 'bestellung_datum', beschriftung: 'Datum der Bestellung', quelle: 'Stammdaten' },
+  {
+    name: 'bestellungsabsatz',
+    beschriftung: 'Der ganze Bestellungsabsatz',
+    quelle: 'Aus Gericht, Aktenzeichen und Bestellungsdatum gebaut',
+  },
+  { name: 'vertrag_gesellschaft', beschriftung: 'Gesellschaft', quelle: 'Vertrag, falls gewählt' },
+  { name: 'vertrag_nummer', beschriftung: 'Vertragsnummer', quelle: 'Vertrag, falls gewählt' },
+  { name: 'vertrag_bezeichnung', beschriftung: 'Vertragsbezeichnung', quelle: 'Vertrag, falls gewählt' },
+  { name: 'stichtag', beschriftung: 'Stichtag', quelle: 'Beim Erzeugen gewählt' },
+  { name: 'datum_heute', beschriftung: 'Heutiges Datum', quelle: 'Beim Erzeugen' },
+]
+
+const BEKANNT = new Set<string>(PLATZHALTER.map((p) => p.name))
+
+/** Die sichtbare Luecke, wenn Daten fehlen: "[Aktenzeichen des Gerichts]". */
+function luecke(name: PlatzhalterName): string {
+  const eintrag = PLATZHALTER.find((p) => p.name === name)
+  return `[${eintrag?.beschriftung ?? name}]`
+}
+
+export type PlatzhalterWerte = Partial<Record<PlatzhalterName, string | null>>
+
+export type ErsetzungsErgebnis = {
+  text: string
+  /** Bekannte Platzhalter ohne Daten - als Luecke eingesetzt. */
+  luecken: PlatzhalterName[]
+  /** Unbekannte Platzhalter - markiert im Text. */
+  unbekannte: string[]
+}
+
+/** Findet alle {{...}}-Vorkommen. Grosszuegig beim Namen: auch Tippfehler
+ *  sollen gefunden (und dann markiert) werden. */
+const MUSTER = /\{\{\s*([a-zA-Z0-9_äöüÄÖÜß-]+)\s*\}\}/g
+
+export function platzhalterErsetzen(
+  vorlage: string,
+  werte: PlatzhalterWerte,
+): ErsetzungsErgebnis {
+  const luecken = new Set<PlatzhalterName>()
+  const unbekannte = new Set<string>()
+
+  const text = vorlage.replace(MUSTER, (treffer, roh: string) => {
+    const name = roh.trim()
+
+    if (!BEKANNT.has(name)) {
+      unbekannte.add(name)
+      return `[Unbekannter Platzhalter: {{${name}}}]`
+    }
+
+    const wert = werte[name as PlatzhalterName]
+    if (wert === null || wert === undefined || wert.trim() === '') {
+      luecken.add(name as PlatzhalterName)
+      return luecke(name as PlatzhalterName)
+    }
+
+    return wert
+  })
+
+  return { text, luecken: [...luecken], unbekannte: [...unbekannte] }
+}
+
+/** Welche Platzhalter benutzt eine Vorlage? Fuer die Anzeige in der Liste. */
+export function benutztePlatzhalter(vorlage: string): string[] {
+  const gefunden = new Set<string>()
+  for (const treffer of vorlage.matchAll(MUSTER)) {
+    gefunden.add(treffer[1]!.trim())
+  }
+  return [...gefunden]
+}
+
+/**
+ * Fehlt der Bestellungsabsatz?
+ *
+ * Erfuellt ist die Pruefung durch den Platzhalter {{bestellungsabsatz}}
+ * ODER durch einen von Hand geschriebenen Absatz, der erkennbar die
+ * Bestellung nachweist (Beschluss + Betreuer im selben Text). Wer den
+ * Absatz ausformuliert hat, soll nicht gegaengelt werden.
+ *
+ * Die Warnung ist eine Warnung, kein Verbot: Ein Schreiben an die eigene
+ * Hausverwaltung braucht keinen Bestellungsnachweis. Aber wer ihn
+ * weglaesst, soll es wissentlich tun.
+ */
+export function bestellungsabsatzFehlt(vorlage: string): boolean {
+  if (/\{\{\s*bestellungsabsatz\s*\}\}/.test(vorlage)) return false
+  const klein = vorlage.toLowerCase()
+  const nennBestellung =
+    klein.includes('beschluss') && (klein.includes('betreuer') || klein.includes('betreuung'))
+  return !nennBestellung
+}
@@ -17,7 +17,7 @@
 */

 /** Muss zur "version" in der package.json passen. */
-export const VERSION = '1.5.0'
+export const VERSION = '1.7.0'

 /**
 * Kurzer Git-Stand, beim Bauen hineingereicht:
@@ -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
+}
@@ -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()
+  })
+}
@@ -50,6 +50,7 @@ const PAPIERKORB_TABELLEN = [
  'bescheid',
  'leistung',
  'bericht',
+  'schreibvorlage',
  'betreute',
 ] as const

@@ -105,6 +105,14 @@ function eintragsarten(): Record<string, Eintragsart> {
    ),
    Immobilie: einfach('Immobilie', 'Immobilie', 'Immobilien', 'IMMOBILIE', z.immobilie, 'bezeichnung'),
    Vertrag: einfach('Vertrag', 'Vertrag', 'Verträge', 'VERTRAEGE', z.vertrag, 'bezeichnung'),
+    Schreibvorlage: einfach(
+      'Schreibvorlage',
+      'Vorlage',
+      'Vorlagen',
+      'DOKUMENTE',
+      z.schreibvorlage,
+      'name',
+    ),
    Kontakt: einfach('Kontakt', 'Kontakt', 'Kontakte', 'KONTAKTE', z.kontakt, 'name'),
    Kontaktprotokoll: einfach(
      'Kontaktprotokoll',
@@ -0,0 +1,187 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+import { db, nichtGeloescht } from '@/lib/db'
+import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
+import { protokollieren, aenderungErmitteln } from '@/lib/audit'
+import { bestellungsabsatzFehlt } from '@/lib/schreiben/platzhalter'
+
+/**
+ * Server Actions fuer eigene Schreibvorlagen.
+ *
+ * Die Warnung beim fehlenden Bestellungsabsatz ist zweistufig: Der erste
+ * Speicherversuch ohne ihn kommt mit einer Warnung zurueck; erst die
+ * ausdrueckliche Bestaetigung ("ohneBestellungsabsatz") speichert. So
+ * laesst sich der Absatz weglassen - aber nur wissentlich. Ohne den
+ * Nachweis der Bestellung antwortet keine Versicherung, und das faellt
+ * erst nach vier Wochen auf.
+ */
+
+export type VorlagenZustand = {
+  fehler?: string
+  /** Die Bestellungsabsatz-Warnung - Speichern erst nach Bestaetigung. */
+  warnung?: string
+  erfolg?: string
+  felder?: Record<string, string>
+}
+
+function zugriffsfehler(ausnahme: unknown): VorlagenZustand | null {
+  if (ausnahme instanceof ZugriffVerweigert) return { fehler: ausnahme.message }
+  return null
+}
+
+const vorlageSchema = z.object({
+  betreuteId: z.string().min(1),
+  vorlageId: z.string().trim().default(''),
+  name: z.string().trim().min(1, 'Bitte einen Namen vergeben.').max(120),
+  betreff: z.string().trim().max(200).default(''),
+  text: z.string().trim().min(10, 'Der Text ist zu kurz für eine Vorlage.').max(50_000),
+  ohneBestellungsabsatz: z.string().default(''),
+})
+
+export async function vorlageSpeichern(
+  _zustand: VorlagenZustand,
+  daten: FormData,
+): Promise<VorlagenZustand> {
+  const gelesen = vorlageSchema.safeParse({
+    betreuteId: daten.get('betreuteId'),
+    vorlageId: daten.get('vorlageId') ?? '',
+    name: daten.get('name'),
+    betreff: daten.get('betreff') ?? '',
+    text: daten.get('text'),
+    ohneBestellungsabsatz: daten.get('ohneBestellungsabsatz') ?? '',
+  })
+
+  if (!gelesen.success) {
+    const felder = gelesen.error.flatten().fieldErrors
+    return {
+      fehler: 'Bitte prüfe die Eingaben.',
+      felder: Object.fromEntries(
+        Object.entries(felder).map(([name, meldungen]) => [name, meldungen?.[0] ?? '']),
+      ),
+    }
+  }
+
+  const werte = gelesen.data
+  const bestaetigt = werte.ohneBestellungsabsatz === 'ja'
+
+  try {
+    const { benutzer } = await erfordereZugang(werte.betreuteId, 'DOKUMENTE', 'schreiben')
+
+    // Die zweistufige Warnung: erst warnen, dann - bestaetigt - speichern.
+    if (bestellungsabsatzFehlt(werte.text) && !bestaetigt) {
+      return {
+        warnung:
+          'In dieser Vorlage fehlt der Bestellungsabsatz — der Nachweis, dass du zur Vertretung ' +
+          'befugt bist. Ohne ihn antworten Versicherungen und Behörden mit „aus ' +
+          'datenschutzrechtlichen Gründen keine Auskunft", und das fällt erst nach Wochen auf. ' +
+          'Füge {{bestellungsabsatz}} ein — oder speichere bewusst ohne.',
+      }
+    }
+
+    if (werte.vorlageId) {
+      const vorhanden = await db.schreibvorlage.findFirst({
+        where: { id: werte.vorlageId, betreuteId: werte.betreuteId, ...nichtGeloescht },
+      })
+      if (!vorhanden) return { fehler: 'Diese Vorlage gibt es nicht (mehr).' }
+
+      const nachher = await db.schreibvorlage.update({
+        where: { id: vorhanden.id },
+        data: {
+          name: werte.name,
+          betreff: werte.betreff,
+          text: werte.text,
+          ohneBestellungsabsatz: bestaetigt,
+        },
+      })
+
+      await protokollieren({
+        aktion: 'GEAENDERT',
+        entitaet: 'Schreibvorlage',
+        entitaetId: nachher.id,
+        bezeichnung: nachher.name,
+        betreuteId: werte.betreuteId,
+        userId: benutzer.id,
+        userEmail: benutzer.email,
+        userName: benutzer.name,
+        aenderung: aenderungErmitteln(
+          { name: vorhanden.name, betreff: vorhanden.betreff, text: vorhanden.text },
+          { name: nachher.name, betreff: nachher.betreff, text: nachher.text },
+        ),
+      })
+    } else {
+      const neu = await db.schreibvorlage.create({
+        data: {
+          betreuteId: werte.betreuteId,
+          name: werte.name,
+          betreff: werte.betreff,
+          text: werte.text,
+          ohneBestellungsabsatz: bestaetigt,
+        },
+      })
+
+      await protokollieren({
+        aktion: 'ERSTELLT',
+        entitaet: 'Schreibvorlage',
+        entitaetId: neu.id,
+        bezeichnung: neu.name,
+        betreuteId: werte.betreuteId,
+        userId: benutzer.id,
+        userEmail: benutzer.email,
+        userName: benutzer.name,
+      })
+    }
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[vorlagen] Speichern fehlgeschlagen:', ausnahme)
+    return { fehler: 'Die Vorlage konnte nicht gespeichert werden.' }
+  }
+
+  revalidatePath('/einstellungen/vorlagen')
+  return { erfolg: `„${werte.name}“ ist gespeichert.` }
+}
+
+/** Papierkorb: geloeschtAm setzen, 30 Tage rueckholbar wie ueberall. */
+export async function vorlageLoeschen(
+  _zustand: VorlagenZustand,
+  daten: FormData,
+): Promise<VorlagenZustand> {
+  const betreuteId = String(daten.get('betreuteId') ?? '')
+  const vorlageId = String(daten.get('vorlageId') ?? '')
+
+  try {
+    const { benutzer } = await erfordereZugang(betreuteId, 'DOKUMENTE', 'schreiben')
+
+    const vorlage = await db.schreibvorlage.findFirst({
+      where: { id: vorlageId, betreuteId, ...nichtGeloescht },
+      select: { id: true, name: true },
+    })
+    if (!vorlage) return { fehler: 'Diese Vorlage gibt es nicht (mehr).' }
+
+    await db.schreibvorlage.update({
+      where: { id: vorlage.id },
+      data: { geloeschtAm: new Date() },
+    })
+
+    await protokollieren({
+      aktion: 'GELOESCHT',
+      entitaet: 'Schreibvorlage',
+      entitaetId: vorlage.id,
+      bezeichnung: vorlage.name,
+      betreuteId,
+      userId: benutzer.id,
+      userEmail: benutzer.email,
+      userName: benutzer.name,
+    })
+  } catch (ausnahme) {
+    const verweigert = zugriffsfehler(ausnahme)
+    if (verweigert) return verweigert
+    console.error('[vorlagen] Löschen fehlgeschlagen:', ausnahme)
+    return { fehler: 'Die Vorlage konnte nicht gelöscht werden.' }
+  }
+
+  revalidatePath('/einstellungen/vorlagen')
+  return { erfolg: 'In den Papierkorb gelegt — 30 Tage rückholbar.' }
+}
@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest'
+import {
+  PLATZHALTER,
+  benutztePlatzhalter,
+  bestellungsabsatzFehlt,
+  platzhalterErsetzen,
+} from '@/lib/schreiben/platzhalter'
+
+/**
+ * Platzhalter in Schreibvorlagen.
+ *
+ * Der Grundsatz, den jede Prüfung hier absichert: NICHTS geht
+ * stillschweigend schief. Fehlende Daten werden zur sichtbaren Lücke,
+ * unbekannte Platzhalter zur Markierung — nie zu einer leeren Stelle, die
+ * erst der Empfänger bemerkt.
+ */
+
+describe('Ersetzen', () => {
+  it('setzt bekannte Werte ein', () => {
+    const ergebnis = platzhalterErsetzen('Sehr geehrte Damen und Herren, {{betreuer_name}} hier.', {
+      betreuer_name: 'Florian Wilde',
+    })
+    expect(ergebnis.text).toBe('Sehr geehrte Damen und Herren, Florian Wilde hier.')
+    expect(ergebnis.luecken).toHaveLength(0)
+    expect(ergebnis.unbekannte).toHaveLength(0)
+  })
+
+  it('macht aus fehlenden Daten eine sichtbare Lücke', () => {
+    const ergebnis = platzhalterErsetzen('Az. {{aktenzeichen_gericht}}', {})
+    expect(ergebnis.text).toBe('Az. [Aktenzeichen des Gerichts]')
+    expect(ergebnis.luecken).toEqual(['aktenzeichen_gericht'])
+  })
+
+  it('behandelt leere Zeichenketten wie fehlende Daten', () => {
+    const ergebnis = platzhalterErsetzen('{{betreuungsgericht}}', { betreuungsgericht: '  ' })
+    expect(ergebnis.text).toContain('[Betreuungsgericht]')
+  })
+
+  it('markiert unbekannte Platzhalter, statt abzubrechen', () => {
+    // Ein Tippfehler in der Vorlage darf das Schreiben nicht verhindern —
+    // aber er muss ins Auge springen.
+    const ergebnis = platzhalterErsetzen('Hallo {{betreur_name}}!', {})
+    expect(ergebnis.text).toBe('Hallo [Unbekannter Platzhalter: {{betreur_name}}]!')
+    expect(ergebnis.unbekannte).toEqual(['betreur_name'])
+  })
+
+  it('verträgt Leerzeichen in den Klammern', () => {
+    const ergebnis = platzhalterErsetzen('{{ betreuer_name }}', { betreuer_name: 'F. Wilde' })
+    expect(ergebnis.text).toBe('F. Wilde')
+  })
+
+  it('ersetzt mehrere Vorkommen und meldet jede Lücke nur einmal', () => {
+    const ergebnis = platzhalterErsetzen('{{stichtag}} und nochmal {{stichtag}}', {})
+    expect(ergebnis.luecken).toEqual(['stichtag'])
+    expect(ergebnis.text.match(/\[Stichtag\]/g)).toHaveLength(2)
+  })
+
+  it('lässt Text ohne Platzhalter unangetastet', () => {
+    const text = 'Ein Brief ohne alles. Auch { einzelne } Klammern bleiben.'
+    expect(platzhalterErsetzen(text, {}).text).toBe(text)
+  })
+})
+
+describe('Platzhalterliste', () => {
+  it('beschreibt jeden Platzhalter mit Beschriftung und Quelle', () => {
+    // Die Liste steht neben dem Editor - niemand soll Namen raten müssen.
+    for (const platzhalter of PLATZHALTER) {
+      expect(platzhalter.beschriftung.length, platzhalter.name).toBeGreaterThan(3)
+      expect(platzhalter.quelle.length, platzhalter.name).toBeGreaterThan(3)
+    }
+  })
+
+  it('findet die benutzten Platzhalter einer Vorlage', () => {
+    expect(
+      benutztePlatzhalter('{{betreuer_name}} an {{vertrag_gesellschaft}}, nochmal {{betreuer_name}}'),
+    ).toEqual(['betreuer_name', 'vertrag_gesellschaft'])
+  })
+})
+
+describe('Bestellungsabsatz-Warnung', () => {
+  it('ist zufrieden mit dem Platzhalter', () => {
+    expect(bestellungsabsatzFehlt('Text mit {{bestellungsabsatz}} darin.')).toBe(false)
+  })
+
+  it('ist zufrieden mit einem von Hand geschriebenen Nachweis', () => {
+    // Wer den Absatz ausformuliert hat, wird nicht gegängelt.
+    expect(
+      bestellungsabsatzFehlt(
+        'Durch Beschluss des Amtsgerichts bin ich zum Betreuer bestellt.',
+      ),
+    ).toBe(false)
+  })
+
+  it('warnt bei einer Vorlage ohne jeden Nachweis', () => {
+    expect(bestellungsabsatzFehlt('Sehr geehrte Damen und Herren, bitte um Auskunft.')).toBe(true)
+  })
+
+  it('lässt sich nicht von einem halben Nachweis täuschen', () => {
+    // "Beschluss" allein (etwa der Beschluss der Eigentümerversammlung)
+    // ist kein Bestellungsnachweis.
+    expect(bestellungsabsatzFehlt('Zum Beschluss der Eigentümerversammlung...')).toBe(true)
+  })
+})
@@ -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)
+  })
+})
Author	SHA1	Message	Date
florian.wilde	57ce73dfbc	Merge #18 : Eigene Vorlagen fuer Anschreiben Behebt Issue #7: eigene Schreibvorlagen unter Einstellungen, Platzhalter mit sichtbaren Luecken, zweistufige Bestellungsabsatz-Warnung, vier mitgelieferte Vorlagen als Kopiervorlage, Auswahl beim freien Schreiben. Closes #7	2026-08-23 11:59:44 +00:00
Florian Wilde	f8d7752c27	Eigene Vorlagen fuer Anschreiben Wer zum dritten Mal denselben Brief tippt, tippt ihn beim vierten Mal falsch. Neu unter Einstellungen -> Schreibvorlagen: eigene Texte hinterlegen, beim freien Schreiben auswaehlen, Platzhalter fuellen sich aus den Daten, die ohnehin im System stehen. Aufbau: - Die Ersetzung als reine Funktionen in schreiben/platzhalter.ts. Drei Faelle, keiner davon still: Wert einsetzen, sichtbare Luecke [Aktenzeichen des Gerichts], unbekannter Platzhalter markiert. Ein Tippfehler in der Vorlage darf das Schreiben nicht verhindern - aber er muss ins Auge springen. - Die Bestellungsabsatz-Warnung ist zweistufig: Der erste Speicherversuch ohne ihn kommt mit einer Rueckfrage zurueck, erst die Bestaetigung speichert. Ohne den Nachweis der Vertretungsmacht kommt keine Auskunft, und das faellt erst nach vier Wochen auf. Ein ausformulierter Absatz zaehlt so viel wie der Platzhalter, ein halber Nachweis ("Beschluss der Eigentuemerversammlung") nicht. - Vier mitgelieferte Vorlagen bleiben Code und damit unveraenderlich; "Als Kopie uebernehmen" legt eine eigene Fassung an. Fuer Rueckkaufswert und Kuendigung fuehrt die Oberflaeche weiter zuerst zu den fallbezogenen Erzeugern - die rechnen Kuendigungstermine aus, was eine Vorlage nicht kann. - Vorlagen haengen an der betreuten Person, nicht am Benutzer: Sie beziehen sich auf ihren Fall, liegen im Papierkorb wie alles andere und sind im Vollexport ihrer Akte enthalten. Der Editor haelt Betreff und Text als eigenen State. Beim Wechsel der Vorlage ueberlebte der alte Entwurf die Navigation, die Vorlage kam nie im Textfeld an - ein key auf dem Editor setzt ihn neu auf. Gefunden hat das erst der End-to-End-Test. Geprueft: dreizehn Einheitstests fuer die Ersetzung, sechs End-to-End-Tests fuer Warnung, Kopie, Aufloesung und Papierkorb. Refs #7	2026-08-23 13:41:51 +02:00
florian.wilde	0a8878d8d2	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	2026-08-23 10:18:02 +00:00
Florian Wilde	9fe6f10f25	Rueckkaufswerte aller Versicherungen in einem Zug anfragen Vor Vermoegensverzeichnis und Jahresbericht braucht es von jeder Lebens- und Rentenversicherung den Rueckkaufswert zum Stichtag - jedes Mal dieselben fuenf bis zehn Briefe. Neu unter Vertraege: Stichtag waehlen, Liste pruefen, ein Klick. Heraus kommt ein ZIP mit einer Word-Datei je Gesellschaft plus Begleitblatt; je Vertrag entstehen nebenbei die PDF-Fassung in der Akte, die Wiedervorlage nach 28 Tagen und der Anfragevermerk. Aufbau: - Auswahllogik als reine Funktionen in vertraege/serienabfrage.ts: Vorauswahl, Hindernisse mit Begruendung statt stummem Ausblenden, 28-Tage-Sperre im Gleichschritt mit der Wiedervorlage. - Der Lauf in vertraege/serienlauf.ts: je Vertrag das volle Paket aus Issue #4, aber in einem Durchgang. Kein Alles-oder-nichts - ein gescheiterter Vertrag steht mit Grund im Begleitblatt, die uebrigen laufen durch. Eine Transaktion ueber alle waere die falsche Zusage. - Dublettenschutz tagesgenau: Der Doppelklick erzeugt nichts Doppeltes, die bewusste zweite Anfrage nach einer Woche bleibt moeglich. - Die Anzahl steht vor dem Klick auf dem Knopf. Gekuendigte Vertraege bleiben anfragbar: Bis zum Wirksamwerden besteht der Vertrag, und genau dann will der Sozialhilfetraeger den Wert sehen. Geprueft: zwoelf Einheitstests, drei End-to-End-Tests inklusive der Nebenwirkungen in der Datenbank und des Dublettenschutzes. 602 Unit-Tests, 87 e2e, null Typfehler. Refs #6	2026-08-23 12:10:32 +02:00