Merge #15: Schreiben erzeugen, ausgeben und ablegen

Behebt Issue #4: Ein Schreiben geht jetzt den ganzen Weg - bearbeiten,
Word-Datei, Ablage als Ausgangsdokument, Wiedervorlage. Auch an Stellen,
zu denen es noch keinen Datensatz gibt.

Closes #4

CHANGELOG.md

@@ -26,6 +26,74 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [1.4.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Schreiben erzeugen, ausgeben und ablegen**
+  ([#4](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/4)).
+  Die Anschreiben an Versicherer und Behörden gab es bisher nur als Text
+  zum Kopieren. Danach war Handarbeit: in Word nachbauen, ausdrucken,
+  abschicken — und noch einmal von Hand als Dokument in die Akte legen.
+  Vier Schritte, und der letzte wurde am häufigsten vergessen. Dann fehlt
+  der Nachweis genau dort, wo er gebraucht wird.
+
+  Neu unter **Schreiben**: Text bearbeiten, als **Word-Datei**
+  herunterladen, **in die Akte legen** und dabei eine **Wiedervorlage**
+  setzen — in einem Zug.
+
+  Der Text bleibt vollständig bearbeitbar. Jeder Fall hat eine
+  Besonderheit, die in den Brief gehört; ein Formulartext, den man nicht
+  mehr ändern kann, wird früher oder später falsch abgeschickt.
+
+- **Schreiben ohne Vertrag und ohne Vorgang.** Bisher ging ein Anschreiben
+  nur zu einem vorhandenen Datensatz. Am Anfang einer Betreuung schreibt
+  man aber gerade an Stellen, zu denen es noch keinen gibt — man fragt ja
+  an, um zu erfahren, ob dort überhaupt etwas besteht. Jetzt geht es an
+  einen **Kontakt** oder an eine **frei getippte Anschrift**, aus der sich
+  mit einem Klick ein Kontakt anlegen lässt. So wächst das Adressbuch
+  nebenbei beim Schreiben statt durch Pflege.
+
+- **Die Wiedervorlage entsteht mit.** Rückkaufswert 28 Tage, Kündigung 21,
+  Sachstandsanfrage 42 — jeweils änderbar, und daneben steht, warum die
+  Frist so lang ist. Bei einer Sachstandsanfrage wird zusätzlich der letzte
+  Kontakt am Vorgang nachgezogen, damit *Wartet auf andere* auf „Heute"
+  stimmt.
+
+### Zwei Entscheidungen, die erklärt gehören
+
+**In die Akte kommt eine PDF-Fassung, heruntergeladen wird eine
+Word-Datei.** Der Objektspeicher nimmt nur PDF und Bilder an, geprüft an
+den Magic Bytes — eine Word-Datei ist ein ZIP-Archiv, sie durchzulassen
+hieße jedes ZIP durchzulassen. Diese Prüfung ist eine bewusste Zusage der
+Anwendung; sie für eine Bequemlichkeit aufzuweichen wäre der falsche
+Handel. Und sachlich ist PDF für den Nachweis ohnehin das richtige Format:
+Es ändert sich nicht mehr.
+
+Daraus folgt eine Einschränkung, die auch in der Oberfläche steht:
+**Änderst du die Word-Datei danach noch**, weicht die Akte davon ab. Dann
+lieber dort fertig schreiben, den Text zurückkopieren und erst dann
+ablegen.
+
+**Der Berichtssatz wurde nicht umgebogen.** Die vorhandene DOCX-Ausgabe
+setzt einen Bericht mit Kopfzeilen und Unterschriftenblock; ein Brief
+braucht Absender, Anschriftenfeld, Datumszeile und Grußformel. Beides in
+eine Funktion zu zwingen hätte beide Ausgaben schlechter gemacht.
+
+### Geprüft
+
+- Zehn Einheitstests, darunter der Gleichschritt der Wiedervorlagefristen:
+  Sie stehen an zwei Stellen und dürfen nicht auseinanderlaufen, sonst
+  mahnt die Anwendung zu zwei verschiedenen Terminen.
+- Fünf End-to-End-Tests: Entwurf mit Bestellungsabsatz, Vertragsbezug,
+  Word-Download, Ablage samt Wiedervorlage und Kontakt aus freier
+  Anschrift.
+
+  Zwei Fehler hat erst der Browsertest gefunden — beide in den Tests
+  selbst: Die Dokumentenliste rendert Tabelle **und** Karten, je nach
+  Bildschirmbreite ist eine davon versteckt. Ein Treffer auf die
+  unsichtbare Fassung sieht aus wie ein Fehler in der Anwendung.
+
 ## [1.3.0] – 2026-08-23
 
 ### Hinzugefügt
@@ -700,7 +768,8 @@ 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.3.0...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.4.0...HEAD
+[1.4.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.3.0...v1.4.0
 [1.3.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.2.0...v1.3.0
 [1.2.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.2...v1.2.0
 [1.1.2]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.1...v1.1.2

README.md

@@ -580,11 +580,11 @@ Fehler, die während des Baus aufgefallen sind.
 
 | | | nachzuzählen mit |
 |---|---:|---|
-| Zeilen TypeScript/TSX | 76.216 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
+| Zeilen TypeScript/TSX | 76.610 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
 | Prisma-Modelle | 34 | `grep -c '^model ' prisma/schema.prisma` |
-| Seiten | 79 | `find src/app -name page.tsx \| wc -l` |
+| Seiten | 81 | `find src/app -name page.tsx \| wc -l` |
-| Unit-Tests (Vitest) | 560 | `npm test` |
+| Unit-Tests (Vitest) | 570 | `npm test` |
-| End-to-End-Tests (Playwright) | 63 | `npm run test:e2e` — 35 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
+| End-to-End-Tests (Playwright) | 73 | `npm run test:e2e` — 40 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
 | TypeScript-Fehler | 0 | `npm run typecheck` |
 
 Die Befehle stehen dabei, weil die Zahlen sonst altern, ohne dass es

docs/INSTALLATION.md

@@ -131,14 +131,14 @@ cd /opt/betreuungs-cockpit
 
 # Auf die letzte veröffentlichte Fassung wechseln,
 # nicht auf den laufenden Entwicklungsstand
-git checkout v1.3.0
+git checkout v1.4.0
 ```
 
 ### Kontrolle
 
 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.3.0
+git describe --tags                              # v1.4.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.3.0","commit":"..."}
+# {"status":"bereit","version":"1.4.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.3.0",...}
+# {"status":"bereit","version":"1.4.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.3.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.4.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.3.0` | auf eine bestimmte Fassung |
+| `./scripts/update.sh v1.4.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.3.0
+git checkout v1.4.0
 
 # 4. Neu bauen und starten
 GIT_COMMIT=$(git rev-parse --short HEAD) BUILD_ZEIT=$(date -Iseconds) docker compose up -d --build

docs/ROADMAP.md

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

e2e/schreiben.spec.ts

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

package.json

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { notFound } from 'next/navigation'
 import Link from 'next/link'
-import { ArrowLeft, Clock } from 'lucide-react'
+import { ArrowLeft, FileDown, Clock } from 'lucide-react'
 import type { VorgangStatus } from '@prisma/client'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
@@ -245,6 +245,14 @@ export default async function VorgangSeite({ params }: { params: Promise<{ id: s
                 darfSchreiben={schreiben}
               />
             )}
+            {schreiben && (
+              <Button asChild variant="outline">
+                <Link href={`/schreiben/neu?art=SACHSTAND&vorgangId=${vorgang.id}`}>
+                  <FileDown aria-hidden="true" />
+                  Als Word-Datei und in die Akte
+                </Link>
+              </Button>
+            )}
             {schreiben && <VorgangLoeschen vorgangId={vorgang.id} titel={vorgang.titel} />}
           </>
         }

src/components/schreiben/schreiben-editor.tsx

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

src/components/vertraege/kuendigungs-assistent.tsx

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

src/components/vertraege/rueckkaufswert.tsx

@@ -1,7 +1,8 @@
 'use client'
 
+import Link from 'next/link'
 import { useActionState, useState } from 'react'
-import { Coins, Mail, Plus } from 'lucide-react'
+import { Coins, FileDown, Mail, Plus } from 'lucide-react'
 import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
@@ -149,6 +150,15 @@ export function Rueckkaufswert({
               hoehe="min-h-[32rem]"
             />
 
+            {/* Der Weg, der nicht beim Kopieren endet: bearbeiten,
+                Word-Datei, Ablage in der Akte, Wiedervorlage. */}
+            <Button asChild variant="outline">
+              <Link href={`/schreiben/neu?art=RUECKKAUFSWERT&vertragId=${vertragId}`}>
+                <FileDown aria-hidden="true" />
+                Bearbeiten, als Word-Datei und in die Akte
+              </Link>
+            </Button>
+
             <form action={anfrageAktion} className="space-y-4" noValidate>
               <input type="hidden" name="betreuteId" value={betreuteId} />
               <input type="hidden" name="vertragId" value={vertragId} />

src/lib/schreiben/arten.ts

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

src/lib/schreiben/docx.ts

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

src/lib/schreiben/entwurf.ts

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

src/lib/schreiben/pdf.tsx

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

src/lib/version.ts

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

src/server/actions/schreiben.ts

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

tests/schreiben.test.ts

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