Merge #14: Dauerzahlungen gelten als belegt

Behebt Issue #11: Bei einem Dauerschuldverhaeltnis ist der Vertrag der
Beleg - fuer zwoelf gleiche Lastschriften gibt es keine zwoelf
Quittungen, sondern eine Police.

Closes #11

CHANGELOG.md

@@ -26,6 +26,90 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [1.3.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Dauerzahlungen zu einem Vertrag gelten als belegt**
+  ([#11](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/11)).
+  Bei einer monatlichen Versicherungsprämie gibt es keinen Beleg — es gibt
+  einen Vertrag, und der wird einmal abgeschlossen, nicht monatlich
+  quittiert. Bisher blieb nur ein Freitextfeld pro Buchung: zwölfmal im
+  Jahr derselbe Satz, mal Anzahl der Verträge.
+
+  Eine Buchung lässt sich jetzt einem **Vertrag** zuordnen, und diese
+  Zuordnung zählt als Nachweis. Bei einem Dauerschuldverhältnis ist der
+  Vertrag der Beleg: Ein Rechtspfleger will für zwölf gleiche Lastschriften
+  keine zwölf Quittungen sehen, sondern die Police.
+
+  **Die Belegquote weist drei Fälle getrennt aus** — mit Beleg, durch
+  Vertrag belegt, begründet ohne Beleg. Zusammengeworfen verlöre die Zahl
+  ihre Aussage.
+
+- **Automatisch beim Import**, wenn die Gegenstelle zu genau *einem*
+  Vertrag passt. Bei Mehrdeutigkeit geschieht nichts: Hausrat und
+  Haftpflicht bei derselben Gesellschaft lassen sich nicht auseinanderhalten,
+  und eine falsche Zuordnung wäre schlimmer als gar keine — sie behauptet
+  einen Beleg, und niemand sieht noch einmal hin. Automatisch gesetzte
+  Zuordnungen sind in der Liste als solche gekennzeichnet.
+
+- **Sammelzuordnung** unter *Wiederkehrende Zahlungen*: Liegt zu einer
+  Gruppe ein Vertrag vor, werden alle ihre Zahlungen mit einem Klick
+  zugeordnet. Bei drei Jahren Laufzeit sind das 36 Buchungen.
+
+- **Die Rechnungslegung nennt den Vertrag.** Statt „ohne Beleg – …" steht
+  dort „Dauerzahlung zu Vertrag «Bezeichnung», Nr. …". Die Lücke wird nicht
+  versteckt, sondern erklärt: Wer nachprüfen will, weiß sofort, welches
+  Papier er aus dem Ordner holt.
+
+### Die Sicherung dagegen
+
+**Weicht der Betrag um mehr als ein Fünftel vom hinterlegten Beitrag ab,
+gilt die Zahlung nicht als belegt**, sondern wird als *Betrag prüfen*
+markiert. Sonst wäre die Zuordnung eine Hintertür, durch die auch eine
+verzehnfachte Prämie unbemerkt durchginge.
+
+Ein Fünftel ist bewusst großzügig: Beitragsanpassungen und
+Versicherungsteuer bewegen sich in dieser Größenordnung, und dabei soll
+die Anwendung nicht meckern. Wer die Grenze enger zieht, bekommt täglich
+Warnungen und sieht die eine wichtige nicht mehr.
+
+Steht am Vertrag **kein** Beitrag, findet keine Prüfung statt. Die
+Zuordnung gilt trotzdem — es wird nur nicht so getan, als wäre geprüft
+worden.
+
+Und: **Verschwindet der Vertrag, fällt die Buchung zurück in „Beleg
+fehlt".** Ein Nachweis, der auf etwas zeigt, das es nicht mehr gibt, wäre
+schlimmer als gar keiner.
+
+### Zu beachten
+
+- **Eine Datenbank-Migration ist nötig**
+  (`20260823062000_buchung_vertragszahlung`). Sie fügt zwei Spalten hinzu
+  und ändert nichts an vorhandenen Daten.
+- Bestehende Buchungen sind nicht betroffen: Ohne Zuordnung bleibt alles,
+  wie es war.
+
+### Geprüft
+
+- 23 neue Einheitstests. Die Hälfte prüft, dass die Anerkennung auch
+  wirklich **wegfällt** — der gefährliche Fehler wäre hier ein zu mildes
+  Urteil, nicht ein zu strenges.
+- Fünf End-to-End-Tests: Sammelzuordnung, Anzeige in der Buchungsliste,
+  die abweichende Zahlung, die Kachel auf „Heute", und der Rückfall nach
+  dem Löschen des Vertrags.
+
+  Der Browsertest hat zwei Fehler gefunden, die alle anderen Prüfungen
+  durchgelassen haben — siehe unten.
+
+### Behoben
+
+- **Die Buchungsliste hatte eine eigene, fast gleiche Datenabfrage** neben
+  der gemeinsamen aus `berichte/gemeinsam.ts`. Als die Dauerzahlungen
+  dazukamen, wurde nur eine von beiden nachgezogen: In der Liste stand
+  weiter „Beleg fehlt", obwohl der Vertrag hinterlegt war. Beide benutzen
+  jetzt dieselbe Abbildung — die kann nicht halb vergessen werden.
+
 ## [1.2.0] – 2026-08-23
 
 ### Hinzugefügt
@@ -616,7 +700,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.2.0...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.3.0...HEAD
+[1.3.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.2.0...v1.3.0
 [1.2.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.2...v1.2.0
 [1.1.2]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.1...v1.1.2
 [1.1.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.0...v1.1.1

README.md

@@ -580,11 +580,11 @@ Fehler, die während des Baus aufgefallen sind.
 
 | | | nachzuzählen mit |
 |---|---:|---|
-| Zeilen TypeScript/TSX | 74.119 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
+| Zeilen TypeScript/TSX | 76.216 | `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` |
-| Unit-Tests (Vitest) | 537 | `npm test` |
+| Unit-Tests (Vitest) | 560 | `npm test` |
-| End-to-End-Tests (Playwright) | 53 | `npm run test:e2e` — 30 Tests über zwei Geräteprofile, geräteabhängige übersprungen |
+| End-to-End-Tests (Playwright) | 63 | `npm run test:e2e` — 35 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.2.0
+git checkout v1.3.0
 ```
 
 ### Kontrolle
 
 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.2.0
+git describe --tags                              # v1.3.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.2.0","commit":"..."}
+# {"status":"bereit","version":"1.3.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.2.0",...}
+# {"status":"bereit","version":"1.3.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.2.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.3.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.2.0` | auf eine bestimmte Fassung |
+| `./scripts/update.sh v1.3.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.2.0
+git checkout v1.3.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.1.2** ([CHANGELOG](../CHANGELOG.md))
+Stand: 23.08.2026 · Aktuelle Fassung: **1.3.0** ([CHANGELOG](../CHANGELOG.md))
 
 ---
 

e2e/dauerzahlung.spec.ts

@@ -0,0 +1,176 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Dauerzahlungen zu einem Vertrag — gegen die echte Anwendung.
+ *
+ * Die Einheitstests nageln die Belegzustände fest. Hier geht es um das, was
+ * sie nicht sehen: Kommt die Zuordnung in der Datenbank an, verschwindet die
+ * Buchung wirklich aus „Beleg fehlt", und trägt die abweichende Zahlung
+ * sichtbar die Warnung?
+ *
+ * Der Test legt Vertrag und Buchungen selbst an und räumt sie weg.
+ */
+
+const GESELLSCHAFT = 'Prüfhausen Rentenversicherung'
+const VERTRAG = 'Prüfhausen Rente (Test)'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.buchung.deleteMany({ where: { gegenstelle: GESELLSCHAFT } })
+    await db.vertrag.deleteMany({ where: { bezeichnung: VERTRAG } })
+  })
+}
+
+/**
+ * Sechs passende Monatsraten plus eine, die zehnmal so hoch ist.
+ * Die letzte ist der eigentliche Prüffall.
+ */
+async function testdatenAnlegen(): Promise<void> {
+  await mitDb(async (db) => {
+    const betreute = await db.betreute.findMany({
+      where: { geloeschtAm: null },
+      select: { id: true },
+    })
+
+    for (const person of betreute) {
+      const vertrag = await db.vertrag.create({
+        data: {
+          betreuteId: person.id,
+          bezeichnung: VERTRAG,
+          gesellschaft: GESELLSCHAFT,
+          art: 'RENTENVERSICHERUNG_PRIVAT',
+          beitragCent: 4250n,
+          rhythmus: 'MONATLICH',
+        },
+        select: { id: true },
+      })
+
+      const konto = await db.konto.findFirst({
+        where: { betreuteId: person.id, geloeschtAm: null },
+        select: { id: true },
+      })
+
+      const gemeinsam = {
+        betreuteId: person.id,
+        kontoId: konto?.id ?? null,
+        richtung: 'AUSGABE' as const,
+        kategorie: 'VERSICHERUNG' as const,
+        betrifftBetreute: true,
+        gegenstelle: GESELLSCHAFT,
+      }
+
+      for (let monat = 1; monat <= 6; monat++) {
+        await db.buchung.create({
+          data: {
+            ...gemeinsam,
+            datum: new Date(Date.UTC(2026, monat - 1, 1)),
+            betragCent: 4250n,
+          },
+        })
+      }
+
+      // Die Ausreißerin: schon zugeordnet, aber zehnmal so hoch.
+      await db.buchung.create({
+        data: {
+          ...gemeinsam,
+          datum: new Date(Date.UTC(2026, 6, 1)),
+          betragCent: 42_500n,
+          vertragId: vertrag.id,
+        },
+      })
+    }
+  })
+}
+
+test.describe('Dauerzahlungen', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+    await testdatenAnlegen()
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('ordnet alle Zahlungen einer Gruppe in einem Schritt zu', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    // Der Vertrag liegt vor, also steht die Gruppe unter „schon zugeordnet".
+    const eintrag = page.locator('li', { hasText: VERTRAG }).first()
+    await expect(eintrag).toBeVisible()
+
+    // Sechs offene Zahlungen — die siebte hängt schon am Vertrag.
+    const knopf = eintrag.getByRole('button', { name: /6 Zahlungen als belegt zuordnen/ })
+    await expect(knopf).toBeVisible()
+    await knopf.click()
+
+    // Die Rückmeldung ist der neue Zustand, nicht eine Meldung: Sind alle
+    // Zahlungen zugeordnet, verschwindet der Knopf und die Gruppe meldet
+    // sich als vollständig.
+    await expect(eintrag).toContainText('Alle 7 Zahlungen sind dem Vertrag zugeordnet')
+    await expect(eintrag.getByRole('button', { name: /als belegt zuordnen/ })).toHaveCount(0)
+  })
+
+  test('zeigt die Zahlungen danach als durch Vertrag belegt', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const zeilen = page.locator('tr', { hasText: GESELLSCHAFT })
+    await expect(zeilen.first()).toBeVisible()
+
+    // Die passenden Raten gelten als belegt …
+    await expect(page.getByText('durch Vertrag belegt').first()).toBeVisible()
+    // … und keine davon steht mehr als „Beleg fehlt".
+    const zeileMitFehlt = page.locator('tr', { hasText: GESELLSCHAFT }).filter({
+      hasText: 'Beleg fehlt',
+    })
+    await expect(zeileMitFehlt).toHaveCount(0)
+  })
+
+  test('markiert die abweichende Zahlung zur Prüfung, statt sie durchzuwinken', async ({
+    page,
+  }) => {
+    // Die Zusage, auf der alles steht: Die Zuordnung darf keine Hintertür
+    // sein, durch die eine verzehnfachte Prämie unbemerkt als belegt gilt.
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const ausreisser = page.locator('tr', { hasText: '425,00' })
+    await expect(ausreisser).toContainText('Betrag prüfen')
+  })
+
+  test('nimmt die Zuordnung aus der Kachel auf „Heute“ heraus', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/heute')
+
+    // Die sechs zugeordneten Zahlungen dürfen dort nicht mehr auftauchen.
+    const kachel = page.locator('section, div').filter({ hasText: 'Unverbuchte Belege' }).last()
+    await expect(kachel).not.toContainText(GESELLSCHAFT)
+  })
+
+  test('fällt zurück in „Beleg fehlt“, wenn der Vertrag verschwindet', async ({ page }) => {
+    // Ein Nachweis, der auf etwas zeigt, das es nicht mehr gibt, wäre
+    // schlimmer als gar keiner.
+    await mitDb(async (db) => {
+      await db.vertrag.deleteMany({ where: { bezeichnung: VERTRAG } })
+    })
+
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const zeilen = page.locator('tr', { hasText: GESELLSCHAFT })
+    await expect(zeilen.first()).toContainText('Beleg fehlt')
+  })
+})

package.json

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

prisma/migrations/20260823062000_buchung_vertragszahlung/migration.sql

@@ -0,0 +1,19 @@
+-- Dauerzahlungen: Buchung.vertragId.
+--
+-- ACHTUNG, zum dritten Mal: "prisma migrate diff" wollte wieder die
+-- Trigramm-Indizes "dokument_absender_trgm" und "vorgang_titel_trgm"
+-- loeschen. Sie stammen aus prisma/sql/suche.sql und sind Prisma
+-- unbekannt; ein DROP legt die unscharfe Suche stumm, ohne dass etwas
+-- fehlschlaegt. Zeilen entfernt. Wer die naechste Migration erzeugt:
+-- nachsehen.
+
+-- AlterTable
+ALTER TABLE "buchung" ADD COLUMN     "vertragAutomatisch" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "vertragId" TEXT;
+
+-- CreateIndex
+CREATE INDEX "buchung_vertragId_idx" ON "buchung"("vertragId");
+
+-- AddForeignKey
+ALTER TABLE "buchung" ADD CONSTRAINT "buchung_vertragId_fkey" FOREIGN KEY ("vertragId") REFERENCES "vertrag"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+

prisma/schema.prisma

@@ -890,6 +890,21 @@ model Buchung {
   /// Buchung ohne Beleg wird in der Liste markiert - Belegzwang.
   belegFehltBegruendung String?
 
+  /// Dauerzahlung zu einem Vertrag. Bei einem Dauerschuldverhaeltnis IST
+  /// der Vertrag der Beleg - fuer zwoelf gleiche Lastschriften gibt es
+  /// keine zwoelf Quittungen, sondern eine Police.
+  ///
+  /// onDelete: SetNull ist Absicht und Teil der Zusage: Verschwindet der
+  /// Vertrag, faellt die Buchung zurueck in "Beleg fehlt". Ein Nachweis,
+  /// der auf etwas zeigt, das es nicht mehr gibt, waere schlimmer als
+  /// gar keiner.
+  vertragId String?
+  vertrag   Vertrag? @relation("Vertragszahlung", fields: [vertragId], references: [id], onDelete: SetNull)
+
+  /// Wurde die Zuordnung beim Import automatisch gesetzt? Dann ist sie
+  /// eine Vermutung der Maschine und in der Liste als solche erkennbar.
+  vertragAutomatisch Boolean @default(false)
+
   /// false = Auslage des Betreuers, die erstattet werden muss.
   betrifftBetreute  Boolean @default(true)
   /// Verschiebt das Vermoegen (z.B. Verkaufserloes), nicht nur laufende
@@ -908,6 +923,7 @@ model Buchung {
   @@unique([kontoId, importReferenz])
   @@index([betreuteId, datum])
   @@index([betreuteId, kategorie])
+  @@index([vertragId])
   @@map("buchung")
 }
 
@@ -1173,6 +1189,7 @@ model Vertrag {
 
   vermoegensposten Vermoegensposten[]
   verknuepfungen   DokumentVerknuepfung[]
+  zahlungen        Buchung[]              @relation("Vertragszahlung")
 
   @@index([betreuteId, status])
   @@map("vertrag")

src/app/(app)/finanzen/buchungen/[id]/page.tsx

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

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

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

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

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

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

@@ -17,7 +17,7 @@ import { centZuZahl } from '@/lib/db'
 import { formatCent, formatDatum } from '@/lib/utils'
 import { finanzKontext } from '@/lib/finanzen/seite'
 import { heute, monatePlus, tagePlus } from '@/lib/finanzen/datum'
-import { kennzahlen, vermischungsWarnung } from '@/lib/finanzen/kassenbuch'
+import { belegDurchVertrag, betragPruefen, kennzahlen, vermischungsWarnung } from '@/lib/finanzen/kassenbuch'
 import { KATEGORIE_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
 import { laufendesBetreuungsjahr } from '@/lib/finanzen/betreuungsjahr'
 import { buchungenLaden, kontenLaden, kontostaendeZumStichtag, vermoegenLaden } from '@/lib/berichte/gemeinsam'
@@ -121,9 +121,13 @@ export default async function FinanzenSeite() {
           titel="Belegquote (12 Monate)"
           wert={`${zahlen.beleg.quoteProzent} %`}
           hinweis={
-            zahlen.beleg.ohneNachweis > 0
+            zahlen.beleg.zuPruefen > 0
-              ? `${zahlen.beleg.ohneNachweis} Buchung(en) ohne Beleg und ohne Begründung`
+              ? `${zahlen.beleg.zuPruefen} Zahlung(en) weichen vom hinterlegten Beitrag ab`
-              : 'Alle Buchungen sind belegt oder begründet'
+              : zahlen.beleg.ohneNachweis > 0
+                ? `${zahlen.beleg.ohneNachweis} Buchung(en) ohne Beleg und ohne Begründung`
+                : zahlen.beleg.durchVertrag > 0
+                  ? `Belegt, begründet oder durch Vertrag gedeckt (${zahlen.beleg.durchVertrag} Dauerzahlungen)`
+                  : 'Alle Buchungen sind belegt oder begründet'
           }
           ton={zahlen.beleg.ohneNachweis > 0 ? 'achtung' : 'gut'}
           href="/finanzen/buchungen?nurOhneBeleg=on"
@@ -318,6 +322,11 @@ export default async function FinanzenSeite() {
                         belegId={buchung.belegId}
                         belegTitel={buchung.belegTitel ?? null}
                         begruendung={buchung.belegFehltBegruendung}
+                        vertragBezeichnung={
+                        belegDurchVertrag(buchung) ? (buchung.vertragBezeichnung ?? null) : null
+                        }
+                        vertragAutomatisch={buchung.vertragAutomatisch ?? false}
+                        betragZuPruefen={betragPruefen(buchung)}
                       />
                     </TableCell>
                     <TableCell className="text-right">

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

@@ -9,6 +9,7 @@ import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
 import { Betrag } from '@/components/finanzen/bausteine'
 import {
   AlsGeklaertAbhaken,
+  ZahlungenZuordnen,
   Zurueckholen,
 } from '@/components/finanzen/wiederkehrend-aktionen'
 import { finanzKontext } from '@/lib/finanzen/seite'
@@ -245,22 +246,40 @@ export default async function WiederkehrendSeite() {
               <CardContent>
                 <ul className="divide-y text-sm">
                   {mitVertrag.map((gruppe) => (
-                    <li
+                    <li key={gruppe.schluessel} className="space-y-2 py-2">
-                      key={gruppe.schluessel}
+                      <div className="flex flex-wrap items-center justify-between gap-2">
-                      className="flex flex-wrap items-center justify-between gap-2 py-2"
+                        <span>
-                    >
+                          <span className="font-medium">{gruppe.anzeigename}</span>
-                      <span>
+                          <span className="ml-2 text-muted-foreground">
-                        <span className="font-medium">{gruppe.anzeigename}</span>
+                            {RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]},{' '}
-                        <span className="ml-2 text-muted-foreground">
+                            {formatCent(centZuZahl(gruppe.jahresbetragCent))} im Jahr
-                          {RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]},{' '}
+                          </span>
-                          {formatCent(centZuZahl(gruppe.jahresbetragCent))} im Jahr
                         </span>
-                      </span>
+                        <Button asChild variant="ghost" size="sm">
-                      <Button asChild variant="ghost" size="sm">
+                          <Link href={`/vertraege/${gruppe.vertragId}`}>
-                        <Link href={`/vertraege/${gruppe.vertragId}`}>
+                            {gruppe.vertragBezeichnung}
-                          {gruppe.vertragBezeichnung}
+                          </Link>
-                        </Link>
+                        </Button>
-                      </Button>
+                      </div>
+
+                      {/* Der Vertrag liegt vor - dann belegt er auch die
+                          Zahlungen. Einzeln anzuklicken waeren bei drei
+                          Jahren Laufzeit 36 Klicks. */}
+                      {schreiben && gruppe.offeneBuchungIds.length > 0 && (
+                        <ZahlungenZuordnen
+                          betreuteId={betreute.id}
+                          vertragId={gruppe.vertragId!}
+                          vertragBezeichnung={gruppe.vertragBezeichnung ?? 'Vertrag'}
+                          buchungIds={gruppe.offeneBuchungIds}
+                        />
+                      )}
+
+                      {gruppe.offeneBuchungIds.length === 0 && (
+                        <p className="text-xs text-ampel-gruen">
+                          Alle {gruppe.anzahl} Zahlungen sind dem Vertrag zugeordnet und damit
+                          belegt.
+                        </p>
+                      )}
                     </li>
                   ))}
                 </ul>

src/components/finanzen/bausteine.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react'
 import Link from 'next/link'
-import { AlertTriangle, FileWarning, Paperclip } from 'lucide-react'
+import { AlertTriangle, FileCheck, FileWarning, Paperclip } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Card, CardContent } from '@/components/ui/card'
 import { cn, formatCent } from '@/lib/utils'
@@ -104,10 +104,19 @@ export function Belegzeichen({
   belegTitel,
   begruendung,
   belegId,
+  vertragBezeichnung = null,
+  vertragAutomatisch = false,
+  betragZuPruefen = false,
 }: {
   belegId: string | null
   belegTitel: string | null
   begruendung: string | null
+  /** Dauerzahlung: gesetzt, wenn der Vertrag als Beleg gilt. */
+  vertragBezeichnung?: string | null
+  /** Beim Import automatisch zugeordnet - eine Vermutung, kein Urteil. */
+  vertragAutomatisch?: boolean
+  /** Zugeordnet, aber der Betrag weicht ab. */
+  betragZuPruefen?: boolean
 }) {
   if (belegId) {
     return (
@@ -118,6 +127,36 @@ export function Belegzeichen({
     )
   }
 
+  // Zugeordnet, aber der Betrag passt nicht. Steht vor allem anderen: Das
+  // ist der Fall, den jemand ansehen soll.
+  if (betragZuPruefen) {
+    return (
+      <Badge
+        variant="rot"
+        title="Der Betrag weicht deutlich vom hinterlegten Beitrag ab. Meist eine Beitragsanpassung, die am Vertrag noch fehlt."
+      >
+        <AlertTriangle className="size-3.5" aria-hidden="true" />
+        Betrag prüfen
+      </Badge>
+    )
+  }
+
+  if (vertragBezeichnung) {
+    return (
+      <Badge
+        variant="gruen"
+        title={
+          vertragAutomatisch
+            ? `Beim Import automatisch dem Vertrag „${vertragBezeichnung}“ zugeordnet. Bitte einmal durchsehen.`
+            : `Dauerzahlung zu Vertrag „${vertragBezeichnung}“.`
+        }
+      >
+        <FileCheck className="size-3.5" aria-hidden="true" />
+        {vertragAutomatisch ? 'Vertrag (automatisch)' : 'durch Vertrag belegt'}
+      </Badge>
+    )
+  }
+
   if (begruendung && begruendung.trim() !== '') {
     return (
       <Badge variant="gelb" title={begruendung}>

src/components/finanzen/buchungs-formular.tsx

@@ -33,6 +33,12 @@ export type BelegAuswahl = {
   titel: string
 }
 
+export type VertragAuswahl = {
+  id: string
+  bezeichnung: string
+  gesellschaft: string | null
+}
+
 export type BuchungWerte = {
   id: string
   kontoId: string | null
@@ -45,6 +51,7 @@ export type BuchungWerte = {
   verwendungszweck: string | null
   belegId: string | null
   belegFehltBegruendung: string | null
+  vertragId: string | null
   betrifftBetreute: boolean
   vermoegenswirksam: boolean
 }
@@ -65,6 +72,7 @@ export function Buchungsformular({
   betreuteId,
   konten,
   belege,
+  vertraege,
   buchung,
   standardDatum,
   schnellerfassung = false,
@@ -72,6 +80,7 @@ export function Buchungsformular({
   betreuteId: string
   konten: KontoAuswahl[]
   belege: BelegAuswahl[]
+  vertraege: VertragAuswahl[]
   buchung?: BuchungWerte
   /** Vorbelegung des Datumsfeldes bei einer neuen Buchung. */
   standardDatum?: string
@@ -87,6 +96,7 @@ export function Buchungsformular({
   )
   const [betrifftBetreute, setBetrifftBetreute] = React.useState(buchung?.betrifftBetreute ?? true)
   const [belegId, setBelegId] = React.useState(buchung?.belegId ?? '')
+  const [vertragId, setVertragId] = React.useState(buchung?.vertragId ?? '')
 
   const konto = konten.find((k) => k.id === kontoId)
   const vermischt = Boolean(konto?.istBetreuerkonto) && betrifftBetreute
@@ -275,7 +285,30 @@ export function Buchungsformular({
           </Select>
         </Feld>
 
-        {belegId === '' && (
+        {belegId === '' && vertraege.length > 0 && (
+          <Feld
+            id="vertragId"
+            beschriftung="Oder: Dauerzahlung zu einem Vertrag"
+            erklaerung="Bei einem Dauerschuldverhältnis ist der Vertrag der Beleg — für zwölf gleiche Lastschriften gibt es keine zwölf Quittungen, sondern eine Police. Weicht der Betrag deutlich vom hinterlegten Beitrag ab, wird die Buchung trotzdem zur Prüfung markiert."
+            fehler={zustand.felder?.vertragId}
+          >
+            <Select
+              name="vertragId"
+              value={vertragId}
+              onChange={(ereignis) => setVertragId(ereignis.target.value)}
+            >
+              <option value="">– keine Dauerzahlung –</option>
+              {vertraege.map((vertrag) => (
+                <option key={vertrag.id} value={vertrag.id}>
+                  {vertrag.bezeichnung}
+                  {vertrag.gesellschaft ? ` (${vertrag.gesellschaft})` : ''}
+                </option>
+              ))}
+            </Select>
+          </Feld>
+        )}
+
+        {belegId === '' && vertragId === '' && (
           <Feld
             id="belegFehltBegruendung"
             beschriftung="Warum fehlt der Beleg?"

src/components/finanzen/wiederkehrend-aktionen.tsx

@@ -2,12 +2,13 @@
 
 import * as React from 'react'
 import { useActionState } from 'react'
-import { AlertCircle, CheckCircle2, Undo2, XCircle } from 'lucide-react'
+import { AlertCircle, CheckCircle2, Link2, Undo2, XCircle } from 'lucide-react'
 import { Alert, AlertDescription } from '@/components/ui/alert'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
 import { Absendeknopf } from '@/components/finanzen/eingaben'
 import {
+  zahlungenVertragZuordnen,
   zahlungsgruppeAbhaken,
   zahlungsgruppeZurueckholen,
   type Formularzustand,
@@ -126,3 +127,51 @@ export function Rueckmeldung({ text }: { text: string | null }) {
     </Alert>
   )
 }
+
+/**
+ * Ordnet alle noch offenen Buchungen einer Gruppe dem Vertrag zu.
+ *
+ * Der Sinn dieses Knopfes ist die Menge: Eine monatliche Prämie über drei
+ * Jahre sind 36 Buchungen. Sie einzeln anzuklicken wäre genau die stumpfe
+ * Arbeit, die diese Zuordnung abschaffen soll.
+ */
+export function ZahlungenZuordnen({
+  betreuteId,
+  vertragId,
+  vertragBezeichnung,
+  buchungIds,
+}: {
+  betreuteId: string
+  vertragId: string
+  vertragBezeichnung: string
+  buchungIds: string[]
+}) {
+  const [zustand, absenden] = useActionState<Formularzustand, FormData>(
+    zahlungenVertragZuordnen,
+    {},
+  )
+
+  if (buchungIds.length === 0) return null
+
+  return (
+    <form action={absenden} className="flex flex-wrap items-center gap-2">
+      <input type="hidden" name="betreuteId" value={betreuteId} />
+      <input type="hidden" name="vertragId" value={vertragId} />
+      <input type="hidden" name="buchungIds" value={buchungIds.join(',')} />
+
+      {zustand.fehler && (
+        <span className="text-xs text-destructive">{zustand.fehler}</span>
+      )}
+      {zustand.erfolg && (
+        <span className="text-xs text-ampel-gruen">{zustand.erfolg}</span>
+      )}
+
+      <Absendeknopf variant="outline" size="sm" wartetext="Wird zugeordnet …">
+        <Link2 aria-hidden="true" />
+        {buchungIds.length} Zahlung{buchungIds.length === 1 ? '' : 'en'} als belegt zuordnen
+      </Absendeknopf>
+
+      <span className="text-xs text-muted-foreground">zu „{vertragBezeichnung}“</span>
+    </form>
+  )
+}

src/lib/berichte/gemeinsam.ts

@@ -1,4 +1,5 @@
 import 'server-only'
+import type { Prisma } from '@prisma/client'
 import type { Betreute, User } from '@prisma/client'
 import { db, nichtGeloescht } from '@/lib/db'
 import { protokollieren } from '@/lib/audit'
@@ -85,6 +86,62 @@ export function berichtskopf(eingabe: {
 // Laden
 // -----------------------------------------------------------------------------
 
+/**
+ * Was eine Buchung mitbringen muss, damit sich daraus eine BuchungEingabe
+ * bauen laesst.
+ *
+ * Steht hier und nicht in jeder Seite einzeln: Die Buchungsliste hatte
+ * lange eine eigene, fast gleiche Abfrage. Als die Dauerzahlungen
+ * dazukamen, wurde nur eine der beiden nachgezogen - und in der Liste
+ * stand weiter "Beleg fehlt", obwohl der Vertrag hinterlegt war. Ein
+ * gemeinsamer Einbezug kann nicht halb vergessen werden.
+ */
+export const BUCHUNG_EINBEZUG = {
+  konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
+  beleg: { select: { id: true, titel: true } },
+  // Bei einer Dauerzahlung ist der Vertrag der Beleg, und sein Beitrag ist
+  // der Massstab fuer die Betragspruefung.
+  vertrag: {
+    select: {
+      id: true,
+      bezeichnung: true,
+      beitragCent: true,
+      rhythmus: true,
+      vertragsnummerVerschluesselt: true,
+    },
+  },
+} as const
+
+type BuchungMitBezug = Prisma.BuchungGetPayload<{ include: typeof BUCHUNG_EINBEZUG }>
+
+/** Wandelt eine geladene Zeile in die Form um, mit der die Auswertung rechnet. */
+export function zuBuchungEingabe(zeile: BuchungMitBezug): BuchungEingabe {
+  const offen = oeffnen('Buchung', zeile)
+  return {
+    id: zeile.id,
+    datum: zeile.datum,
+    betragCent: zeile.betragCent,
+    richtung: zeile.richtung,
+    kategorie: zeile.kategorie,
+    gegenstelle: zeile.gegenstelle,
+    verwendungszweck: offen.verwendungszweck,
+    kontoId: zeile.kontoId,
+    kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
+    belegId: zeile.belegId,
+    belegTitel: zeile.beleg?.titel ?? null,
+    belegFehltBegruendung: zeile.belegFehltBegruendung,
+    vertragId: zeile.vertragId,
+    vertragBezeichnung: zeile.vertrag?.bezeichnung ?? null,
+    vertragsnummer: zeile.vertrag ? oeffnen('Vertrag', zeile.vertrag).vertragsnummer : null,
+    vertragBeitragCent: zeile.vertrag?.beitragCent ?? null,
+    vertragRhythmus: zeile.vertrag?.rhythmus ?? null,
+    vertragAutomatisch: zeile.vertragAutomatisch,
+    betrifftBetreute: zeile.betrifftBetreute,
+    vermoegenswirksam: zeile.vermoegenswirksam,
+    aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
+  }
+}
+
 /**
  * Alle Buchungen einer betreuten Person, entschluesselt und um die
  * Angaben ergaenzt, die die Auswertung braucht (Kontoname, Belegtitel,
@@ -102,33 +159,11 @@ export async function buchungenLaden(
         ? { datum: { gte: alsTag(zeitraum.von), lte: alsTag(zeitraum.bis) } }
         : {}),
     },
-    include: {
+    include: BUCHUNG_EINBEZUG,
-      konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
-      beleg: { select: { id: true, titel: true } },
-    },
     orderBy: [{ datum: 'asc' }, { erstelltAm: 'asc' }],
   })
 
-  return zeilen.map((zeile) => {
+  return zeilen.map(zuBuchungEingabe)
-    const offen = oeffnen('Buchung', zeile)
-    return {
-      id: zeile.id,
-      datum: zeile.datum,
-      betragCent: zeile.betragCent,
-      richtung: zeile.richtung,
-      kategorie: zeile.kategorie,
-      gegenstelle: zeile.gegenstelle,
-      verwendungszweck: offen.verwendungszweck,
-      kontoId: zeile.kontoId,
-      kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
-      belegId: zeile.belegId,
-      belegTitel: zeile.beleg?.titel ?? null,
-      belegFehltBegruendung: zeile.belegFehltBegruendung,
-      betrifftBetreute: zeile.betrifftBetreute,
-      vermoegenswirksam: zeile.vermoegenswirksam,
-      aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
-    }
-  })
 }
 
 /** Konten mit ihrer vollstaendigen Saldostand-Historie. */

src/lib/berichte/rechnungslegung.tsx

@@ -444,6 +444,15 @@ export function RechnungslegungDokument({
                 <View style={stile.mittel}>
                   {beleg.belegTitel ? (
                     <Text style={stile.klein}>{beleg.belegTitel}</Text>
+                  ) : beleg.vertragBezeichnung ? (
+                    <Text style={stile.klein}>
+                      Dauerzahlung zu Vertrag „{beleg.vertragBezeichnung}“
+                      {beleg.vertragsnummer ? `, Nr. ${beleg.vertragsnummer}` : ''}
+                    </Text>
+                  ) : beleg.betragZuPruefen ? (
+                    <Text style={[stile.klein, stile.fett]}>
+                      Beleg fehlt – Betrag weicht vom Vertrag ab
+                    </Text>
                   ) : beleg.belegFehltBegruendung ? (
                     <Text style={stile.klein}>
                       ohne Beleg – {beleg.belegFehltBegruendung}

src/lib/dashboard/laden.ts

@@ -167,7 +167,17 @@ export async function dashboardLaden(
     // 5b. Buchungen ohne Beleg und ohne Begruendung - Belegzwang.
     darfFinanzen
       ? db.buchung.findMany({
-          where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
+          where: {
+            betreuteId,
+            belegId: null,
+            belegFehltBegruendung: null,
+            // Dauerzahlungen sind durch ihren Vertrag belegt - sie gehoeren
+            // nicht in die Liste der offenen Belege. Die Betragspruefung
+            // laeuft erst spaeter auf den geladenen Zeilen; hier wird nur
+            // grob vorgefiltert.
+            vertragId: null,
+            ...nichtGeloescht,
+          },
           orderBy: { datum: 'desc' },
           take: KACHEL_ZEILEN,
           select: {
@@ -182,7 +192,17 @@ export async function dashboardLaden(
       : null,
     darfFinanzen
       ? db.buchung.count({
-          where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
+          where: {
+            betreuteId,
+            belegId: null,
+            belegFehltBegruendung: null,
+            // Dauerzahlungen sind durch ihren Vertrag belegt - sie gehoeren
+            // nicht in die Liste der offenen Belege. Die Betragspruefung
+            // laeuft erst spaeter auf den geladenen Zeilen; hier wird nur
+            // grob vorgefiltert.
+            vertragId: null,
+            ...nichtGeloescht,
+          },
         })
       : null,
 

src/lib/finanzen/kassenbuch.ts

@@ -1,4 +1,4 @@
-import type { BuchungKategorie, BuchungRichtung } from '@prisma/client'
+import type { BuchungKategorie, BuchungRichtung, ZahlRhythmus } from '@prisma/client'
 import { summe, teileGerundet } from '@/lib/finanzen/betrag'
 import { alsTag, imZeitraum, nachTagSortieren } from '@/lib/finanzen/datum'
 import {
@@ -39,6 +39,15 @@ export type BuchungEingabe = {
   belegId: string | null
   belegTitel?: string | null
   belegFehltBegruendung: string | null
+  /** Dauerzahlung zu einem Vertrag - dann ist der Vertrag der Beleg. */
+  vertragId?: string | null
+  vertragBezeichnung?: string | null
+  vertragsnummer?: string | null
+  /** Hinterlegter Beitrag samt Zahlweise - Grundlage der Betragspruefung. */
+  vertragBeitragCent?: bigint | null
+  vertragRhythmus?: ZahlRhythmus | null
+  /** Wurde die Zuordnung beim Import automatisch gesetzt? */
+  vertragAutomatisch?: boolean
   betrifftBetreute: boolean
   vermoegenswirksam: boolean
   /** Laeuft die Buchung ueber ein Konto des Betreuers? */
@@ -54,24 +63,134 @@ export function istVermoegensbuchung(buchung: BuchungEingabe): boolean {
 // Belegzwang
 // -----------------------------------------------------------------------------
 
+/**
+ * Wie weit darf die Zahlung vom hinterlegten Beitrag abweichen?
+ *
+ * Ein Fuenftel. Das ist grosszuegig und mit Absicht: Beitragsanpassungen,
+ * Versicherungsteuer und ein nachtraeglich geaenderter Selbstbehalt bewegen
+ * sich in dieser Groessenordnung, und bei jeder davon soll die Anwendung
+ * nicht meckern.
+ *
+ * Was sie fangen soll, ist die andere Groessenordnung: die Praemie, die von
+ * 42 auf 420 Euro springt, oder die Lastschrift, die versehentlich zweimal
+ * lief. Wer die Grenze enger zieht, bekommt taeglich Warnungen und sieht
+ * die eine wichtige nicht mehr.
+ */
+export const BETRAGS_TOLERANZ_PROZENT = 20n
+
+/**
+ * Passt der Betrag zu dem, was am Vertrag steht?
+ *
+ * Verglichen wird gegen den hinterlegten Beitrag, unveraendert. Kein
+ * Umrechnen auf andere Zahlweisen.
+ *
+ * Der erste Entwurf tat genau das - Jahresbetrag bilden und gegen
+ * jaehrlich, halbjaehrlich, vierteljaehrlich und monatlich pruefen, damit
+ * es auch passt, wenn die Bank anders abbucht als der Vertrag es fuehrt.
+ * Das Ergebnis war ein Toleranzband mit vier Loechern: Bei einem
+ * Monatsbeitrag von 42,50 EUR liegen 420 EUR innerhalb von 20 Prozent des
+ * Jahresbetrags von 510 EUR. Ausgerechnet der Fall, vor dem diese Pruefung
+ * schuetzen soll, waere durchgerutscht.
+ *
+ * Bucht die Bank tatsaechlich jaehrlich ab, waehrend am Vertrag "monatlich"
+ * steht, dann stimmen die Vertragsdaten nicht - und dann soll die
+ * Buchung als "zu pruefen" auffallen, statt stillschweigend akzeptiert zu
+ * werden. Die Zahlweise am Vertrag zu berichtigen dauert zehn Sekunden und
+ * macht die Akte richtiger.
+ *
+ * Ohne hinterlegten Beitrag gibt es nichts zu vergleichen - dann lautet die
+ * Antwort "unbekannt" (null), nicht "in Ordnung". Der Unterschied zaehlt:
+ * Es soll nicht so aussehen, als waere geprueft worden.
+ */
+export function betragPasstZumVertrag(
+  betragCent: bigint,
+  beitragCent: bigint | null | undefined,
+  rhythmus: ZahlRhythmus | null | undefined,
+): boolean | null {
+  if (beitragCent === null || beitragCent === undefined || beitragCent <= 0n) return null
+  // Zu einer Einmalzahlung gibt es keine wiederkehrende Rate, gegen die
+  // sich vergleichen liesse.
+  if (!rhythmus || rhythmus === 'EINMALIG') return null
+
+  const betrag = betragCent < 0n ? -betragCent : betragCent
+  const abweichung = betrag > beitragCent ? betrag - beitragCent : beitragCent - betrag
+
+  return abweichung * 100n <= beitragCent * BETRAGS_TOLERANZ_PROZENT
+}
+
+/**
+ * Ist die Buchung durch einen Vertrag belegt?
+ *
+ * Bei einem Dauerschuldverhaeltnis ist der Vertrag der Beleg - fuer zwoelf
+ * gleiche Lastschriften gibt es keine zwoelf Quittungen, sondern eine
+ * Police.
+ *
+ * Die Anerkennung faellt weg, sobald der Betrag deutlich abweicht. Sonst
+ * waere die Zuordnung eine Hintertuer, durch die auch eine verdreifachte
+ * Praemie unbemerkt als "belegt" durchginge.
+ */
+export function belegDurchVertrag(buchung: BuchungEingabe): boolean {
+  if (buchung.belegId) return false
+  if (!buchung.vertragId) return false
+  return (
+    betragPasstZumVertrag(
+      buchung.betragCent,
+      buchung.vertragBeitragCent,
+      buchung.vertragRhythmus,
+    ) !== false
+  )
+}
+
+/**
+ * Zugeordnet, aber der Betrag passt nicht - das will jemand ansehen.
+ *
+ * Kein Fehler und kein Vorwurf: Meistens ist es eine Beitragsanpassung, die
+ * am Vertrag noch nicht nachgetragen wurde. Genau deshalb steht sie hier
+ * und nicht wortlos unter "Beleg fehlt".
+ */
+export function betragPruefen(buchung: BuchungEingabe): boolean {
+  if (buchung.belegId) return false
+  if (!buchung.vertragId) return false
+  return (
+    betragPasstZumVertrag(
+      buchung.betragCent,
+      buchung.vertragBeitragCent,
+      buchung.vertragRhythmus,
+    ) === false
+  )
+}
+
 /**
  * Fehlt der Beleg? Eine Begruendung heilt das Fehlen fuer die Statistik,
  * nicht fuer den Aktenordner - aber sie beantwortet die Frage des
  * Rechtspflegers "und wo ist der Beleg?" schon vorab.
  */
 export function belegFehlt(buchung: BuchungEingabe): boolean {
-  return !buchung.belegId && !(buchung.belegFehltBegruendung ?? '').trim()
+  if (buchung.belegId) return false
+  if (belegDurchVertrag(buchung)) return false
+  return !(buchung.belegFehltBegruendung ?? '').trim()
 }
 
 export function belegBegruendet(buchung: BuchungEingabe): boolean {
-  return !buchung.belegId && (buchung.belegFehltBegruendung ?? '').trim() !== ''
+  if (buchung.belegId) return false
+  if (belegDurchVertrag(buchung)) return false
+  return (buchung.belegFehltBegruendung ?? '').trim() !== ''
 }
 
 export type Belegquote = {
   gesamt: number
   mitBeleg: number
+  /**
+   * Dauerzahlung zu einem Vertrag - eigene Kategorie, NICHT eingerechnet in
+   * "begruendet". Ein Vertrag belegt, eine Begruendung erklaert nur; das
+   * zusammenzuwerfen nimmt der Zahl ihre Aussage gegenueber dem
+   * Rechtspfleger.
+   */
+  durchVertrag: number
   begruendet: number
   ohneNachweis: number
+  /** Zugeordnet, aber der Betrag weicht ab. Teilmenge von ohneNachweis. */
+  zuPruefen: number
   /** 0 bis 100, ganzzahlig. Bei null Buchungen: 100 - es fehlt ja nichts. */
   quoteProzent: number
 }
@@ -79,11 +198,13 @@ export type Belegquote = {
 export function belegquote(buchungen: BuchungEingabe[]): Belegquote {
   const gesamt = buchungen.length
   const mitBeleg = buchungen.filter((b) => Boolean(b.belegId)).length
+  const durchVertrag = buchungen.filter((b) => belegDurchVertrag(b)).length
   const begruendet = buchungen.filter((b) => belegBegruendet(b)).length
   const ohneNachweis = buchungen.filter((b) => belegFehlt(b)).length
+  const zuPruefen = buchungen.filter((b) => betragPruefen(b)).length
   const quoteProzent =
-    gesamt === 0 ? 100 : Math.round(((mitBeleg + begruendet) / gesamt) * 100)
+    gesamt === 0 ? 100 : Math.round(((mitBeleg + durchVertrag + begruendet) / gesamt) * 100)
-  return { gesamt, mitBeleg, begruendet, ohneNachweis, quoteProzent }
+  return { gesamt, mitBeleg, durchVertrag, begruendet, ohneNachweis, zuPruefen, quoteProzent }
 }
 
 /**

src/lib/finanzen/rechnungslegung.ts

@@ -3,7 +3,9 @@ import { alsTag, imZeitraum, nachTagSortieren, tagePlus, vorOderGleich } from '@
 import type { Betreuungsjahr } from '@/lib/finanzen/betreuungsjahr'
 import {
   ausgabenGruppiert,
+  belegDurchVertrag,
   belegFehlt,
+  betragPruefen,
   einnahmenGruppiert,
   istVermoegensbuchung,
   belegquote,
@@ -158,6 +160,16 @@ export type Belegzeile = {
   belegId: string | null
   belegTitel: string | null
   belegFehltBegruendung: string | null
+  /**
+   * Dauerzahlung zu einem Vertrag. Steht im Bericht anstelle von
+   * "Beleg fehlt" - die Luecke wird damit nicht versteckt, sondern
+   * erklaert: Wer nachpruefen will, weiss, welches Papier er aus dem
+   * Ordner holt.
+   */
+  vertragBezeichnung: string | null
+  vertragsnummer: string | null
+  /** Zugeordnet, aber der Betrag weicht ab - im Bericht ausgewiesen. */
+  betragZuPruefen: boolean
   fehlt: boolean
 }
 
@@ -179,6 +191,9 @@ export function beleglisteErstellen(buchungen: BuchungEingabe[]): Belegzeile[] {
     belegId: buchung.belegId,
     belegTitel: buchung.belegTitel ?? null,
     belegFehltBegruendung: buchung.belegFehltBegruendung,
+    vertragBezeichnung: belegDurchVertrag(buchung) ? (buchung.vertragBezeichnung ?? null) : null,
+    vertragsnummer: belegDurchVertrag(buchung) ? (buchung.vertragsnummer ?? null) : null,
+    betragZuPruefen: betragPruefen(buchung),
     fehlt: belegFehlt(buchung),
   }))
 }

src/lib/finanzen/wiederkehrend-laden.ts

@@ -40,7 +40,13 @@ export async function wiederkehrendLaden(betreuteId: string): Promise<Wiederkehr
         betrifftBetreute: true,
         ...nichtGeloescht,
       },
-      select: { id: true, datum: true, betragCent: true, gegenstelle: true },
+      select: {
+        id: true,
+        datum: true,
+        betragCent: true,
+        gegenstelle: true,
+        vertragId: true,
+      },
       orderBy: { datum: 'asc' },
     }),
     db.vertrag.findMany({

src/lib/finanzen/wiederkehrend.ts

@@ -32,6 +32,8 @@ export type ZahlungEingabe = {
   datum: Date
   betragCent: bigint
   gegenstelle: string | null
+  /** Haengt die Buchung schon an einem Vertrag? (Issue #11) */
+  vertragId?: string | null
 }
 
 /** Ein hinterlegter Vertrag - zum Abgleich, ob die Zahlung schon erklaert ist. */
@@ -94,6 +96,14 @@ export type Zahlungsgruppe = {
   vertragId: string | null
   vertragBezeichnung: string | null
   buchungIds: string[]
+  /**
+   * Wie viele Buchungen der Gruppe haengen bereits an einem Vertrag?
+   * Grundlage fuer die Sammelzuordnung: Nur der Rest muss noch verknuepft
+   * werden.
+   */
+  bereitsZugeordnet: number
+  /** Buchungen der Gruppe ohne Vertragsbezug. */
+  offeneBuchungIds: string[]
 }
 
 // -----------------------------------------------------------------------------
@@ -366,6 +376,8 @@ export function gruppieren(
       vertragId: vertrag?.id ?? null,
       vertragBezeichnung: vertrag?.bezeichnung ?? null,
       buchungIds: sortiert.map((p) => p.id),
+      bereitsZugeordnet: posten.filter((p) => Boolean(p.vertragId)).length,
+      offeneBuchungIds: sortiert.filter((p) => !p.vertragId).map((p) => p.id),
     })
   }
 
@@ -506,6 +518,28 @@ export function alsZahlRhythmus(rhythmus: Rhythmus): string | null {
   }
 }
 
+/**
+ * Sucht den Vertrag, zu dem eine Gegenstelle EINDEUTIG passt.
+ *
+ * Gedacht fuer die automatische Zuordnung beim Import. Die Betonung liegt
+ * auf eindeutig: Passen zwei Vertraege (Hausrat und Haftpflicht bei
+ * derselben Gesellschaft), wird nichts zugeordnet. Eine falsche Zuordnung
+ * waere schlimmer als gar keine - sie behauptet einen Beleg, den es nicht
+ * gibt, und niemand sieht noch einmal hin.
+ *
+ * Gibt null zurueck, wenn nichts oder mehr als eines passt.
+ */
+export function eindeutigerVertrag(
+  gegenstelle: string | null | undefined,
+  vertraege: VertragAbgleich[],
+): VertragAbgleich | null {
+  const schluessel = normalisieren(gegenstelle)
+  if (!schluessel) return null
+
+  const treffer = vertraege.filter((vertrag) => normalisieren(vertrag.gesellschaft) === schluessel)
+  return treffer.length === 1 ? treffer[0]! : null
+}
+
 /** Wie viele Gruppen warten noch auf eine Entscheidung? Fuer das Dashboard. */
 export function offeneKandidaten(gruppen: Zahlungsgruppe[]): number {
   return gruppen.filter((gruppe) => gruppe.vertragId === null).length

src/lib/validierung/finanzen.ts

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

src/lib/version.ts

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

src/server/actions/finanzen.ts

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

tests/dauerzahlung.test.ts

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

tests/wiederkehrend.test.ts

@@ -8,6 +8,7 @@ import {
   einzelneZahlungen,
   gruppieren,
   normalisieren,
+  eindeutigerVertrag,
   offeneKandidaten,
   rhythmusAusAbstand,
   rhythmusErklaerung,
@@ -281,6 +282,22 @@ describe('Gruppieren', () => {
     expect(gruppen[0]!.jahresbetragCent).toBe(30_000n)
   })
 
+  it('sagt, wie viele Zahlungen der Gruppe schon an einem Vertrag hängen', () => {
+    // Grundlage der Sammelzuordnung (Issue #11): Nur der Rest muss noch
+    // verknüpft werden, nicht alles noch einmal.
+    const zahlungen = monatlich('Debeka AG', 30, 4)
+    zahlungen[0]!.vertragId = 'v1'
+    zahlungen[1]!.vertragId = 'v1'
+
+    const gruppe = gruppieren(zahlungen, {
+      vertraege: [{ id: 'v1', bezeichnung: 'Krankenzusatz', gesellschaft: 'Debeka' }],
+    })[0]!
+
+    expect(gruppe.anzahl).toBe(4)
+    expect(gruppe.bereitsZugeordnet).toBe(2)
+    expect(gruppe.offeneBuchungIds).toHaveLength(2)
+  })
+
   it('zählt für das Dashboard nur ungeklärte Gruppen', () => {
     const gruppen = gruppieren(
       [...monatlich('Debeka AG', 30, 4), ...monatlich('Unbekannt Versicherung', 20, 4)],
@@ -351,3 +368,28 @@ describe('Erklärung unter der Gruppe', () => {
     expect(rhythmusErklaerung(gruppe)).toContain('ohne erkennbaren Abstand')
   })
 })
+
+describe('Eindeutige Vertragszuordnung beim Import', () => {
+  const vertraege = [
+    { id: 'v1', bezeichnung: 'Hausrat', gesellschaft: 'Allianz Versicherung' },
+    { id: 'v2', bezeichnung: 'Haftpflicht', gesellschaft: 'Allianz Versicherung' },
+    { id: 'v3', bezeichnung: 'Krankenzusatz', gesellschaft: 'Debeka AG' },
+  ]
+
+  it('ordnet zu, wenn genau ein Vertrag passt', () => {
+    expect(eindeutigerVertrag('Debeka', vertraege)?.id).toBe('v3')
+  })
+
+  it('ordnet NICHT zu, wenn zwei Verträge zur selben Gesellschaft gehören', () => {
+    // Hausrat und Haftpflicht bei derselben Gesellschaft. Eine falsche
+    // Zuordnung wäre schlimmer als gar keine — sie behauptet einen Beleg,
+    // und niemand sieht noch einmal hin.
+    expect(eindeutigerVertrag('Allianz Versicherung', vertraege)).toBeNull()
+  })
+
+  it('ordnet nichts zu, wenn nichts passt', () => {
+    expect(eindeutigerVertrag('Stadtwerke Bamberg', vertraege)).toBeNull()
+    expect(eindeutigerVertrag(null, vertraege)).toBeNull()
+    expect(eindeutigerVertrag('', vertraege)).toBeNull()
+  })
+})