diff --git a/docs/schema-wuensche/fristen.md b/docs/schema-wuensche/fristen.md
new file mode 100644
index 0000000..bcfa2af
--- /dev/null
+++ b/docs/schema-wuensche/fristen.md
@@ -0,0 +1,86 @@
+# Schema-Wünsche aus dem Modul „Fristen & Kalender"
+
+Das Modul ist vollständig mit dem bestehenden `model Frist` umgesetzt —
+nichts davon blockiert. Die folgenden Punkte sind Verbesserungen, die
+jeweils eine Behelfslösung ersetzen würden. `prisma/schema.prisma` wurde
+nicht angefasst.
+
+---
+
+## 1. Getrennte Felder für Erledigungsnotiz, Verschiebungs- und Entfallgrund
+
+**Behelf heute:** Beim Erledigen, Verschieben und Entfallenlassen hängen die
+Server Actions den Grund als Textzeile an `beschreibung` an
+(`"Verschoben vom 14.03.2026: Unterlagen fehlten noch."`).
+
+**Warum das stört:** `beschreibung` ist der Text, der sagt, *was zu tun
+ist* — er wandert unverändert in den ICS-Feed und in die Vorwarnungen. Mit
+angehängter Historie wird er über die Jahre unlesbar, und die Ableitung der
+Pflichtfristen überschreibt ihn bei offenen Fristen ohnehin wieder (dann
+ist die Notiz weg). Ausserdem lässt sich nicht auswerten, wie oft eine
+Frist verschoben wurde — genau die Zahl, die im Jahresbericht auffällt.
+
+**Wunsch:**
+
+```prisma
+/// Freitext beim Abhaken: wie wurde erledigt, was ging raus, an wen.
+erledigtNotiz     String?
+/// Grund der letzten Verschiebung bzw. des Entfallens.
+statusGrund       String?
+/// Wie oft wurde diese Frist schon verschoben? Fuer die Selbstkontrolle.
+verschobenAnzahl  Int      @default(0)
+```
+
+---
+
+## 2. Wer hat die Frist erledigt?
+
+**Behelf heute:** Steht nur im Audit-Log (`AuditLog.userId`).
+
+**Warum das stört:** Für die Anzeige („erledigt am 14.03. von Florian
+Wilde") müsste die Liste für jede Frist im Audit-Log nachschlagen. Bei
+mehreren Betreuern oder einem mitlesenden Geschwisterteil ist das die erste
+Frage, die gestellt wird.
+
+**Wunsch:** analog zu `Vorgang.angelegtVonId`
+
+```prisma
+erledigtVonId String?
+erledigtVon   User?   @relation("FristErledigtVon", fields: [erledigtVonId], references: [id], onDelete: SetNull)
+```
+
+---
+
+## 3. `vorgaengerFristId` ist `@unique` — die Kette ist einspurig
+
+**Behelf heute:** Funktioniert für den Normalfall (eine erledigte Frist →
+genau eine Nachfolgefrist).
+
+**Warum das stört:** Beim Verschieben *und* bei der Wiederholung zeigt die
+neue Frist auf dieselbe Vorgängerin. Wird eine verschobene Frist später
+irrtümlich noch einmal verschoben, läuft das in eine Verletzung der
+Eindeutigkeit statt in eine verständliche Meldung. Ein einfacher `@@index`
+statt `@unique` würde reichen; die Kette bliebe über `vorgaengerFristId`
+weiterhin rückwärts lesbar.
+
+---
+
+## 4. Kein Feld für den Kalender-Token — bewusst so
+
+Zur Klarstellung, damit niemand später eines nachrüstet: Der abonnierbare
+ICS-Feed kommt **ohne** Schemafeld aus. Die Adresse trägt eine Signatur
+`base64url(<betreuteId>.<userId>.<HMAC-SHA256>)`, berechnet mit
+`AUTH_SECRET` (siehe `src/lib/fristen/ics.ts`).
+
+Vorteil: Es liegt kein dauerhaft gültiges Geheimnis in der Datenbank, das
+bei einem Datenbank-Leck mitgelesen werden könnte. Die Route prüft bei
+jedem Abruf zusätzlich, ob der Benutzer noch aktiv ist und noch Lesezugriff
+auf das Modul `FRISTEN` hat — ein entzogener Zugang leert den Kalender
+sofort.
+
+Nachteil, der in Kauf genommen wird: Eine einzelne Adresse lässt sich nicht
+gezielt widerrufen, nur durch Wechsel von `AUTH_SECRET` (was alle
+Anmeldungen beendet). Falls das je gebraucht wird, wäre ein
+`kalenderGeneration Int @default(0)` an `BetreuungsZugang` die kleinste
+Lösung: Sie geht in den HMAC ein, und ein Hochzählen entwertet nur die
+Adressen dieses einen Zugangs.
diff --git a/src/components/fristen/erledigen-knopf.tsx b/src/components/fristen/erledigen-knopf.tsx
index 63ad53a..8fdaed2 100644
--- a/src/components/fristen/erledigen-knopf.tsx
+++ b/src/components/fristen/erledigen-knopf.tsx
@@ -52,7 +52,7 @@ export function ErledigenKnopf({
         size={groesse}
         onClick={abhaken}
         disabled={laeuft}
-        aria-label={`Frist „${titel}" als erledigt abhaken`}
+        aria-label={`Frist „${titel}“ als erledigt abhaken`}
       >
         {laeuft ? (
           <Loader2 className="animate-spin" aria-hidden="true" />
diff --git a/src/lib/fristen/pflichtfristen.ts b/src/lib/fristen/pflichtfristen.ts
index f43148e..510aa74 100644
--- a/src/lib/fristen/pflichtfristen.ts
+++ b/src/lib/fristen/pflichtfristen.ts
@@ -314,7 +314,10 @@ export function pflichtfristenAbleiten(stammdaten: Pflichtfristenstammdaten): Pf
     ...kuenftige(jahresberichte, heute, anzahl),
     ...kuenftige(uebersichten, heute, anzahl),
     ...kuenftige(rueckkaufswerte, heute, anzahl),
-    ...kuenftige(pauschalen, heute, anzahl + 1),
+    // Die Pauschalen sind chronologisch sortiert - die noch laufende
+    // Ausschlussfrist des eben abgelaufenen Betreuungsjahres steht damit
+    // vorn und ueberlebt die Begrenzung auf jahreVoraus Termine.
+    ...kuenftige(pauschalen, heute, anzahl),
   )
 
   // --- Wiederkehrende Fristen am Kalenderjahr ------------------------------
diff --git a/tests/fristen.test.ts b/tests/fristen.test.ts
new file mode 100644
index 0000000..ed169f7
--- /dev/null
+++ b/tests/fristen.test.ts
@@ -0,0 +1,572 @@
+import { describe, expect, it } from 'vitest'
+import { fristAmpel } from '@/lib/fristen/ampel'
+import {
+  alsIsoTag,
+  ausIsoTag,
+  feiertagName,
+  istWochenende,
+  nichtWerktagHinweis,
+  plusMonate,
+  plusTage,
+  tag,
+} from '@/lib/fristen/datum'
+import {
+  alsIcsDatum,
+  icsErzeugen,
+  signaturErzeugen,
+  signaturPruefen,
+  textEscapen,
+  zeileFalten,
+} from '@/lib/fristen/ics'
+import {
+  betreuungsjahrBeginn,
+  betreuungsjahrEnde,
+  laufendesBetreuungsjahr,
+  pflichtfristenAbleiten,
+  type Pflichtfrist,
+} from '@/lib/fristen/pflichtfristen'
+import { naechsteFristAusErledigter, naechsterTermin, rruleGueltig } from '@/lib/fristen/wiederholung'
+
+/**
+ * Diese Tests beschreiben, was fachlich gelten soll - nicht, wie es
+ * programmiert ist. Sie kommen ohne Datenbank aus: geprueft wird die reine
+ * Rechenlogik, an der im Betreuungsalltag Geld und Ansprueche haengen.
+ */
+
+const STAMMDATEN = {
+  befreiterBetreuer: true,
+  ehrenamtlich: true,
+  pflegegrad: 3,
+}
+
+function schluessel(fristen: Pflichtfrist[]): string[] {
+  return fristen.map((f) => f.systemSchluessel)
+}
+
+function finde(fristen: Pflichtfrist[], gesucht: string): Pflichtfrist {
+  const treffer = fristen.find((f) => f.systemSchluessel === gesucht)
+  if (!treffer) throw new Error(`Frist "${gesucht}" wurde nicht abgeleitet.`)
+  return treffer
+}
+
+// -----------------------------------------------------------------------------
+
+describe('Betreuungsjahr', () => {
+  it('läuft ab dem Tag der Bestellung, nicht ab dem Kalenderjahr', () => {
+    const bestellung = tag(2025, 3, 15)
+    expect(alsIsoTag(betreuungsjahrBeginn(bestellung, 1))).toBe('2025-03-15')
+    expect(alsIsoTag(betreuungsjahrEnde(bestellung, 1))).toBe('2026-03-14')
+    expect(alsIsoTag(betreuungsjahrBeginn(bestellung, 2))).toBe('2026-03-15')
+    expect(alsIsoTag(betreuungsjahrEnde(bestellung, 2))).toBe('2027-03-14')
+  })
+
+  it('reicht über den Jahreswechsel, ohne auf den 31.12. zu springen', () => {
+    const bestellung = tag(2025, 11, 20)
+    expect(alsIsoTag(betreuungsjahrEnde(bestellung, 1))).toBe('2026-11-19')
+    expect(alsIsoTag(betreuungsjahrBeginn(bestellung, 3))).toBe('2027-11-20')
+    expect(alsIsoTag(betreuungsjahrEnde(bestellung, 3))).toBe('2028-11-19')
+  })
+
+  it('endet bei Bestellung am 29. Februar im Folgejahr am 28. Februar', () => {
+    // § 188 Abs. 3 BGB: Fehlt der massgebende Tag im letzten Monat, endet
+    // die Frist mit dem letzten Tag dieses Monats.
+    const bestellung = tag(2024, 2, 29)
+    expect(alsIsoTag(betreuungsjahrEnde(bestellung, 1))).toBe('2025-02-28')
+    expect(alsIsoTag(betreuungsjahrBeginn(bestellung, 2))).toBe('2025-03-01')
+    expect(alsIsoTag(betreuungsjahrEnde(bestellung, 2))).toBe('2026-02-28')
+  })
+
+  it('lässt kein Datum zwischen zwei Betreuungsjahren durchfallen', () => {
+    const bestellung = tag(2024, 2, 29)
+    for (let n = 1; n <= 8; n++) {
+      const ende = betreuungsjahrEnde(bestellung, n)
+      const naechsterBeginn = betreuungsjahrBeginn(bestellung, n + 1)
+      expect(alsIsoTag(naechsterBeginn)).toBe(alsIsoTag(plusTage(ende, 1)))
+    }
+  })
+
+  it('weiß, in welchem Betreuungsjahr ein Tag liegt', () => {
+    const bestellung = tag(2025, 3, 15)
+    expect(laufendesBetreuungsjahr(bestellung, tag(2025, 3, 15))).toBe(1)
+    expect(laufendesBetreuungsjahr(bestellung, tag(2026, 3, 14))).toBe(1)
+    expect(laufendesBetreuungsjahr(bestellung, tag(2026, 3, 15))).toBe(2)
+    expect(laufendesBetreuungsjahr(bestellung, tag(2030, 1, 1))).toBe(5)
+    // Vor der Bestellung gibt es noch kein abgelaufenes Jahr.
+    expect(laufendesBetreuungsjahr(bestellung, tag(2024, 1, 1))).toBe(1)
+  })
+})
+
+// -----------------------------------------------------------------------------
+
+describe('Ausschlussfrist der Aufwandspauschale', () => {
+  const bestellung = tag(2025, 3, 15)
+
+  it('verfällt sechs Monate nach Ablauf des Betreuungsjahres', () => {
+    // Betreuungsjahr 1: 15.03.2025 bis 14.03.2026. Sechs Monate nach dessen
+    // Ablauf ist der 14.09.2026 - § 1878 Abs. 2 BGB.
+    const fristen = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      bestellungAm: bestellung,
+      heute: tag(2025, 6, 1),
+    })
+    const pauschale = finde(fristen, 'aufwandspauschale-2026')
+    expect(alsIsoTag(pauschale.datum)).toBe('2026-09-14')
+    expect(pauschale.ausschlussfrist).toBe(true)
+    expect(pauschale.rechtsgrundlage).toBe('§ 1878 BGB')
+  })
+
+  it('warnt früher vor als eine gewöhnliche Frist', () => {
+    const fristen = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      bestellungAm: bestellung,
+      heute: tag(2025, 6, 1),
+    })
+    expect(finde(fristen, 'aufwandspauschale-2026').vorwarnungTage).toEqual([90, 60, 30, 14, 7, 1])
+    expect(finde(fristen, 'jahresbericht-2026').vorwarnungTage).toEqual([60, 30, 7, 1])
+  })
+
+  it('bleibt für das eben abgelaufene Betreuungsjahr stehen, solange sie läuft', () => {
+    // Am 01.06.2026 ist das erste Betreuungsjahr vorbei, die Pauschale
+    // dafür aber noch bis 14.09.2026 zu holen. Genau dieses Geld darf die
+    // Anwendung nicht verschweigen.
+    const fristen = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      bestellungAm: bestellung,
+      heute: tag(2026, 6, 1),
+    })
+    expect(schluessel(fristen)).toContain('aufwandspauschale-2026')
+  })
+
+  it('verschwindet, sobald sie endgültig verfallen ist', () => {
+    const fristen = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      bestellungAm: bestellung,
+      heute: tag(2026, 9, 15),
+    })
+    expect(schluessel(fristen)).not.toContain('aufwandspauschale-2026')
+  })
+
+  it('entsteht gar nicht, wenn die Betreuung berufsmäßig geführt wird', () => {
+    const fristen = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      ehrenamtlich: false,
+      bestellungAm: bestellung,
+      heute: tag(2025, 6, 1),
+    })
+    expect(schluessel(fristen).filter((s) => s.startsWith('aufwandspauschale'))).toHaveLength(0)
+  })
+})
+
+// -----------------------------------------------------------------------------
+
+describe('Ableitung der Pflichtfristen', () => {
+  const bestellung = tag(2025, 3, 15)
+  const heute = tag(2025, 6, 1)
+
+  it('bringt Vermögensverzeichnis und Anfangsbericht drei Monate nach der Bestellung', () => {
+    const fristen = pflichtfristenAbleiten({ ...STAMMDATEN, bestellungAm: bestellung, heute })
+    expect(alsIsoTag(finde(fristen, 'vermoegensverzeichnis').datum)).toBe('2025-06-15')
+    expect(alsIsoTag(finde(fristen, 'anfangsbericht').datum)).toBe('2025-06-15')
+    expect(finde(fristen, 'anfangsbericht').rechtsgrundlage).toBe('§ 1863 Abs. 1 BGB')
+  })
+
+  it('liefert bei gleichen Stammdaten zweimal genau dasselbe (Idempotenz)', () => {
+    const eingabe = { ...STAMMDATEN, bestellungAm: bestellung, heute }
+    const ersteLauf = pflichtfristenAbleiten(eingabe)
+    const zweiterLauf = pflichtfristenAbleiten(eingabe)
+
+    expect(schluessel(zweiterLauf)).toEqual(schluessel(ersteLauf))
+    expect(zweiterLauf.map((f) => alsIsoTag(f.datum))).toEqual(
+      ersteLauf.map((f) => alsIsoTag(f.datum)),
+    )
+  })
+
+  it('vergibt jeden Systemschlüssel nur einmal — sonst gäbe es Dubletten', () => {
+    const fristen = pflichtfristenAbleiten({ ...STAMMDATEN, bestellungAm: bestellung, heute })
+    expect(new Set(schluessel(fristen)).size).toBe(fristen.length)
+  })
+
+  it('erzeugt standardmäßig drei Jahre im Voraus', () => {
+    const fristen = pflichtfristenAbleiten({ ...STAMMDATEN, bestellungAm: bestellung, heute })
+    expect(schluessel(fristen).filter((s) => s.startsWith('jahresbericht-'))).toHaveLength(3)
+    expect(schluessel(fristen).filter((s) => s.startsWith('landespflegegeld-'))).toHaveLength(3)
+  })
+
+  it('richtet sich nach dem Parameter jahreVoraus', () => {
+    const fristen = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      bestellungAm: bestellung,
+      heute,
+      jahreVoraus: 1,
+    })
+    expect(schluessel(fristen).filter((s) => s.startsWith('jahresbericht-'))).toHaveLength(1)
+  })
+
+  it('leitet ohne Bestellungsdatum gar nichts ab', () => {
+    expect(pflichtfristenAbleiten({ ...STAMMDATEN, bestellungAm: null, heute })).toEqual([])
+  })
+
+  it('lässt Landespflegegeld unter Pflegegrad 2 weg', () => {
+    const mitPflegegrad = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      pflegegrad: 2,
+      bestellungAm: bestellung,
+      heute,
+    })
+    const ohne = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      pflegegrad: 1,
+      bestellungAm: bestellung,
+      heute,
+    })
+    expect(schluessel(mitPflegegrad).some((s) => s.startsWith('landespflegegeld-'))).toBe(true)
+    expect(schluessel(ohne).some((s) => s.startsWith('landespflegegeld-'))).toBe(false)
+  })
+
+  it('nennt beim befreiten Betreuer die Vermögensübersicht, sonst die Rechnungslegung', () => {
+    const befreit = pflichtfristenAbleiten({ ...STAMMDATEN, bestellungAm: bestellung, heute })
+    const voll = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      befreiterBetreuer: false,
+      bestellungAm: bestellung,
+      heute,
+    })
+    expect(finde(befreit, 'vermoegensuebersicht-2026').rechtsgrundlage).toBe('§ 1859 Abs. 1 BGB')
+    expect(finde(voll, 'vermoegensuebersicht-2026').rechtsgrundlage).toBe('§ 1865 BGB')
+    // Der Schluessel bleibt gleich, damit ein Wechsel der Einstufung keine
+    // zweite Frist neben der bestehenden erzeugt.
+    expect(finde(voll, 'vermoegensuebersicht-2026').titel).toContain('Rechnungslegung')
+  })
+
+  it('weist auf Stichtage hin, die auf ein Wochenende fallen — ohne sie zu verschieben', () => {
+    // Der 14.09.2025 ist ein Sonntag; Bestellung am 14.06.2025 legt den
+    // Anfangsbericht genau dorthin.
+    const fristen = pflichtfristenAbleiten({
+      ...STAMMDATEN,
+      bestellungAm: tag(2025, 6, 14),
+      heute: tag(2025, 6, 20),
+    })
+    const bericht = finde(fristen, 'anfangsbericht')
+    expect(alsIsoTag(bericht.datum)).toBe('2025-09-14')
+    expect(istWochenende(bericht.datum)).toBe(true)
+    expect(bericht.beschreibung).toContain('Sonntag')
+    expect(bericht.beschreibung).toContain('§ 193 BGB')
+  })
+
+  it('ist chronologisch sortiert', () => {
+    const fristen = pflichtfristenAbleiten({ ...STAMMDATEN, bestellungAm: bestellung, heute })
+    const daten = fristen.map((f) => f.datum.getTime())
+    expect([...daten].sort((a, b) => a - b)).toEqual(daten)
+  })
+})
+
+// -----------------------------------------------------------------------------
+
+describe('Wiederkehrende Fristen', () => {
+  it('findet den nächsten Jahrestermin', () => {
+    const naechster = naechsterTermin('FREQ=YEARLY;INTERVAL=1', tag(2026, 3, 14))
+    expect(alsIsoTag(naechster!)).toBe('2027-03-14')
+  })
+
+  it('gibt nie den Tag zurück, der gerade erledigt wurde', () => {
+    const naechster = naechsterTermin('FREQ=MONTHLY;INTERVAL=1', tag(2026, 1, 31))
+    expect(alsIsoTag(naechster!)).not.toBe('2026-01-31')
+    // Der Februar hat keinen 31. - die naechste Wiederholung ist der 31.03.
+    expect(alsIsoTag(naechster!)).toBe('2026-03-31')
+  })
+
+  it('rechnet vierteljährlich in Dreimonatsschritten', () => {
+    expect(alsIsoTag(naechsterTermin('FREQ=MONTHLY;INTERVAL=3', tag(2026, 2, 10))!)).toBe(
+      '2026-05-10',
+    )
+  })
+
+  it('endet, wenn die Regel erschöpft ist', () => {
+    expect(naechsterTermin('FREQ=YEARLY;COUNT=1', tag(2026, 3, 14))).toBeNull()
+    expect(naechsterTermin('FREQ=MONTHLY;UNTIL=20260201T000000Z', tag(2026, 1, 15))).toBeNull()
+  })
+
+  it('erkennt unbrauchbare Regeln, statt sie stillschweigend zu schlucken', () => {
+    expect(rruleGueltig('FREQ=YEARLY;INTERVAL=1')).toBe(true)
+    expect(rruleGueltig('jeden Montag')).toBe(false)
+    expect(naechsterTermin('Unsinn', tag(2026, 1, 1))).toBeNull()
+  })
+
+  it('verkettet die Nachfolgefrist mit der erledigten', () => {
+    const nachfolger = naechsteFristAusErledigter({
+      id: 'frist-1',
+      betreuteId: 'betreute-1',
+      vorgangId: 'vorgang-9',
+      titel: 'Kontoauszüge holen',
+      beschreibung: 'Bei der Sparkasse abholen.',
+      datum: tag(2026, 1, 15),
+      typ: 'WIEDERVORLAGE',
+      rechtsgrundlage: null,
+      vorwarnungTage: [7, 1],
+      wiederholungRrule: 'FREQ=MONTHLY;INTERVAL=1',
+      ausschlussfrist: false,
+    })
+
+    expect(nachfolger).not.toBeNull()
+    expect(nachfolger!.vorgaengerFristId).toBe('frist-1')
+    expect(alsIsoTag(nachfolger!.datum)).toBe('2026-02-15')
+    expect(nachfolger!.titel).toBe('Kontoauszüge holen')
+    expect(nachfolger!.vorgangId).toBe('vorgang-9')
+    expect(nachfolger!.wiederholungRrule).toBe('FREQ=MONTHLY;INTERVAL=1')
+  })
+
+  it('rechnet ab dem Solltermin, nicht ab dem Tag der Erledigung', () => {
+    // Wer drei Tage zu spaet abhakt, soll nicht dauerhaft nachrutschen.
+    const nachfolger = naechsteFristAusErledigter({
+      id: 'frist-2',
+      betreuteId: 'betreute-1',
+      titel: 'Heimkosten prüfen',
+      datum: tag(2026, 1, 1),
+      typ: 'WIEDERVORLAGE',
+      vorwarnungTage: [7],
+      wiederholungRrule: 'FREQ=MONTHLY;INTERVAL=1',
+      ausschlussfrist: false,
+    })
+    expect(alsIsoTag(nachfolger!.datum)).toBe('2026-02-01')
+  })
+
+  it('legt ohne Wiederholungsregel keine Nachfolgefrist an', () => {
+    const nachfolger = naechsteFristAusErledigter({
+      id: 'frist-3',
+      betreuteId: 'betreute-1',
+      titel: 'Einmalige Sache',
+      datum: tag(2026, 1, 1),
+      typ: 'SELBST_GESETZT',
+      vorwarnungTage: [],
+      wiederholungRrule: null,
+      ausschlussfrist: false,
+    })
+    expect(nachfolger).toBeNull()
+  })
+})
+
+// -----------------------------------------------------------------------------
+
+describe('Fristenampel', () => {
+  const heute = tag(2026, 5, 20)
+
+  it('färbt Überfälliges rot und sagt seit wann', () => {
+    const gestern = fristAmpel(tag(2026, 5, 19), 'OFFEN', heute)
+    expect(gestern.stufe).toBe('ueberfaellig')
+    expect(gestern.variante).toBe('rot')
+    expect(gestern.text).toBe('Überfällig seit gestern')
+
+    const vorheriger = fristAmpel(tag(2026, 5, 10), 'OFFEN', heute)
+    expect(vorheriger.text).toBe('Überfällig seit 10 Tagen')
+  })
+
+  it('zählt heute und morgen zur laufenden Woche', () => {
+    expect(fristAmpel(heute, 'OFFEN', heute)).toMatchObject({
+      stufe: 'diese_woche',
+      variante: 'orange',
+      text: 'Heute fällig',
+    })
+    expect(fristAmpel(tag(2026, 5, 21), 'OFFEN', heute)).toMatchObject({
+      stufe: 'diese_woche',
+      text: 'Morgen fällig',
+    })
+  })
+
+  it('trennt „diese Woche“ von „dieser Monat“ genau nach sieben Tagen', () => {
+    const siebter = fristAmpel(tag(2026, 5, 27), 'OFFEN', heute)
+    const achter = fristAmpel(tag(2026, 5, 28), 'OFFEN', heute)
+
+    expect(siebter.tage).toBe(7)
+    expect(siebter.stufe).toBe('diese_woche')
+    expect(siebter.variante).toBe('orange')
+
+    expect(achter.tage).toBe(8)
+    expect(achter.stufe).toBe('dieser_monat')
+    expect(achter.variante).toBe('gelb')
+  })
+
+  it('schaltet nach 31 Tagen auf „später“', () => {
+    expect(fristAmpel(tag(2026, 6, 20), 'OFFEN', heute).stufe).toBe('dieser_monat')
+    expect(fristAmpel(tag(2026, 6, 21), 'OFFEN', heute).stufe).toBe('spaeter')
+    expect(fristAmpel(tag(2026, 6, 21), 'OFFEN', heute).variante).toBe('gruen')
+  })
+
+  it('nimmt Abgeschlossenes aus der Ampel heraus', () => {
+    for (const status of ['ERLEDIGT', 'VERSCHOBEN', 'ENTFALLEN'] as const) {
+      const ampel = fristAmpel(tag(2026, 1, 1), status, heute)
+      expect(ampel.stufe).toBe('erledigt')
+      expect(ampel.variante).toBe('secondary')
+    }
+  })
+
+  it('liefert zu jeder Stufe einen Text — Farbe allein ist keine Information', () => {
+    const tage = [-30, -1, 0, 1, 5, 7, 8, 20, 31, 32, 400]
+    for (const versatz of tage) {
+      const ampel = fristAmpel(plusTage(heute, versatz), 'OFFEN', heute)
+      expect(ampel.text.length).toBeGreaterThan(3)
+    }
+  })
+})
+
+// -----------------------------------------------------------------------------
+
+describe('Tagesdatum und Feiertage', () => {
+  it('rechnet Monatsschritte kalendarisch, nicht in 30 Tagen', () => {
+    expect(alsIsoTag(plusMonate(tag(2026, 1, 31), 1))).toBe('2026-02-28')
+    expect(alsIsoTag(plusMonate(tag(2024, 1, 31), 1))).toBe('2024-02-29')
+    expect(alsIsoTag(plusMonate(tag(2026, 3, 15), 6))).toBe('2026-09-15')
+  })
+
+  it('liest und schreibt ISO-Tagesdaten verlustfrei', () => {
+    expect(alsIsoTag(ausIsoTag('2026-09-14')!)).toBe('2026-09-14')
+    expect(ausIsoTag('2026-02-31')).toBeNull()
+    expect(ausIsoTag('14.09.2026')).toBeNull()
+    expect(ausIsoTag('')).toBeNull()
+  })
+
+  it('kennt die beweglichen bayerischen Feiertage', () => {
+    // Ostersonntag 2026 ist der 05.04.
+    expect(feiertagName(tag(2026, 4, 3))).toBe('Karfreitag')
+    expect(feiertagName(tag(2026, 4, 6))).toBe('Ostermontag')
+    expect(feiertagName(tag(2026, 5, 14))).toBe('Christi Himmelfahrt')
+    expect(feiertagName(tag(2026, 6, 4))).toBe('Fronleichnam')
+    expect(feiertagName(tag(2026, 1, 6))).toBe('Heilige Drei Könige')
+    expect(feiertagName(tag(2026, 7, 7))).toBeNull()
+  })
+
+  it('warnt vor arbeitsfreien Stichtagen, ohne das Datum zu ändern', () => {
+    const hinweis = nichtWerktagHinweis(tag(2026, 4, 3))
+    expect(hinweis).toContain('Karfreitag')
+    expect(hinweis).toContain('§ 193 BGB')
+    expect(nichtWerktagHinweis(tag(2026, 7, 7))).toBeNull()
+  })
+})
+
+// -----------------------------------------------------------------------------
+
+describe('ICS-Kalender', () => {
+  const frist = {
+    id: 'abc123',
+    titel: 'Jahresbericht 2026 an das Betreuungsgericht',
+    beschreibung: 'Bericht über das Betreuungsjahr; mit Vermögensübersicht, Belegen.',
+    datum: tag(2026, 3, 14),
+    rechtsgrundlage: '§ 1863 Abs. 3 BGB',
+    typ: 'GESETZLICH',
+    ausschlussfrist: false,
+    vorwarnungTage: [60, 30, 7, 1],
+  }
+
+  const kalender = () =>
+    icsErzeugen({
+      kalendername: 'Betreuung EM — Fristen',
+      fristen: [frist],
+      jetzt: new Date(Date.UTC(2026, 1, 1, 10, 15, 0)),
+    })
+
+  it('faltet keine Zeile über 75 Oktette hinaus', () => {
+    const lang =
+      'SUMMARY:Vermögensübersicht 2027 einreichen — Kontostände, Rückkaufswerte, ' +
+      'Verbindlichkeiten, jeweils mit Nachweis für das Betreuungsgericht'
+    const gefaltet = zeileFalten(lang)
+
+    for (const zeile of gefaltet.split('\r\n')) {
+      expect(Buffer.byteLength(zeile, 'utf8')).toBeLessThanOrEqual(75)
+    }
+    // Jede Folgezeile beginnt mit genau einem Leerzeichen.
+    for (const zeile of gefaltet.split('\r\n').slice(1)) {
+      expect(zeile.startsWith(' ')).toBe(true)
+    }
+    // Entfaltet muss wieder das Original herauskommen.
+    expect(gefaltet.split('\r\n ').join('')).toBe(lang)
+  })
+
+  it('zerschneidet keine Umlaute beim Falten', () => {
+    const zeile = `DESCRIPTION:${'ä'.repeat(120)}`
+    const gefaltet = zeileFalten(zeile)
+    expect(gefaltet).not.toContain('�')
+    expect(gefaltet.split('\r\n ').join('')).toBe(zeile)
+    for (const teil of gefaltet.split('\r\n')) {
+      expect(Buffer.byteLength(teil, 'utf8')).toBeLessThanOrEqual(75)
+    }
+  })
+
+  it('lässt kurze Zeilen unangetastet', () => {
+    expect(zeileFalten('VERSION:2.0')).toBe('VERSION:2.0')
+  })
+
+  it('maskiert Sonderzeichen nach RFC 5545', () => {
+    expect(textEscapen('a;b,c\\d')).toBe('a\\;b\\,c\\\\d')
+    expect(textEscapen('Zeile 1\nZeile 2')).toBe('Zeile 1\\nZeile 2')
+  })
+
+  it('baut ein gültiges Gerüst mit CRLF-Zeilenenden', () => {
+    const ics = kalender()
+    expect(ics.startsWith('BEGIN:VCALENDAR\r\n')).toBe(true)
+    expect(ics.endsWith('END:VCALENDAR\r\n')).toBe(true)
+    expect(ics).toContain('VERSION:2.0')
+    // Kein nacktes Zeilenende ohne Wagenruecklauf.
+    expect(/[^\r]\n/.test(ics)).toBe(false)
+  })
+
+  it('schreibt ganztägige Termine mit Ende am Folgetag', () => {
+    const ics = kalender()
+    expect(ics).toContain('DTSTART;VALUE=DATE:20260314')
+    expect(ics).toContain('DTEND;VALUE=DATE:20260315')
+    expect(alsIcsDatum(tag(2026, 3, 14))).toBe('20260314')
+  })
+
+  it('macht aus jeder Vorwarnstufe einen Wecker', () => {
+    const ics = kalender()
+    for (const tage of [60, 30, 7, 1]) {
+      expect(ics).toContain(`TRIGGER;RELATED=START:-P${tage}D`)
+    }
+    expect(ics).not.toContain('-P0D')
+  })
+
+  it('markiert Ausschlussfristen schon im Titel', () => {
+    const ics = icsErzeugen({
+      kalendername: 'Test',
+      fristen: [{ ...frist, ausschlussfrist: true }],
+      jetzt: new Date(Date.UTC(2026, 1, 1)),
+    })
+    expect(ics).toContain('Ausschlussfrist!')
+    expect(ics).toContain('PRIORITY:1')
+  })
+})
+
+// -----------------------------------------------------------------------------
+
+describe('Signatur des Kalender-Abonnements', () => {
+  it('lässt sich erzeugen und wieder auflösen', () => {
+    const signatur = signaturErzeugen('betreute-1', 'user-1')
+    expect(signaturPruefen(signatur)).toEqual({ betreuteId: 'betreute-1', userId: 'user-1' })
+  })
+
+  it('enthält die Kennungen nicht im Klartext in der Adresse', () => {
+    expect(signaturErzeugen('betreute-1', 'user-1')).not.toContain('betreute-1')
+  })
+
+  it('weist eine veränderte Signatur ab', () => {
+    const echt = signaturErzeugen('betreute-1', 'user-1')
+    const gefaelscht = Buffer.from('betreute-2.user-1.irgendwas', 'utf8').toString('base64url')
+
+    expect(signaturPruefen(gefaelscht)).toBeNull()
+    expect(signaturPruefen(`${echt}xyz`)).toBeNull()
+    expect(signaturPruefen('kein-base64url-inhalt')).toBeNull()
+  })
+
+  it('gilt nur für genau dieses Paar aus Person und Benutzer', () => {
+    const fuerA = signaturErzeugen('betreute-1', 'user-1')
+    const fuerB = signaturErzeugen('betreute-1', 'user-2')
+    expect(fuerA).not.toBe(fuerB)
+    expect(signaturPruefen(fuerB)!.userId).toBe('user-2')
+  })
+
+  it('verträgt die Endung .ics an der Adresse', () => {
+    const signatur = signaturErzeugen('betreute-1', 'user-1')
+    expect(signaturPruefen(`${signatur}.ics`)).toEqual({
+      betreuteId: 'betreute-1',
+      userId: 'user-1',
+    })
+  })
+})