Dauerzahlungen zu einem Vertrag gelten als belegt

Bei einer monatlichen Praemie gibt es keinen Beleg - es gibt einen Vertrag, und der wird einmal abgeschlossen, nicht monatlich quittiert. Bisher blieb nur ein Freitextfeld pro Buchung: zwoelfmal im Jahr derselbe Satz, mal Anzahl der Vertraege. Buchung.vertragId mit onDelete: SetNull. Der Belegzustand kennt jetzt drei Faelle statt zwei, getrennt ausgewiesen - ein Vertrag belegt, eine Begruendung erklaert nur; zusammengeworfen verliert die Belegquote ihre Aussage gegenueber dem Rechtspfleger. Dazu: automatische Zuordnung beim Import bei eindeutiger Gegenstelle, Sammelzuordnung ueber die Gruppen aus Issue #3, und die Rechnungslegung nennt den Vertrag samt Nummer statt "ohne Beleg". Die Sicherung dagegen: Weicht der Betrag um mehr als ein Fuenftel vom hinterlegten Beitrag ab, faellt die Anerkennung weg und die Buchung wird als "Betrag pruefen" markiert. Sonst waere die Zuordnung eine Hintertuer. Zur Toleranz - ein Entwurf und seine Korrektur: Zuerst verglich ich den Betrag gegen alle ueblichen Zahlweisen, damit es auch passt, wenn die Bank anders abbucht als der Vertrag es fuehrt. Der eigene Test hat das widerlegt: Bei 42,50 monatlich liegen 420 innerhalb von 20 Prozent des Jahresbetrags von 510 - ausgerechnet der Fall aus der Aufgabenstellung waere durchgerutscht. Jetzt wird stur gegen den hinterlegten Beitrag verglichen. Bucht die Bank anders ab, stimmen die Vertragsdaten nicht, und das soll auffallen. Behoben: Die Buchungsliste hatte eine eigene, fast gleiche Datenabfrage neben der aus berichte/gemeinsam.ts. Nur eine von beiden wurde nachgezogen, in der Liste stand weiter "Beleg fehlt". Beide benutzen jetzt BUCHUNG_EINBEZUG und zuBuchungEingabe - das kann nicht halb vergessen werden. Gefunden hat es der Browsertest. Nebenbei: Die Roadmap trug noch "Aktuelle Fassung 1.1.2" - Nachwirkung der parallelen Bearbeitung von #3 und #10. Nachgezogen wie zugesagt. Geprueft: 23 neue Einheitstests, die Haelfte davon darauf gerichtet, dass die Anerkennung auch wirklich wegfaellt. Fuenf End-to-End-Tests auf beiden Geraeteprofilen. 560 Unit-Tests, 63 e2e, null Typfehler. Refs #11
2026-08-23 09:00:46 +02:00
parent 8779cc6a25
commit fa994350d6
28 changed files with 1105 additions and 96 deletions
@@ -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,
@@ -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())}
      />
@@ -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: {
-        konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
-        beleg: { select: { id: true, titel: true } },
-      },
+      include: BUCHUNG_EINBEZUG,
      orderBy: [{ datum: 'desc' }, { erstelltAm: 'desc' }],
      take: HOECHSTZAHL,
    }),
@@ -97,26 +94,7 @@ export default async function BuchungenSeite({
    }),
  ])

-  const buchungen: BuchungEingabe[] = zeilen.map((zeile) => {
-    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 buchungen: BuchungEingabe[] = zeilen.map(zuBuchungEingabe)

  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">
@@ -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.ohneNachweis} Buchung(en) ohne Beleg und ohne Begründung`
-              : 'Alle Buchungen sind belegt oder begründet'
+            zahlen.beleg.zuPruefen > 0
+              ? `${zahlen.beleg.zuPruefen} Zahlung(en) weichen vom hinterlegten Beitrag ab`
+              : 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">
@@ -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
-                      key={gruppe.schluessel}
-                      className="flex flex-wrap items-center justify-between gap-2 py-2"
-                    >
-                      <span>
-                        <span className="font-medium">{gruppe.anzeigename}</span>
-                        <span className="ml-2 text-muted-foreground">
-                          {RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]},{' '}
-                          {formatCent(centZuZahl(gruppe.jahresbetragCent))} im Jahr
+                    <li key={gruppe.schluessel} className="space-y-2 py-2">
+                      <div className="flex flex-wrap items-center justify-between gap-2">
+                        <span>
+                          <span className="font-medium">{gruppe.anzeigename}</span>
+                          <span className="ml-2 text-muted-foreground">
+                            {RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]},{' '}
+                            {formatCent(centZuZahl(gruppe.jahresbetragCent))} im Jahr
+                          </span>
                        </span>
-                      </span>
-                      <Button asChild variant="ghost" size="sm">
-                        <Link href={`/vertraege/${gruppe.vertragId}`}>
-                          {gruppe.vertragBezeichnung}
-                        </Link>
-                      </Button>
+                        <Button asChild variant="ghost" size="sm">
+                          <Link href={`/vertraege/${gruppe.vertragId}`}>
+                            {gruppe.vertragBezeichnung}
+                          </Link>
+                        </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>
@@ -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}>
@@ -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?"
@@ -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>
+  )
+}
@@ -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: {
-      konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
-      beleg: { select: { id: true, titel: true } },
-    },
+    include: BUCHUNG_EINBEZUG,
    orderBy: [{ datum: 'asc' }, { erstelltAm: 'asc' }],
  })

-  return zeilen.map((zeile) => {
-    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,
-    }
-  })
+  return zeilen.map(zuBuchungEingabe)
 }

 /** Konten mit ihrer vollstaendigen Saldostand-Historie. */
@@ -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}
@@ -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,

@@ -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)
-  return { gesamt, mitBeleg, begruendet, ohneNachweis, quoteProzent }
+    gesamt === 0 ? 100 : Math.round(((mitBeleg + durchVertrag + begruendet) / gesamt) * 100)
+  return { gesamt, mitBeleg, durchVertrag, begruendet, ohneNachweis, zuPruefen, quoteProzent }
 }

 /**
@@ -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),
  }))
 }
@@ -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({
@@ -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
@@ -229,6 +229,7 @@ export const buchungSchema = z
    verwendungszweck: optionalerText(500),
    belegId: optionaleId,
    belegFehltBegruendung: optionalerText(300),
+    vertragId: optionaleId,
    betrifftBetreute: schalter,
    vermoegenswirksam: schalter,
  })
@@ -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:
@@ -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.' }
+  }
+}