feat: add password recovery and everyday workflow improvements

deploy/README.md

@@ -53,7 +53,7 @@ Grenzen: 10 MiB pro Datei, fünf Dateien und 25 MiB pro Nachricht; standardmäß
 
 `npm run uploads:cleanup` zeigt zunächst nur verwaiste Dateien mit mindestens 24 Stunden Alter. Nach Prüfung entfernt `npm run uploads:cleanup -- --delete` diese Dateien. Backups, Speicherüberwachung und eine Aufbewahrungs-/Löschstrategie für Backups separat einrichten. Dateien gelöschter Datensätze werden auch unmittelbar bestmöglich entfernt.
 
-Die SQL-Migrationen ergänzen **41 zusammengesetzte Tenant-Fremdschlüssel**, die Prisma wegen der vorhandenen optionalen Cascade-/SetNull-Beziehungen nicht vollständig abbildet. Zukünftige generierte Migrationen auf unbeabsichtigtes Entfernen dieser Constraints prüfen. Kein `prisma db push` auf verwalteten Datenbanken einsetzen. Runtime-Grants nach zukünftigen Migrationen erneut bereitstellen.
+Die SQL-Migrationen ergänzen **45 zusammengesetzte Tenant-Fremdschlüssel**, die Prisma wegen der vorhandenen optionalen Cascade-/SetNull-Beziehungen nicht vollständig abbildet. Zukünftige generierte Migrationen auf unbeabsichtigtes Entfernen dieser Constraints prüfen. Kein `prisma db push` auf verwalteten Datenbanken einsetzen. Runtime-Grants nach zukünftigen Migrationen erneut bereitstellen.
 
 ## Verifikation und Updates
 
@@ -68,3 +68,20 @@ npm audit --omit=dev
 Die Integrationstests setzen eine ausdrücklich isolierte lokale PostgreSQL-Datenbank namens `kita_security_test` voraus; `SECURITY_TEST_DATABASE_URL` darf keine Anwendungsdaten enthalten. `npm run test:security` prüft Aktionen und echte DB-Transaktionen. `npm run test:security:http` benötigt den Production-Server auf localhost:3057 mit derselben Testdatenbank, `UPLOAD_DIR` und dem im Test dokumentierten Test-Secret. Niemals dieses Test-Secret in Produktion verwenden.
 
 Docker-Images sind auf Digests fixiert. Neue Sicherheitsreleases regelmäßig prüfen und die Digests bewusst aktualisieren. Zum Prüfzeitpunkt verbleibt eine ungepatchte `braces`-Schwachstelle in der Entwicklungs-Lint-Kette; `npm audit --force` löst sie nicht sinnvoll. Der Runtime-Audit ist ohne bekannte Findings. NextAuth bleibt eine Beta-Abhängigkeit und benötigt weiterhin Update-Beobachtung.
+
+## Familieneinladungen und Abwesenheiten
+
+Die Migration `20261010000000_family_invitation_flows` ergänzt den Versandstatus und die mandantengebundene Empfängerreferenz. Der bestehende Migrationsdienst spielt sie vor dem App-Start ein; kein `prisma db push` und kein erneutes Löschen erforderlich. Fehlgeschlagene Familieneinladungen können in der Familienübersicht erneut versendet werden. Fachliche Abläufe: [Familien und Abwesenheiten](../docs/FAMILIEN_UND_ABWESENHEITEN.md).
+
+
+## Notdienst-Erinnerungen und Veröffentlichungsmails
+
+Die Migration `20261012000000_notdienst_notifications` ergänzt Mailaufträge und die monatliche Erinnerungsrunde. Vor dem Start der neuen App `npm run db:migrate:deploy` ausführen und die Runtime-Grants erneut bereitstellen. Der bestehende Initialisierungsdienst erledigt beide Schritte im Compose-Deployment. Kein `db push` verwenden; die bisherigen Tenant-Constraints bleiben erhalten.
+
+`NOTDIENST_JOB_SECRET` (mindestens 32 Zeichen), `AUTH_URL`/`NEXT_PUBLIC_SITE_URL`, `RESEND_API_KEY` und `EMAIL_FROM` müssen eingerichtet sein. Ein neues Secret oder ein zusätzlicher externer Cronjob ist nicht nötig, wenn der vorhandene Notdienstjob bereits konfiguriert ist. Der Produktionsstart überwacht Webserver und Worker gemeinsam: der Worker wird nach einem Abbruch neu gestartet; beim Ende des Webservers werden beide Prozesse beendet.
+
+Der geschützte `POST /api/jobs/notdienstalarme` verarbeitet weiterhin Alarme und zusätzlich Planungserinnerungen/gespeicherte Benachrichtigungen. Die JSON-Antwort ergänzt `planning` mit `queued`, `sent`, `failed` und `skipped`. Ein Lauf bearbeitet bis zu 100 fällige Kitas und zwölf Planungsmails (vier parallel). Der Worker ruft die Route minütlich auf. Versanddetails und manuelle Wiederholung finden sich in der Monatsplanung.
+
+Die automatische Runde läuft einmal pro Kita und Folgemonat, ab 9 Uhr Berliner Zeit, standardmäßig ab dem 19. (sieben Tage vor Ende der Eintragsfrist am 26.). Ein verpasster Termin wird bis zum 26. nachgeholt. Die Einstellung 0 schaltet diese Runde ab; ein bereits veröffentlichter Plan beendet Verfügbarkeitserinnerungen. Manuelle Erinnerungen sind für den offenen Folgemonat möglich und je Konto/Tag mit der automatischen Runde zusammen dedupliziert.
+
+Veröffentlichung und Mailvorbereitung sind eine Transaktion. Anschließend wird der Versand versucht; ein Mailfehler setzt den Plan nicht zurück. Wiederholungen prüfen aktuelle Konten, Haushalt, aktive Kinder und Einteilungen erneut. Pro Konto wird eine Mail mit allen aktuellen eigenen Diensten vorbereitet. Versandaufträge erhalten einen stabilen Idempotenzschlüssel je Nachrichteninhalt und eine fünfminütige Reservierung; Fehler erhalten zunehmende Wartezeiten und bleiben sichtbar. Der Mailtransport bricht HTTP-Anfragen nach zehn Sekunden ab. Anbieterannahme, wiederholter Versand nach unbekanntem Transportausgang und tatsächliche Postfachzustellung sind weiterhin durch die Garantien des Mailanbieters begrenzt.

deploy/production.env.example

@@ -40,7 +40,7 @@ RESEND_API_KEY="re_[PRODUCTION_API_KEY]"
 EMAIL_FROM="Kita-Planer <[absender@deine-domain.de]>"
 ADMIN_EMAIL="[kontakt@deine-domain.de]"
 
-# Automatische Notdienst-Fristpruefung im App-Container.
+# Automatische Notdienst-Fristpruefung, Verfuegbarkeitserinnerungen und Mail-Wiederholungen.
 # Eigenes Secret, mindestens 32 Zeichen; generieren mit: openssl rand -hex 32
 NOTDIENST_JOB_SECRET="[GENERATE_ME]"
 

deploy/sql/familieneinladungen.sql

@@ -0,0 +1,32 @@
+-- Historical upgrade helper, retained for compatibility tests only.
+-- Production uses prisma/migrations/20261010000000_family_invitation_flows.
+-- Additive upgrade before Prisma db push; safe to run repeatedly.
+-- On a fresh database Prisma creates the entire schema afterwards.
+DO $upgrade$
+BEGIN
+  IF to_regclass('invitations') IS NULL THEN
+    RETURN;
+  END IF;
+
+  ALTER TABLE "invitations"
+    ADD COLUMN IF NOT EXISTS "userId" TEXT,
+    ADD COLUMN IF NOT EXISTS "sentAt" TIMESTAMP(3),
+    ADD COLUMN IF NOT EXISTS "lastAttemptAt" TIMESTAMP(3),
+    ADD COLUMN IF NOT EXISTS "leaseUntil" TIMESTAMP(3),
+    ADD COLUMN IF NOT EXISTS "attempts" INTEGER NOT NULL DEFAULT 0,
+    ADD COLUMN IF NOT EXISTS "failed" BOOLEAN NOT NULL DEFAULT false;
+
+  CREATE UNIQUE INDEX IF NOT EXISTS "invitations_userId_key" ON "invitations"("userId");
+
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_constraint
+    WHERE conname = 'invitations_userId_fkey'
+      AND conrelid = 'invitations'::regclass
+  ) THEN
+    ALTER TABLE "invitations"
+      ADD CONSTRAINT "invitations_userId_fkey"
+      FOREIGN KEY ("userId") REFERENCES "users"("id")
+      ON DELETE CASCADE ON UPDATE CASCADE;
+  END IF;
+END
+$upgrade$;

deploy/sql/notdienstalarm.sql

@@ -1,5 +1,7 @@
+-- HISTORISCHER UPGRADEPFAD: aktuelle Releases verwenden prisma/migrations und deploy/README.md.
+-- Nicht zusätzlich zu versionierten Migrationen oder auf bereits aktualisierten Datenbanken ausführen.
 -- Additives Upgrade für einen Personalbereich einschließlich vorhandener Mail-Erweiterung.
--- Einmalig vor dem Start der neuen Anwendung ausführen, sofern nicht prisma db push verwendet wird.
+-- Beschreibt ausschließlich den damaligen Ausgangsstand vor Einführung der Migrationshistorie.
 BEGIN;
 
 -- CreateEnum

deploy/sql/personalbereich-email.sql

@@ -1,5 +1,7 @@
+-- HISTORISCHER UPGRADEPFAD: aktuelle Releases verwenden prisma/migrations und deploy/README.md.
+-- Nicht zusätzlich zu versionierten Migrationen oder auf bereits aktualisierten Datenbanken ausführen.
 -- Nur E-Mail-Erweiterung für einen bereits mit 043fed2 eingeführten Personalbereich.
--- Alternative zu prisma db push, nicht zusätzlich oder mehrfach ausführen.
+-- Beschreibt ausschließlich den damaligen Ausgangsstand vor Einführung der Migrationshistorie.
 BEGIN;
 
 -- AlterTable

deploy/sql/personalbereich.sql

@@ -1,5 +1,7 @@
+-- HISTORISCHER UPGRADEPFAD: aktuelle Releases verwenden prisma/migrations und deploy/README.md.
+-- Nicht zusätzlich zu versionierten Migrationen oder auf bereits aktualisierten Datenbanken ausführen.
 -- Einmalige Einführung des vollständigen Personalbereichs inklusive E-Mails ab ec3f4f9.
--- Alternative zu prisma db push, nicht zusätzlich oder mehrfach ausführen.
+-- Beschreibt ausschließlich den damaligen Ausgangsstand vor Einführung der Migrationshistorie.
 BEGIN;
 
 -- CreateEnum

docs/ABLAUFPRUEFUNG.md

@@ -0,0 +1,214 @@
+# Prüfung der Bedienabläufe im Kita-Planer
+
+Stand: 9. Oktober 2026 · geprüfter Code: `4702bf5abb0037ab9e0913dbef01ffbe21bbb96d` (`origin/main` zum Prüfzeitpunkt).
+
+Fortschreibung: F01 (Familieneinladungen), F02 (Abwesenheitsverwaltung) und die Entfernung des künstlichen Gruppenfilters aus F12 wurden anschließend auf `codex/family-absence-flows` bearbeitet. Den neuen Ablauf und die Deployment-Schritte beschreibt [Familien und Abwesenheiten](FAMILIEN_UND_ABWESENHEITEN.md). F03, F04 und F05 (Verfügbarkeit bei manueller Zuweisung sowie Erstveröffentlichung) sind inzwischen ebenfalls umgesetzt; den aktuellen Stand und die Prüfungen dokumentiert die Ergänzung vom 12.10.2026 in [Funktionsübersicht](FUNKTIONSUEBERSICHT.md). F06 (Agenda-Details und Mitbringen), F09 (Arbeitszeitkontext und Ein-Tages-Anträge), F10 (personenbezogene Ämter-Schaltflächen) und F11 (Passwort-Wiederherstellung/-Änderung) sind ebenfalls umgesetzt; F08 enthält nun kontoabhängiges Ausblenden des Einrichtungshinweises. Die weiteren Teile von F08 und F11 bleiben durch diese Ergänzung unberührt. Die folgenden Befunde dokumentieren weiterhin den ursprünglichen Prüfstand.
+
+## Umfang und Methode
+
+Geprüft wurden die zentralen Abläufe für Eltern, Fachkräfte, Kita-Admins und Notdienst-Koordination: Einrichtung, Familien, Profile, Einladungen, Abwesenheiten, Arbeitszeit und Urlaub, Kalender und Anmeldungen, Mitteilungen, Dienste, Notdienstplanung und Alarmierung. Login, Kontoverwaltung und die Superadmin-Oberflächen wurden ergänzend im Quellcode geprüft.
+
+Grundlage sind die aktuellen Seiten, Formulare, Server-Aktionen und Datenmodelle. Einzelne Abläufe wurden zusätzlich in einer lokalen Vorschau mit synthetischen Testkonten nachvollzogen: Familienverwaltung, Eltern-Abwesenheiten sowie Kalender in Agenda- und Listenansicht. Dabei wurden keine fachlichen Datensätze angelegt, geändert oder gelöscht und keine E-Mails verschickt. Die produktive Website wurde nicht getestet.
+
+Die folgenden Befunde beschreiben den bestehenden Stand. Die vorgeschlagenen Zielabläufe sind noch nicht umgesetzt. Diese Prüfung ist kein vollständiger Sicherheitstest oder Test aller Berechnungen. Die ältere `FUNKTIONSUEBERSICHT.md` wurde nicht als Beleg für fehlende Funktionen verwendet: Kalender-Anmeldungen, Mitteilungen, Personalverwaltung und Notdienstalarm sind inzwischen vorhanden.
+
+## Bereits mit dem Nutzer geklärt
+
+- Eltern dürfen eigene Abwesenheitsmeldungen **für zukünftige Tage** ändern und zurücknehmen. Für laufende Tage ist die Kita zuständig.
+- **Kita-Admins dürfen innerhalb ihrer eigenen Kita weitere Admins und die Notdienst-Koordination ernennen.**
+
+Diese Regeln sind für die spätere Umsetzung verbindlich. Die Datumsregel muss auch auf dem Server gelten. Für Meldungen, die einen laufenden und zukünftige Tage umfassen, ist die Behandlung des zukünftigen Teilzeitraums noch zu konkretisieren.
+
+## Prioritäten
+
+„Hoch“ bezeichnet einen blockierten Ablauf, widersprüchliche Rückmeldungen oder fachlich irreführende Angaben. „Mittel“ bezeichnet vermeidbare Nacharbeit oder einen fehlenden direkten Weg. „Niedrig“ bezeichnet kleinere Verbesserungen bei Benennung und Orientierung.
+
+| ID | Priorität | Bereich | Wichtigster Befund |
+| --- | --- | --- | --- |
+| F01 | Hoch | Familieneinladungen | Gespeicherte Familie erscheint bei Mailfehler als fehlgeschlagener Vorgang; erneutes Senden fehlt. |
+| F02 | Hoch | Kinder-Abwesenheiten | Elternlink führt zu „Zugriff verweigert“; Ändern und Zurücknehmen fehlen. |
+| F03 | Hoch | Notdienst-Erinnerungen | Oberfläche verspricht Automatik, die Einstellung wird dafür nicht verwendet; unvollständige Rückmeldungen werden übergangen. |
+| F04 | Hoch | Rollenverwaltung | Weitere Kita-Admins und Koordination lassen sich nicht regulär ernennen. |
+| F05 | Mittel | Notdienstplan | Manuelle Einteilung zeigt Verfügbarkeit nicht am Auswahlpunkt; Erstveröffentlichung verschickt keine Nachricht. |
+| F06 | Mittel | Kalender und Mitbringen | Funktionen hängen von der Ansicht ab; Mitbring-Einträge lassen sich nur löschen und neu anlegen. |
+| F07 | Mittel | Mitteilungen | Korrektur und gezieltes erneutes Senden fehlen. |
+| F08 | Mittel | Eigene Ersteinrichtung | Haushalt, Kinder und Kontakt werden separat gespeichert; Admins ohne eigene Kinder gelten als unvollständig. |
+| F09 | Mittel | Personal | Neue Zeiterfassung verliert den betrachteten Zeitraum; Ein-Tages-Anträge verlangen zweimal das Datum. |
+| F10 | Niedrig | Ämter und Dienste | Gleich benannte Ämter-Schaltflächen lassen die betroffene Person erst nach dem Öffnen erkennen. |
+| F11 | Mittel | Zugang und Wiederherstellung | Passwort-Wiederherstellung fehlt; alte Aktivierungslinks und seltene Alt-Konten enden in Sackgassen. |
+| F12 | Hoch / Niedrig | Filter und Anzeigen | Abwesenheitsgruppen sind aus Namen erfunden; die Notdienst-Zahl im Menü ist fest eingetragen. |
+
+## F01 – Familieneinladungen sauber abschließen und erneut senden
+
+**Aktueller Ablauf:** Admin legt eine Familie samt Eltern und Kindern an. Die Datenbank speichert die Familie, Konten und Aktivierungslinks. Anschließend werden die Einladungsmails versendet. Scheitert eine Mail, meldet die Aktion einen Formularfehler; der erfolgreiche Abschluss und die Aktualisierung der Ansicht bleiben aus. Ein erneuter Speicherversuch kann dann an den bereits angelegten E-Mail-Adressen scheitern. Bei mehreren Einladungen stoppt der Versand bereits beim ersten Fehler.
+
+Die Familienliste zeigt offene Einladungen, bietet aber weder dort noch in „Details“ eine Funktion zum erneuten Senden. Das wurde im lokalen Browser bestätigt. Auch der Hinweis eines abgelaufenen Aktivierungslinks, beim Admin einen neuen Link anzufordern, hat damit keinen passenden Bedienweg.
+
+**Vorgeschlagener Zielablauf:** Familie einmal anlegen → Erfolg anzeigen und Liste aktualisieren → Versandstatus je Elternteil anzeigen → bei Bedarf ausschließlich die Einladung erneut senden. Der Datensatz bleibt unabhängig vom Mailversand erfolgreich angelegt. Fehlgeschlagene Mails werden gespeichert und gezielt wiederholt; weitere Empfänger werden trotz eines einzelnen Fehlers bearbeitet.
+
+**Belege:** `src/app/dashboard/families/actions.ts:125`, `:277`, `:459`; `src/app/dashboard/families/add-family-dialog.tsx`; `src/app/dashboard/families/_components/families-list-client.tsx`; `src/app/dashboard/families/edit-family-dialog.tsx`.
+
+**Abnahme:** Simulierter Mailfehler führt zu genau einer Familie, sichtbarem Versandfehler und einem funktionierenden erneuten Senden ohne erneute Personeneingabe. Der kürzlich verbesserte Fachkräfte-Ablauf dient als Vorlage.
+
+## F02 – Eigene Abwesenheiten direkt verwalten
+
+**Aktueller Ablauf:** Eltern melden ein Kind ab und sehen die Meldung auf der Übersicht. Dort fehlen Änderungs- und Rücknahmeaktionen. „Alle Abwesenheiten“ führt auf eine Seite, die nur Admins, Koordination und Fachkräfte betreten dürfen. Der Elternaccount erreicht im lokalen Browser „Zugriff verweigert“.
+
+Die vorhandene Server-Aktion `deleteAbsence` wird von keiner Oberfläche verwendet. Sie prüft die Haushaltszugehörigkeit, aber bisher keine Beschränkung auf zukünftige Tage. Eine Aktion zum Ändern fehlt. Die Kita-Übersicht bietet ebenfalls nur die Anzeige, keinen direkten Korrekturweg für laufende Meldungen.
+
+**Vorgeschlagener Zielablauf:** „Meine Abwesenheiten“ → Meldung ansehen → zukünftige Tage bearbeiten oder zurücknehmen. Für laufende Tage führt ein verständlicher Hinweis zur Kita; berechtigte Kita-Nutzer können die Meldung in ihrer Übersicht korrigieren. Eltern bekommen eine eigene Haushaltsansicht. Die kitaweite Übersicht behält ihre bestehenden Zugriffsgrenzen.
+
+**Belege:** `src/app/dashboard/absence-card.tsx:234`, `:241`; `src/app/dashboard/admin/abwesenheiten/page.tsx:16`; `src/actions/absences.ts:107`; `src/app/dashboard/admin/abwesenheiten/absence-table.tsx`.
+
+**Abnahme:** Eltern erreichen ihre Meldungen ohne Zugriffsfehler. Änderungen gelten nur für den eigenen Haushalt und die erlaubten Tage; Kita-Korrekturen sind innerhalb derselben Kita möglich. Für die Datumsgrenze gilt die lokale Kita-Zeitzone.
+
+## F03 – Notdienst-Einstellungen und Erinnerungen verständlich machen
+
+**Aktueller Ablauf:** „Mindesteinteilungen pro Kind/Monat“ wird als Richtmaß der automatischen Verteilung erklärt. Tatsächlich bestimmt der Wert die erforderliche Anzahl gemeldeter Verfügbarkeiten. „Erinnerungsfrist“ verspricht automatische E-Mails; im geprüften Code wird die Einstellung gespeichert und angezeigt, aber von keinem Erinnerungsjob ausgewertet. Die Eingabesperre folgt stattdessen dem fest codierten Stichtag 26. Der vorhandene Notdienstalarm-Job betrifft Alarm-Erinnerungen und ersetzt diese Verfügbarkeits-Erinnerung nicht.
+
+Die manuelle Erinnerungsaktion behandelt eine Familie schon nach einem einzigen Verfügbarkeitseintrag als beantwortet. Familien unterhalb ihrer geforderten Anzahl werden dadurch nicht angeschrieben. Einzelne Versandfehler landen im Log; die Oberfläche zeigt nur die Anzahl erfolgreicher Mails. Erneutes Auslösen wiederholt auch bereits erfolgreich versendete Mails.
+
+Zusätzlich kann die Planung einen beliebigen Monat anzeigen. Der Link in einer Erinnerung führt dagegen ohne Monatsangabe zur Elternseite, die den nächsten Monat öffnet. Erinnerung und Eingabe können dadurch unterschiedliche Monate betreffen.
+
+**Vorgeschlagener Zielablauf:** „Erforderliche Verfügbarkeiten“ und tatsächlichen Abgabeschluss klar benennen → Rücklauf als „fehlt / unvollständig / vollständig“ zeigen → Empfänger vor dem Versand sichtbar machen → Versandstatus und gezieltes Wiederholen anbieten. Eine automatische Erinnerung benötigt einen echten Job und eine passende Einstellung. Erinnerungen müssen den betroffenen Monat öffnen oder auf den tatsächlich bearbeitbaren Monat beschränkt sein.
+
+**Belege:** `src/app/dashboard/notdienst/plan/_components/settings-modal.tsx:76`, `:95`; `src/app/dashboard/notdienst/page.tsx:52`; `src/lib/date-utils.ts:14`; `src/app/dashboard/notdienst/plan/actions.ts:426`, `:485`, `:503`, `:532`.
+
+**Abnahme:** Texte entsprechen der tatsächlichen Berechnung und Automatik. Auch teilweise ausgefüllte Haushalte werden berücksichtigt. Der E-Mail-Link führt zur richtigen Eingabe; fehlgeschlagene Zustellungen können einzeln wiederholt werden.
+
+## F04 – Rollen dort verwalten, wo Personen verwaltet werden
+
+**Aktueller Ablauf:** Registrierung und Kita-Einrichtung erzeugen den ersten Admin. Familienanlage erzeugt Elternkonten; die Fachkräfte-Anlage erzeugt Fachkraftkonten. Es gibt keinen regulären Weg, einen weiteren Kita-Admin oder eine Notdienst-Koordination zu ernennen. Auch die Superadmin-Aktionen bieten keine Rollenänderung.
+
+Ein festes Amt wie „Vorstand“ ist eine gesonderte Zuordnung und verleiht keine Admin-Rechte. Diese Trennung ist in der Bedienung nicht ausreichend erkennbar.
+
+**Vorgeschlagener Zielablauf, vom Nutzer bestätigt:** Kita-Admin öffnet eine Person innerhalb seiner Kita → wählt deren Zugriffsrolle → speichert die Änderung. Zuständigkeiten/Ämter und Zugriffsrechte erhalten klar getrennte Bezeichnungen. Mindestens ein erreichbarer Kita-Admin muss bestehen bleiben. Dies muss auch bei der eigenen Kontolöschung berücksichtigt werden: `deleteMyAccount` prüft derzeit Notdienst-Verpflichtungen, aber keine letzte Admin-Rolle.
+
+**Belege:** `src/app/register/actions.ts:91`; `src/app/onboarding/actions.ts:130`; `src/app/dashboard/families/actions.ts:236`, `:404`; `src/app/admin/actions.ts`; `src/app/dashboard/families/duty-manager.tsx`; `src/app/dashboard/profil/actions.ts:286`.
+
+**Abnahme:** Rollenänderungen wirken innerhalb der eigenen Kita und sind nachvollziehbar. Ein Amt allein verändert keine Berechtigungen. Bestehende Fachkraftprofile und Haushaltszuordnungen werden bei einer Rollenänderung ausdrücklich berücksichtigt.
+
+## F05 – Manuelle Notdienstplanung ohne Gegenprüfung in einer zweiten Ansicht
+
+**Aktueller Ablauf:** Bei der manuellen Einteilung enthält die Auswahl sämtliche aktiven Kinder samt Familie und bisheriger Einteilungszahl. Ob die Familie am gewählten Tag verfügbar ist, steht nicht in dieser Auswahl. Die Koordination muss die Verfügbarkeit in einer anderen Ansicht prüfen. Geschwister erscheinen als separate Auswahlmöglichkeiten für denselben Haushalt.
+
+Beim erstmaligen Veröffentlichen wird der Plan freigegeben, aber keine E-Mail versendet. Spätere Änderungen können dagegen Benachrichtigungen auslösen. Das ist eine uneinheitliche Kommunikation; eine Mail zur Erstveröffentlichung ist ein Verbesserungsvorschlag, bisher keine bestätigte Produktregel.
+
+**Vorgeschlagener Zielablauf:** Tag auswählen → verfügbare Haushalte direkt erkennen → Einteilung vornehmen. Andere Haushalte bleiben für bewusst begründete Sonderfälle auswählbar und sind gekennzeichnet. Veröffentlichung bietet einen klar bezeichneten Schritt zur Information der Familien mit sichtbarem Versandstatus.
+
+**Belege:** `src/app/dashboard/notdienst/plan/page.tsx:118`; `src/app/dashboard/notdienst/plan/plan-view.tsx:643`; `src/app/dashboard/notdienst/plan/actions.ts:139`, `:353`.
+
+Der Übergang vom Plan zum Notdienstalarm ist dagegen bereits sinnvoll: Der Link übergibt die konkrete Einteilung, sodass diese im Alarmformular nicht erneut gesucht werden muss.
+
+## F06 – Kalenderfunktionen in jeder Ansicht erreichbar machen
+
+**Aktueller Ablauf:** Die Listenansicht bietet „Details“ einschließlich Mitbring-Liste. Die Monatsansicht bietet diese Inhalte über den Tagesdialog. Die Agenda zeigt zwar Termine und RSVP-Antworten, bietet aber keinen entsprechenden Detailzugang und keine Mitbring-Liste. Eltern müssen die Ansicht wechseln, um denselben Termin vollständig zu bearbeiten. Der Unterschied wurde im lokalen Browser bestätigt.
+
+Mitbring-Einträge besitzen nur Hinzufügen und Löschen. Eine Mengenänderung oder ein Tippfehler erfordert Löschen und erneute Eingabe.
+
+**Vorgeschlagener Zielablauf:** Einheitlicher Termindialog aus Monat, Agenda und Liste → Beschreibung, Anmeldung und Mitbringen am selben Ort. Eigene Mitbring-Einträge lassen sich direkt bearbeiten. Bestehende Berechtigungen für fremde Einträge bleiben maßgeblich. Aktueller Zeitraum und Filter bleiben beim Öffnen und Schließen erhalten.
+
+**Belege:** `src/app/dashboard/kalender/_components/calendar-overview-client.tsx:329`, `:856`; `src/app/dashboard/kalender/_components/termin-list.tsx:326`, `:429`; `src/app/dashboard/kalender/_components/mitbringsel-list.tsx:32`, `:46`; `src/app/dashboard/kalender/actions.ts:1048`, `:1089`.
+
+Die Anmeldung pro Familie oder Kind ist bereits vorhanden und integriert. Sie muss dafür nicht neu gebaut werden.
+
+## F07 – Mitteilungen korrigieren und Versand unabhängig wiederholen
+
+**Aktueller Ablauf:** Admins können eine Mitteilung erstellen und optional per E-Mail versenden. Nach der Veröffentlichung gibt es keine Bearbeitungsfunktion und keinen erneuten Versand. Die Admin-Seite zeigt nur die letzten acht Mitteilungen, ohne weiterführende Verwaltungsansicht. Eine Korrektur führt deshalb praktisch zu einem weiteren Beitrag; ein Mailfehler hat keinen Wiederholungsweg.
+
+Positiv: Die Aktion behandelt einen Mailfehler bereits als Warnung zu einer erfolgreich gespeicherten Mitteilung. Die Familienanlage sollte denselben verständlichen Abschluss bieten.
+
+**Vorgeschlagener Zielablauf:** Veröffentlichte Mitteilung öffnen → Inhalt korrigieren und Änderungsstand sichtbar machen → bei Bedarf über die Korrektur informieren. Für den Versand gibt es einen eigenen Status und eine gezielte Wiederholung. Ältere Mitteilungen bleiben für Admins verwaltbar.
+
+**Belege:** `src/actions/announcements.ts:80`, `:172`, `:203`, `:211`; `src/app/dashboard/admin/news/page.tsx:50`, `:116`.
+
+## F08 – Die eigene Ersteinrichtung zusammenführen und rollenabhängig gestalten
+
+**Aktueller Ablauf:** Wer noch keinen eigenen Haushalt hat, legt zuerst dessen Namen an, schließt den Dialog, legt Kinder in einem anderen Dialog an und ergänzt Kontaktdaten in einem weiteren Formular. Der Einrichtungshinweis verlangt einen Haushalt samt Kindern für alle Rollen außer Fachkräften – also auch für Admins oder Koordination ohne eigene Kita-Kinder.
+
+Dieser Befund betrifft die eigene Ersteinrichtung. Eltern, die über die Familienverwaltung eingeladen wurden, haben ihren Haushalt bereits; dort werden Eltern und Kinder zusammen erfasst.
+
+**Vorgeschlagener Zielablauf:** Eine geführte Einrichtung mit bekannten Angaben, Kontakten und – wenn relevant – Haushalt samt Kindern. Nach jedem Schritt ist der nächste direkt erreichbar. Admins und Koordination können angeben, ob sie auch als Eltern teilnehmen; fehlende eigene Kinder dürfen sonst keinen dauerhaften Unvollständigkeitshinweis erzeugen. Diese Rollenvariante ist noch fachlich zu bestätigen.
+
+Kleine Zusatzkorrektur: „Hinweis dauerhaft ausblenden“ wird heute über einen browserweiten Schlüssel gespeichert. Die Einstellung sollte dem jeweiligen Nutzer zugeordnet sein, damit ein anderes Konto am selben Gerät seine eigenen Hinweise behält.
+
+**Belege:** `src/app/dashboard/profil/_components/create-family-dialog.tsx:29`, `:57`; `src/app/dashboard/profil/page.tsx`; `src/components/OnboardingDialog.tsx:46`, `:55`.
+
+## F09 – Personalformulare mit dem betrachteten Tag verbinden
+
+**Aktueller Ablauf:** „Arbeitszeit erfassen“ erhält nur das Personalprofil. Ein neuer Eintrag startet immer mit dem heutigen Datum, 08:00–16:00 Uhr und 30 Minuten Pause – auch wenn gerade eine andere Woche betrachtet wird. Nach dem Speichern schließt sich das Formular. Für weitere Arbeitsblöcke muss die Fachkraft es erneut öffnen und den Tag wieder wählen.
+
+Freizeitausgleich und halber Urlaubstag verlangen laut Formular „Von = Bis“, zeigen aber zwei unabhängige Datumsfelder. Ein einzelner Tag muss damit zweimal angegeben werden.
+
+**Vorgeschlagener Zielablauf:** „Zeit erfassen“ am konkreten Tag mit vorausgewähltem Datum. „Speichern und weiteren Block erfassen“ behält den Tag bei. Bei Ein-Tages-Anträgen genügt ein Datum; das Ende wird daraus abgeleitet. Tatsächliche Arbeitszeiten bleiben ausdrücklich eingegebene Werte, auch bei festen Arbeitstagen.
+
+Für die erstmalige Personaleinrichtung wäre ergänzend ein geführter Abschluss für Arbeitsmodell, Urlaubskonto und Anfangssaldo hilfreich. Die getrennten Einstellungen sind für spätere Änderungen sinnvoll; die bisher vereinbarte Anlage mit anschließender Profileinrichtung ist daher kein Fehler.
+
+**Belege:** `src/app/dashboard/personal/page.tsx:287`; `src/app/dashboard/personal/forms.tsx:368`, `:375`, `:477`, `:498`, `:643`.
+
+## F10 – Ämter-Schaltflächen eindeutig einer Person zuordnen
+
+**Aktueller Ablauf:** Eine Familie mit zwei Elternkonten bekommt zwei nahezu gleich beschriftete „Ämter“-Schaltflächen. Erst nach dem Öffnen zeigt der Dialog, welches Elternteil gemeint ist. Das wurde im lokalen Browser bestätigt. Ein neues Amt anzulegen und es der gerade geöffneten Person zuzuweisen sind außerdem separate Aktionen.
+
+**Vorgeschlagener Zielablauf:** „Ämter: Vorname“ oder eine gemeinsame Familienansicht mit klar getrennten Personen. Im Personenkontext kann „Amt anlegen und zuweisen“ beide Schritte verbinden.
+
+Die festen persönlichen Ämter und die wechselnden Elterndienste sind fachlich verschiedene Dinge. Verständliche Bezeichnungen sollten diese Unterscheidung sichtbar machen.
+
+**Belege:** `src/app/dashboard/families/_components/families-list-client.tsx:292`; `src/app/dashboard/families/duty-manager.tsx:107`, `:123`; `prisma/schema.prisma` (`ParentDuty`, `DutyType`).
+
+## F11 – Zugang wiederherstellen statt außerhalb der Anwendung lösen
+
+**Aktueller Ablauf:** Im Login fehlt „Passwort vergessen“, im Profil die eigene Passwortänderung. Ein bereits verwendeter Aktivierungslink kann nach dem Löschen des Tokens eine allgemeine 404-Seite liefern. Abgelaufene Links verweisen auf den Admin; bei Familien fehlt dessen erneuter Versandweg aus F01.
+
+Ein seltener Alt-Daten-Fall führt zusätzlich auf „Datenschutz-Einwilligung erforderlich“, bietet dort aber nur einen Verweis an Admin oder Support. Die Seite hat keinen direkten Abschluss; auch die bestehenden Support-Aktionen bieten dafür keinen passenden Korrekturablauf. Der normale Registrierungs- und Einladungsablauf erfasst die Einwilligung bereits.
+
+**Vorgeschlagener Zielablauf:** Passwort-Wiederherstellung über einen zeitlich begrenzten Link; eindeutige Weiterleitung zum Login nach bereits erfolgter Aktivierung; passende Möglichkeit für einen neuen Einladungslink. Alt-Konten können eine fehlende Einwilligung innerhalb der Anwendung nachholen.
+
+**Belege:** `src/app/login/login-form.tsx`; `src/app/dashboard/profil/page.tsx`; `src/app/invite/[token]/page.tsx:39`, `:84`; `src/app/invite/[token]/actions.ts:153`; `src/app/onboarding/consent/page.tsx:46`; `src/app/admin/actions.ts`.
+
+## F12 – Fachliche Filter und Statuszahlen verlässlich anzeigen
+
+**Hoch:** Der Gruppenfilter in der Kita-Abwesenheitsübersicht ordnet Kinder über den Zeichencode des ersten Buchstabens ihres Namens „Krippe“ oder „Elementar“ zu. Das ist keine tatsächliche Gruppenzuordnung. Der Filter kann Kinder aus einer vermeintlich fachlichen Übersicht entfernen und dadurch falsche Schlüsse nahelegen.
+
+**Niedrig:** Das Menü zeigt beim Notdienst fest die Zahl „4“. Sie wird nicht aus offenen Aufgaben berechnet und verändert sich durch deren Erledigung nicht.
+
+**Vorgeschlagener Zielablauf:** Gruppenfilter erst mit einer echten gespeicherten Gruppenzuordnung anbieten; bis dahin ausblenden. Statuszahlen aus den jeweiligen offenen Aufgaben berechnen und ihre Bedeutung benennen oder weglassen.
+
+**Belege:** `src/app/dashboard/admin/abwesenheiten/_components/absences-client.tsx:69`, `:77`; `src/components/dashboard/sidebar-nav.tsx:60`.
+
+## Bereits sinnvolle Abläufe und Prüfungsabdeckung
+
+| Bereich | Ergebnis der Ablaufprüfung |
+| --- | --- |
+| Fachkraft anlegen und aktivieren | Name, Pflicht-E-Mail und Starttermin gemeinsam; Profilübergang sowie Einladungsstatus und erneutes Senden vorhanden. |
+| Familie anlegen | Eltern und Kinder gemeinsam erfassbar; hauptsächlich der Abschluss bei Mailproblemen und der erneute Versand brauchen Verbesserung (F01). |
+| Profil und Kinderverwaltung | Eigene Kinder und Kontaktdaten bearbeitbar; Ersteinrichtung und Wiederherstellung siehe F08/F11. |
+| Adressbuch | Suchen, Filtern und Kontakt öffnen am selben Ort; Freigabe im Profil ist eine nachvollziehbare gesonderte Einstellung. |
+| Kinder-Abwesenheiten | Meldung direkt vom Dashboard möglich; Verwaltung und Gruppenfilter siehe F02/F12. |
+| Arbeitszeit und Urlaub | Zeiten, Wochenfreigaben, Anträge, feste Arbeitsmodelle und Konten integriert; Eingabekontext siehe F09. |
+| Feiertage im Personalbereich | Eintrag im selben Personalbereich; nicht automatisch mit Kita-Schließtagen gleichsetzen, da Schließtage Arbeitstage sein können. |
+| Kalender und RSVP | Anmeldung pro Familie/Kind sowie Terminverwaltung vorhanden; Detailzugang und Mitbringen siehe F06. |
+| Terminanfragen und Notdiensttausch | Anfrage und Antwortaktionen vorhanden; Freigabe bzw. Zustimmung anderer Personen ist ein notwendiger fachlicher Schritt. |
+| Mitteilungen | Dashboard-Anzeige und eigenes Archiv vorhanden; Korrektur und Versandverwaltung siehe F07. |
+| Wechselnde Elterndienste | Dienstarten und Einteilung auf derselben Verwaltungsseite; fachliche Unterscheidung zu persönlichen Ämtern siehe F10. |
+| Notdienstplanung | Automatischer Vorschlag, Vorschau, manuelle Einteilung und Veröffentlichung vorhanden; F03/F05 betreffen Orientierung und Kommunikation. |
+| Notdienstalarm | Einteilung aus dem Plan vorausgewählt; Rückmeldung, Frist und Mailstatus integriert. Separater Alarmdialog ist fachlich sinnvoll. |
+| Kita-Einrichtung, Login und Superadmin | Bestehende Einrichtung, Diagnose und Support geprüft; Zugriffsrollen und Wiederherstellung siehe F04/F11. Keine produktiven Support-Aktionen ausgeführt. |
+
+„Vorhanden“ bedeutet hier, dass der Bedienweg im aktuellen Code nachvollziehbar ist. Es ist keine Zusicherung, dass jede Ausnahme oder Berechnung bereits durch diese Prüfung getestet wurde.
+
+## Empfohlene Umsetzungspakete
+
+1. **Sackgassen und falsche Anzeigen beseitigen:** Eltern-Abwesenheitslink und eigene Verwaltungsansicht (F02), erfundenen Gruppenfilter entfernen (F12), gespeicherte Familien bei Mailfehler korrekt abschließen und Einladungen erneut senden (F01).
+2. **Notdienst-Rücklauf verlässlich machen:** Einstellungen richtig benennen, unvollständige Meldungen erkennen, Monatsbezug und Versandstatus korrigieren (F03); anschließend manuelle Einteilung und Veröffentlichung vereinfachen (F05).
+3. **Personen und Zugänge verwalten:** Kita-interne Rollenverwaltung gemäß Nutzerentscheidung (F04), Passwort- und Aktivierungs-Wiederherstellung (F11).
+4. **Alltagskorrekturen direkt ermöglichen:** Einheitliche Kalenderdetails und editierbare Mitbring-Einträge (F06), bearbeitbare Mitteilungen mit eigenständigem Versandstatus (F07).
+5. **Weniger wiederholte Eingaben:** Tagesbezogene Arbeitszeitformulare und Ein-Tages-Anträge (F09), geführte Ersteinrichtung (F08), eindeutig beschriftete Ämter (F10) und echte Menü-Zahlen (F12).
+
+Vor der Umsetzung der jeweiligen Zusatzregel noch zu entscheiden: Umgang mit mehrtägigen Abwesenheiten über die Grenze „heute“ hinweg; Teilnahme von Admins/Koordination ohne eigene Kinder; automatische Verfügbarkeits-Erinnerungen samt Termin; E-Mail zur ersten Planveröffentlichung. Diese Punkte verhindern nicht die bereits eindeutig beschriebenen Korrekturen.
+
+## Verifikation und nächster Arbeitsstand
+
+Die Quellcodebefunde wurden gegen den genannten Commit geprüft. Im lokalen Browser bestätigt wurden insbesondere der nicht nutzbare Eltern-Abwesenheitslink, die fehlenden Einladungsaktionen in Familien-Details, gleich benannte Ämter-Schaltflächen sowie unterschiedliche Detailzugänge im Kalender.
+
+Dieses Dokument liegt auf der eigenen Arbeitsbranch `codex/flow-audit`. Für die Dokumentation wurden keine Anwendungstests oder ein neuer Build benötigt. Bei der Umsetzung gehören gezielte Tests der Datums-/Rollenregeln und der Mailfehlerfälle zu den jeweiligen Paketen.

docs/FAMILIEN_UND_ABWESENHEITEN.md

@@ -0,0 +1,68 @@
+# Familieneinladungen und Abwesenheitsverwaltung
+
+Stand: 9. Oktober 2026. Umsetzung der Befunde F01 und F02 aus der [Ablaufprüfung](ABLAUFPRUEFUNG.md), einschließlich Entfernung des künstlichen Gruppenfilters aus F12.
+
+## Familieneinladungen
+
+- Die Familienanlage erfasst weiterhin Eltern und Kinder gemeinsam. Die Familie, Konten, Aktivierungslinks und Versandaufträge werden gemeinsam gespeichert.
+- Scheitert danach der Mailversand, bleibt die Familienanlage erfolgreich. Das Formular schließt, die Liste aktualisiert sich und eine Warnung weist auf den erneuten Versand hin. Auch die Ergänzung eines Elternteils in einer bestehenden Familie folgt diesem Ablauf.
+- Jeder Empfänger wird bearbeitet, auch wenn eine andere Einladung fehlschlägt.
+- Tabelle, Kartenansicht und Familien-Details zeigen den Status je Elternkonto: aktiviert, Aktivierung offen, Versand läuft, versendet, fehlgeschlagen oder abgelaufen. Soweit vorhanden, wird das Ablaufdatum angezeigt.
+- Kita-Admins können die Einladung innerhalb ihrer Kita beim jeweiligen Elternteil erneut senden. Aktivierte Konten werden nicht erneut eingeladen. Parallel ausgelöste Versandversuche werden gegen doppelte Bearbeitung geschützt.
+- Ein noch gültiger, fehlgeschlagener Versand wird mit demselben Link wiederholt. Bei abgelaufenem oder zuvor erfolgreich versendetem Link wird ein neuer Link für sieben Tage erstellt; ältere Aktivierungslinks des Kontos werden ersetzt. Direkt nach einem erfolgreichen Versand gilt eine Minute Abstand bis zum erneuten Versand.
+- Wird die Adresse eines noch nicht aktivierten Kontos korrigiert, versendet das Speichern automatisch eine neue Einladung an diese Adresse. Solange die Adressänderung ungespeichert ist, ist der separate erneute Versand gesperrt.
+- Bereits bestehende Elternkonten und Aktivierungslinks bleiben gültig. Alte Konten ohne gespeicherten Versandstatus erscheinen als „Aktivierung offen“; beim erneuten Senden wird der Status ergänzt. Das Löschen und Neuanlegen einer Familie ist dafür nicht nötig.
+- Nach der Aktivierung wird der Einladungsstatus abgeschlossen. „Versendet“ bedeutet, dass der Mailtransport die Nachricht angenommen hat; eine tatsächliche Zustellung oder ein späterer Bounce wird hier nicht überwacht.
+
+Bei Eingabefehlern bleiben die Formulardaten erhalten. Nach einem erfolgreichen Vorgang öffnet sich das Formular wieder mit einem frischen Zustand. Die Kinder-Schaltfläche entfernt das tatsächlich gewählte Kind aus dem Entwurf.
+
+## Kinder-Abwesenheiten
+
+„Meine Abwesenheiten“ ist über das Menü und die Dashboard-Karte erreichbar. Die Seite zeigt ausschließlich Meldungen des eigenen Haushalts, getrennt nach aktuellen/zukünftigen und vergangenen Meldungen, mit jeweils bis zu 20 Meldungen pro Seite.
+
+| Rolle | Neue Meldung | Ändern oder zurücknehmen |
+| --- | --- | --- |
+| Eltern | Eigene aktive Kinder, ab heute | Eigene Meldungen, deren Beginn nach heute liegt; auch der neue Beginn muss zukünftig bleiben. |
+| Kita-Admin, Notdienst-Koordination, Fachkraft | Der bestehende Dashboard-Meldeweg betrifft den eigenen Haushalt. | Vorhandene Meldungen innerhalb der eigenen Kita, einschließlich laufender Meldungen, in der Kita-Tagesübersicht korrigieren oder zurücknehmen. |
+
+Die vom Nutzer bestätigte Mehrtagesregel gilt für die gesamte Meldung: **Sobald sie begonnen hat, übernimmt die Kita auch die noch zukünftigen Tage.** Eltern können die zukünftige Hälfte einer laufenden Meldung nicht eigenständig abtrennen.
+
+Die Bearbeitung zeigt Zeitraum, Grund und Bemerkung in einem Dialog. Bei Verschieben des Beginns hinter das bisherige Ende wird das Ende angepasst. Eine Rücknahme erhält einen eigenen Bestätigungsdialog. Laufende Meldungen zeigen Eltern einen verständlichen Hinweis auf die Kita.
+
+Die Regeln gelten auch serverseitig:
+
+- Aktuelle Rollen und Haushaltszugehörigkeit werden vor Schreibzugriffen aus der Datenbank geprüft.
+- Kalendertage werden unabhängig von der Server-Zeitzone als UTC-Datum gespeichert; die Grenze „heute“ folgt `Europe/Berlin`.
+- Ungültige Tage, umgekehrte Zeiträume und Überschneidungen werden abgewiesen. Gleichzeitige Meldungen für dasselbe Kind werden serialisiert.
+- Ein veralteter Bearbeitungsstand überschreibt keine zwischenzeitliche Änderung. Die Oberfläche bietet bei diesem Konflikt das Aktualisieren der Ansicht an.
+- Erfolgreiche Änderungen aktualisieren Dashboard, eigene Verwaltung und Kita-Tagesübersicht.
+
+Der bisherige Gruppenfilter „Krippe/Elementar“ wurde entfernt, weil keine tatsächliche Gruppenzuordnung hinterlegt ist. Ein fachlicher Gruppenfilter bleibt ein eigener späterer Ausbau.
+
+## Deployment und Betrieb
+
+Das Prisma-Modell `Invitation` erhält einen optionalen Bezug zum Elternkonto sowie Versandzeit, Versuchszähler, Fehlerstatus und eine zeitlich begrenzte Versandsperre. Vorhandene Datensätze müssen nicht neu angelegt werden.
+
+Der vorgeschaltete Compose-Dienst `migrate` führt `prisma migrate deploy` und die eingeschränkten Runtime-Grants aus. Die versionierte Migration `20261010000000_family_invitation_flows` ergänzt die Felder und prüft die Mandantenzuordnung des Empfängers. Der App-Start benötigt keine Schema- oder Administrationsrechte. **Es sind keine neuen Umgebungsvariablen nötig.** Resend-Absender, API-Schlüssel und App-Adresse werden wie bisher verwendet.
+
+Bei einem eigenen Startablauf die versionierten Migrationen und Runtime-Grants vor dem neuen App-Code ausführen; siehe die zentrale Deployment-Anleitung. Kein `prisma db push` und kein historisches SQL-Upgrade zusätzlich zu den Migrationen verwenden.
+
+Die normalen Sicherungs- und Schema-Prüfschritte gelten weiterhin; siehe [Deployment und Mailversand](../deploy/DEPLOYMENT_UND_MAILVERSAND.md). Für Familieneinladungen ist kein zusätzlicher Cronjob erforderlich. Fehlgeschlagene oder unterbrochene Versandversuche werden gezielt durch Kita-Admins wiederholt.
+
+## Prüfung
+
+- Unit-Tests für echte Kalendertage, Berliner Mitternachts-/Zeitumstellungsgrenzen und Einladungszustände.
+- PostgreSQL-Integrationstests mit simuliertem Mailtransport: Speicherung trotz Mailfehler, zweiter Empfänger, gezieltes erneutes Senden, Ablauf/Erneuerung, Alt-Konten, paralleler Versand, Aktivierungsabschluss, Adresskorrektur und Berechtigungen.
+- PostgreSQL-Integrationstests für Eltern- und Kita-Korrekturen, begonnene Mehrtagesmeldungen, fremde Haushalte/Kitas, Überschneidungen, konkurrierende Erstellung und veraltete Bearbeitungsstände.
+- Wiederholbarkeit des SQL-Upgrades auf leerem und bestehendem Testschema mit Erhalt vorhandener Tokens.
+- Lokale Browserprüfung mit deaktiviertem echtem Mailversand: Anlage und Bearbeitung schließen trotz Versandwarnung; Formulare behalten Fehler-Eingaben und lassen sich erneut öffnen; zukünftige Elternmeldung und laufende Kita-Meldung werden erfolgreich korrigiert.
+- TypeScript, ESLint und Produktionsbuild.
+
+Testbefehle:
+
+```sh
+npm run test:family-absence
+TEST_DATABASE_URL='postgresql://USER@127.0.0.1:PORT/TEST_DATABASE' npm run test:family-absence:integration
+```
+
+Integrationstests akzeptieren nur eine ausdrücklich benannte lokale Testdatenbank. Die Browserprüfung nutzt ausschließlich synthetische Daten und verschickt keine echten E-Mails.

docs/FUNKTIONSUEBERSICHT.md

@@ -1,5 +1,75 @@
 # Kita-Planer – Funktionsübersicht und aktueller Stand
 
+## Ergänzung vom 12.10.2026: Kontozugang und weniger wiederholte Eingaben
+
+- Die Ämter-Schaltflächen nennen die betroffene Person („Ämter: Vorname“) und tragen einen vollständigen zugänglichen Namen. Der Einrichtungshinweis wird je Konto in diesem Browser ausgeblendet. Das alte gemeinsame Ausblenden gilt nicht mehr für alle Konten; fehlender Browser-Speicher verhindert die Nutzung nicht.
+- Unter `/passwort-vergessen` können aktivierte Konten einen Wiederherstellungslink anfordern. Die öffentliche Antwort bleibt für bestehende, unbekannte, deaktivierte und begrenzte Anfragen gleich. Kontosuche und Mailversand laufen nach der Antwort über Next.js `after`; ein Fehler verrät öffentlich keine Kontodaten.
+- Reset-Links sind 30 Minuten gültig, einmal nutzbar und an die aktuelle Sitzungsfassung gebunden. Die vorhandene Verifikationstabelle speichert ausschließlich den Tokenhash und einen eigenen Reset-Zweck. Einladungslinks können kein Passwort zurücksetzen. Neue Reset-Anfragen ersetzen ältere Links; zwischenzeitliche E-Mail-/Passwortänderungen, administrative Kontosperren oder Löschungen verhindern die Verwendung alter Links. Fehlgeschlagener Versand entfernt ausschließlich den eigenen neu erzeugten Link.
+- Im Profil lässt sich das Passwort mit dem aktuellen Passwort und übereinstimmender Bestätigung ändern. Sowohl Wiederherstellung als auch eigene Änderung erhöhen die Sitzungsfassung und beenden alte Anmeldungen; eine neue Anmeldung ist erforderlich. Persönliche Alarmlinks, die an diese frühere Sitzungsfassung gebunden sind, werden ebenfalls ungültig. Kontoaktivierung, Kita, Haushalt, Rollen und Einwilligungen bleiben erhalten. Es gelten weiterhin mindestens acht Zeichen und die bcrypt-Grenze von 72 UTF-8-Bytes.
+- Anfragebegrenzungen: drei Reset-Anfragen je E-Mail/Stunde, fünf Reset-Abschlussversuche je Link/15 Minuten und fünf eigene Passwortänderungsversuche je Konto/15 Minuten; zusätzlich die bestehenden gemeinsamen und ggf. Proxy-IP-Limits. Bestehende Mailkonfiguration und App-Adresse werden verwendet. Keine neue Umgebungsvariable oder Datenbankmigration erforderlich.
+- Die Kalender-Agenda öffnet den bereits vorhandenen Tagesdetaildialog mit Beschreibung, Rückmeldung, Mitbringliste und berechtigten Verwaltungsaktionen. Ansicht und Suche bleiben beim Schließen erhalten. Die Agenda passt sich auf schmalen Bildschirmen an.
+- Neue Arbeitszeitformulare übernehmen die betrachtete Woche bzw. den ausgewählten Tag. Tage in der Zukunft sind nicht erfassbar. „Speichern und weiteren Block erfassen“ hält den tatsächlich eingegebenen Tag fest, leert die Uhrzeiten, setzt die Pause auf null und fokussiert den Beginn. Bestehende Zeiteinträge werden weiterhin einzeln bearbeitet; serverseitige Zeit-, Überschneidungs- und Freigaberegeln bleiben maßgeblich.
+- Freizeitausgleich und halber Urlaubstag benötigen ein Datum. Das Ende wird aus diesem Datum übernommen; mehrtägiger Urlaub und Krankheit behalten Von/Bis. Die Berechnungs- und Genehmigungsregeln ändern sich nicht.
+
+Prüfbefehl: `TEST_DATABASE_URL=postgresql://USER:PASSWORD@127.0.0.1:PORT/kita_account_test npm run test:account` nach Anwendung der vorhandenen Migrationen auf dieser separaten lokalen Testdatenbank. Die 20 neuen PostgreSQL-Tests prüfen den tatsächlichen Passwortdienst, Server Actions, bcrypt und JWT-Entwertung mit ersetztem Mailtransport. Dazu 139 bestehende Sicherheits-, Rollen-, Kalender-, Familien- und Personaltests erfolgreich (159 insgesamt, keine übersprungenen Tests).
+
+Browser-Abnahme mit synthetischen Konten auf Desktop und bei 390 Pixeln: neutrale Reset-Bestätigung und tatsächliche nachgelagerte Vorbereitung, gültige/ungültige Linkseiten, Passwortformular im Profil, getrennte Einrichtungshinweise bei Konto-Wechsel, eindeutige Ämter, Agenda-Details samt gespeichertem Mitbringbeitrag und erhaltenem Suchfilter. Arbeitszeit in vergangener Woche und am ausgewählten Tag geprüft; zwei Blöcke mit 60 und 45 Minuten am selben eingegebenen Tag gespeichert. Halber Urlaubstag mit identischem Start/Ende gespeichert; Freizeitausgleich zeigt ebenfalls nur ein Datum. Passwortänderungen selbst wurden in den Integrationstests ausgeführt. Es wurden keine echten Mails verschickt oder produktiven Daten verändert. Produktionsbuild und TypeScript erfolgreich; ESLint ohne Fehler mit fünf bestehenden Warnungen.
+
+
+## Ergänzung vom 12.10.2026: Manuelle Planung und Zugriffsrechte
+
+- Die manuelle Notdienst-Zuweisung gruppiert verfügbare Haushalte zuerst. Familien ohne Verfügbarkeit für den gewählten Tag bleiben als abgestimmter Sonderfall auswählbar und werden nach einer solchen Einteilung ausdrücklich gekennzeichnet. Geschwister zählen als ein Haushalt; Einteilungszahlen gelten ebenfalls je Haushalt. Die Anzeige verwendet dieselben gültigen Monatstage wie die Planung. Bestehende Alarm- und Schließtagssperren bleiben bestehen.
+- Kita-Admins verwalten Zugriffsrollen unter `/dashboard/zugriffsrechte` sowie direkt bei Personen in Familien- und Teamverwaltung. Die Übersicht enthält auch Konten ohne eigenen Haushalt, eine Suche und die letzten 15 protokollierten Rollenänderungen der eigenen Kita.
+- Haushaltskonten können Eltern, Notdienst-Koordination oder Kita-Admin sein. Ohne Haushalt stehen Koordination und Kita-Admin zur Verfügung. Konten mit Personalprofil können Fachkraft oder Kita-Admin sein; Arbeitszeiten, Anträge und Haushalt bleiben erhalten. Ein Personalprofil wird durch eine Rollenänderung nicht neu angelegt. Systemadmins werden hier nicht verwaltet. Ämter wie „Vorstand“ verleihen keine Zugriffsrechte.
+- Rollenänderungen prüfen Akteur und Zielkonto erneut innerhalb einer serialisierbaren Transaktion. Eine zwischenzeitlich geänderte Rolle wird nicht überschrieben. Das bestehende Login liest die Rolle bei jeder Anfrage neu; eigene Herabstufung führt zurück zur Übersicht. Offene Aktivierungslinks benötigen weiterhin die Aktivierung, bevor Zugang entsteht.
+- Mindestens ein aktiver Kita-Admin mit verifiziertem Konto, Passwort und Datenschutzzustimmung bleibt erhalten. Herabstufung, eigene Kontolöschung, Support-Löschung/-Sperre und eine E-Mail-Änderung mit erneuter Aktivierung berücksichtigen denselben Schutz. Offene Einladungen, deaktivierte/gesperrte Konten oder fehlende Zustimmung zählen nicht als Ersatz. Gleichzeitige Änderungen werden abgefangen.
+- Eltern mit Admin-/Koordinationsrolle erhalten weiterhin Haushaltsalarme, können über ihre persönlichen Links antworten und erhalten Mails nach manueller Umteilung. Fachkräfte mit Admin-Rolle können ihr verknüpftes Personalprofil weiter nutzen; persönliche Benachrichtigungseinstellungen und offene Fachkraftaktivierungen bleiben funktionsfähig.
+- Kein Schema-Upgrade erforderlich.
+
+Prüfbefehl: `TEST_DATABASE_URL=postgresql://USER:PASSWORD@127.0.0.1:PORT/kita_roles_test npm run test:roles` nach Anwendung der vorhandenen Migrationen auf dieser separaten lokalen Testdatenbank. Die 27 Rollen-/PostgreSQL-Tests und sechs tatsächlichen Komponenten-Rendertests verwenden synthetische Konten und ersetzte Mailtransporte.
+
+Abnahme: 33 neue Tests und 193 bestehende Sicherheits-, Planungs-, Kalender-, Versand-, Familien-, Personal- und Alarmtests erfolgreich (226 insgesamt, keine übersprungenen Tests). Browserprüfung auf Desktop und bei 390 Pixeln: verfügbare und bewusst abweichende Einteilung, Rollenänderung aus Familien-/Teamverwaltung, Suche, Änderungshistorie, Schutz für einzigen Admin und eigene Herabstufung mit unmittelbar verweigertem Verwaltungszugriff. Produktionsbuild und TypeScript erfolgreich; ESLint ohne Fehler mit sieben bestehenden Warnungen.
+
+
+## Ergänzung vom 12.10.2026: Notdienst-Benachrichtigungen
+
+- Automatische Erinnerungen erfassen auch unvollständige Verfügbarkeiten. Das Soll wird aus allen aktiven Kindern und die Istzahl aus unterschiedlichen gültigen Tagen berechnet. Admin-/Koordinationskonten mit eigenem Haushalt gehören zur Eltern-Empfängergruppe.
+- Die Erinnerungsfrist bezieht sich jetzt ausdrücklich auf den 26. als Ende der Eintragsfrist. Standard: sieben Tage vorher ab 9 Uhr Berliner Zeit; 0 deaktiviert die automatische Runde. Verpasste Läufe werden innerhalb der noch offenen Frist nachgeholt. Jede Kita/Folgemonat erhält eine automatische Runde; manuelle Erinnerungen sind je Konto/Tag dedupliziert.
+- Beim ersten Veröffentlichen werden Mailaufträge in derselben Transaktion gespeichert. Pro erreichbarem Konto wird eine gemeinsame Nachricht mit den aktuellen eigenen Diensten erzeugt. Mehrfaches Veröffentlichen erzeugt keine zweite Runde. Mailfehler ändern den veröffentlichten Status nicht.
+- Die Monatsplanung zeigt Versandzahlen und Einzelstatus sowie eine manuelle Wiederholung offener/fehlgeschlagener Nachrichten. Bereits versendete oder inzwischen überholte Aufträge werden dabei nicht neu verschickt.
+- Der bestehende geschützte Notdienstjob verarbeitet die Nachrichten automatisch. Gespeicherte Reservierungen, Idempotenzschlüssel, zunehmende Wiederholungsabstände und erneute Berechtigungs-/Einteilungsprüfung sichern die Verarbeitung. Der Produktionsstart startet einen abgebrochenen Worker erneut.
+- Additive Migration: `20261012000000_notdienst_notifications`. Sie erhält die bisherigen Constraints und ergänzt drei weitere Tenant-Fremdschlüssel. Einrichtung und Grenzen stehen in [deploy/README.md](../deploy/README.md).
+
+Prüfbefehle: `npm run test:mail`, `npm run test:runtime`, `npm run test:notdienst` und `TEST_DATABASE_URL=postgresql://USER:PASSWORD@127.0.0.1:PORT/kita_notifications_test npm run test:notdienst:notifications` nach Anwendung der Migrationen auf dieser separaten Testdatenbank. Die Versandtests verwenden ersetzte Transporte; reale Eltern werden nicht angeschrieben.
+
+Abnahme: 33 neue Versand-Integrationstests, vier Tests des tatsächlichen SDK-Transports, zwei Supervisor-Tests, sechs Datums-/Fristtests sowie 106 bestehende Sicherheits-, Planungs-, Kalender- und Elternablauftests erfolgreich (151 insgesamt, keine übersprungenen Tests). Browserprüfung mit lokalem Mailserver: automatische Erinnerung einmalig, Veröffentlichung trotz simuliertem Versandfehler, sichtbare Einzelstatus, erfolgreiche Wiederholung und mobile Anzeige. TypeScript und Produktionsbuild erfolgreich; ESLint ohne Fehler mit acht bestehenden Warnungen.
+Zusätzliche Upgrade-Prüfung gegen das vorige Schema: vorhandene Familien, Konten, Kinder, veröffentlichter Plan und Einteilung unverändert erhalten; keine nachträglichen Veröffentlichungsmails angelegt. Die Zahl der ergänzenden Tenant-Fremdschlüssel steigt von 41 auf 44.
+
+## Ergänzung vom 12.10.2026: Kalender und kleine Bedienungsverbesserungen
+
+- Eigene Mitbringbeiträge lassen sich direkt mit Speichern/Abbrechen bearbeiten. Enter speichert; Escape schließt den Termindialog und verwirft den Entwurf. Eingaben werden auf 1 bis 500 Zeichen begrenzt; fremde Beiträge können auch von Admin/Koordination nicht umgeschrieben werden. Ein bestätigter Termin mit aktiver Mitbringliste und die Kita-/Autorzuordnung werden serverseitig geprüft.
+- Eltern mit Admin- oder Koordinationsrolle können für den eigenen Haushalt Dienste tauschen. Kalenderknöpfe und offene eingehende/ausgehende Anfragen stehen ihnen ebenfalls zur Verfügung. Tauschmails berücksichtigen verifizierte, aktive Elternkonten aller drei Rollen im jeweils beteiligten Haushalt. Konten ohne eigenen Haushalt erhalten dadurch kein Tauschrecht; fremde Angebote und aktive Alarme bleiben gesperrt.
+- Die fest eingetragene „4“ am Menüpunkt Notdienst wurde entfernt.
+- Kein Schema-Upgrade erforderlich. Automatische Erinnerungen und Veröffentlichungsmails bleiben die nächste Etappe.
+
+Prüfbefehl für die neuen Abläufe: `TEST_DATABASE_URL=postgresql://USER:PASSWORD@127.0.0.1:PORT/kita_quickwins_test npm run test:calendar:integration`. Er verlangt eine ausdrücklich benannte lokale Testdatenbank mit den vorhandenen Migrationen. Die 26 Fälle prüfen echte Server Actions und PostgreSQL; Mailtransport und Anmeldesession werden isoliert ersetzt. Die bestehenden Elternabläufe wurden ebenfalls mit 9 Integrationstests und 9 Berechnungstests geprüft.
+
+Im Browser geprüft: eigener Beitrag speichern und abbrechen, Anzeige bei 390 Pixeln, fehlender Bearbeiten-Knopf bei fremden Beiträgen, Navigation ohne festen Zähler, Admin-Tauschanfrage mit eigenem Angebot sowie Anzeige und Annahme durch Koordination. E-Mails wurden dabei ausschließlich im Entwicklungsmodus simuliert.
+
+Abnahme dieser Etappe: 26 neue Integrationstests, 18 bestehende Elternablauftests und 28 Sicherheitstests erfolgreich (72 insgesamt, keine übersprungenen Tests). TypeScript und Produktionsbuild erfolgreich; projektweites ESLint ohne Fehler mit acht bestehenden Warnungen.
+
+## Ergänzung vom 12.10.2026: Verlässliche Notdienst-Planungsregeln
+
+- Das Verfügbarkeitssoll wird aus allen aktiven Kindern des angemeldeten Haushalts berechnet. Ausgelassene, doppelte, fremde oder inaktive Kinder werden zurückgewiesen; doppelte Datumsangaben zählen nur einmal.
+- Oberfläche, Speicherung, Generierung und manuelle Zuweisung verwenden gemeinsame Regeln: nur Werktage des Planungsmonats, ohne bestätigte Schließtage und Teamtage. Mehrtägige Termine schließen beide Randtage ein; Kalenderzeiten werden in `Europe/Berlin` ausgewertet. Ausstehende/abgelehnte Termine und Termine anderer Kitas blockieren nichts.
+- Alte ungültige Verfügbarkeiten werden nicht für neue Pläne verwendet. Vor der Veröffentlichung werden Entwürfe auf zulässige Tage und aktive Kinder geprüft. Ungültige vorhandene Einteilungen bleiben sichtbar und können über „Manuell zuweisen“ entfernt werden; aktive Alarme und vergangene veröffentlichte Dienste behalten ihre Bearbeitungssperre.
+- Kindlöschung im Elternprofil und in der Familienverwaltung ist bei heutigen/zukünftigen veröffentlichten Notdiensten oder aktiven Alarmen gesperrt. Zuerst muss die Koordination die Einteilung klären. Prüfung und Löschung laufen in derselben serialisierbaren Transaktion mit einer Sperre der betroffenen Kinder.
+- Kein Schema-Upgrade erforderlich. Automatische Erinnerungen und Benachrichtigungen bei Erstveröffentlichung sind weiterhin offen.
+
+Prüfbefehle: `npm run test:notdienst` (Datumsregeln) und `TEST_DATABASE_URL=postgresql://USER:PASSWORD@127.0.0.1:PORT/kita_notdienst_test npm run test:notdienst:integration` (echte Server Actions und PostgreSQL). Der Integrationsbefehl verlangt ausdrücklich eine separate lokale Testdatenbank; fehlende Konfiguration führt zu einem Fehler. Zuvor die vorhandenen Migrationen auf dieser Testdatenbank anwenden.
+
+Abnahme: 4 Datumstests, 34 PostgreSQL-Regressionstests und 28 bestehende Sicherheitstests erfolgreich. Im Browser geprüft: gesperrter Teamtag/Wochenende, Speicherung des vollständigen Haushaltssolls, Veröffentlichungssperre, Entfernen einer alten ungültigen Einteilung und gültige manuelle Zuweisung mit anschließender Veröffentlichung. TypeScript und Produktionsbuild erfolgreich; projektweites ESLint ohne Fehler mit acht bestehenden Warnungen.
+
 ## Ergänzung vom 09.10.2026: Notdienstalarm
 
 Der Notdienstalarm ist inzwischen umgesetzt. Admins und Koordination alarmieren die eingeteilte Familie für einen ganzen Tag oder ein Zeitfenster. Persönliche Rückmeldelinks erzeugen eine gemeinsame Haushaltsantwort; Dashboard-Hinweise, eine 30-Minuten-Frist, Klärungsbedarf, verspätete Freigabe, telefonische Korrektur, Stornierung, Versandstatus und Hintergrundprüfung sind angebunden. Aktive Alarme sperren Planumzuordnung und Diensttausche. Siehe [NOTDIENSTALARM.md](NOTDIENSTALARM.md) für Bedienung und benötigte Hosting-Konfiguration.

docs/NOTDIENSTALARM.md

@@ -47,7 +47,7 @@ HTTP 401 bedeutet fehlende/falsche Berechtigung, 503 fehlendes/zu kurzes Job-Sec
 
 Das Schema ergänzt einen gemeinsamen Alarmvorgang, einzelne Empfänger und Tokens, Hinweise, Mailaufträge und einen Verlauf. Die bisherigen `NotdienstAlert`-Datensätze bleiben erhalten. Ein aktiver Alarm reserviert seine Einteilung eindeutig; Transaktionen schützen konkurrierende Antworten und Planänderungen.
 
-Der bestehende Docker-Start nutzt `prisma db push --skip-generate`. Für kontrollierte SQL-Upgrades liegt alternativ [deploy/sql/notdienstalarm.sql](../deploy/sql/notdienstalarm.sql) vor. Es setzt den vollständigen Personalbereich einschließlich seiner Mail-Erweiterung voraus, ist einmalig auszuführen und enthält keine Datenlöschung. Nicht zusätzlich ausführen, wenn `db push` diese Änderungen bereits angewandt hat. Datenbanksicherung und Prüfung des Ausgangsschemas gehören zum Deployment. Die Auswahl der SQL-Alternativen erklärt die [zentrale Deployment- und Mailanleitung](../deploy/DEPLOYMENT_UND_MAILVERSAND.md).
+Aktuelle Releases verwenden versionierte Prisma-Migrationen über den separaten Initialisierungsdienst. Die Einrichtung beschreibt [deploy/README.md](../deploy/README.md); `prisma db push` und die historischen SQL-Upgrades sind kein aktueller Betriebsweg. Der bestehende Hintergrundjob übernimmt zusätzlich Verfügbarkeitserinnerungen und gespeicherte Veröffentlichungsmails.
 
 Bisherige Einzelalarme werden beim Verwaltungsaufruf, Joblauf oder Aufruf eines alten Links in Gruppen pro Einteilung übernommen. Alte gültige Tokens bleiben nutzbar; Originalantworten bleiben gespeichert. Nur vollständig übereinstimmende gültige Antworten ergeben eine sichere gemeinsame Zusage. Widersprüche, fehlende/ungeklärte Empfänger oder doppelte Einzelalarme führen zu Klärungsbedarf. Bei doppelten Datensätzen eines Elternkontos wird ein Rückmeldetoken übernommen; die übrigen Originaldatensätze bleiben erhalten. Die Übernahme verschickt keine erneute Alarmanfrage.
 

docs/PERSONALBEREICH.md

@@ -60,12 +60,9 @@ Parallele Änderungen laufen in serialisierbaren Datenbanktransaktionen mit Wied
 
 ## Einführung und Schema
 
-Das Projekt verwendet weiterhin seinen vorhandenen Ablauf mit `prisma db push`. Es gibt keine vollständige versionierte Prisma-Migrationshistorie. Die neuen Tabellen sind additiv; vorhandene Personen erhalten noch kein automatisch befülltes Beschäftigungsprofil.
+Aktuelle Releases verwenden die versionierten Migrationen in `prisma/migrations` und einen separaten Initialisierungsdienst vor dem App-Start. Die [zentrale Betriebsanleitung](../deploy/README.md) beschreibt Installation, Updates, Baseline für bestehende Datenbanken und Runtime-Grants. `scripts/start-production.sh` startet die Anwendung; es verändert das Schema nicht. Kein `prisma db push` auf verwalteten Datenbanken verwenden.
 
-- Lokal: Abhängigkeiten installieren, Prisma-Client generieren, Schema gegen eine dafür vorgesehene Datenbank anwenden, App starten und Profile einrichten.
+Die historischen SQL-Dateien [Personalbereich](../deploy/sql/personalbereich.sql) und [Personalbereich-E-Mails](../deploy/sql/personalbereich-email.sql) dokumentieren ihre damaligen Ausgangsstände. Sie sind kein aktueller Deployment-Schritt und dürfen nicht zusätzlich zu den versionierten Migrationen ausgeführt werden. Vorhandene Personen erhalten weiterhin erst durch Einrichtung ein Beschäftigungsprofil.
-- Im vorhandenen Docker-Ablauf erzeugt `npm run build:prod` den Client; `scripts/start-production.sh` wendet das Schema vor App-Start an.
-- [Prüfbares SQL](../deploy/sql/personalbereich.sql) beschreibt dieselbe additive Änderung gegen den dokumentierten Ausgangsstand. Es ist einmalig und nicht idempotent. Entweder den vorhandenen Schemaabgleich **oder** dieses SQL verwenden; das SQL nicht nach bereits erfolgtem Schemaabgleich erneut ausführen.
-- Ist der Personalbereich bereits auf Stand `043fed2` eingeführt, beschreibt [Personalbereich-E-Mail-SQL](../deploy/sql/personalbereich-email.sql) ausschließlich die zusätzlichen Mail-Tabellen und die Profileinstellung. Auch dieses Skript ist eine einmalige Alternative zum Schemaabgleich.
 
 Die reale Projekt- und Produktionsdatenbank wurde bei dieser Umsetzung nicht verändert. Alle DB- und Browserprüfungen liefen mit synthetischen Daten in einer separaten lokalen PostgreSQL-Datenbank.
 

docs/elternablaeufe.md

@@ -12,16 +12,9 @@
 
 ## Bestehende Daten und Schemaaktualisierung
 
-Das Projekt verwendet weiterhin `prisma db push`; es besitzt keine Prisma-Migrationshistorie. Der vorhandene Produktionsstart aktualisiert das Schema automatisch. Die neuen Pflichtfelder haben kompatible Defaults: bisherige Termine bleiben `CHILD`, bisherige Meldungen erhalten `ALLE`. Bestehende Kinderantworten werden nicht verändert.
+Aktuelle Releases verwenden die versionierten Migrationen in `prisma/migrations`. Der separate Initialisierungsdienst wendet sie vor dem App-Start an und stellt die Runtime-Grants bereit. Einrichtung und Updates beschreibt [deploy/README.md](../deploy/README.md). Kein `prisma db push` auf verwalteten Datenbanken einsetzen: zusätzliche Tenant-Constraints ergänzen das Prisma-Modell.
 
-Für eine kontrollierte, einmalige Aktualisierung einer Datenbank mit dem bisherigen Schema liegt zusätzlich die additive SQL-Datei `prisma/updates/20261007_parent_flows.sql` vor. Sie ist eine Alternative zum ersten `db push`, kein nachträglich anzuwendender zweiter Schritt. Beispiel:
+`prisma/updates/20261007_parent_flows.sql` dokumentiert den historischen Ausgangsstand vor Einführung der Migrationshistorie. Es gehört nicht zum aktuellen Deployment und darf nicht zusätzlich zu bereits angewandten Migrationen ausgeführt werden. Die kompatiblen Defaults für bisherige Termine (`CHILD`) und Meldungen (`ALLE`) sind in den versionierten Migrationen enthalten.
-
-```sh
-psql "$DATABASE_URL" -v ON_ERROR_STOP=1 --single-transaction -f prisma/updates/20261007_parent_flows.sql
-npm run prisma:generate
-```
-
-Die Datei gehört bewusst nicht in `prisma/migrations`: Eine Einführung von `prisma migrate deploy` würde zuerst eine Baseline für bereits existierende Datenbanken verlangen.
 
 ## Verifikation
 

package.json

@@ -24,7 +24,17 @@
     "test:staff:integration": "tsx --test tests/staff-service.test.ts",
     "test:alarms": "tsx --experimental-test-module-mocks --test tests/notdienst-alarm.test.ts",
     "test:parent-flows": "tsx --test tests/parent-flows.test.ts",
-    "test:parent-flows:integration": "tsx --experimental-test-module-mocks --test tests/parent-flows.integration.test.ts"
+    "test:parent-flows:integration": "tsx --experimental-test-module-mocks --test tests/parent-flows.integration.test.ts",
+    "test:notdienst": "tsx --test tests/notdienst-days.test.ts",
+    "test:notdienst:integration": "node --test tests/notdienst-planning.integration.test.cjs",
+    "test:calendar:integration": "node --test tests/calendar-actions.integration.test.cjs",
+    "test:notdienst:notifications": "node --test tests/notdienst-notifications.integration.test.cjs",
+    "test:mail": "node --test tests/mail-transport.test.cjs",
+    "test:account": "node --test tests/password-management.integration.test.cjs",
+    "test:roles": "node --test tests/kita-roles.integration.test.cjs tests/notdienst-assignment-view.test.cjs",
+    "test:runtime": "node --test tests/runtime-supervisor.test.cjs",
+    "test:family-absence": "tsx --test tests/absence-policy.test.ts",
+    "test:family-absence:integration": "tsx --experimental-test-module-mocks --test tests/family-absence-flows.integration.test.ts"
   },
   "prisma": {
     "seed": "tsx prisma/seed.ts"

prisma/migrations/20261010000000_family_invitation_flows/migration.sql

@@ -0,0 +1,13 @@
+-- Family invitation delivery status; applied before the restricted runtime starts.
+ALTER TABLE "invitations"
+  ADD COLUMN "userId" TEXT,
+  ADD COLUMN "sentAt" TIMESTAMP(3),
+  ADD COLUMN "lastAttemptAt" TIMESTAMP(3),
+  ADD COLUMN "leaseUntil" TIMESTAMP(3),
+  ADD COLUMN "attempts" INTEGER NOT NULL DEFAULT 0,
+  ADD COLUMN "failed" BOOLEAN NOT NULL DEFAULT false;
+CREATE UNIQUE INDEX "invitations_userId_key" ON "invitations"("userId");
+ALTER TABLE "invitations" ADD CONSTRAINT "invitations_userId_fkey"
+  FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "invitations" ADD CONSTRAINT "invitations_userId_tenant_fkey"
+  FOREIGN KEY ("userId", "kitaId") REFERENCES "users"("id", "kitaId") ON DELETE CASCADE ON UPDATE NO ACTION;

prisma/migrations/20261012000000_notdienst_notifications/migration.sql

@@ -0,0 +1,47 @@
+BEGIN;
+CREATE TABLE "notdienst_emails" (
+  "id" TEXT NOT NULL,
+  "kitaId" TEXT NOT NULL,
+  "familyId" TEXT NOT NULL,
+  "userId" TEXT NOT NULL,
+  "planId" TEXT,
+  "year" INTEGER NOT NULL,
+  "month" INTEGER NOT NULL,
+  "kind" TEXT NOT NULL,
+  "eventKey" TEXT NOT NULL,
+  "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "sentAt" TIMESTAMP(3),
+  "skippedAt" TIMESTAMP(3),
+  "leaseUntil" TIMESTAMP(3),
+  "claimToken" TEXT,
+  "nextAttemptAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "failed" BOOLEAN NOT NULL DEFAULT false,
+  "attempts" INTEGER NOT NULL DEFAULT 0,
+  "lastError" TEXT,
+  CONSTRAINT "notdienst_emails_pkey" PRIMARY KEY ("id"),
+  CONSTRAINT "notdienst_emails_month_check" CHECK ("month" BETWEEN 1 AND 12),
+  CONSTRAINT "notdienst_emails_kind_check" CHECK ("kind" IN ('REMINDER','PUBLICATION')),
+  CONSTRAINT "notdienst_emails_plan_check" CHECK (("kind" = 'PUBLICATION' AND "planId" IS NOT NULL) OR ("kind" = 'REMINDER' AND "planId" IS NULL))
+);
+CREATE UNIQUE INDEX "notdienst_emails_kitaId_userId_kind_year_month_eventKey_key" ON "notdienst_emails"("kitaId","userId","kind","year","month","eventKey");
+CREATE INDEX "notdienst_emails_sentAt_skippedAt_nextAttemptAt_idx" ON "notdienst_emails"("sentAt","skippedAt","nextAttemptAt");
+CREATE INDEX "notdienst_emails_kitaId_year_month_idx" ON "notdienst_emails"("kitaId","year","month");
+ALTER TABLE "notdienst_emails" ADD CONSTRAINT "notdienst_emails_kitaId_fkey" FOREIGN KEY ("kitaId") REFERENCES "kitas"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "notdienst_emails" ADD CONSTRAINT "notdienst_emails_familyId_fkey" FOREIGN KEY ("familyId") REFERENCES "families"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "notdienst_emails" ADD CONSTRAINT "notdienst_emails_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "notdienst_emails" ADD CONSTRAINT "notdienst_emails_planId_fkey" FOREIGN KEY ("planId") REFERENCES "notdienst_plans"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "notdienst_emails" ADD CONSTRAINT "notdienst_emails_familyId_tenant_fkey" FOREIGN KEY ("familyId","kitaId") REFERENCES "families"("id","kitaId") ON DELETE NO ACTION ON UPDATE NO ACTION;
+ALTER TABLE "notdienst_emails" ADD CONSTRAINT "notdienst_emails_userId_tenant_fkey" FOREIGN KEY ("userId","kitaId") REFERENCES "users"("id","kitaId") ON DELETE NO ACTION ON UPDATE NO ACTION;
+ALTER TABLE "notdienst_emails" ADD CONSTRAINT "notdienst_emails_planId_tenant_fkey" FOREIGN KEY ("planId","kitaId") REFERENCES "notdienst_plans"("id","kitaId") ON DELETE NO ACTION ON UPDATE NO ACTION;
+CREATE TABLE "notdienst_reminder_runs" (
+  "id" TEXT NOT NULL,
+  "kitaId" TEXT NOT NULL,
+  "year" INTEGER NOT NULL,
+  "month" INTEGER NOT NULL,
+  "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CONSTRAINT "notdienst_reminder_runs_pkey" PRIMARY KEY ("id"),
+  CONSTRAINT "notdienst_reminder_runs_month_check" CHECK ("month" BETWEEN 1 AND 12)
+);
+CREATE UNIQUE INDEX "notdienst_reminder_runs_kitaId_year_month_key" ON "notdienst_reminder_runs"("kitaId","year","month");
+ALTER TABLE "notdienst_reminder_runs" ADD CONSTRAINT "notdienst_reminder_runs_kitaId_fkey" FOREIGN KEY ("kitaId") REFERENCES "kitas"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+COMMIT;

prisma/schema.prisma

@@ -159,7 +159,9 @@ model Kita {
   termine                 Termin[]
   mitbringselItems        MitbringselItem[]
   eventParticipations     EventParticipation[]
-  notdienstPlans          NotdienstPlan[]
+  notdienstEmails        NotdienstEmail[]
+  notdienstReminderRuns  NotdienstReminderRun[]
+  notdienstPlans         NotdienstPlan[]
   notdienstAvailabilities NotdienstAvailability[]
   notdienstAssignments    NotdienstAssignment[]
   notdienstAlerts         NotdienstAlert[]
@@ -184,6 +186,7 @@ model Family {
 
   name            String
   notdienstAlarms NotdienstAlarm[]
+  notdienstEmails NotdienstEmail[]
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -268,6 +271,7 @@ model User {
 
   mitbringselItems   MitbringselItem[]
   invitationsCreated Invitation[]                 @relation("InvitationCreator")
+  familyInvitation   Invitation?                  @relation("InvitationRecipient")
   auditLogsAuthored  AuditLog[]                   @relation("AuditLogActor")
   staffProfile       StaffProfile?
   staffNotifications StaffNotification[]
@@ -275,6 +279,7 @@ model User {
   alarmRecipients    NotdienstAlarmRecipient[]
   alarmNotifications NotdienstAlarmNotification[]
   alarmEmails        NotdienstAlarmEmail[]
+  notdienstEmails   NotdienstEmail[]
 
   @@index([kitaId])
   @@index([familyId])
@@ -749,10 +754,19 @@ model Invitation {
   email String
   role  UserRole @default(ELTERN)
 
+  // Nullable for older, unlinked invitations. Family invitations belong to a user.
+  userId String? @unique
+  user   User?   @relation("InvitationRecipient", fields: [userId], references: [id], onDelete: Cascade)
+
   token      String           @unique
   status     InvitationStatus @default(PENDING)
   expiresAt  DateTime
   acceptedAt DateTime?
+  sentAt        DateTime?
+  lastAttemptAt DateTime?
+  leaseUntil    DateTime?
+  attempts      Int       @default(0)
+  failed        Boolean   @default(false)
 
   invitedById String?
   invitedBy   User?   @relation("InvitationCreator", fields: [invitedById], references: [id], onDelete: SetNull)
@@ -902,6 +916,7 @@ model NotdienstPlan {
   updatedAt DateTime @updatedAt
 
   assignments NotdienstAssignment[]
+  emails      NotdienstEmail[]
 
   @@unique([kitaId, year, month])
   @@index([kitaId])
@@ -1208,3 +1223,46 @@ model PendingRegistration {
   @@index([expiresAt])
   @@map("pending_registrations")
 }
+
+/// Durable notification jobs. No bearer tokens or personal response links.
+model NotdienstEmail {
+  id            String   @id @default(cuid())
+  kitaId        String
+  kita          Kita     @relation(fields: [kitaId], references: [id], onDelete: Cascade)
+  familyId      String
+  family        Family   @relation(fields: [familyId], references: [id], onDelete: Cascade)
+  userId        String
+  user          User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  planId        String?
+  plan          NotdienstPlan? @relation(fields: [planId], references: [id], onDelete: Cascade)
+  year          Int
+  month         Int
+  kind          String
+  eventKey      String
+  createdAt     DateTime @default(now())
+  sentAt        DateTime?
+  skippedAt     DateTime?
+  leaseUntil    DateTime?
+  claimToken    String?
+  nextAttemptAt DateTime @default(now())
+  failed        Boolean  @default(false)
+  attempts      Int      @default(0)
+  lastError     String?
+
+  @@unique([kitaId, userId, kind, year, month, eventKey])
+  @@index([sentAt, skippedAt, nextAttemptAt])
+  @@index([kitaId, year, month])
+  @@map("notdienst_emails")
+}
+
+model NotdienstReminderRun {
+  id        String   @id @default(cuid())
+  kitaId    String
+  kita      Kita     @relation(fields: [kitaId], references: [id], onDelete: Cascade)
+  year      Int
+  month     Int
+  createdAt DateTime @default(now())
+
+  @@unique([kitaId, year, month])
+  @@map("notdienst_reminder_runs")
+}

prisma/updates/20261007_parent_flows.sql

@@ -1,3 +1,5 @@
+-- HISTORISCHER UPGRADEPFAD: aktuelle Releases verwenden prisma/migrations und deploy/README.md.
+-- Nicht zusätzlich zu versionierten Migrationen oder auf bereits aktualisierten Datenbanken ausführen.
 -- CreateEnum
 CREATE TYPE "RsvpMode" AS ENUM ('CHILD', 'FAMILY');
 

scripts/check-tenant-integrity.sql

@@ -59,4 +59,11 @@ UNION ALL
 SELECT 'notdienst_alerts.educatorId' AS relation, count(*) AS invalid_rows FROM "notdienst_alerts" c JOIN "educators" p ON c."educatorId" = p.id WHERE c."kitaId" IS DISTINCT FROM p."kitaId"
 UNION ALL
 SELECT 'announcement_reads.userId' AS relation, count(*) AS invalid_rows FROM announcement_reads r JOIN announcements a ON r."announcementId" = a.id JOIN users u ON r."userId" = u.id WHERE u."kitaId" IS DISTINCT FROM a."kitaId"
+
+UNION ALL
+SELECT 'notdienst_emails.familyId' AS relation, count(*) AS invalid_rows FROM "notdienst_emails" c JOIN "families" p ON c."familyId" = p.id WHERE c."kitaId" IS DISTINCT FROM p."kitaId"
+UNION ALL
+SELECT 'notdienst_emails.userId' AS relation, count(*) AS invalid_rows FROM "notdienst_emails" c JOIN "users" p ON c."userId" = p.id WHERE c."kitaId" IS DISTINCT FROM p."kitaId"
+UNION ALL
+SELECT 'notdienst_emails.planId' AS relation, count(*) AS invalid_rows FROM "notdienst_emails" c JOIN "notdienst_plans" p ON c."planId" = p.id WHERE c."kitaId" IS DISTINCT FROM p."kitaId"
 ) violations WHERE invalid_rows > 0;

scripts/notdienst-alarm-worker.mjs

@@ -2,7 +2,7 @@
 const secret = process.env.NOTDIENST_JOB_SECRET;
 if (!secret || secret.length < 32) {
   console.error(
-    "Notdienst-Fristprüfung deaktiviert: NOTDIENST_JOB_SECRET muss mindestens 32 Zeichen haben.",
+    "Notdienst-Hintergrundjob deaktiviert: NOTDIENST_JOB_SECRET muss mindestens 32 Zeichen haben.",
   );
   process.exit(1);
 }
@@ -23,11 +23,11 @@ async function tick() {
     );
     if (!response.ok)
       console.error(
-        `Notdienst-Fristprüfung: HTTP ${response.status}; erneuter Versuch in einer Minute.`,
+        `Notdienst-Hintergrundjob: HTTP ${response.status}; erneuter Versuch in einer Minute.`,
       );
   } catch {
     console.error(
-      "Notdienst-Fristprüfung momentan nicht erreichbar; erneuter Versuch in einer Minute.",
+      "Notdienst-Hintergrundjob momentan nicht erreichbar; erneuter Versuch in einer Minute.",
     );
   }
   if (!stopped)

scripts/prepare-standalone.mjs

@@ -6,3 +6,5 @@ cpSync('scripts/start-production.sh', '.next/standalone/scripts/start-production
 cpSync('scripts/notdienst-alarm-worker.mjs', '.next/standalone/scripts/notdienst-alarm-worker.mjs');
 cpSync('scripts/runtime-database-url.mjs', '.next/standalone/scripts/runtime-database-url.mjs');
 cpSync('scripts/verify-runtime-isolation.mjs', '.next/standalone/scripts/verify-runtime-isolation.mjs');
+
+cpSync('scripts/start-runtime.mjs', '.next/standalone/scripts/start-runtime.mjs');

scripts/start-production.sh

@@ -7,7 +7,8 @@ if [ -n "${APP_DATABASE_PASSWORD_FILE:-}" ]; then
 fi
 unset POSTGRES_PASSWORD PGADMIN_DEFAULT_PASSWORD APP_DATABASE_PASSWORD MIGRATION_DATABASE_URL
 # Schema changes are applied by the maintenance image before runtime startup.
-if [ -n "${NOTDIENST_JOB_SECRET:-}" ]; then
+if [ -n "${NOTDIENST_JOB_SECRET:-}" ] && [ "${#NOTDIENST_JOB_SECRET}" -lt 32 ]; then
-  node scripts/notdienst-alarm-worker.mjs &
+  echo "NOTDIENST_JOB_SECRET muss mindestens 32 Zeichen haben." >&2
+  exit 1
 fi
-exec node server.js
+exec node scripts/start-runtime.mjs

scripts/start-runtime.mjs

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+let stopping = false,
+  worker,
+  restartTimer,
+  stopTimer;
+const server = spawn(process.execPath, ["server.js"], { stdio: "inherit" });
+function shutdown(code = 0) {
+  if (stopping) return;
+  stopping = true;
+  process.exitCode = code;
+  clearTimeout(restartTimer);
+  server.kill("SIGTERM");
+  worker?.kill("SIGTERM");
+  stopTimer = setTimeout(() => {
+    server.kill("SIGKILL");
+    worker?.kill("SIGKILL");
+    process.exit(code);
+  }, 4000);
+  stopTimer.unref();
+  Promise.all(
+    [server, worker]
+      .filter(Boolean)
+      .map((child) =>
+        child.exitCode !== null || child.signalCode !== null
+          ? Promise.resolve()
+          : new Promise((resolve) => child.once("close", resolve)),
+      ),
+  ).then(() => {
+    clearTimeout(stopTimer);
+    process.exit(code);
+  });
+}
+function startWorker() {
+  if (stopping) return;
+  worker = spawn(process.execPath, ["scripts/notdienst-alarm-worker.mjs"], {
+    stdio: "inherit",
+  });
+  worker.on("close", () => {
+    if (stopping) return;
+    console.error(
+      "Notdienst-Hintergrundjob beendet; Neustart in fünf Sekunden.",
+    );
+    restartTimer = setTimeout(startWorker, 5000);
+  });
+  worker.on("error", () => {
+    if (!stopping)
+      console.error("Notdienst-Hintergrundjob konnte nicht starten.");
+  });
+}
+server.on("exit", (code) => shutdown(code ?? 1));
+server.on("error", () => shutdown(1));
+for (const signal of ["SIGTERM", "SIGINT"])
+  process.on(signal, () => shutdown(0));
+if ((process.env.NOTDIENST_JOB_SECRET?.length ?? 0) >= 32) startWorker();
+else
+  console.warn(
+    "Automatische Notdienst-Jobs deaktiviert: gültiges NOTDIENST_JOB_SECRET fehlt.",
+  );

src/actions/absences.ts

@@ -1,24 +1,33 @@
 "use server";
 
 import { revalidatePath } from "next/cache";
-import { AbsenceReason, UserRole } from "@prisma/client";
+import { AbsenceReason, Prisma, UserRole } from "@prisma/client";
 import { dateOnlySchema } from "@/lib/date-schema";
 import { z } from "zod";
-
 import { requireKitaSession, requireRole } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
+import {
+  absenceDate,
+  absenceToday,
+  canManageKitaAbsences,
+} from "@/lib/absence-policy";
 
-const reportAbsenceSchema = z.object({
+const dateSchema = dateOnlySchema;
-  childId: z.string().min(1),
+const fieldsSchema = z.object({
-  startDate: dateOnlySchema,
+  startDate: dateSchema,
-  endDate: dateOnlySchema,
+  endDate: dateSchema,
   reason: z.nativeEnum(AbsenceReason),
   note: z.string().trim().max(500).optional(),
 });
-
+const reportSchema = fieldsSchema.extend({
-const dailyAbsenceSchema = z.object({
+  childId: z.string().min(1).max(128),
-  date: dateOnlySchema,
 });
+const identitySchema = z.object({
+  id: z.string().min(1).max(128),
+  updatedAt: z.string().datetime({ offset: true }),
+});
+const updateSchema = fieldsSchema.extend(identitySchema.shape);
+type MutationResult = { success?: boolean; error?: string };
 
 export type DailyAbsenceDto = {
   id: string;
@@ -28,112 +37,216 @@ export type DailyAbsenceDto = {
   note: string | null;
   startDate: string;
   endDate: string;
+  updatedAt: string;
 };
 
-function parseDateOnly(value: string) {
+function refreshAbsences() {
-  const date = new Date(`${value.slice(0, 10)}T00:00:00`);
-  if (Number.isNaN(date.getTime())) {
-    throw new Error("Ungueltiges Datum.");
-  }
-  return date;
-}
-
-function toDateKey(date: Date) {
-  return date.toISOString().slice(0, 10);
-}
-
-export async function reportAbsence(rawPayload: unknown) {
-  const session = await requireKitaSession();
-  const parsed = reportAbsenceSchema.safeParse(rawPayload);
-
-  if (!parsed.success) {
-    return { error: "Ungültige Eingabedaten." };
-  }
-
-  if (!session.user.familyId) {
-    return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
-  }
-
-  const startDate = parseDateOnly(parsed.data.startDate);
-  const endDate = parseDateOnly(parsed.data.endDate);
-
-  if (endDate < startDate) {
-    return { error: "Das Enddatum darf nicht vor dem Startdatum liegen." };
-  }
-
-  const child = await prisma.child.findFirst({
-    where: {
-      id: parsed.data.childId,
-      kitaId: session.user.kitaId,
-      familyId: session.user.familyId,
-      active: true,
-    },
-    select: { id: true },
-  });
-
-  if (!child) {
-    return { error: "Dieses Kind gehört nicht zu deinem Haushalt." };
-  }
-
-  const overlappingAbsence = await prisma.absence.findFirst({
-    where: {
-      kitaId: session.user.kitaId,
-      childId: child.id,
-      startDate: { lte: endDate },
-      endDate: { gte: startDate },
-    },
-    select: { id: true },
-  });
-
-  if (overlappingAbsence) {
-    return { error: "Für diesen Zeitraum existiert bereits eine Abmeldung." };
-  }
-
-  await prisma.absence.create({
-    data: {
-      kitaId: session.user.kitaId,
-      childId: child.id,
-      startDate,
-      endDate,
-      reason: parsed.data.reason,
-      note: parsed.data.note || null,
-    },
-  });
-
   revalidatePath("/dashboard");
+  revalidatePath("/dashboard/abwesenheiten");
   revalidatePath("/dashboard/admin/abwesenheiten");
-  return { success: true };
 }
 
-export async function deleteAbsence(id: string) {
+async function currentActor(
-  const session = await requireKitaSession();
+  tx: Prisma.TransactionClient,
-
+  id: string,
-  if (!session.user.familyId) {
+  kitaId: string,
-    return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
+) {
-  }
+  return tx.user.findFirst({
-
-  const absence = await prisma.absence.findFirst({
     where: {
       id,
-      kitaId: session.user.kitaId,
+      kitaId,
-      child: {
+      role: {
-        familyId: session.user.familyId,
+        in: [
+          UserRole.ELTERN,
+          UserRole.ADMIN,
+          UserRole.KOORDINATOR,
+          UserRole.ERZIEHER,
+        ],
       },
     },
-    select: { id: true },
+    select: { id: true, role: true, familyId: true },
   });
+}
 
-  if (!absence) {
+async function lockChild(
-    return { error: "Diese Abmeldung gehört nicht zu deinem Haushalt." };
+  tx: Prisma.TransactionClient,
-  }
+  childId: string,
+  kitaId: string,
+) {
+  // Serializes overlapping create/edit/delete operations for this child.
+  await tx.$queryRaw`SELECT "id" FROM "children" WHERE "id" = ${childId} AND "kitaId" = ${kitaId} FOR UPDATE`;
+}
 
-  await prisma.absence.delete({
+export async function reportAbsence(
-    where: { id: absence.id },
+  rawPayload: unknown,
+): Promise<MutationResult> {
+  const session = await requireKitaSession();
+  const parsed = reportSchema.safeParse(rawPayload);
+  if (!parsed.success)
+    return {
+      error:
+        "Bitte gültige Daten und einen Grund angeben. Die Bemerkung darf höchstens 500 Zeichen haben.",
+    };
+  const { childId, startDate, endDate, reason, note } = parsed.data;
+  if (endDate < startDate)
+    return { error: "Das Enddatum darf nicht vor dem Startdatum liegen." };
+  const result = await prisma.$transaction(async (tx) => {
+    const actor = await currentActor(tx, session.user.id, session.user.kitaId);
+    if (!actor?.familyId)
+      return { error: "Dein Account ist keinem Haushalt zugeordnet." };
+    if (!canManageKitaAbsences(actor.role) && startDate < absenceToday())
+      return {
+        error:
+          "Vergangene Tage kann nur die Kita nachtragen. Bitte melde dich dort.",
+      };
+    await lockChild(tx, childId, session.user.kitaId);
+    const child = await tx.child.findFirst({
+      where: {
+        id: childId,
+        kitaId: session.user.kitaId,
+        familyId: actor.familyId,
+        active: true,
+      },
+      select: { id: true },
+    });
+    if (!child)
+      return {
+        error:
+          "Dieses Kind gehört nicht zu deinem Haushalt oder ist nicht mehr aktiv.",
+      };
+    const start = absenceDate(startDate),
+      end = absenceDate(endDate);
+    const overlap = await tx.absence.findFirst({
+      where: {
+        kitaId: session.user.kitaId,
+        childId,
+        startDate: { lte: end },
+        endDate: { gte: start },
+      },
+      select: { id: true },
+    });
+    if (overlap)
+      return { error: "Für diesen Zeitraum existiert bereits eine Abmeldung." };
+    await tx.absence.create({
+      data: {
+        kitaId: session.user.kitaId,
+        childId,
+        startDate: start,
+        endDate: end,
+        reason,
+        note: note || null,
+      },
+    });
+    return { success: true };
   });
+  if (result.success) refreshAbsences();
+  return result;
+}
 
-  revalidatePath("/dashboard");
+async function changeAbsence(
-  revalidatePath("/dashboard/admin/abwesenheiten");
+  rawPayload: unknown,
-  return { success: true };
+  remove: boolean,
+): Promise<MutationResult> {
+  const session = await requireKitaSession();
+  const parsed = remove
+    ? identitySchema.safeParse(rawPayload)
+    : updateSchema.safeParse(rawPayload);
+  if (!parsed.success)
+    return {
+      error:
+        "Ungültige Eingabedaten. Bitte die Ansicht aktualisieren und gültige Daten angeben.",
+    };
+  const input = parsed.data;
+  const fields = remove ? null : updateSchema.parse(rawPayload);
+  if (fields && fields.endDate < fields.startDate)
+    return { error: "Das Enddatum darf nicht vor dem Startdatum liegen." };
+  const result = await prisma.$transaction(async (tx) => {
+    const actor = await currentActor(tx, session.user.id, session.user.kitaId);
+    if (!actor) return { error: "Keine Berechtigung für diese Meldung." };
+    const team = canManageKitaAbsences(actor.role);
+    if (!team && !actor.familyId)
+      return { error: "Dein Account ist keinem Haushalt zugeordnet." };
+    const where: Prisma.AbsenceWhereInput = {
+      id: input.id,
+      kitaId: session.user.kitaId,
+      child: {
+        kitaId: session.user.kitaId,
+        ...(team ? {} : { familyId: actor.familyId! }),
+      },
+    };
+    const candidate = await tx.absence.findFirst({
+      where,
+      select: { childId: true },
+    });
+    if (!candidate)
+      return {
+        error:
+          "Meldung wurde nicht gefunden oder gehört nicht zu deinem Haushalt.",
+      };
+    await lockChild(tx, candidate.childId, session.user.kitaId);
+    const absence = await tx.absence.findFirst({ where });
+    if (!absence)
+      return {
+        error:
+          "Die Meldung ist nicht mehr vorhanden. Bitte die Ansicht aktualisieren.",
+      };
+    if (
+      absence.updatedAt.toISOString() !==
+      new Date(input.updatedAt).toISOString()
+    )
+      return {
+        error:
+          "Die Meldung wurde inzwischen geändert. Bitte die Ansicht aktualisieren.",
+      };
+    const today = absenceToday();
+    if (
+      !team &&
+      (absence.startDate.toISOString().slice(0, 10) <= today ||
+        (fields && fields.startDate <= today))
+    )
+      return {
+        error:
+          "Bereits begonnene Meldungen und laufende Tage verwaltet die Kita. Bitte melde dich dort.",
+      };
+    if (remove) await tx.absence.delete({ where: { id: absence.id } });
+    else if (fields) {
+      const startDate = absenceDate(fields.startDate),
+        endDate = absenceDate(fields.endDate);
+      const overlap = await tx.absence.findFirst({
+        where: {
+          kitaId: session.user.kitaId,
+          childId: absence.childId,
+          id: { not: absence.id },
+          startDate: { lte: endDate },
+          endDate: { gte: startDate },
+        },
+        select: { id: true },
+      });
+      if (overlap)
+        return {
+          error: "Für diesen Zeitraum existiert bereits eine andere Abmeldung.",
+        };
+      await tx.absence.update({
+        where: { id: absence.id },
+        data: {
+          startDate,
+          endDate,
+          reason: fields.reason,
+          note: fields.note || null,
+        },
+      });
+    }
+    return { success: true };
+  });
+  if (result.success) refreshAbsences();
+  return result;
+}
+
+export async function updateAbsence(rawPayload: unknown) {
+  return changeAbsence(rawPayload, false);
+}
+export async function deleteAbsence(rawPayload: unknown) {
+  return changeAbsence(rawPayload, true);
 }
 
 export async function getDailyAbsences(
@@ -144,17 +257,10 @@ export async function getDailyAbsences(
     UserRole.KOORDINATOR,
     UserRole.ERZIEHER,
   ]);
-
+  if (!session.user.kitaId) return { error: "Kein Mandant zugeordnet." };
-  if (!session.user.kitaId) {
+  const parsed = z.object({ date: dateSchema }).safeParse(rawPayload);
-    return { error: "Kein Mandant zugeordnet." };
+  if (!parsed.success) return { error: "Ungültiges Datum." };
-  }
+  const date = absenceDate(parsed.data.date);
-
-  const parsed = dailyAbsenceSchema.safeParse(rawPayload);
-  if (!parsed.success) {
-    return { error: "Ungültiges Datum." };
-  }
-
-  const date = parseDateOnly(parsed.data.date);
   const rows = await prisma.absence.findMany({
     where: {
       kitaId: session.user.kitaId,
@@ -167,24 +273,17 @@ export async function getDailyAbsences(
       note: true,
       startDate: true,
       endDate: true,
+      updatedAt: true,
       child: {
         select: {
           firstName: true,
           lastName: true,
-          family: {
+          family: { select: { name: true } },
-            select: {
-              name: true,
-            },
-          },
         },
       },
     },
-    orderBy: [
+    orderBy: [{ child: { lastName: "asc" } }, { child: { firstName: "asc" } }],
-      { child: { lastName: "asc" } },
-      { child: { firstName: "asc" } },
-    ],
   });
-
   return {
     absences: rows.map((absence) => ({
       id: absence.id,
@@ -192,8 +291,9 @@ export async function getDailyAbsences(
       familyName: absence.child.family.name,
       reason: absence.reason,
       note: absence.note,
-      startDate: toDateKey(absence.startDate),
+      startDate: absence.startDate.toISOString().slice(0, 10),
-      endDate: toDateKey(absence.endDate),
+      endDate: absence.endDate.toISOString().slice(0, 10),
+      updatedAt: absence.updatedAt.toISOString(),
     })),
   };
 }

src/app/admin/actions.ts

@@ -7,6 +7,12 @@ import { AuditTargetType, UserRole } from "@prisma/client";
 import { z } from "zod";
 
 import { requireRole } from "@/lib/auth-utils";
+import {
+  assertKitaAdminRemains,
+  lockKitaAccounts,
+} from "@/lib/kita-admin-guard";
+import { serializableTransaction } from "@/lib/transaction";
+import { UserFacingError } from "@/lib/action-error";
 import { prisma } from "@/lib/prisma";
 
 const deleteKitaSchema = z.object({
@@ -28,7 +34,8 @@ type ActionResult = {
 
 async function requireSuperadminActor() {
   const session = await requireRole([UserRole.SUPERADMIN]);
-  if (Date.now() - session.user.authenticatedAt > 15 * 60_000) redirect("/login?reauth=1&callbackUrl=/admin");
+  if (Date.now() - session.user.authenticatedAt > 15 * 60_000)
+    redirect("/login?reauth=1&callbackUrl=/admin");
   return {
     id: session.user.id,
     email: session.user.email ?? session.user.name ?? "Unbekannter Superadmin",
@@ -96,7 +103,10 @@ export async function deleteKita(
   const counts = await getKitaDeleteCounts(kita.id);
 
   const attachmentIds = await prisma.$transaction(async (tx) => {
-    const attachments = await tx.attachment.findMany({ where: { announcement: { kitaId: kita.id } }, select: { id: true } });
+    const attachments = await tx.attachment.findMany({
+      where: { announcement: { kitaId: kita.id } },
+      select: { id: true },
+    });
     await tx.auditLog.create({
       data: {
         actorUserId: actor.id,
@@ -111,7 +121,7 @@ export async function deleteKita(
     });
 
     await tx.kita.delete({ where: { id: kita.id } });
-    return attachments.map(item => item.id);
+    return attachments.map((item) => item.id);
   });
 
   await removeAttachmentFiles(attachmentIds);
@@ -156,13 +166,19 @@ async function findMutableTenantUser(userId: string, actorId: string) {
     return { error: "Benutzer wurde nicht gefunden." } as const;
   }
   if (user.id === actorId) {
-    return { error: "Das eigene Superadmin-Konto kann hier nicht geändert werden." } as const;
+    return {
+      error: "Das eigene Superadmin-Konto kann hier nicht geändert werden.",
+    } as const;
   }
   if (user.role === UserRole.SUPERADMIN) {
-    return { error: "Andere Superadmins werden in V1 nicht verwaltet." } as const;
+    return {
+      error: "Andere Superadmins werden in V1 nicht verwaltet.",
+    } as const;
   }
   if (!user.kitaId) {
-    return { error: "Nur tenant-gebundene Benutzer können verwaltet werden." } as const;
+    return {
+      error: "Nur tenant-gebundene Benutzer können verwaltet werden.",
+    } as const;
   }
 
   return { user } as const;
@@ -188,34 +204,44 @@ export async function deleteUser(rawPayload: unknown): Promise<ActionResult> {
     };
   }
 
-  const attachmentIds = await prisma.$transaction(async (tx) => {
+  let attachmentIds: string[];
-    const attachments = await tx.attachment.findMany({ where: { announcement: { authorId: user.id } }, select: { id: true } });
+  try {
-    await tx.verificationToken.deleteMany({
+    attachmentIds = await serializableTransaction(async (tx) => {
-      where: { identifier: user.id },
+      await lockKitaAccounts(tx, user.kitaId!);
-    });
+      await assertKitaAdminRemains(tx, user.kitaId!, [user.id]);
-    await tx.auditLog.create({
+      const attachments = await tx.attachment.findMany({
-      data: {
+        where: { announcement: { authorId: user.id } },
-        actorUserId: actor.id,
+        select: { id: true },
-        actorEmail: actor.email,
+      });
-        action: "USER_DELETE",
+      await tx.verificationToken.deleteMany({
-        targetType: AuditTargetType.USER,
+        where: { identifier: user.id },
-        targetId: user.id,
+      });
-        targetLabel: `${user.firstName} ${user.lastName} <${user.email}>`,
+      await tx.auditLog.create({
-        targetKitaId: user.kitaId,
+        data: {
-        metadata: {
+          actorUserId: actor.id,
-          role: user.role,
+          actorEmail: actor.email,
-          kitaName: user.kita?.name ?? null,
+          action: "USER_DELETE",
-          kitaSlug: user.kita?.slug ?? null,
+          targetType: AuditTargetType.USER,
-          familyId: user.familyId,
+          targetId: user.id,
-          familyName: user.family?.name ?? null,
+          targetLabel: `${user.firstName} ${user.lastName} <${user.email}>`,
-          familyUserCountBeforeDelete: user.family?._count.users ?? null,
+          targetKitaId: user.kitaId,
+          metadata: {
+            role: user.role,
+            kitaName: user.kita?.name ?? null,
+            kitaSlug: user.kita?.slug ?? null,
+            familyId: user.familyId,
+            familyName: user.family?.name ?? null,
+            familyUserCountBeforeDelete: user.family?._count.users ?? null,
+          },
         },
-      },
+      });
+      await tx.user.delete({ where: { id: user.id } });
+      return attachments.map((item) => item.id);
     });
-    await tx.user.delete({ where: { id: user.id } });
+  } catch (error) {
-    return attachments.map(item => item.id);
+    if (!(error instanceof UserFacingError)) throw error;
-  });
+    return { ok: false, error: error.message };
-
+  }
   await removeAttachmentFiles(attachmentIds);
   revalidatePath("/admin");
   revalidatePath(`/admin/kitas/${user.kitaId}`);
@@ -245,29 +271,41 @@ async function updateUserSupportState(
 
   const { user } = lookup;
 
-  await prisma.$transaction(async (tx) => {
+  try {
-    await tx.user.update({
+    await serializableTransaction(async (tx) => {
-      where: { id: user.id },
+      await lockKitaAccounts(tx, user.kitaId!);
-      data: { ...data, ...(action === "USER_LOCK" ? { sessionVersion: { increment: 1 } } : {}) },
+      if (action === "USER_LOCK")
-    });
+        await assertKitaAdminRemains(tx, user.kitaId!, [user.id]);
-    await tx.auditLog.create({
+      await tx.user.update({
-      data: {
+        where: { id: user.id },
-        actorUserId: actor.id,
+        data: {
-        actorEmail: actor.email,
+          ...data,
-        action,
+          ...(action === "USER_LOCK"
-        targetType: AuditTargetType.USER,
+            ? { sessionVersion: { increment: 1 } }
-        targetId: user.id,
+            : {}),
-        targetLabel: `${user.firstName} ${user.lastName} <${user.email}>`,
-        targetKitaId: user.kitaId,
-        metadata: {
-          role: user.role,
-          previousLockedUntil: user.lockedUntil?.toISOString() ?? null,
-          previousFailedLoginAttempts: user.failedLoginAttempts,
         },
-      },
+      });
+      await tx.auditLog.create({
+        data: {
+          actorUserId: actor.id,
+          actorEmail: actor.email,
+          action,
+          targetType: AuditTargetType.USER,
+          targetId: user.id,
+          targetLabel: `${user.firstName} ${user.lastName} <${user.email}>`,
+          targetKitaId: user.kitaId,
+          metadata: {
+            role: user.role,
+            previousLockedUntil: user.lockedUntil?.toISOString() ?? null,
+            previousFailedLoginAttempts: user.failedLoginAttempts,
+          },
+        },
+      });
     });
-  });
+  } catch (error) {
-
+    if (!(error instanceof UserFacingError)) throw error;
+    return { ok: false, error: error.message };
+  }
   revalidatePath("/admin");
   revalidatePath(`/admin/kitas/${user.kitaId}`);
   revalidatePath("/admin/audit");
@@ -296,4 +334,3 @@ export async function resetFailedLoginAttempts(
     failedLoginAttempts: 0,
   });
 }
-

src/app/api/jobs/notdienstalarme/route.ts

@@ -1,6 +1,8 @@
 import { revalidatePath } from "next/cache";
 import { authorizeAlarmJob, runAlarmJob } from "@/lib/alarms/job";
 
+import { runNotdienstNotificationJob } from "@/lib/notdienst-notifications";
+
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 export async function POST(request: Request) {
@@ -16,9 +18,12 @@ export async function POST(request: Request) {
       { status },
     );
   try {
-    const result = await runAlarmJob();
+    const [alarm, planning] = await Promise.allSettled([runAlarmJob(), runNotdienstNotificationJob()]);
+    if (alarm.status === "rejected" || planning.status === "rejected") throw new Error("Ein Hintergrundlauf ist fehlgeschlagen.");
+    const result = { ...alarm.value, planning: planning.value };
     revalidatePath("/dashboard");
     revalidatePath("/dashboard/notdienst/alarm");
+    revalidatePath("/dashboard/notdienst/plan");
     return Response.json(result);
   } catch {
     return Response.json(

src/app/dashboard/absence-card.tsx

@@ -1,13 +1,14 @@
 "use client";
 
 import Link from "next/link";
-import { useMemo, useTransition } from "react";
+import { useMemo, useState, useTransition } from "react";
 import { AbsenceReason } from "@prisma/client";
 import { Baby, CalendarX2, Check, ChevronRight, Loader2 } from "lucide-react";
 import { reasonColor, reasonLabel } from "@/lib/absence-utils";
 import { toast } from "sonner";
 
 import { reportAbsence } from "@/actions/absences";
+import { AbsenceManagementActions } from "@/components/absence-management-actions";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import {
@@ -40,6 +41,7 @@ type AbsenceListItem = {
   note: string | null;
   startDate: string;
   endDate: string;
+  updatedAt: string;
 };
 
 export function AbsenceCard({
@@ -47,10 +49,11 @@ export function AbsenceCard({
   today,
 }: {
   childOptions: ChildOption[];
-  absences: AbsenceListItem[];
   today: string;
 }) {
   const [isPending, startTransition] = useTransition();
+  const [startDate, setStartDate] = useState(today);
+  const [endDate, setEndDate] = useState(today);
   const defaultChildId = childOptions[0]?.id;
   const hasChildren = childOptions.length > 0;
 
@@ -92,92 +95,113 @@ export function AbsenceCard({
 
       <CardContent>
         {hasChildren ? (
-          <form action={handleSubmit}>
+          <form
-            <div className="grid gap-4 md:grid-cols-2">
+            onReset={() => {
-              <FieldLabel label="Welches Kind?">
+              setStartDate(today);
-                <Select name="childId" defaultValue={defaultChildId} required>
+              setEndDate(today);
-                  <SelectTrigger>
+            }}
-                    <SelectValue placeholder="Kind auswählen" />
+            onSubmit={(event) => {
-                  </SelectTrigger>
+              event.preventDefault();
-                  <SelectContent>
+              handleSubmit(new FormData(event.currentTarget));
-                    {childOptions.map((child) => (
+            }}
-                      <SelectItem key={child.id} value={child.id}>
+          >
-                        {child.name}
+            <fieldset disabled={isPending}>
+              <div className="grid gap-4 md:grid-cols-2">
+                <FieldLabel label="Welches Kind?">
+                  <Select name="childId" defaultValue={defaultChildId} required>
+                    <SelectTrigger>
+                      <SelectValue placeholder="Kind auswählen" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {childOptions.map((child) => (
+                        <SelectItem key={child.id} value={child.id}>
+                          {child.name}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                </FieldLabel>
+
+                <FieldLabel label="Grund">
+                  <Select
+                    name="reason"
+                    defaultValue={AbsenceReason.ILLNESS}
+                    required
+                  >
+                    <SelectTrigger>
+                      <SelectValue placeholder="Grund auswählen" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value={AbsenceReason.ILLNESS}>
+                        Krank
                       </SelectItem>
-                    ))}
+                      <SelectItem value={AbsenceReason.VACATION}>
-                  </SelectContent>
+                        Urlaub
-                </Select>
+                      </SelectItem>
-              </FieldLabel>
+                      <SelectItem value={AbsenceReason.OTHER}>
+                        Sonstiges
+                      </SelectItem>
+                    </SelectContent>
+                  </Select>
+                </FieldLabel>
 
-              <FieldLabel label="Grund">
+                <FieldLabel label="Von" htmlFor="absence-startDate">
-                <Select
+                  <Input
-                  name="reason"
+                    id="absence-startDate"
-                  defaultValue={AbsenceReason.ILLNESS}
+                    name="startDate"
-                  required
+                    type="date"
-                >
+                    value={startDate}
-                  <SelectTrigger>
+                    min={today}
-                    <SelectValue placeholder="Grund auswählen" />
+                    onChange={(event) => {
-                  </SelectTrigger>
+                      const date = event.target.value;
-                  <SelectContent>
+                      setStartDate(date);
-                    <SelectItem value={AbsenceReason.ILLNESS}>Krank</SelectItem>
+                      if (date > endDate) setEndDate(date);
-                    <SelectItem value={AbsenceReason.VACATION}>
+                    }}
-                      Urlaub
+                    required
-                    </SelectItem>
+                  />
-                    <SelectItem value={AbsenceReason.OTHER}>
+                </FieldLabel>
-                      Sonstiges
-                    </SelectItem>
-                  </SelectContent>
-                </Select>
-              </FieldLabel>
 
-              <FieldLabel label="Von" htmlFor="absence-startDate">
+                <FieldLabel label="Bis" htmlFor="absence-endDate">
-                <Input
+                  <Input
-                  id="absence-startDate"
+                    id="absence-endDate"
-                  name="startDate"
+                    name="endDate"
-                  type="date"
+                    type="date"
-                  defaultValue={today}
+                    value={endDate}
-                  required
+                    min={startDate}
-                />
+                    onChange={(event) => setEndDate(event.target.value)}
-              </FieldLabel>
+                    required
+                  />
+                </FieldLabel>
 
-              <FieldLabel label="Bis" htmlFor="absence-endDate">
+                <div className="grid gap-2 md:col-span-2">
-                <Input
+                  <Label
-                  id="absence-endDate"
+                    htmlFor="absence-note"
-                  name="endDate"
+                    className="text-xs font-semibold text-[var(--ink-soft)]"
-                  type="date"
+                  >
-                  defaultValue={today}
+                    Bemerkung{" "}
-                  required
+                    <span className="font-medium text-[var(--ink-faint)]">
-                />
+                      optional
-              </FieldLabel>
+                    </span>
-
+                  </Label>
-              <div className="grid gap-2 md:col-span-2">
+                  <Textarea
-                <Label
+                    id="absence-note"
-                  htmlFor="absence-note"
+                    name="note"
-                  className="text-xs font-semibold text-[var(--ink-soft)]"
+                    rows={4}
-                >
+                    placeholder="z. B. voraussichtlich wieder da am Freitag."
-                  Bemerkung{" "}
+                  />
-                  <span className="font-medium text-[var(--ink-faint)]">
+                </div>
-                    optional
-                  </span>
-                </Label>
-                <Textarea
-                  id="absence-note"
-                  name="note"
-                  rows={4}
-                  placeholder="z. B. voraussichtlich wieder da am Freitag."
-                />
               </div>
-            </div>
 
-            <div className="mt-7 flex items-center justify-between border-t border-[var(--hairline-soft)] pt-5">
+              <div className="mt-7 flex items-center justify-between border-t border-[var(--hairline-soft)] pt-5">
-              <Button type="reset" variant="ghost">
+                <Button type="reset" variant="ghost">
-                Zurücksetzen
+                  Zurücksetzen
-              </Button>
+                </Button>
-              <Button type="submit" disabled={isPending}>
+                <Button type="submit" disabled={isPending}>
-                {isPending ? <Loader2 className="animate-spin" /> : <Check />}
+                  {isPending ? <Loader2 className="animate-spin" /> : <Check />}
-                Abwesenheit melden
+                  Abwesenheit melden
-              </Button>
+                </Button>
-            </div>
+              </div>
+            </fieldset>
           </form>
         ) : (
           <div className="flex min-h-72 flex-col items-center justify-center rounded-[14px] border border-dashed border-[var(--hairline)] bg-[var(--surface-2)] p-6 text-center">
@@ -201,8 +225,12 @@ export function AbsenceCard({
 
 export function UpcomingAbsencesCard({
   absences,
+  today,
+  team = false,
 }: {
   absences: AbsenceListItem[];
+  today: string;
+  team?: boolean;
 }) {
   return (
     <Card>
@@ -233,16 +261,21 @@ export function UpcomingAbsencesCard({
         ) : (
           <div className="divide-y divide-[var(--hairline-soft)]">
             {absences.map((absence) => (
-              <AbsenceRow key={absence.id} absence={absence} />
+              <AbsenceRow
+                key={`${absence.id}-${absence.updatedAt}`}
+                absence={absence}
+                today={today}
+                team={team}
+              />
             ))}
           </div>
         )}
 
         <Link
-          href="/dashboard/admin/abwesenheiten"
+          href="/dashboard/abwesenheiten"
           className="mt-4 inline-flex items-center gap-1 text-[13px] font-semibold text-[var(--accent-deep)] transition hover:gap-2 focus-visible:outline-none focus-visible:ring-[3px] focus-visible:ring-[var(--focus-ring)]"
         >
-          Alle Abwesenheiten
+          Meine Abwesenheiten
           <ChevronRight className="h-3.5 w-3.5" />
         </Link>
       </CardContent>
@@ -272,7 +305,15 @@ function FieldLabel({
   );
 }
 
-function AbsenceRow({ absence }: { absence: AbsenceListItem }) {
+function AbsenceRow({
+  absence,
+  today,
+  team,
+}: {
+  absence: AbsenceListItem;
+  today: string;
+  team: boolean;
+}) {
   const { day, month, detail } = useMemo(() => {
     const start = new Date(`${absence.startDate}T00:00:00`);
     const end = new Date(`${absence.endDate}T00:00:00`);
@@ -327,9 +368,8 @@ function AbsenceRow({ absence }: { absence: AbsenceListItem }) {
             {absence.note}
           </p>
         ) : null}
+        <AbsenceManagementActions absence={absence} today={today} team={team} />
       </div>
     </div>
   );
 }
-
-

src/app/dashboard/abwesenheiten/page.tsx

@@ -0,0 +1,203 @@
+import Link from "next/link";
+import { requireKitaSession } from "@/lib/auth-utils";
+import { prisma } from "@/lib/prisma";
+import {
+  absenceDate,
+  absenceToday,
+  canManageKitaAbsences,
+} from "@/lib/absence-policy";
+import { reasonLabel } from "@/lib/absence-utils";
+import { AbsenceManagementActions } from "@/components/absence-management-actions";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+
+export const metadata = { title: "Meine Abwesenheiten · Kita-Planer" };
+
+export default async function OwnAbsencesPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ view?: string; page?: string }>;
+}) {
+  const session = await requireKitaSession();
+  const actor = await prisma.user.findFirstOrThrow({
+    where: { id: session.user.id, kitaId: session.user.kitaId },
+    select: { familyId: true, role: true },
+  });
+  const query = await searchParams;
+  const past = query.view === "past";
+  const parsedPage = Number(query.page ?? 1);
+  const requestedPage =
+    Number.isSafeInteger(parsedPage) && parsedPage > 0 ? parsedPage : 1;
+  const today = absenceToday();
+  const where = {
+    kitaId: session.user.kitaId,
+    child: { kitaId: session.user.kitaId, familyId: actor.familyId ?? "" },
+    endDate: past ? { lt: absenceDate(today) } : { gte: absenceDate(today) },
+  };
+  const count = actor.familyId ? await prisma.absence.count({ where }) : 0;
+  const pages = Math.max(1, Math.ceil(count / 20));
+  const page = Math.min(requestedPage, pages);
+  const absences = actor.familyId
+    ? await prisma.absence.findMany({
+        where,
+        select: {
+          id: true,
+          startDate: true,
+          endDate: true,
+          reason: true,
+          note: true,
+          updatedAt: true,
+          child: { select: { firstName: true, lastName: true } },
+        },
+        orderBy: [{ startDate: past ? "desc" : "asc" }, { id: "asc" }],
+        take: 20,
+        skip: (page - 1) * 20,
+      })
+    : [];
+  const href = (nextPage: number) =>
+    `/dashboard/abwesenheiten?view=${past ? "past" : "current"}&page=${nextPage}`;
+  const dateLabel = (date: Date) =>
+    new Intl.DateTimeFormat("de-DE", {
+      dateStyle: "medium",
+      timeZone: "UTC",
+    }).format(date);
+  return (
+    <div className="mx-auto max-w-[1100px] px-11 py-9 max-[760px]:px-5">
+      <header className="mb-7">
+        <p className="text-[11px] font-semibold uppercase tracking-widest text-[var(--accent-deep)]">
+          MEIN HAUSHALT
+        </p>
+        <h1 className="mt-2 text-4xl tracking-tight">
+          Meine{" "}
+          <em className="font-normal text-[var(--accent-deep)]">
+            Abwesenheiten
+          </em>
+        </h1>
+        <p className="mt-3 max-w-2xl text-sm leading-6 text-[var(--ink-soft)]">
+          Zukünftige Meldungen deiner Kinder kannst du ändern oder zurücknehmen.
+          Sobald eine Meldung begonnen hat, übernimmt die Kita die gesamte
+          Meldung.
+        </p>
+        <div className="mt-4 flex flex-wrap gap-2">
+          <Button asChild variant="outline" size="sm">
+            <Link href="/dashboard">Kind abmelden</Link>
+          </Button>
+          {canManageKitaAbsences(actor.role) && (
+            <Button asChild variant="outline" size="sm">
+              <Link href="/dashboard/admin/abwesenheiten">
+                Kita-Tagesübersicht
+              </Link>
+            </Button>
+          )}
+        </div>
+      </header>
+      {!actor.familyId ? (
+        <Card>
+          <CardContent className="py-6">
+            <p className="mb-3">
+              Deinem Konto ist noch kein Haushalt zugeordnet.
+            </p>
+            <Button asChild variant="outline">
+              <Link href="/dashboard/profil">Profil öffnen</Link>
+            </Button>
+          </CardContent>
+        </Card>
+      ) : (
+        <>
+          <nav aria-label="Abwesenheitszeitraum" className="mb-5 flex gap-2">
+            <Button asChild size="sm" variant={!past ? "default" : "outline"}>
+              <Link href="/dashboard/abwesenheiten">Aktuell & zukünftig</Link>
+            </Button>
+            <Button asChild size="sm" variant={past ? "default" : "outline"}>
+              <Link href="/dashboard/abwesenheiten?view=past">Vergangen</Link>
+            </Button>
+          </nav>
+          <p className="mb-3 text-sm text-[var(--ink-muted)]">
+            {count} Meldung{count === 1 ? "" : "en"}
+          </p>
+          <div className="grid gap-4">
+            {absences.length === 0 && (
+              <Card>
+                <CardContent className="py-8 text-sm text-[var(--ink-soft)]">
+                  Für diesen Zeitraum sind keine Abwesenheiten gemeldet.
+                </CardContent>
+              </Card>
+            )}
+            {absences.map((absence) => {
+              const startDate = absence.startDate.toISOString().slice(0, 10);
+              return (
+                <Card key={absence.id}>
+                  <CardContent className="py-5">
+                    <div className="flex flex-wrap items-start justify-between gap-3">
+                      <div>
+                        <h2 className="font-semibold">
+                          {absence.child.firstName} {absence.child.lastName}
+                        </h2>
+                        <p className="mt-1 text-sm text-[var(--ink-soft)]">
+                          {dateLabel(absence.startDate)}
+                          {absence.endDate.getTime() !==
+                          absence.startDate.getTime()
+                            ? ` – ${dateLabel(absence.endDate)}`
+                            : ""}{" "}
+                          · {reasonLabel(absence.reason)}
+                        </p>
+                      </div>
+                      <Badge variant="secondary">
+                        {past
+                          ? "Vergangen"
+                          : startDate <= today
+                            ? "Laufend"
+                            : "Zukünftig"}
+                      </Badge>
+                    </div>
+                    {absence.note && (
+                      <p className="mt-3 whitespace-pre-wrap break-words text-sm text-[var(--ink-soft)]">
+                        {absence.note}
+                      </p>
+                    )}
+                    <AbsenceManagementActions
+                      key={`${absence.id}-${absence.updatedAt.toISOString()}`}
+                      today={today}
+                      team={canManageKitaAbsences(actor.role)}
+                      absence={{
+                        id: absence.id,
+                        reason: absence.reason,
+                        note: absence.note,
+                        childName: `${absence.child.firstName} ${absence.child.lastName}`,
+                        startDate,
+                        endDate: absence.endDate.toISOString().slice(0, 10),
+                        updatedAt: absence.updatedAt.toISOString(),
+                      }}
+                    />
+                  </CardContent>
+                </Card>
+              );
+            })}
+          </div>
+          {pages > 1 && (
+            <div className="mt-5 flex items-center justify-between gap-3">
+              {page > 1 ? (
+                <Button asChild variant="outline">
+                  <Link href={href(page - 1)}>Zurück</Link>
+                </Button>
+              ) : (
+                <span />
+              )}
+              <span className="text-sm text-[var(--ink-muted)]">
+                Seite {page} von {pages}
+              </span>
+              {page < pages ? (
+                <Button asChild variant="outline">
+                  <Link href={href(page + 1)}>Weiter</Link>
+                </Button>
+              ) : (
+                <span />
+              )}
+            </div>
+          )}
+        </>
+      )}
+    </div>
+  );
+}

src/app/dashboard/admin/abwesenheiten/_components/absences-client.tsx

@@ -3,7 +3,7 @@
 import { useState, useMemo } from "react";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
-import { addDays, format, isWeekend, parseISO } from "date-fns";
+import { addDays, format, parseISO } from "date-fns";
 import { de } from "date-fns/locale";
 import {
   ArrowLeft,
@@ -55,34 +55,23 @@ export function AbsencesClient({
   const today = parseISO(todayStr);
 
   // Filters State
-  const [selectedGroup, setSelectedGroup] = useState<"all" | "Krippe" | "Elementar">("all");
   const [selectedReason, setSelectedReason] = useState<"all" | AbsenceReason>("all");
 
   // Dropdown UI state
-  const [isGroupOpen, setIsGroupOpen] = useState(false);
   const [isReasonOpen, setIsReasonOpen] = useState(false);
 
   // Date input state
   const [inputDate, setInputDate] = useState(dateKey);
 
-  // Group resolver function
-  const mockGroup = (childName: string) => {
-    const charCode = childName.charCodeAt(0);
-    return charCode % 2 === 0 ? "Krippe" : "Elementar";
-  };
-
   // Filter computation
   const filteredAbsences = useMemo(() => {
     return initialAbsences.filter((item) => {
-      if (selectedGroup !== "all" && mockGroup(item.childName) !== selectedGroup) {
-        return false;
-      }
       if (selectedReason !== "all" && item.reason !== selectedReason) {
         return false;
       }
       return true;
     });
-  }, [initialAbsences, selectedGroup, selectedReason]);
+  }, [initialAbsences, selectedReason]);
 
   // Recalculate reasons count based on filtered absences
   const countsByReason = useMemo(() => {
@@ -113,9 +102,9 @@ export function AbsencesClient({
             TAGESÜBERSICHT
           </p>
           <h1 className="mt-2 text-[36px] font-normal leading-tight tracking-[-0.025em] text-[var(--ink)]">
-            Heute fehlen{" "}
+            {isToday ? "Heute" : "An diesem Tag"}{filteredAbsences.length === 1 ? " fehlt " : " fehlen "}
             <em className="font-normal italic text-[var(--accent-deep)]">
-              {filteredAbsences.length} Kinder
+              {filteredAbsences.length} {filteredAbsences.length === 1 ? "Kind" : "Kinder"}
             </em>
           </h1>
           <p className="mt-2 text-[15px] leading-6 text-[var(--ink-soft)]">
@@ -126,7 +115,7 @@ export function AbsencesClient({
         <div className="flex flex-wrap items-center justify-end gap-3">
           <span className="inline-flex h-9 items-center gap-2 rounded-full border border-[var(--hairline)] bg-[var(--surface)] px-3 text-[13px] font-semibold text-[var(--ink-soft)]">
             <Stethoscope className="h-4 w-4 text-[var(--accent-deep)] [stroke-width:1.7]" />
-            {childCount - filteredAbsences.length} anwesend
+            {Math.max(0, childCount - initialAbsences.length)} anwesend
           </span>
           <div className="inline-flex overflow-hidden rounded-full border border-[var(--hairline)] bg-[var(--surface)]">
             <button
@@ -167,71 +156,6 @@ export function AbsencesClient({
 
       <div className="mt-5 flex flex-wrap items-center justify-between gap-3">
         <div className="flex flex-wrap gap-2">
-          {/* Group Dropdown Filter */}
-          <div className="relative">
-            <button
-              type="button"
-              onClick={() => setIsGroupOpen(!isGroupOpen)}
-              className={`inline-flex h-9 items-center gap-2 rounded-full border px-4 text-[13px] font-semibold transition focus-visible:outline-none focus-visible:ring-[3px] focus-visible:ring-[var(--focus-ring)] ${
-                selectedGroup !== "all"
-                  ? "border-[var(--accent-mid)] bg-[var(--accent-soft)] text-[var(--accent-deep)]"
-                  : "border-[var(--hairline)] bg-transparent text-[var(--ink-soft)] hover:bg-[var(--surface-2)]"
-              }`}
-            >
-              {selectedGroup === "all" ? "Alle Gruppen" : selectedGroup}
-              <ChevronDown className="h-3.5 w-3.5" />
-            </button>
-            {isGroupOpen && (
-              <>
-                <div className="fixed inset-0 z-10" onClick={() => setIsGroupOpen(false)} />
-                <div className="absolute left-0 mt-1.5 w-44 rounded-lg border border-[var(--hairline)] bg-[var(--surface)] py-1.5 shadow-lg z-20">
-                  <button
-                    type="button"
-                    onClick={() => {
-                      setSelectedGroup("all");
-                      setIsGroupOpen(false);
-                    }}
-                    className={`w-full text-left px-4 py-2 text-[13px] transition-colors ${
-                      selectedGroup === "all"
-                        ? "bg-[var(--accent-soft)] text-[var(--accent-deep)] font-semibold"
-                        : "text-[var(--ink-soft)] hover:bg-[var(--surface-2)]"
-                    }`}
-                  >
-                    Alle Gruppen
-                  </button>
-                  <button
-                    type="button"
-                    onClick={() => {
-                      setSelectedGroup("Krippe");
-                      setIsGroupOpen(false);
-                    }}
-                    className={`w-full text-left px-4 py-2 text-[13px] transition-colors ${
-                      selectedGroup === "Krippe"
-                        ? "bg-[var(--accent-soft)] text-[var(--accent-deep)] font-semibold"
-                        : "text-[var(--ink-soft)] hover:bg-[var(--surface-2)]"
-                    }`}
-                  >
-                    Krippe (Mock)
-                  </button>
-                  <button
-                    type="button"
-                    onClick={() => {
-                      setSelectedGroup("Elementar");
-                      setIsGroupOpen(false);
-                    }}
-                    className={`w-full text-left px-4 py-2 text-[13px] transition-colors ${
-                      selectedGroup === "Elementar"
-                        ? "bg-[var(--accent-soft)] text-[var(--accent-deep)] font-semibold"
-                        : "text-[var(--ink-soft)] hover:bg-[var(--surface-2)]"
-                    }`}
-                  >
-                    Elementar (Mock)
-                  </button>
-                </div>
-              </>
-            )}
-          </div>
-
           {/* Reason Dropdown Filter */}
           <div className="relative">
             <button
@@ -361,7 +285,7 @@ export function AbsencesClient({
               </div>
             </CardHeader>
             <CardContent>
-              <AbsenceTable absences={filteredAbsences} />
+              <AbsenceTable absences={filteredAbsences} today={todayStr} />
             </CardContent>
           </Card>
         ) : isTooFarFuture ? (

src/app/dashboard/admin/abwesenheiten/absence-table.tsx

@@ -4,6 +4,8 @@ import { useState } from "react";
 import { AbsenceReason } from "@prisma/client";
 import { CalendarDays, Circle, MessageSquareText, UserRound } from "lucide-react";
 import { reasonColor, reasonLabel } from "@/lib/absence-utils";
+import { AbsenceManagementActions } from "@/components/absence-management-actions";
+import { Button } from "@/components/ui/button";
 
 import { Badge } from "@/components/ui/badge";
 import {
@@ -30,12 +32,12 @@ export type AbsenceTableItem = {
   note: string | null;
   startDate: string;
   endDate: string;
+  updatedAt: string;
 };
 
-export function AbsenceTable({ absences }: { absences: AbsenceTableItem[] }) {
+export function AbsenceTable({ absences, today }: { absences: AbsenceTableItem[]; today: string }) {
-  const [activeAbsence, setActiveAbsence] = useState<AbsenceTableItem | null>(
+  const [activeId, setActiveId] = useState<string | null>(null);
-    null,
+  const activeAbsence = absences.find((absence) => absence.id === activeId) ?? null;
-  );
 
   return (
     <>
@@ -47,6 +49,7 @@ export function AbsenceTable({ absences }: { absences: AbsenceTableItem[] }) {
             <TableHead>Grund</TableHead>
             <TableHead>Bemerkung</TableHead>
             <TableHead>Status</TableHead>
+            <TableHead><span className="sr-only">Aktionen</span></TableHead>
           </TableRow>
         </TableHeader>
         <TableBody>
@@ -54,7 +57,7 @@ export function AbsenceTable({ absences }: { absences: AbsenceTableItem[] }) {
             <TableRow
               key={absence.id}
               className="cursor-pointer border-[var(--hairline-soft)] hover:bg-[var(--surface-2)]"
-              onClick={() => setActiveAbsence(absence)}
+              onClick={() => setActiveId(absence.id)}
             >
               <TableCell>
                 <div className="flex items-center gap-3">
@@ -89,6 +92,9 @@ export function AbsenceTable({ absences }: { absences: AbsenceTableItem[] }) {
               <TableCell>
                 <Badge variant="success">Bestätigt</Badge>
               </TableCell>
+              <TableCell>
+                <Button type="button" variant="ghost" size="sm" onClick={(event) => { event.stopPropagation(); setActiveId(absence.id); }} aria-label={`Abwesenheit öffnen: ${absence.childName}`}>Details & bearbeiten</Button>
+              </TableCell>
             </TableRow>
           ))}
         </TableBody>
@@ -96,9 +102,9 @@ export function AbsenceTable({ absences }: { absences: AbsenceTableItem[] }) {
 
       <Dialog
         open={!!activeAbsence}
-        onOpenChange={(open) => !open && setActiveAbsence(null)}
+        onOpenChange={(open) => !open && setActiveId(null)}
       >
-        <DialogContent className="left-auto right-0 top-0 h-full max-w-md translate-x-0 translate-y-0 rounded-none border-y-0 border-r-0 border-[var(--hairline)] bg-[var(--surface)] data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right">
+        <DialogContent className="left-auto right-0 top-0 h-full max-w-md overflow-y-auto translate-x-0 translate-y-0 rounded-none border-y-0 border-r-0 border-[var(--hairline)] bg-[var(--surface)] data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right">
           {activeAbsence ? (
             <>
               <DialogHeader>
@@ -129,6 +135,7 @@ export function AbsenceTable({ absences }: { absences: AbsenceTableItem[] }) {
                   value={activeAbsence.note || "Keine Bemerkung hinterlegt."}
                 />
                 <DetailLine icon={UserRound} label="Status" value="Bestätigt" />
+                <AbsenceManagementActions key={activeAbsence.updatedAt} absence={activeAbsence} today={today} team onChanged={() => setActiveId(null)} />
               </div>
             </>
           ) : null}

src/app/dashboard/admin/abwesenheiten/page.tsx

@@ -1,9 +1,9 @@
-import { differenceInCalendarDays, format, isWeekend } from "date-fns";
 import { TerminStatus, TerminType, UserRole } from "@prisma/client";
 
 import { getDailyAbsences } from "@/actions/absences";
 import { requireRole } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
+import { absenceDate, absenceToday, isAbsenceDate } from "@/lib/absence-policy";
 import { AbsencesClient } from "./_components/absences-client";
 import { type AbsenceTableItem } from "./absence-table";
 
@@ -21,9 +21,10 @@ export default async function AdminAbwesenheitenPage({
   ]);
   const resolvedSearchParams = await searchParams;
   const kitaId = session.user.kitaId!;
-  const today = startOfLocalDay(new Date());
+  const todayKey = absenceToday();
+  const today = absenceDate(todayKey);
   const selectedDate = parseDateParam(resolvedSearchParams.date, today);
-  const dateKey = format(selectedDate, "yyyy-MM-dd");
+  const dateKey = selectedDate.toISOString().slice(0, 10);
   const result = await getDailyAbsences({ date: dateKey });
   const absences = result.absences ?? [];
   const childCount = await prisma.child.count({
@@ -46,9 +47,9 @@ export default async function AdminAbwesenheitenPage({
     select: { title: true, type: true },
     orderBy: { startDate: "asc" },
   });
-  const isToday = dateKey === format(today, "yyyy-MM-dd");
+  const isToday = dateKey === todayKey;
-  const isTooFarFuture = differenceInCalendarDays(selectedDate, today) > 30;
+  const isTooFarFuture = (selectedDate.getTime() - today.getTime()) / 86_400_000 > 30;
-  const isClosedDay = isWeekend(selectedDate) || !!closure;
+  const isClosedDay = [0, 6].includes(selectedDate.getUTCDay()) || !!closure;
   const tableItems: AbsenceTableItem[] = absences.map((absence) => ({
     id: absence.id,
     childName: absence.childName,
@@ -57,6 +58,7 @@ export default async function AdminAbwesenheitenPage({
     note: absence.note,
     startDate: absence.startDate,
     endDate: absence.endDate,
+    updatedAt: absence.updatedAt,
   }));
 
   return (
@@ -67,11 +69,11 @@ export default async function AdminAbwesenheitenPage({
         upcomingAbsenceCount={upcomingAbsenceCount}
         closure={closure}
         dateKey={dateKey}
-        selectedDateStr={selectedDate.toISOString()}
+        selectedDateStr={dateKey}
         isToday={isToday}
         isTooFarFuture={isTooFarFuture}
         isClosedDay={isClosedDay}
-        todayStr={today.toISOString()}
+        todayStr={todayKey}
         error={result.error ?? null}
       />
     </div>
@@ -79,13 +81,5 @@ export default async function AdminAbwesenheitenPage({
 }
 
 function parseDateParam(value: string | undefined, fallback: Date) {
-  if (!value) return fallback;
+  return value && isAbsenceDate(value) ? absenceDate(value) : fallback;
-  const parsed = new Date(`${value}T00:00:00`);
-  return Number.isNaN(parsed.getTime()) ? fallback : parsed;
-}
-
-function startOfLocalDay(date: Date) {
-  const nextDate = new Date(date);
-  nextDate.setHours(0, 0, 0, 0);
-  return nextDate;
 }

src/app/dashboard/erzieher/_components/erzieher-list.tsx

@@ -1,5 +1,9 @@
 "use client";
 
+import {
+  RoleChangeButton,
+  type RolePerson,
+} from "../../zugriffsrechte/role-change-button";
 import { useState, useTransition } from "react";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
@@ -47,6 +51,7 @@ type EducatorDto = {
   email: string | null;
   verified: boolean;
   inviteFailed: boolean;
+  account: RolePerson | null;
 };
 
 function AccessFields({
@@ -119,9 +124,11 @@ function AccessFields({
 }
 
 export function ErzieherList({
+  currentUserId,
   educators,
   today,
 }: {
+  currentUserId: string;
   educators: EducatorDto[];
   today: string;
 }) {
@@ -377,6 +384,14 @@ export function ErzieherList({
                       </Badge>
                     </TableCell>
                     <TableCell className="pr-6 text-right">
+                      {ed.account ? (
+                        <span className="mr-2 inline-block">
+                          <RoleChangeButton
+                            person={ed.account}
+                            ownAccount={ed.account.id === currentUserId}
+                          />
+                        </span>
+                      ) : null}
                       <Button
                         variant="outline"
                         size="sm"

src/app/dashboard/erzieher/page.tsx

@@ -21,7 +21,15 @@ export default async function ErzieherPage() {
       staffProfile: {
         select: {
           id: true,
-          user: { select: { email: true, emailVerifiedAt: true } },
+          user: {
+            select: {
+              id: true,
+              role: true,
+              familyId: true,
+              email: true,
+              emailVerifiedAt: true,
+            },
+          },
           emails: {
             where: { inviteToken: { not: null }, skippedAt: null },
             orderBy: { createdAt: "desc" },
@@ -65,10 +73,20 @@ export default async function ErzieherPage() {
       </header>
 
       <ErzieherList
+        currentUserId={session.user.id}
         today={todayKey()}
         educators={educators.map(({ staffProfile, ...educator }) => ({
           ...educator,
           hasProfile: !!staffProfile,
+          account: staffProfile?.user
+            ? {
+                id: staffProfile.user.id,
+                name: `${educator.firstName} ${educator.lastName}`,
+                role: staffProfile.user.role,
+                familyId: staffProfile.user.familyId,
+                hasStaffProfile: true,
+              }
+            : null,
           email: staffProfile?.user?.email ?? null,
           verified: !!staffProfile?.user?.emailVerifiedAt,
           inviteFailed: !!staffProfile?.emails[0]?.failed,

src/app/dashboard/families/_components/families-list-client.tsx

@@ -1,5 +1,8 @@
 "use client";
 
+import type { UserRole } from "@prisma/client";
+import { RoleChangeButton } from "../../zugriffsrechte/role-change-button";
+import { RoleBadge } from "@/components/ui/role-badge";
 import { useState, useTransition } from "react";
 import { LayoutGrid, Mail, Search, Table, Users } from "lucide-react";
 import { toast } from "sonner";
@@ -19,6 +22,8 @@ import {
 import { AddFamilyDialog } from "../add-family-dialog";
 import { DutyManager } from "../duty-manager";
 import { EditFamilyDialog } from "../edit-family-dialog";
+import { InvitationStatus } from "../invitation-status";
+import type { FamilyInvitationView } from "@/lib/family-invitation-view";
 
 interface FamilyUser {
   id: string;
@@ -26,6 +31,9 @@ interface FamilyUser {
   lastName: string;
   email: string;
   emailVerifiedAt: Date | null;
+  invitation: FamilyInvitationView;
+  role: UserRole;
+  staffProfile: { id: string } | null;
   dutyAssignments: {
     id: string;
     dutyId: string;
@@ -57,12 +65,14 @@ interface DutyData {
 }
 
 interface FamiliesListClientProps {
+  currentUserId: string;
   initialFamilies: FamilyData[];
   allDuties: DutyData[];
   canManageDuties: boolean;
 }
 
 export function FamiliesListClient({
+  currentUserId,
   initialFamilies,
   allDuties,
   canManageDuties,
@@ -82,7 +92,7 @@ export function FamiliesListClient({
       (user) =>
         user.firstName.toLowerCase().includes(q) ||
         user.lastName.toLowerCase().includes(q) ||
-        user.email.toLowerCase().includes(q)
+        user.email.toLowerCase().includes(q),
     );
     if (matchesParent) return true;
 
@@ -90,20 +100,20 @@ export function FamiliesListClient({
     const matchesChild = family.children.some(
       (child) =>
         child.firstName.toLowerCase().includes(q) ||
-        child.lastName.toLowerCase().includes(q)
+        child.lastName.toLowerCase().includes(q),
     );
     return matchesChild;
   });
 
   const childCount = filteredFamilies.reduce(
     (acc, family) => acc + family.children.length,
-    0
+    0,
   );
 
   const pendingInviteCount = filteredFamilies.reduce(
     (acc, family) =>
       acc + family.users.filter((user) => !user.emailVerifiedAt).length,
-    0
+    0,
   );
 
   return (
@@ -120,14 +130,17 @@ export function FamiliesListClient({
             </em>
           </h1>
           <p className="mt-2 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
-            Haushalte, Elternteile, Kinder und Ämter an einem ruhigen Ort pflegen.
+            Haushalte, Elternteile, Kinder und Ämter an einem ruhigen Ort
+            pflegen.
           </p>
         </div>
         <div className="flex shrink-0 flex-wrap gap-2">
           <Button
             variant="ghost"
             size="sm"
-            onClick={() => setViewMode(viewMode === "table" ? "cards" : "table")}
+            onClick={() =>
+              setViewMode(viewMode === "table" ? "cards" : "table")
+            }
             className="flex items-center gap-1.5"
           >
             {viewMode === "table" ? (
@@ -149,7 +162,9 @@ export function FamiliesListClient({
       <div className="mb-5 flex flex-wrap items-center justify-between gap-3">
         <div className="flex flex-wrap gap-2">
           <span className="inline-flex h-9 items-center gap-2 rounded-full border border-[var(--hairline)] bg-[var(--surface)] px-3 text-[13px] font-semibold text-[var(--ink-soft)]">
-            <span className="text-[var(--ink)] tabular-nums">{filteredFamilies.length}</span>
+            <span className="text-[var(--ink)] tabular-nums">
+              {filteredFamilies.length}
+            </span>
             Familien
           </span>
           <span className="inline-flex h-9 items-center gap-2 rounded-full border border-[var(--hairline)] bg-[var(--surface)] px-3 text-[13px] font-semibold text-[var(--ink-soft)]">
@@ -157,7 +172,9 @@ export function FamiliesListClient({
             Kinder
           </span>
           <span className="inline-flex h-9 items-center gap-2 rounded-full border border-[var(--hairline)] bg-[var(--surface)] px-3 text-[13px] font-semibold text-[var(--ink-soft)]">
-            <span className="text-[var(--ink)] tabular-nums">{pendingInviteCount}</span>
+            <span className="text-[var(--ink)] tabular-nums">
+              {pendingInviteCount}
+            </span>
             Offene Einladungen
           </span>
         </div>
@@ -193,7 +210,8 @@ export function FamiliesListClient({
             <div>
               <CardTitle>Haushalte</CardTitle>
               <p className="mt-1 text-[13.5px] text-[var(--ink-soft)]">
-                {filteredFamilies.length} {filteredFamilies.length === 1 ? "Familie" : "Familien"} ·{" "}
+                {filteredFamilies.length}{" "}
+                {filteredFamilies.length === 1 ? "Familie" : "Familien"} ·{" "}
                 {childCount} Kinder · {pendingInviteCount} offene Einladungen
               </p>
             </div>
@@ -215,7 +233,7 @@ export function FamiliesListClient({
               <TableBody>
                 {filteredFamilies.map((family) => {
                   const hasPendingInvite = family.users.some(
-                    (user) => !user.emailVerifiedAt
+                    (user) => !user.emailVerifiedAt,
                   );
 
                   return (
@@ -247,9 +265,29 @@ export function FamiliesListClient({
                                 <Mail className="h-3 w-3 shrink-0 [stroke-width:1.7]" />
                                 <span className="break-words [overflow-wrap:anywhere]">
                                   {parent.email}
-                                  {!parent.emailVerifiedAt && <ResendInviteButton userId={parent.id} />}
+                                  {!parent.emailVerifiedAt && (
+                                    <ResendInviteButton userId={parent.id} />
+                                  )}
                                 </span>
                               </div>
+                              <InvitationStatus
+                                userId={parent.id}
+                                name={`${parent.firstName} ${parent.lastName}`}
+                                invitation={parent.invitation}
+                              />
+                              <div className="mt-2 flex flex-wrap items-center gap-2">
+                                <RoleBadge role={parent.role} />
+                                <RoleChangeButton
+                                  ownAccount={parent.id === currentUserId}
+                                  person={{
+                                    id: parent.id,
+                                    name: `${parent.firstName} ${parent.lastName}`,
+                                    role: parent.role,
+                                    familyId: family.id,
+                                    hasStaffProfile: !!parent.staffProfile,
+                                  }}
+                                />
+                              </div>
                             </div>
                           ))}
                         </div>
@@ -273,7 +311,9 @@ export function FamiliesListClient({
                         )}
                       </TableCell>
                       <TableCell>
-                        <Badge variant={hasPendingInvite ? "warning" : "success"}>
+                        <Badge
+                          variant={hasPendingInvite ? "warning" : "success"}
+                        >
                           {hasPendingInvite ? "Einladung offen" : "Aktiv"}
                         </Badge>
                       </TableCell>
@@ -288,6 +328,7 @@ export function FamiliesListClient({
                                 firstName: parent.firstName,
                                 lastName: parent.lastName,
                                 email: parent.email,
+                                invitation: parent.invitation,
                               })),
                               children: family.children,
                             }}
@@ -318,7 +359,7 @@ export function FamiliesListClient({
         <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
           {filteredFamilies.map((family) => {
             const hasPendingInvite = family.users.some(
-              (user) => !user.emailVerifiedAt
+              (user) => !user.emailVerifiedAt,
             );
             return (
               <Card key={family.id} className="flex flex-col h-full">
@@ -328,9 +369,12 @@ export function FamiliesListClient({
                       {family.name.slice(0, 1)}
                     </div>
                     <div>
-                      <CardTitle className="text-lg font-semibold">{family.name}</CardTitle>
+                      <CardTitle className="text-lg font-semibold">
+                        {family.name}
+                      </CardTitle>
                       <p className="text-xs text-[var(--ink-muted)]">
-                        {family.users.length} Elternteil{family.users.length === 1 ? "" : "e"}
+                        {family.users.length} Elternteil
+                        {family.users.length === 1 ? "" : "e"}
                       </p>
                     </div>
                   </div>
@@ -354,9 +398,29 @@ export function FamiliesListClient({
                               <Mail className="h-3.5 w-3.5 shrink-0 [stroke-width:1.7]" />
                               <span className="break-words [overflow-wrap:anywhere]">
                                 {parent.email}
-                                {!parent.emailVerifiedAt && <ResendInviteButton userId={parent.id} />}
+                                {!parent.emailVerifiedAt && (
+                                  <ResendInviteButton userId={parent.id} />
+                                )}
                               </span>
                             </div>
+                            <InvitationStatus
+                              userId={parent.id}
+                              name={`${parent.firstName} ${parent.lastName}`}
+                              invitation={parent.invitation}
+                            />
+                            <div className="mt-2 flex flex-wrap items-center gap-2">
+                              <RoleBadge role={parent.role} />
+                              <RoleChangeButton
+                                ownAccount={parent.id === currentUserId}
+                                person={{
+                                  id: parent.id,
+                                  name: `${parent.firstName} ${parent.lastName}`,
+                                  role: parent.role,
+                                  familyId: family.id,
+                                  hasStaffProfile: !!parent.staffProfile,
+                                }}
+                              />
+                            </div>
                           </div>
                         ))}
                       </div>
@@ -393,6 +457,7 @@ export function FamiliesListClient({
                           firstName: parent.firstName,
                           lastName: parent.lastName,
                           email: parent.email,
+                          invitation: parent.invitation,
                         })),
                         children: family.children,
                       }}
@@ -423,8 +488,21 @@ export function FamiliesListClient({
 
 function ResendInviteButton({ userId }: { userId: string }) {
   const [pending, startTransition] = useTransition();
-  return <Button type="button" size="sm" variant="ghost" disabled={pending} onClick={() => startTransition(async () => {
+  return (
-    const result = await resendParentInvite(userId);
+    <Button
-    if (result.error) toast.error(result.error); else toast.success("Einladung erneut gesendet.");
+      type="button"
-  })}>{pending ? "Wird gesendet…" : "Einladung erneut senden"}</Button>;
+      size="sm"
+      variant="ghost"
+      disabled={pending}
+      onClick={() =>
+        startTransition(async () => {
+          const result = await resendParentInvite(userId);
+          if (result.error) toast.error(result.error);
+          else toast.success("Einladung erneut gesendet.");
+        })
+      }
+    >
+      {pending ? "Wird gesendet…" : "Einladung erneut senden"}
+    </Button>
+  );
 }

src/app/dashboard/families/actions.ts

@@ -1,45 +1,60 @@
 "use server";
 
-import { hashToken, newToken } from "@/lib/tokens";
-import { createElement } from "react";
 import { revalidatePath } from "next/cache";
 import { Prisma, UserRole } from "@prisma/client";
 import { z } from "zod";
 
-import { InviteEmail } from "@/emails/InviteEmail";
 import { requireRole } from "@/lib/auth-utils";
-import { getAppEmailConfigError, sendAppEmail } from "@/lib/mail";
 import { rateLimit } from "@/lib/rate-limit";
+import {
+  deliverFamilyInvitations,
+  queueFamilyInvitation,
+  resendFamilyInvitation,
+} from "@/lib/family-invitations";
+import {
+  assertKitaAdminRemains,
+  lockKitaAccounts,
+} from "@/lib/kita-admin-guard";
 import { prisma } from "@/lib/prisma";
-
+import { assertChildrenRemovable } from "@/lib/notdienst-planning";
-const INVITE_TOKEN_TTL_DAYS = 7;
+import { UserFacingError, publicActionError } from "@/lib/action-error";
-const BASE_URL =
-  process.env.NEXTAUTH_URL ?? process.env.AUTH_URL ?? "http://localhost:3000";
 
 const childSchema = z.object({
-  firstName: z.string().min(1, "Vorname des Kindes fehlt.").max(100).trim(),
+  firstName: z.string().trim().min(1, "Vorname des Kindes fehlt.").max(100),
-  lastName: z.string().min(1, "Nachname des Kindes fehlt.").max(100).trim(),
+  lastName: z.string().trim().min(1, "Nachname des Kindes fehlt.").max(100),
 });
 
 const parentInputSchema = z.object({
-  firstName: z.string().min(1, "Vorname ist erforderlich.").max(100).trim(),
+  firstName: z.string().trim().min(1, "Vorname ist erforderlich.").max(100),
-  lastName: z.string().min(1, "Nachname ist erforderlich.").max(100).trim(),
+  lastName: z.string().trim().min(1, "Nachname ist erforderlich.").max(100),
   email: z
     .string()
-    .email("Bitte eine gültige E-Mail-Adresse angeben.")
+    .trim()
     .toLowerCase()
-    .trim(),
+    .email("Bitte eine gültige E-Mail-Adresse angeben."),
 });
 
 const addFamilySchema = z.object({
-  familyName: z.string().min(1, "Familienname ist erforderlich.").max(120).trim(),
+  familyName: z
-  parent1FirstName: z.string().min(1, "Vorname ist erforderlich.").max(100).trim(),
+    .string()
-  parent1LastName: z.string().min(1, "Nachname ist erforderlich.").max(100).trim(),
+    .trim()
+    .min(1, "Familienname ist erforderlich.")
+    .max(120),
+  parent1FirstName: z
+    .string()
+    .trim()
+    .min(1, "Vorname ist erforderlich.")
+    .max(100),
+  parent1LastName: z
+    .string()
+    .trim()
+    .min(1, "Nachname ist erforderlich.")
+    .max(100),
   parent1Email: z
     .string()
-    .email("Bitte eine gültige E-Mail-Adresse angeben.")
+    .trim()
     .toLowerCase()
-    .trim(),
+    .email("Bitte eine gültige E-Mail-Adresse angeben."),
   parent2FirstName: z.string().max(100).trim().optional(),
   parent2LastName: z.string().max(100).trim().optional(),
   parent2Email: z.string().trim().optional(),
@@ -52,12 +67,19 @@ const addFamilySchema = z.object({
 
 const updateFamilySchema = z.object({
   familyId: z.string().min(1),
-  familyName: z.string().min(1, "Familienname ist erforderlich.").max(120).trim(),
+  familyName: z
-  parents: z.array(
+    .string()
-    parentInputSchema.extend({
+    .trim()
-      id: z.string().min(1),
+    .min(1, "Familienname ist erforderlich.")
-    }),
+    .max(120),
-  ).min(1).max(2),
+  parents: z
+    .array(
+      parentInputSchema.extend({
+        id: z.string().min(1),
+      }),
+    )
+    .min(1)
+    .max(2),
   newParents: z.array(parentInputSchema).max(1).default([]),
   children: z
     .array(
@@ -83,12 +105,7 @@ export type AddFamilyState = {
     _form?: string[];
   };
   success?: boolean;
-};
+  warning?: string;
-
-type InviteJob = {
-  to: string;
-  parentName: string;
-  inviteUrl: string;
 };
 
 function optionalParentFromForm(data: z.infer<typeof addFamilySchema>) {
@@ -115,32 +132,14 @@ function optionalParentFromForm(data: z.infer<typeof addFamilySchema>) {
   return { ok: true as const, parent: parsed.data };
 }
 
-function createInviteToken() {
+async function sendInviteJobs(ids: string[]) {
-  const token = newToken();
+  try {
-  const expires = new Date(
+    const result = await deliverFamilyInvitations(ids);
-    Date.now() + INVITE_TOKEN_TTL_DAYS * 24 * 60 * 60_000,
+    if (!result.failed) return undefined;
-  );
+  } catch {
-  return { token, expires, inviteUrl: `${BASE_URL}/invite/${token}` };
+    // A committed family remains successful even if delivery/status storage fails.
-}
-
-async function sendInviteJobs(kitaName: string, jobs: InviteJob[]) {
-  for (const job of jobs) {
-    const result = await sendAppEmail({
-      to: job.to,
-      subject: `Einladung zu ${kitaName} im Kita-Planer`,
-      react: createElement(InviteEmail, {
-        parentName: job.parentName,
-        kitaName,
-        inviteLink: job.inviteUrl,
-      }),
-    });
-
-    if (!result.success) {
-      return result.error;
-    }
   }
-
+  return "Familie gespeichert. Mindestens eine Einladung konnte nicht versendet werden. Den Versand kannst du beim jeweiligen Elternteil erneut versuchen.";
-  return null;
 }
 
 export async function addFamilyAction(
@@ -154,7 +153,12 @@ export async function addFamilyAction(
     return { errors: { _form: ["Kein Mandant zugeordnet."] } };
   }
 
-  if (!(await rateLimit(`family-invites:${kitaId}`, 30, 3600)).allowed) return { errors: { _form: ["Zu viele Einladungen. Bitte versuche es später erneut."] } };
+  if (!(await rateLimit(`family-invites:${kitaId}`, 30, 3600)).allowed)
+    return {
+      errors: {
+        _form: ["Zu viele Einladungen. Bitte versuche es später erneut."],
+      },
+    };
 
   const parsedFamily = addFamilySchema.safeParse(Object.fromEntries(formData));
   if (!parsedFamily.success) {
@@ -185,11 +189,6 @@ export async function addFamilyAction(
     childrenRaw.push(parsed.data);
   }
 
-  const mailConfigError = getAppEmailConfigError();
-  if (mailConfigError) {
-    return { errors: { _form: [mailConfigError] } };
-  }
-
   const kita = await prisma.kita.findUnique({
     where: { id: kitaId },
     select: { name: true },
@@ -211,12 +210,14 @@ export async function addFamilyAction(
   if (emailSet.size !== parents.length) {
     return {
       errors: {
-        _form: ["Die E-Mail-Adressen der Elternteile müssen unterschiedlich sein."],
+        _form: [
+          "Die E-Mail-Adressen der Elternteile müssen unterschiedlich sein.",
+        ],
       },
     };
   }
 
-  const inviteJobs: InviteJob[] = [];
+  const inviteJobs: string[] = [];
 
   try {
     await prisma.$transaction(async (tx) => {
@@ -239,19 +240,12 @@ export async function addFamilyAction(
             role: UserRole.ELTERN,
           },
         });
-        const invite = createInviteToken();
+        const invite = await queueFamilyInvitation(
-        inviteJobs.push({
+          tx,
-          to: parent.email,
+          createdParent.id,
-          parentName: `${parent.firstName} ${parent.lastName}`,
+          session.user.id,
-          inviteUrl: invite.inviteUrl,
+        );
-        });
+        inviteJobs.push(invite.id);
-        await tx.verificationToken.create({
-          data: {
-            identifier: createdParent.id,
-            token: hashToken(invite.token),
-            expires: invite.expires,
-          },
-        });
       }
 
       await tx.child.createMany({
@@ -274,26 +268,25 @@ export async function addFamilyAction(
         },
       };
     }
-    throw err;
+    console.error("Familie konnte nicht angelegt werden:", err);
-  }
-
-  const emailError = await sendInviteJobs(kita.name, inviteJobs);
-  if (emailError) {
     return {
       errors: {
         _form: [
-          `Familie wurde angelegt, aber mindestens eine Einladung konnte nicht versendet werden: ${emailError}`,
+          "Familie konnte nicht angelegt werden. Bitte erneut versuchen.",
         ],
       },
     };
   }
 
+  const warning = await sendInviteJobs(inviteJobs);
   revalidatePath("/dashboard/families");
   revalidatePath("/dashboard");
-  return { success: true };
+  return { success: true, warning };
 }
 
-export async function updateFamilyAction(rawPayload: unknown) {
+export async function updateFamilyAction(
+  rawPayload: unknown,
+): Promise<{ success?: boolean; error?: string; warning?: string }> {
   const session = await requireRole([UserRole.ADMIN]);
   const kitaId = session.user.kitaId;
 
@@ -316,25 +309,25 @@ export async function updateFamilyAction(rawPayload: unknown) {
     removedChildIds,
   } = parsed.data;
 
-  const parentEmails = [...parents, ...newParents].map((parent) => parent.email);
+  const parentEmails = [...parents, ...newParents].map(
+    (parent) => parent.email,
+  );
   if (new Set(parentEmails).size !== parentEmails.length) {
-    return { error: "Die E-Mail-Adressen der Elternteile müssen unterschiedlich sein." };
+    return {
+      error: "Die E-Mail-Adressen der Elternteile müssen unterschiedlich sein.",
+    };
   }
 
   const removedChildIdSet = new Set(removedChildIds);
-  const activeChildren = children.filter((child) => !removedChildIdSet.has(child.id));
+  const activeChildren = children.filter(
-  if (activeChildren.length + newChildren.length > 20) return { error: "Maximal 20 Kinder pro Familie." };
+    (child) => !removedChildIdSet.has(child.id),
+  );
+  if (activeChildren.length + newChildren.length > 20)
+    return { error: "Maximal 20 Kinder pro Familie." };
   if (activeChildren.length + newChildren.length === 0) {
     return { error: "Eine Familie benötigt mindestens ein Kind." };
   }
 
-  if (newParents.length > 0) {
-    const mailConfigError = getAppEmailConfigError();
-    if (mailConfigError) {
-      return { error: mailConfigError };
-    }
-  }
-
   const kita = await prisma.kita.findUnique({
     where: { id: kitaId },
     select: { name: true },
@@ -344,7 +337,7 @@ export async function updateFamilyAction(rawPayload: unknown) {
     return { error: "Kita wurde nicht gefunden." };
   }
 
-  const inviteJobs: InviteJob[] = [];
+  const inviteJobs: string[] = [];
 
   try {
     const existingFamily = await prisma.family.findFirst({
@@ -360,18 +353,31 @@ export async function updateFamilyAction(rawPayload: unknown) {
       return { error: "Familie wurde nicht gefunden." };
     }
 
-    const needsEmail = newParents.length > 0 || parents.some(parent => existingFamily.users.find(user => user.id === parent.id)?.email !== parent.email);
+    const needsEmail =
+      newParents.length > 0 ||
+      parents.some(
+        (parent) =>
+          existingFamily.users.find((user) => user.id === parent.id)?.email !==
+          parent.email,
+      );
     if (needsEmail) {
-      const configError = getAppEmailConfigError();
+      if (!(await rateLimit(`family-invites:${kitaId}`, 30, 3600)).allowed)
-      if (configError) return { error: configError };
+        return {
-      if (!(await rateLimit(`family-invites:${kitaId}`, 30, 3600)).allowed) return { error: "Zu viele Einladungen. Bitte versuche es später erneut." };
+          error: "Zu viele Einladungen. Bitte versuche es später erneut.",
+        };
     }
 
-    const existingParentIds = new Set(existingFamily.users.map((user) => user.id));
+    const existingParentIds = new Set(
-    const existingChildIds = new Set(existingFamily.children.map((child) => child.id));
+      existingFamily.users.map((user) => user.id),
+    );
+    const existingChildIds = new Set(
+      existingFamily.children.map((child) => child.id),
+    );
 
     if (!parents.every((parent) => existingParentIds.has(parent.id))) {
-      return { error: "Mindestens ein Elternteil gehört nicht zu dieser Familie." };
+      return {
+        error: "Mindestens ein Elternteil gehört nicht zu dieser Familie.",
+      };
     }
 
     if (!children.every((child) => existingChildIds.has(child.id))) {
@@ -386,81 +392,109 @@ export async function updateFamilyAction(rawPayload: unknown) {
       return { error: "Pro Familie sind maximal zwei Elternteile vorgesehen." };
     }
 
-    await prisma.$transaction(async (tx) => {
+    await prisma.$transaction(
-      await tx.family.update({
+      async (tx) => {
-        where: { id: familyId },
+        await lockKitaAccounts(tx, kitaId);
-        data: { name: familyName },
+        const changedEmails = parents
-      });
+          .filter(
-
+            (parent) =>
-      for (const parent of parents) {
+              existingFamily.users.find((user) => user.id === parent.id)
-        const current = await tx.user.findFirst({ where: { id: parent.id, kitaId, familyId }, select: { email: true } });
+                ?.email !== parent.email,
-        if (!current) throw new Error("Parent assignment changed");
+          )
-        const emailChanged = current.email !== parent.email;
+          .map((parent) => parent.id);
-        await tx.user.update({
+        await assertKitaAdminRemains(tx, kitaId, changedEmails);
-          where: { id: parent.id, kitaId, familyId },
+        await assertChildrenRemovable(tx, kitaId, familyId, removedChildIds);
-          data: { firstName: parent.firstName, lastName: parent.lastName, email: parent.email,
+        const removed = await tx.child.count({
-            ...(emailChanged ? { passwordHash: "", emailVerifiedAt: null, sessionVersion: { increment: 1 } } : {}) },
+          where: { kitaId, familyId, id: { in: removedChildIds } },
         });
-        if (emailChanged) {
+        if (removed !== removedChildIds.length)
-          const invite = createInviteToken();
+          throw new UserFacingError(
-          await tx.verificationToken.deleteMany({ where: { identifier: parent.id } });
+            "Mindestens ein Kind gehört nicht zu dieser Familie.",
-          await tx.verificationToken.create({ data: { identifier: parent.id, token: hashToken(invite.token), expires: invite.expires } });
+          );
-          inviteJobs.push({ to: parent.email, parentName: `${parent.firstName} ${parent.lastName}`, inviteUrl: invite.inviteUrl });
+        await tx.family.update({
+          where: { id: familyId },
+          data: { name: familyName },
+        });
+
+        for (const parent of parents) {
+          const current = await tx.user.findFirst({
+            where: { id: parent.id, kitaId, familyId },
+            select: { email: true },
+          });
+          if (!current) throw new Error("Parent assignment changed");
+          const emailChanged = current.email !== parent.email;
+          await tx.user.update({
+            where: { id: parent.id, kitaId, familyId },
+            data: {
+              firstName: parent.firstName,
+              lastName: parent.lastName,
+              email: parent.email,
+              ...(emailChanged
+                ? {
+                    passwordHash: "",
+                    emailVerifiedAt: null,
+                    sessionVersion: { increment: 1 },
+                  }
+                : {}),
+            },
+          });
+          if (emailChanged) {
+            const invite = await queueFamilyInvitation(
+              tx,
+              parent.id,
+              session.user.id,
+            );
+            inviteJobs.push(invite.id);
+          }
         }
-      }
 
-      for (const parent of newParents) {
+        for (const parent of newParents) {
-        const createdParent = await tx.user.create({
+          const createdParent = await tx.user.create({
-          data: {
+            data: {
-            kitaId,
+              kitaId,
-            familyId,
+              familyId,
-            email: parent.email,
+              email: parent.email,
-            firstName: parent.firstName,
+              firstName: parent.firstName,
-            lastName: parent.lastName,
+              lastName: parent.lastName,
-            passwordHash: "",
+              passwordHash: "",
-            role: UserRole.ELTERN,
+              role: UserRole.ELTERN,
-          },
+            },
-        });
+          });
-        const invite = createInviteToken();
+          const invite = await queueFamilyInvitation(
-        inviteJobs.push({
+            tx,
-          to: parent.email,
+            createdParent.id,
-          parentName: `${parent.firstName} ${parent.lastName}`,
+            session.user.id,
-          inviteUrl: invite.inviteUrl,
+          );
-        });
+          inviteJobs.push(invite.id);
-        await tx.verificationToken.create({
+        }
-          data: {
-            identifier: createdParent.id,
-            token: hashToken(invite.token),
-            expires: invite.expires,
-          },
-        });
-      }
 
-      for (const child of activeChildren) {
+        for (const child of activeChildren) {
-        await tx.child.update({
+          await tx.child.update({
-          where: { id: child.id, kitaId, familyId },
+            where: { id: child.id, kitaId, familyId },
-          data: {
+            data: {
-            firstName: child.firstName,
+              firstName: child.firstName,
-            lastName: child.lastName,
+              lastName: child.lastName,
-          },
+            },
-        });
+          });
-      }
+        }
 
-      for (const childId of removedChildIds) {
+        for (const childId of removedChildIds) {
-        await tx.child.delete({ where: { id: childId, kitaId, familyId } });
+          await tx.child.delete({ where: { id: childId, kitaId, familyId } });
-      }
+        }
 
-      for (const child of newChildren) {
+        for (const child of newChildren) {
-        await tx.child.create({
+          await tx.child.create({
-          data: {
+            data: {
-            kitaId,
+              kitaId,
-            familyId,
+              familyId,
-            firstName: child.firstName,
+              firstName: child.firstName,
-            lastName: child.lastName,
+              lastName: child.lastName,
-          },
+            },
-        });
+          });
-      }
+        }
-    });
+      },
+      { isolationLevel: Prisma.TransactionIsolationLevel.Serializable },
+    );
   } catch (error) {
     if (
       error instanceof Prisma.PrismaClientKnownRequestError &&
@@ -469,45 +503,76 @@ export async function updateFamilyAction(rawPayload: unknown) {
       return { error: "Mindestens eine E-Mail-Adresse existiert bereits." };
     }
 
-    console.error("Fehler beim Aktualisieren der Familie:", error);
+    if (!(error instanceof UserFacingError))
-    return { error: "Familie konnte nicht aktualisiert werden." };
+      console.error("Fehler beim Aktualisieren der Familie:", error);
-  }
-
-  const emailError = await sendInviteJobs(kita.name, inviteJobs);
-  if (emailError) {
     return {
-      error: `Familie wurde aktualisiert, aber mindestens eine Einladung konnte nicht versendet werden: ${emailError}`,
+      error: publicActionError(
+        error,
+        "Familie konnte nicht aktualisiert werden.",
+      ),
     };
   }
 
+  const warning = await sendInviteJobs(inviteJobs);
   revalidatePath("/dashboard/families");
   revalidatePath("/dashboard/profil");
   revalidatePath("/dashboard/notdienst");
   revalidatePath("/dashboard");
-  return { success: true };
+  return { success: true, warning };
+}
+
+export async function resendFamilyInvitationAction(
+  userId: string,
+): Promise<{ success?: boolean; error?: string; warning?: string }> {
+  const session = await requireRole([UserRole.ADMIN]);
+  if (
+    !session.user.kitaId ||
+    typeof userId !== "string" ||
+    !userId ||
+    userId.length > 64
+  )
+    return { error: "Ungültiges Elternkonto." };
+  if (
+    !(await rateLimit(`family-invites:${session.user.kitaId}`, 30, 3600))
+      .allowed
+  )
+    return { error: "Bitte versuche es später erneut." };
+  if (
+    !(
+      await rateLimit(`resend-invite:${session.user.kitaId}:${userId}`, 3, 3600)
+    ).allowed
+  )
+    return { error: "Bitte versuche es später erneut." };
+  const recipient = await prisma.user.findFirst({
+    where: {
+      id: userId,
+      kitaId: session.user.kitaId,
+      familyId: { not: null },
+      emailVerifiedAt: null,
+      passwordHash: "",
+      disabledAt: null,
+    },
+    select: { email: true },
+  });
+  if (!recipient) return { error: "Keine offene Einladung gefunden." };
+  let result;
+  try {
+    result = await resendFamilyInvitation(
+      session.user.kitaId,
+      userId,
+      session.user.id,
+      recipient.email,
+    );
+  } catch {
+    result = {
+      error:
+        "Einladung konnte nicht erneut versendet werden. Bitte den Status prüfen und erneut versuchen.",
+    };
+  }
+  revalidatePath("/dashboard/families");
+  return result;
 }
 
 export async function resendParentInvite(userId: string) {
-  const session = await requireRole([UserRole.ADMIN]);
+  return resendFamilyInvitationAction(userId);
-  if (typeof userId !== "string" || !userId || userId.length > 64) return { error: "Ungültige Eingabedaten." };
-  if (!(await rateLimit(`family-invites:${session.user.kitaId}`, 30, 3600)).allowed) return { error: "Bitte versuche es später erneut." };
-  if (!(await rateLimit(`resend-invite:${session.user.kitaId}:${userId}`, 3, 3600)).allowed) return { error: "Bitte versuche es später erneut." };
-  const user = await prisma.user.findFirst({ where: { id: userId, kitaId: session.user.kitaId, emailVerifiedAt: null, passwordHash: "", disabledAt: null },
-    select: { id: true, email: true, firstName: true, lastName: true, kita: { select: { name: true } } } });
-  if (!user?.kita) return { error: "Keine offene Einladung gefunden." };
-  const configError = getAppEmailConfigError(); if (configError) return { error: configError };
-  const invite = createInviteToken();
-  const renewed = await prisma.$transaction(async tx => {
-    // Lock and re-check the account before issuing a link for the selected mailbox.
-    // A concurrent address change/activation must invalidate this resend.
-    const eligible = await tx.user.updateMany({ where: { id: user.id, email: user.email, kitaId: session.user.kitaId,
-      emailVerifiedAt: null, passwordHash: "", disabledAt: null }, data: { sessionVersion: { increment: 1 } } });
-    if (eligible.count !== 1) return false;
-    await tx.verificationToken.deleteMany({ where: { identifier: user.id } });
-    await tx.verificationToken.create({ data: { identifier: user.id, token: hashToken(invite.token), expires: invite.expires } });
-    return true;
-  });
-  if (!renewed) return { error: "Die Einladung hat sich geändert. Bitte lade die Seite neu." };
-  const error = await sendInviteJobs(user.kita.name, [{ to: user.email, parentName: `${user.firstName} ${user.lastName}`, inviteUrl: invite.inviteUrl }]);
-  return error ? { error } : { success: true };
 }

src/app/dashboard/families/add-family-dialog.tsx

@@ -1,7 +1,8 @@
 "use client";
 
-import { useActionState, useState } from "react";
+import { useState, useTransition } from "react";
 import { Plus, Trash2 } from "lucide-react";
+import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -26,28 +27,24 @@ const initialState: AddFamilyState = {};
 //   • Dialog-Open/Close-State
 //   • Dynamische Kinderliste (min. 1, max. 10)
 //   • Ein oder zwei Elternteile pro Haushalt
-//   • useActionState → Server-Action-Fehler anzeigen
+//   • Eingaben bei Validierungsfehlern behalten
-//   • Bei Erfolg (state.success) Dialog automatisch schließen
+//   • Nach erfolgreichem Speichern schließen, auch bei einer Versandwarnung
 // =====================================================================
 
 export function AddFamilyDialog() {
   const [open, setOpen] = useState(false);
-  const [childCount, setChildCount] = useState(1);
+  const [childIds, setChildIds] = useState(["initial"]);
-  const [state, formAction, pending] = useActionState(
+  const childCount = childIds.length;
-    addFamilyAction,
+  const [state, setState] = useState<AddFamilyState>(initialState);
-    initialState,
+  const [pending, startTransition] = useTransition();
-  );
-
-  // Dialog schließen, wenn die Action erfolgreich war
-  if (state.success && open) {
-    setOpen(false);
-  }
 
   function handleOpenChange(nextOpen: boolean) {
+    if (pending) return;
+    if (nextOpen) {
+      setState(initialState);
+      setChildIds([crypto.randomUUID()]);
+    }
     setOpen(nextOpen);
-    // State beim Schließen zurücksetzen würde useActionState erfordern —
-    // stattdessen schließen wir einfach und der State bleibt bis zur nächsten
-    // Aktion erhalten (unkritisch).
   }
 
   return (
@@ -63,166 +60,185 @@ export function AddFamilyDialog() {
         <DialogHeader>
           <DialogTitle>Familie hinzufügen</DialogTitle>
           <DialogDescription>
-            Lege einen Haushalt mit Elternteilen und Kindern an. Die
+            Lege einen Haushalt mit Elternteilen und Kindern an. Die Elternteile
-            Elternteile erhalten Einladungslinks per E-Mail.
+            erhalten Einladungslinks per E-Mail.
           </DialogDescription>
         </DialogHeader>
 
-        <form action={formAction} className="space-y-6">
+        <form
-          {/* Anzahl Kinder als verstecktes Feld für die Server Action */}
+          onSubmit={(event) => {
-          <input type="hidden" name="childCount" value={childCount} />
+            event.preventDefault();
-
+            const data = new FormData(event.currentTarget);
-          <FormField
+            startTransition(async () => {
-            id="familyName"
+              const result = await addFamilyAction(initialState, data);
-            name="familyName"
+              setState(result);
-            label="Familienname"
+              if (result.success) {
-            placeholder="Familie Schmidt"
+                if (result.warning) toast.warning(result.warning);
-            error={state.errors?.familyName?.[0]}
+                else toast.success("Familie angelegt. Einladungen versendet.");
-          />
+                setOpen(false);
-
+              }
-          {/* ── Elternteile ────────────────────────────────────────── */}
+            });
-          <fieldset className="space-y-4">
+          }}
-            <legend className="text-[11px] font-semibold uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
+          className="space-y-6"
-              Elternteil 1
+        >
-            </legend>
+          <fieldset disabled={pending} className="space-y-6">
-
+            {/* Anzahl Kinder als verstecktes Feld für die Server Action */}
-            <div className="grid grid-cols-2 gap-3">
+            <input type="hidden" name="childCount" value={childCount} />
-              <FormField
-                id="parent1FirstName"
-                name="parent1FirstName"
-                label="Vorname"
-                autoComplete="given-name"
-                error={state.errors?.parent1FirstName?.[0]}
-              />
-              <FormField
-                id="parent1LastName"
-                name="parent1LastName"
-                label="Nachname"
-                autoComplete="family-name"
-                error={state.errors?.parent1LastName?.[0]}
-              />
-            </div>
 
             <FormField
-              id="parent1Email"
+              id="familyName"
-              name="parent1Email"
+              name="familyName"
-              type="email"
+              label="Familienname"
-              label="E-Mail-Adresse"
+              placeholder="Familie Schmidt"
-              autoComplete="email"
+              error={state.errors?.familyName?.[0]}
-              error={state.errors?.parent1Email?.[0]}
             />
-          </fieldset>
 
-          <fieldset className="space-y-4">
+            {/* ── Elternteile ────────────────────────────────────────── */}
-            <legend>
+            <fieldset className="space-y-4">
-              <span className="text-[11px] uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
-                Elternteil 2
-              </span>{" "}
-              <span className="font-normal italic text-[var(--ink-faint)]">
-                optional
-              </span>
-            </legend>
-
-            <div className="grid grid-cols-2 gap-3">
-              <FormField
-                id="parent2FirstName"
-                name="parent2FirstName"
-                label="Vorname"
-                autoComplete="given-name"
-                required={false}
-                error={state.errors?.parent2FirstName?.[0]}
-              />
-              <FormField
-                id="parent2LastName"
-                name="parent2LastName"
-                label="Nachname"
-                autoComplete="family-name"
-                required={false}
-                error={state.errors?.parent2LastName?.[0]}
-              />
-            </div>
-
-            <FormField
-              id="parent2Email"
-              name="parent2Email"
-              type="email"
-              label="E-Mail-Adresse"
-              autoComplete="email"
-              required={false}
-              error={state.errors?.parent2Email?.[0]}
-            />
-          </fieldset>
-
-          {/* ── Kinder ─────────────────────────────────────────────── */}
-          <fieldset className="space-y-3">
-            <div className="flex items-center justify-between">
               <legend className="text-[11px] font-semibold uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
-                Kinder ({childCount})
+                Elternteil 1
               </legend>
-              {childCount < 10 && (
-                <Button
-                  type="button"
-                  variant="ghost"
-                  size="sm"
-                  onClick={() => setChildCount((c) => c + 1)}
-                >
-                  <Plus className="mr-1.5 h-3.5 w-3.5" />
-                  Kind hinzufügen
-                </Button>
-              )}
-            </div>
 
-            {Array.from({ length: childCount }).map((_, i) => (
+              <div className="grid grid-cols-2 gap-3">
-              <div
+                <FormField
-                key={i}
+                  id="parent1FirstName"
-                className="relative rounded-lg border border-[var(--hairline)] bg-[var(--surface-2)] p-4"
+                  name="parent1FirstName"
-              >
+                  label="Vorname"
-                {childCount > 1 && (
+                  autoComplete="given-name"
-                  <button
+                  error={state.errors?.parent1FirstName?.[0]}
-                    type="button"
+                />
-                    onClick={() => {
+                <FormField
-                      // Kind entfernen — childCount reduzieren reicht, da die
+                  id="parent1LastName"
-                      // Felder nach Index benannt sind und der letzte entfernt wird.
+                  name="parent1LastName"
-                      setChildCount((c) => c - 1);
+                  label="Nachname"
-                    }}
+                  autoComplete="family-name"
-                    className="absolute right-3 top-3 rounded-md p-1 text-[var(--ink-muted)] transition-colors hover:bg-[var(--danger-soft)] hover:text-[var(--danger)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--accent)] focus-visible:ring-offset-2 focus-visible:ring-offset-[var(--surface-2)]"
+                  error={state.errors?.parent1LastName?.[0]}
-                    aria-label={`Kind ${i + 1} entfernen`}
+                />
-                  >
-                    <Trash2 className="h-4 w-4" />
-                  </button>
-                )}
-                <p className="mb-3 text-[11px] font-semibold uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
-                  Kind {i + 1}
-                </p>
-                <div className="grid grid-cols-2 gap-3">
-                  <FormField
-                    id={`childFirstName_${i}`}
-                    name={`childFirstName_${i}`}
-                    label="Vorname"
-                  />
-                  <FormField
-                    id={`childLastName_${i}`}
-                    name={`childLastName_${i}`}
-                    label="Nachname"
-                  />
-                </div>
               </div>
-            ))}
 
-            {state.errors?.children?.[0] && (
+              <FormField
-              <p className="text-xs text-[var(--danger)]">
+                id="parent1Email"
-                {state.errors.children[0]}
+                name="parent1Email"
+                type="email"
+                label="E-Mail-Adresse"
+                autoComplete="email"
+                error={state.errors?.parent1Email?.[0]}
+              />
+            </fieldset>
+
+            <fieldset className="space-y-4">
+              <legend>
+                <span className="text-[11px] uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
+                  Elternteil 2
+                </span>{" "}
+                <span className="font-normal italic text-[var(--ink-faint)]">
+                  optional
+                </span>
+              </legend>
+
+              <div className="grid grid-cols-2 gap-3">
+                <FormField
+                  id="parent2FirstName"
+                  name="parent2FirstName"
+                  label="Vorname"
+                  autoComplete="given-name"
+                  required={false}
+                  error={state.errors?.parent2FirstName?.[0]}
+                />
+                <FormField
+                  id="parent2LastName"
+                  name="parent2LastName"
+                  label="Nachname"
+                  autoComplete="family-name"
+                  required={false}
+                  error={state.errors?.parent2LastName?.[0]}
+                />
+              </div>
+
+              <FormField
+                id="parent2Email"
+                name="parent2Email"
+                type="email"
+                label="E-Mail-Adresse"
+                autoComplete="email"
+                required={false}
+                error={state.errors?.parent2Email?.[0]}
+              />
+            </fieldset>
+
+            {/* ── Kinder ─────────────────────────────────────────────── */}
+            <fieldset className="space-y-3">
+              <div className="flex items-center justify-between">
+                <legend className="text-[11px] font-semibold uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
+                  Kinder ({childCount})
+                </legend>
+                {childCount < 10 && (
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="sm"
+                    onClick={() =>
+                      setChildIds((ids) => [...ids, crypto.randomUUID()])
+                    }
+                  >
+                    <Plus className="mr-1.5 h-3.5 w-3.5" />
+                    Kind hinzufügen
+                  </Button>
+                )}
+              </div>
+
+              {childIds.map((childId, i) => (
+                <div
+                  key={childId}
+                  className="relative rounded-lg border border-[var(--hairline)] bg-[var(--surface-2)] p-4"
+                >
+                  {childCount > 1 && (
+                    <button
+                      type="button"
+                      onClick={() => {
+                        setChildIds((ids) =>
+                          ids.filter((id) => id !== childId),
+                        );
+                      }}
+                      className="absolute right-3 top-3 rounded-md p-1 text-[var(--ink-muted)] transition-colors hover:bg-[var(--danger-soft)] hover:text-[var(--danger)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--accent)] focus-visible:ring-offset-2 focus-visible:ring-offset-[var(--surface-2)]"
+                      aria-label={`Kind ${i + 1} entfernen`}
+                    >
+                      <Trash2 className="h-4 w-4" />
+                    </button>
+                  )}
+                  <p className="mb-3 text-[11px] font-semibold uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
+                    Kind {i + 1}
+                  </p>
+                  <div className="grid grid-cols-2 gap-3">
+                    <FormField
+                      id={`childFirstName_${i}`}
+                      name={`childFirstName_${i}`}
+                      label="Vorname"
+                    />
+                    <FormField
+                      id={`childLastName_${i}`}
+                      name={`childLastName_${i}`}
+                      label="Nachname"
+                    />
+                  </div>
+                </div>
+              ))}
+
+              {state.errors?.children?.[0] && (
+                <p className="text-xs text-[var(--danger)]">
+                  {state.errors.children[0]}
+                </p>
+              )}
+            </fieldset>
+
+            {/* Globaler Fehler */}
+            {state.errors?._form?.[0] && (
+              <p className="rounded-lg border border-[var(--danger)] bg-[var(--danger-soft)] p-3 text-sm text-[var(--danger)]">
+                {state.errors._form[0]}
               </p>
             )}
           </fieldset>
 
-          {/* Globaler Fehler */}
-          {state.errors?._form?.[0] && (
-            <p className="rounded-lg border border-[var(--danger)] bg-[var(--danger-soft)] p-3 text-sm text-[var(--danger)]">
-              {state.errors._form[0]}
-            </p>
-          )}
-
           <DialogFooter>
             <Button
               type="button"

src/app/dashboard/families/duty-manager.tsx

@@ -16,7 +16,12 @@ import {
 import { Input } from "@/components/ui/input";
 import { Badge } from "@/components/ui/badge";
 
-import { createDuty, assignDuty, removeDutyAssignment, deleteDuty } from "./duty-actions";
+import {
+  createDuty,
+  assignDuty,
+  removeDutyAssignment,
+  deleteDuty,
+} from "./duty-actions";
 
 type DutyWithAssignments = {
   id: string;
@@ -100,17 +105,25 @@ export function DutyManager({
   };
 
   const unassignedDuties = allDuties.filter(
-    (d) => !userAssignments.some((a) => a.dutyId === d.id)
+    (d) => !userAssignments.some((a) => a.dutyId === d.id),
   );
 
   return (
     <Dialog open={open} onOpenChange={setOpen}>
       <DialogTrigger asChild>
-        <Button variant="ghost" size="sm" className="h-8 gap-1">
+        <Button
+          variant="ghost"
+          size="sm"
+          className="h-8 gap-1"
+          aria-label={`Ämter für ${user.firstName} ${user.lastName}`}
+        >
           <Shield className="h-3.5 w-3.5" />
-          <span className="hidden sm:inline">Ämter</span>
+          <span>Ämter: {user.firstName}</span>
           {userAssignments.length > 0 && (
-            <Badge variant="secondary" className="ml-1 h-4 px-1 py-0 tabular-nums">
+            <Badge
+              variant="secondary"
+              className="ml-1 h-4 px-1 py-0 tabular-nums"
+            >
               {userAssignments.length}
             </Badge>
           )}
@@ -137,7 +150,11 @@ export function DutyManager({
             ) : (
               <div className="flex flex-wrap gap-2">
                 {userAssignments.map((assignment) => (
-                  <Badge key={assignment.id} variant="default" className="gap-1 pr-1">
+                  <Badge
+                    key={assignment.id}
+                    variant="default"
+                    className="gap-1 pr-1"
+                  >
                     {assignment.duty.name}
                     <button
                       className="ml-1 rounded-full p-0.5 transition-colors hover:bg-[oklch(0.98_0.005_45_/_0.18)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[oklch(0.98_0.005_45)]"
@@ -199,7 +216,12 @@ export function DutyManager({
               Neues Amt anlegen
             </h4>
             <form action={handleCreateDuty} className="flex gap-2">
-              <Input name="name" placeholder="z.B. Wäschedienst" className="h-8" required />
+              <Input
+                name="name"
+                placeholder="z.B. Wäschedienst"
+                className="h-8"
+                required
+              />
               <Button size="sm" className="h-8" disabled={isPending}>
                 Erstellen
               </Button>

src/app/dashboard/families/edit-family-dialog.tsx

@@ -1,6 +1,11 @@
 "use client";
 
-import { useMemo, useState, useTransition } from "react";
+import {
+  useMemo,
+  useState,
+  useTransition,
+  type ChangeEventHandler,
+} from "react";
 import { Pencil, Plus, Trash2 } from "lucide-react";
 import { toast } from "sonner";
 
@@ -17,12 +22,15 @@ import {
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { updateFamilyAction } from "./actions";
+import { InvitationStatus } from "./invitation-status";
+import type { FamilyInvitationView } from "@/lib/family-invitation-view";
 
 type EditableParent = {
   id: string;
   firstName: string;
   lastName: string;
   email: string;
+  invitation?: FamilyInvitationView;
 };
 
 type EditableChild = {
@@ -47,6 +55,7 @@ type EditableFamily = {
 };
 
 export function EditFamilyDialog({ family }: { family: EditableFamily }) {
+  const [open, setOpen] = useState(false);
   const [isPending, startTransition] = useTransition();
   const initialParents = useMemo(
     () =>
@@ -154,13 +163,22 @@ export function EditFamilyDialog({ family }: { family: EditableFamily }) {
         return;
       }
 
-      toast.success("Familie aktualisiert. Geänderte E-Mail-Adressen müssen über einen neuen Einladungslink bestätigt werden.");
+      if (result.warning) toast.warning(result.warning);
+      else toast.success("Familie aktualisiert. Geänderte E-Mail-Adressen müssen über einen neuen Einladungslink bestätigt werden.");
+      setOpen(false);
       setRemovedChildIds([]);
     });
   }
 
   return (
-    <Dialog onOpenChange={(open) => !open && resetState()}>
+    <Dialog
+      open={open}
+      onOpenChange={(nextOpen) => {
+        if (isPending) return;
+        resetState();
+        setOpen(nextOpen);
+      }}
+    >
       <DialogTrigger asChild>
         <Button variant="ghost" size="sm" className="h-8 gap-1">
           <Pencil className="h-3.5 w-3.5" />
@@ -168,7 +186,12 @@ export function EditFamilyDialog({ family }: { family: EditableFamily }) {
         </Button>
       </DialogTrigger>
       <DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-2xl">
-        <form action={handleSubmit}>
+        <form
+          onSubmit={(event) => {
+            event.preventDefault();
+            handleSubmit(new FormData(event.currentTarget));
+          }}
+        >
           <DialogHeader>
             <DialogTitle>Familie bearbeiten</DialogTitle>
             <DialogDescription>
@@ -176,7 +199,7 @@ export function EditFamilyDialog({ family }: { family: EditableFamily }) {
             </DialogDescription>
           </DialogHeader>
 
-          <div className="grid gap-6 py-4">
+          <fieldset disabled={isPending} className="grid gap-6 py-4">
             <div className="grid gap-2">
               <Label htmlFor={`familyName-${family.id}`}>Familienname</Label>
               <Input
@@ -251,8 +274,38 @@ export function EditFamilyDialog({ family }: { family: EditableFamily }) {
                       label="E-Mail-Adresse"
                       type="email"
                       defaultValue={parent.email}
+                      onChange={(event) => {
+                        const email = event.target.value;
+                        setParents((current) =>
+                          current.map((item) =>
+                            item.id === parent.id ? { ...item, email } : item,
+                          ),
+                        );
+                      }}
                     />
                   </div>
+                  {parent.kind === "existing" && parent.invitation && (
+                    <InvitationStatus
+                      userId={parent.id}
+                      name={`${parent.firstName} ${parent.lastName}`}
+                      invitation={parent.invitation}
+                      blocked={
+                        parent.email !==
+                        family.parents.find((item) => item.id === parent.id)
+                          ?.email
+                      }
+                    />
+                  )}
+                  {parent.kind === "existing" &&
+                    parent.invitation?.status !== "active" &&
+                    parent.email !==
+                      family.parents.find((item) => item.id === parent.id)
+                        ?.email && (
+                      <p className="mt-2 text-xs text-[var(--ink-soft)]">
+                        Beim Speichern wird eine neue Einladung an die geänderte
+                        Adresse versendet.
+                      </p>
+                    )}
                 </div>
               ))}
             </fieldset>
@@ -319,7 +372,7 @@ export function EditFamilyDialog({ family }: { family: EditableFamily }) {
                 ))
               )}
             </fieldset>
-          </div>
+          </fieldset>
 
           <DialogFooter>
             <Button type="submit" disabled={isPending}>
@@ -338,12 +391,14 @@ function Field({
   label,
   type = "text",
   defaultValue,
+  onChange,
 }: {
   id: string;
   name: string;
   label: string;
   type?: string;
   defaultValue: string;
+  onChange?: ChangeEventHandler<HTMLInputElement>;
 }) {
   return (
     <div className="grid gap-2">
@@ -353,6 +408,7 @@ function Field({
         name={name}
         type={type}
         defaultValue={defaultValue}
+        onChange={onChange}
         required
       />
     </div>

src/app/dashboard/families/invitation-status.tsx

@@ -0,0 +1,73 @@
+"use client";
+
+import { useTransition } from "react";
+import { Mail } from "lucide-react";
+import { toast } from "sonner";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import type { FamilyInvitationView } from "@/lib/family-invitation-view";
+import { resendFamilyInvitationAction } from "./actions";
+
+const labels = {
+  active: "Konto aktiviert",
+  open: "Aktivierung offen",
+  sending: "Versand läuft",
+  sent: "Einladung versendet",
+  failed: "Versand fehlgeschlagen",
+  expired: "Einladung abgelaufen",
+};
+
+export function InvitationStatus({
+  userId,
+  name,
+  invitation,
+  blocked = false,
+}: {
+  userId: string;
+  name: string;
+  invitation: FamilyInvitationView;
+  blocked?: boolean;
+}) {
+  const [pending, startTransition] = useTransition();
+  return (
+    <div className="mt-2 flex flex-wrap items-center gap-2 text-xs">
+      <Badge variant={invitation.status === "active" ? "success" : "warning"}>
+        {labels[invitation.status]}
+      </Badge>
+      {invitation.status !== "active" && (
+        <>
+          {invitation.expiresAt && (
+            <span className="text-[var(--ink-muted)]">
+              {invitation.status === "expired"
+                ? "Gültig gewesen bis"
+                : "Link gültig bis"}{" "}
+              {new Intl.DateTimeFormat("de-DE", {
+                dateStyle: "short",
+                timeZone: "Europe/Berlin",
+              }).format(new Date(invitation.expiresAt))}
+            </span>
+          )}
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            className="h-7 text-xs"
+            disabled={blocked || pending || invitation.status === "sending"}
+            aria-label={`Einladung erneut senden an ${name}`}
+            onClick={() =>
+              startTransition(async () => {
+                const result = await resendFamilyInvitationAction(userId);
+                if (result.error) toast.error(result.error);
+                else if (result.warning) toast.warning(result.warning);
+                else toast.success("Einladung versendet.");
+              })
+            }
+          >
+            <Mail className="h-3 w-3" />
+            {pending ? "Wird versendet…" : "Einladung erneut senden"}
+          </Button>
+        </>
+      )}
+    </div>
+  );
+}

src/app/dashboard/families/page.tsx

@@ -2,6 +2,7 @@ import { UserRole } from "@prisma/client";
 
 import { requireRole } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
+import { familyInvitationView } from "@/lib/family-invitation-view";
 import { FamiliesListClient } from "./_components/families-list-client";
 
 export const metadata = { title: "Familienverwaltung · Kita-Planer" };
@@ -31,7 +32,18 @@ export default async function FamiliesPage() {
           firstName: true,
           lastName: true,
           email: true,
+          role: true,
+          staffProfile: { select: { id: true } },
           emailVerifiedAt: true,
+          familyInvitation: {
+            select: {
+              expiresAt: true,
+              sentAt: true,
+              failed: true,
+              leaseUntil: true,
+              status: true,
+            },
+          },
           dutyAssignments: {
             select: {
               id: true,
@@ -73,7 +85,17 @@ export default async function FamiliesPage() {
   return (
     <div className="mx-auto max-w-[1280px] px-11 py-9 pb-16 max-[760px]:px-5">
       <FamiliesListClient
-        initialFamilies={families}
+        currentUserId={session.user.id}
+        initialFamilies={families.map((family) => ({
+          ...family,
+          users: family.users.map(({ familyInvitation, ...parent }) => ({
+            ...parent,
+            invitation: familyInvitationView(
+              parent.emailVerifiedAt,
+              familyInvitation,
+            ),
+          })),
+        }))}
         allDuties={allDuties}
         canManageDuties={canManageDuties}
       />

src/app/dashboard/kalender/_components/calendar-overview-client.tsx

@@ -1,10 +1,7 @@
 "use client";
 
 import { useState, useMemo, useTransition } from "react";
-import {
+import { TerminType, TerminStatus } from "@prisma/client";
-  TerminType,
-  TerminStatus,
-} from "@prisma/client";
 import {
   format,
   startOfMonth,
@@ -30,7 +27,7 @@ import {
   WashingMachine,
   Trash2,
 } from "lucide-react";
-import { RsvpDialog, RsvpForm } from "@/components/rsvp-form";
+import { RsvpForm } from "@/components/rsvp-form";
 import { Input } from "@/components/ui/input";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent } from "@/components/ui/card";
@@ -42,7 +39,6 @@ import {
   DialogFooter,
   DialogHeader,
   DialogTitle,
-  DialogTrigger,
 } from "@/components/ui/dialog";
 import { toast } from "sonner";
 
@@ -64,12 +60,32 @@ import {
 const categories = [
   { label: "Schließtag", type: TerminType.SCHLIESSTAG, color: "var(--danger)" },
   { label: "Teamtag", type: TerminType.TEAMTAG, color: "var(--danger)" },
-  { label: "Elternabend", type: TerminType.ELTERNABEND, color: "oklch(0.50 0.10 280)" },
+  {
+    label: "Elternabend",
+    type: TerminType.ELTERNABEND,
+    color: "oklch(0.50 0.10 280)",
+  },
   { label: "Fest", type: TerminType.KITA_FEST, color: "var(--good)" },
-  { label: "Geburtstag", type: TerminType.GEBURTSTAG_INTERN, color: "oklch(0.50 0.10 320)" },
+  {
-  { label: "Mein Elterndienst", type: "mein-elterndienst", color: "oklch(0.60 0.16 160)" },
+    label: "Geburtstag",
-  { label: "Elterndienst", type: "elterndienst", color: "oklch(0.75 0.08 160)" },
+    type: TerminType.GEBURTSTAG_INTERN,
-  { label: "Mein Notdienst", type: "mein-notdienst", color: "oklch(0.60 0.18 45)" },
+    color: "oklch(0.50 0.10 320)",
+  },
+  {
+    label: "Mein Elterndienst",
+    type: "mein-elterndienst",
+    color: "oklch(0.60 0.16 160)",
+  },
+  {
+    label: "Elterndienst",
+    type: "elterndienst",
+    color: "oklch(0.75 0.08 160)",
+  },
+  {
+    label: "Mein Notdienst",
+    type: "mein-notdienst",
+    color: "oklch(0.60 0.18 45)",
+  },
   { label: "Notdienst", type: "notdienst", color: "oklch(0.75 0.10 50)" },
   { label: "Sonstiges", type: TerminType.SONSTIGES, color: "var(--ink-muted)" },
 ];
@@ -102,7 +118,9 @@ export function CalendarOverviewClient({
   const [view, setView] = useState<"liste" | "monat" | "agenda">("monat");
   const [searchQuery, setSearchQuery] = useState("");
   const [activeTypes, setActiveTypes] = useState<Set<string>>(new Set());
-  const [filterScope, setFilterScope] = useState<"own" | "all">(isAdmin ? "all" : "own");
+  const [filterScope, setFilterScope] = useState<"own" | "all">(
+    isAdmin ? "all" : "own",
+  );
 
   // Month navigation state
   const [currentMonthDate, setCurrentMonthDate] = useState(new Date());
@@ -152,7 +170,8 @@ export function CalendarOverviewClient({
           item.kind === "notdienst" && item.childName
             ? item.childName.toLowerCase().includes(query)
             : false;
-        if (!titleMatch && !descMatch && !familyMatch && !childMatch) return false;
+        if (!titleMatch && !descMatch && !familyMatch && !childMatch)
+          return false;
       }
 
       // 2. Category filter
@@ -163,10 +182,10 @@ export function CalendarOverviewClient({
               ? "mein-elterndienst"
               : "elterndienst"
             : item.kind === "notdienst"
-            ? item.isOwn
+              ? item.isOwn
-              ? "mein-notdienst"
+                ? "mein-notdienst"
-              : "notdienst"
+                : "notdienst"
-            : item.type;
+              : item.type;
         if (!activeTypes.has(itemType)) return false;
       }
 
@@ -178,9 +197,21 @@ export function CalendarOverviewClient({
   const isEventOnDay = (item: CalendarListItemDto, day: Date) => {
     const eventStart = new Date(item.startDate);
     const eventEnd = new Date(item.endDate);
-    const dayTime = new Date(day.getFullYear(), day.getMonth(), day.getDate()).getTime();
+    const dayTime = new Date(
-    const startTime = new Date(eventStart.getFullYear(), eventStart.getMonth(), eventStart.getDate()).getTime();
+      day.getFullYear(),
-    const endTime = new Date(eventEnd.getFullYear(), eventEnd.getMonth(), eventEnd.getDate()).getTime();
+      day.getMonth(),
+      day.getDate(),
+    ).getTime();
+    const startTime = new Date(
+      eventStart.getFullYear(),
+      eventStart.getMonth(),
+      eventStart.getDate(),
+    ).getTime();
+    const endTime = new Date(
+      eventEnd.getFullYear(),
+      eventEnd.getMonth(),
+      eventEnd.getDate(),
+    ).getTime();
     return dayTime >= startTime && dayTime <= endTime;
   };
 
@@ -207,7 +238,7 @@ export function CalendarOverviewClient({
 
   return (
     <div className="space-y-5">
-      {!isAdmin && pendingSwapRequests.length > 0 && (
+      {pendingSwapRequests.length > 0 && (
         <NotdienstSwapRequestsPanel requests={pendingSwapRequests} />
       )}
 
@@ -330,7 +361,7 @@ export function CalendarOverviewClient({
         <AgendaView
           events={filteredEvents}
           isAdmin={isAdmin}
-          userId={userId}
+          onOpenDetails={(item) => setSelectedDay(new Date(item.startDate))}
           onDeleteTermin={(id, title) => {
             setDeleteEventId(id);
             setDeleteEventTitle(title);
@@ -339,11 +370,15 @@ export function CalendarOverviewClient({
       )}
 
       {/* Day details Dialog for Month View */}
-      <Dialog open={!!selectedDay} onOpenChange={(open) => !open && setSelectedDay(null)}>
+      <Dialog
+        open={!!selectedDay}
+        onOpenChange={(open) => !open && setSelectedDay(null)}
+      >
         <DialogContent className="max-w-xl max-h-[85vh] overflow-y-auto">
           <DialogHeader>
             <DialogTitle className="text-xl">
-              {selectedDay && format(selectedDay, "EEEE, d. MMMM yyyy", { locale: de })}
+              {selectedDay &&
+                format(selectedDay, "EEEE, d. MMMM yyyy", { locale: de })}
             </DialogTitle>
             <DialogDescription>
               Übersicht aller Zuteilungen, Feste und Einträge an diesem Tag.
@@ -372,7 +407,14 @@ export function CalendarOverviewClient({
                         }}
                       />
                       <div className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg bg-[var(--surface-2)] text-[var(--ink-soft)] ml-2">
-                        <WashingMachine className="h-5 w-5 [stroke-width:1.7]" style={{ color: item.isOwn ? "oklch(0.60 0.16 160)" : "oklch(0.75 0.08 160)" }} />
+                        <WashingMachine
+                          className="h-5 w-5 [stroke-width:1.7]"
+                          style={{
+                            color: item.isOwn
+                              ? "oklch(0.60 0.16 160)"
+                              : "oklch(0.75 0.08 160)",
+                          }}
+                        />
                       </div>
                       <div className="flex-1 min-w-0">
                         <div className="flex items-center justify-between gap-2">
@@ -410,7 +452,11 @@ export function CalendarOverviewClient({
                         {isAdmin && (
                           <div className="mt-3 flex gap-2">
                             <a href="/dashboard/admin/dienste">
-                              <Button size="sm" variant="outline" className="h-7 text-xs px-2.5">
+                              <Button
+                                size="sm"
+                                variant="outline"
+                                className="h-7 text-xs px-2.5"
+                              >
                                 Im Planer bearbeiten
                               </Button>
                             </a>
@@ -462,20 +508,30 @@ export function CalendarOverviewClient({
                         </p>
                         {isAdmin && (
                           <div className="mt-3 flex gap-2">
-                            <a href={`/dashboard/notdienst/plan?year=${item.planYear}&month=${item.planMonth}`}>
+                            <a
-                              <Button size="sm" variant="outline" className="h-7 text-xs px-2.5">
+                              href={`/dashboard/notdienst/plan?year=${item.planYear}&month=${item.planMonth}`}
+                            >
+                              <Button
+                                size="sm"
+                                variant="outline"
+                                className="h-7 text-xs px-2.5"
+                              >
                                 Im Planer bearbeiten
                               </Button>
                             </a>
                           </div>
                         )}
-                        {!isAdmin && item.canRequestSwap && (
+                        {item.canRequestSwap && (
                           <div className="mt-3 flex gap-2">
                             <NotdienstSwapDialog
                               target={item}
                               options={notdienstSwapOptions}
                               trigger={
-                                <Button size="sm" variant="outline" className="h-7 px-2.5 text-xs">
+                                <Button
+                                  size="sm"
+                                  variant="outline"
+                                  className="h-7 px-2.5 text-xs"
+                                >
                                   Tausch anfragen
                                 </Button>
                               }
@@ -500,7 +556,8 @@ export function CalendarOverviewClient({
                             style={{
                               color: getCategoryColor(item.type),
                               borderColor: getCategoryColor(item.type) + "44",
-                              backgroundColor: getCategoryColor(item.type) + "11",
+                              backgroundColor:
+                                getCategoryColor(item.type) + "11",
                             }}
                           >
                             {getTypeLabel(item.type)}
@@ -523,10 +580,17 @@ export function CalendarOverviewClient({
                           </p>
                         )}
 
-                        {item.rsvpEvent ? <section className="mt-4 border-t border-[var(--hairline)] pt-4">
+                        {item.rsvpEvent ? (
-                          <h5 className="mb-3 font-medium">Eure Rückmeldung</h5>
+                          <section className="mt-4 border-t border-[var(--hairline)] pt-4">
-                          <RsvpForm key={JSON.stringify(item.rsvpEvent)} event={item.rsvpEvent} />
+                            <h5 className="mb-3 font-medium">
-                        </section> : null}
+                              Eure Rückmeldung
+                            </h5>
+                            <RsvpForm
+                              key={JSON.stringify(item.rsvpEvent)}
+                              event={item.rsvpEvent}
+                            />
+                          </section>
+                        ) : null}
 
                         {item.participantInfo && item.showParticipantInfo && (
                           <div className="mt-3 rounded-lg border border-[var(--warn)] bg-[var(--warn-soft)] p-3 text-xs text-[var(--ink)]">
@@ -534,7 +598,9 @@ export function CalendarOverviewClient({
                               <AlertTriangle className="h-3.5 w-3.5 text-[var(--warn)]" />
                               Hinweis für Teilnehmer
                             </div>
-                            <p className="whitespace-pre-wrap">{item.participantInfo}</p>
+                            <p className="whitespace-pre-wrap">
+                              {item.participantInfo}
+                            </p>
                           </div>
                         )}
 
@@ -582,13 +648,17 @@ export function CalendarOverviewClient({
       </Dialog>
 
       {/* Delete Confirmation Dialog */}
-      <Dialog open={!!deleteEventId} onOpenChange={(open) => !open && setDeleteEventId(null)}>
+      <Dialog
+        open={!!deleteEventId}
+        onOpenChange={(open) => !open && setDeleteEventId(null)}
+      >
         <DialogContent>
           <DialogHeader>
             <DialogTitle>Termin unwiderruflich löschen?</DialogTitle>
             <DialogDescription>
-              Möchtest du den Termin &ldquo;{deleteEventTitle}&rdquo; wirklich löschen? Alle
+              Möchtest du den Termin &ldquo;{deleteEventTitle}&rdquo; wirklich
-              zugehörigen Teilnahmen und Mitbringsel-Einträge gehen verloren.
+              löschen? Alle zugehörigen Teilnahmen und Mitbringsel-Einträge
+              gehen verloren.
             </DialogDescription>
           </DialogHeader>
           <DialogFooter>
@@ -642,7 +712,9 @@ function NotdienstSwapRequestRow({
   const [isPending, startTransition] = useTransition();
 
   const runAction = (
-    action: (requestId: string) => Promise<{ success?: boolean; error?: string }>,
+    action: (
+      requestId: string,
+    ) => Promise<{ success?: boolean; error?: string }>,
     successMessage: string,
   ) => {
     startTransition(async () => {
@@ -659,13 +731,15 @@ function NotdienstSwapRequestRow({
     <div className="flex flex-wrap items-center justify-between gap-4 px-5 py-4">
       <div className="min-w-0">
         <p className="text-sm font-semibold text-[var(--ink)]">
-          {request.direction === "incoming" ? "Anfrage an dich" : "Deine Anfrage"}
+          {request.direction === "incoming"
+            ? "Anfrage an dich"
+            : "Deine Anfrage"}
         </p>
         <p className="mt-1 text-sm leading-5 text-[var(--ink-soft)]">
-          {format(request.targetDate, "dd.MM.yyyy", { locale: de })}{" "}
+          {format(request.targetDate, "dd.MM.yyyy", { locale: de })} (
-          ({request.targetFamilyName}, {request.targetChildName}) gegen{" "}
+          {request.targetFamilyName}, {request.targetChildName}) gegen{" "}
-          {format(request.offeredDate, "dd.MM.yyyy", { locale: de })}{" "}
+          {format(request.offeredDate, "dd.MM.yyyy", { locale: de })} (
-          ({request.offeredFamilyName}, {request.offeredChildName})
+          {request.offeredFamilyName}, {request.offeredChildName})
         </p>
         {request.message && (
           <p className="mt-1 text-xs leading-5 text-[var(--ink-muted)]">
@@ -679,7 +753,10 @@ function NotdienstSwapRequestRow({
             <Button
               size="sm"
               onClick={() =>
-                runAction(acceptNotdienstSwapRequest, "Tausch wurde angenommen.")
+                runAction(
+                  acceptNotdienstSwapRequest,
+                  "Tausch wurde angenommen.",
+                )
               }
               disabled={isPending}
             >
@@ -689,7 +766,10 @@ function NotdienstSwapRequestRow({
               size="sm"
               variant="ghost"
               onClick={() =>
-                runAction(declineNotdienstSwapRequest, "Tausch wurde abgelehnt.")
+                runAction(
+                  declineNotdienstSwapRequest,
+                  "Tausch wurde abgelehnt.",
+                )
               }
               disabled={isPending}
             >
@@ -701,7 +781,10 @@ function NotdienstSwapRequestRow({
             size="sm"
             variant="ghost"
             onClick={() =>
-              runAction(cancelNotdienstSwapRequest, "Tauschanfrage wurde zurückgezogen.")
+              runAction(
+                cancelNotdienstSwapRequest,
+                "Tauschanfrage wurde zurückgezogen.",
+              )
             }
             disabled={isPending}
           >
@@ -791,7 +874,9 @@ function MonthView({
               onClick={() => onDayClick(day)}
               className={[
                 "min-h-[105px] bg-[var(--surface)] p-2 transition-colors hover:bg-[var(--surface-2)] cursor-pointer flex flex-col justify-between",
-                !isCurrentMonth ? "bg-[var(--surface-3)]/30 text-[var(--ink-muted)] opacity-60" : "text-[var(--ink)]",
+                !isCurrentMonth
+                  ? "bg-[var(--surface-3)]/30 text-[var(--ink-muted)] opacity-60"
+                  : "text-[var(--ink)]",
               ].join(" ")}
             >
               {/* Day number cell top */}
@@ -817,10 +902,10 @@ function MonthView({
                         ? "oklch(0.60 0.16 160)"
                         : "oklch(0.75 0.08 160)"
                       : item.kind === "notdienst"
-                      ? item.isOwn
+                        ? item.isOwn
-                        ? "oklch(0.60 0.18 45)"
+                          ? "oklch(0.60 0.18 45)"
-                        : "oklch(0.75 0.10 50)"
+                          : "oklch(0.75 0.10 50)"
-                      : getCategoryColor(item.type);
+                        : getCategoryColor(item.type);
                   return (
                     <div
                       key={item.id}
@@ -856,25 +941,33 @@ function MonthView({
 function AgendaView({
   events,
   isAdmin,
-  userId,
   onDeleteTermin,
+  onOpenDetails,
 }: {
   events: CalendarListItemDto[];
   isAdmin: boolean;
-  userId: string;
   onDeleteTermin: (id: string, title: string) => void;
+  onOpenDetails: (item: CalendarListItemDto) => void;
 }) {
   const grouped = useMemo(() => {
-    const groups = new Map<string, { date: Date; items: CalendarListItemDto[] }>();
+    const groups = new Map<
+      string,
+      { date: Date; items: CalendarListItemDto[] }
+    >();
 
     events.forEach((item) => {
       const key = format(new Date(item.startDate), "yyyy-MM-dd");
-      const group = groups.get(key) ?? { date: new Date(item.startDate), items: [] };
+      const group = groups.get(key) ?? {
+        date: new Date(item.startDate),
+        items: [],
+      };
       group.items.push(item);
       groups.set(key, group);
     });
 
-    return Array.from(groups.values()).sort((a, b) => a.date.getTime() - b.date.getTime());
+    return Array.from(groups.values()).sort(
+      (a, b) => a.date.getTime() - b.date.getTime(),
+    );
   }, [events]);
 
   if (events.length === 0) {
@@ -896,7 +989,10 @@ function AgendaView({
   return (
     <div className="space-y-6 pl-4 border-l-2 border-[var(--hairline)]">
       {grouped.map((group) => (
-        <div key={group.date.toString()} className="relative grid grid-cols-[110px_1fr] gap-4 items-start">
+        <div
+          key={group.date.toString()}
+          className="relative grid grid-cols-1 sm:grid-cols-[110px_minmax(0,1fr)] gap-4 items-start"
+        >
           {/* Timeline marker */}
           <div className="absolute -left-[21px] top-1.5 h-3.5 w-3.5 rounded-full border-2 border-[var(--accent-deep)] bg-[var(--surface)]" />
 
@@ -917,19 +1013,19 @@ function AgendaView({
                 item.kind === "termin"
                   ? getCategoryColor(item.type)
                   : item.kind === "notdienst"
-                  ? item.isOwn
+                    ? item.isOwn
-                    ? "oklch(0.60 0.18 45)"
+                      ? "oklch(0.60 0.18 45)"
-                    : "oklch(0.75 0.10 50)"
+                      : "oklch(0.75 0.10 50)"
-                  : item.kind === "duty"
+                    : item.kind === "duty"
-                  ? item.isOwn
+                      ? item.isOwn
-                    ? "oklch(0.60 0.16 160)"
+                        ? "oklch(0.60 0.16 160)"
-                    : "oklch(0.75 0.08 160)"
+                        : "oklch(0.75 0.08 160)"
-                  : "oklch(0.60 0.15 160)";
+                      : "oklch(0.60 0.15 160)";
 
               return (
                 <div
                   key={item.id}
-                  className="group relative flex items-start justify-between gap-4 rounded-xl border border-[var(--hairline)] bg-[var(--surface)] p-4 shadow-sm transition-shadow hover:shadow-md"
+                  className="group relative flex flex-wrap items-start justify-between gap-4 rounded-xl border border-[var(--hairline)] bg-[var(--surface)] p-4 shadow-sm transition-shadow hover:shadow-md"
                 >
                   <div className="flex items-start gap-3 min-w-0">
                     <div
@@ -965,13 +1061,19 @@ function AgendaView({
                             {item.isOwn ? "Mein Notdienst" : "Notdienst"}
                           </Badge>
                         ) : (
-                          <Badge variant="secondary" className="bg-[oklch(0.95_0.02_160)] text-[oklch(0.40_0.10_160)] text-[10px]">
+                          <Badge
+                            variant="secondary"
+                            className="bg-[oklch(0.95_0.02_160)] text-[oklch(0.40_0.10_160)] text-[10px]"
+                          >
                             Elterndienst
                           </Badge>
                         )}
-                        {item.kind === "termin" && item.status === TerminStatus.PENDING && (
+                        {item.kind === "termin" &&
-                          <Badge variant="warning" className="text-[10px]">Ausstehend</Badge>
+                          item.status === TerminStatus.PENDING && (
-                        )}
+                            <Badge variant="warning" className="text-[10px]">
+                              Ausstehend
+                            </Badge>
+                          )}
                       </div>
 
                       <p className="mt-1 text-xs text-[var(--ink-muted)] flex items-center gap-1.5">
@@ -984,17 +1086,19 @@ function AgendaView({
                                 "HH:mm",
                               )}`
                           : item.kind === "notdienst"
-                          ? `${format(new Date(item.startDate), "dd.MM.yyyy")} (ganztägig)`
+                            ? `${format(new Date(item.startDate), "dd.MM.yyyy")} (ganztägig)`
-                          : `${format(new Date(item.startDate), "dd.MM.")} - ${format(
+                            : `${format(new Date(item.startDate), "dd.MM.")} - ${format(
-                              new Date(item.endDate),
+                                new Date(item.endDate),
-                              "dd.MM.yyyy",
+                                "dd.MM.yyyy",
-                            )}`}
+                              )}`}
-                        {item.kind === "termin" && <MapPin className="ml-1 h-3.5 w-3.5" />}
+                        {item.kind === "termin" && (
+                          <MapPin className="ml-1 h-3.5 w-3.5" />
+                        )}
                         {item.kind === "termin"
                           ? "Kita"
                           : item.kind === "notdienst"
-                          ? `Kind: ${item.childName} · Familie: ${item.familyName}`
+                            ? `Kind: ${item.childName} · Familie: ${item.familyName}`
-                          : `Familie: ${item.familyName}`}
+                            : `Familie: ${item.familyName}`}
                       </p>
 
                       {item.kind === "termin" && item.description && (
@@ -1005,7 +1109,14 @@ function AgendaView({
                     </div>
                   </div>
 
-                  {item.kind === "termin" && item.rsvpEvent ? <RsvpDialog event={item.rsvpEvent} /> : null}
+                  <Button
+                    size="sm"
+                    variant="outline"
+                    aria-label={`Details zu ${item.title}`}
+                    onClick={() => onOpenDetails(item)}
+                  >
+                    Details
+                  </Button>
 
                   {/* Actions for admins */}
                   {isAdmin && item.kind === "termin" && (

src/app/dashboard/kalender/_components/mitbringsel-list.tsx

@@ -1,12 +1,16 @@
 "use client";
 
 import { useState, useTransition } from "react";
-import { Trash2, Plus, Utensils } from "lucide-react";
+import { Trash2, Plus, Utensils, Pencil } from "lucide-react";
 import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
-import { addMitbringsel, deleteMitbringsel } from "../actions";
+import {
+  addMitbringsel,
+  deleteMitbringsel,
+  updateMitbringsel,
+} from "../actions";
 
 type MitbringselItemDto = {
   id: string;
@@ -27,30 +31,42 @@ export function MitbringselList({
   isAdmin: boolean;
 }) {
   const [content, setContent] = useState("");
+  const [editingId, setEditingId] = useState<string | null>(null);
+  const [editContent, setEditContent] = useState("");
   const [isPending, startTransition] = useTransition();
 
   const handleAdd = () => {
-    if (!content.trim()) return;
+    if (isPending || !content.trim()) return;
-
     startTransition(async () => {
       const res = await addMitbringsel({ terminId, content });
-      if (res.error) {
+      if (res.error) toast.error(res.error);
-        toast.error(res.error);
+      else {
-      } else {
         toast.success("Eintrag hinzugefügt.");
         setContent("");
       }
     });
   };
 
+  const handleSave = () => {
+    if (isPending || !editingId || !editContent.trim()) return;
+    startTransition(async () => {
+      const res = await updateMitbringsel({
+        itemId: editingId,
+        content: editContent,
+      });
+      if (res.error) toast.error(res.error);
+      else {
+        toast.success("Beitrag gespeichert.");
+        setEditingId(null);
+      }
+    });
+  };
+
   const handleDelete = (id: string) => {
     startTransition(async () => {
       const res = await deleteMitbringsel(id);
-      if (res.error) {
+      if (res.error) toast.error(res.error);
-        toast.error(res.error);
+      else toast.success("Eintrag gelöscht.");
-      } else {
-        toast.success("Eintrag gelöscht.");
-      }
     });
   };
 
@@ -60,8 +76,7 @@ export function MitbringselList({
         <Utensils className="h-4 w-4 text-[var(--ink-muted)] [stroke-width:1.7]" />
         Mitbring-Liste
       </div>
-
+      <div className="flex max-h-60 flex-col gap-2 overflow-y-auto">
-      <div className="flex flex-col gap-2 max-h-40 overflow-y-auto">
         {items.length === 0 ? (
           <p className="text-xs italic text-[var(--ink-faint)]">
             Noch keine Einträge vorhanden.
@@ -70,54 +85,118 @@ export function MitbringselList({
           items.map((item) => (
             <div
               key={item.id}
-              className="flex items-center justify-between gap-2 rounded-md border border-[var(--hairline-soft)] bg-[var(--surface)] p-2 text-sm text-[var(--ink)]"
+              className="rounded-md border border-[var(--hairline-soft)] bg-[var(--surface)] p-2 text-sm text-[var(--ink)]"
             >
-              <div className="flex flex-col">
+              <div className="flex items-start justify-between gap-2">
-                <span className="text-xs font-medium text-[var(--accent-deep)]">
+                <div className="min-w-0 flex-1">
-                  {item.user.firstName} {item.user.lastName}
+                  <span className="text-xs font-medium text-[var(--accent-deep)]">
-                </span>
+                    {item.user.firstName} {item.user.lastName}
-                <span>{item.content}</span>
+                  </span>
+                  {editingId !== item.id ? (
+                    <p className="break-words">{item.content}</p>
+                  ) : null}
+                </div>
+                {editingId !== item.id ? (
+                  <div className="flex shrink-0 gap-1">
+                    {item.userId === currentUserId ? (
+                      <Button
+                        type="button"
+                        variant="ghost"
+                        size="icon"
+                        className="h-8 w-8"
+                        aria-label={`Beitrag bearbeiten: ${item.content}`}
+                        onClick={() => {
+                          setEditingId(item.id);
+                          setEditContent(item.content);
+                        }}
+                        disabled={isPending}
+                      >
+                        <Pencil className="h-4 w-4" />
+                      </Button>
+                    ) : null}
+                    {isAdmin || item.userId === currentUserId ? (
+                      <Button
+                        type="button"
+                        variant="ghost"
+                        size="icon"
+                        className="h-8 w-8 text-[var(--ink-muted)] hover:bg-[var(--danger-soft)] hover:text-[var(--danger)]"
+                        aria-label={`Beitrag löschen: ${item.content}`}
+                        onClick={() => handleDelete(item.id)}
+                        disabled={isPending}
+                      >
+                        <Trash2 className="h-4 w-4" />
+                      </Button>
+                    ) : null}
+                  </div>
+                ) : null}
               </div>
-              {(isAdmin || item.userId === currentUserId) && (
+              {editingId === item.id ? (
-                <Button
+                <form
-                  variant="ghost"
+                  className="mt-2 flex flex-wrap gap-2"
-                  size="icon"
+                  onSubmit={(event) => {
-                  className="h-6 w-6 shrink-0 text-[var(--ink-muted)] hover:bg-[var(--danger-soft)] hover:text-[var(--danger)]"
+                    event.preventDefault();
-                  onClick={() => handleDelete(item.id)}
+                    handleSave();
-                  disabled={isPending}
+                  }}
                 >
-                  <Trash2 className="h-4 w-4 [stroke-width:1.7]" />
+                  <Input
-                </Button>
+                    autoFocus
-              )}
+                    aria-label="Mitbringbeitrag bearbeiten"
+                    value={editContent}
+                    onChange={(event) => setEditContent(event.target.value)}
+                    maxLength={500}
+                    disabled={isPending}
+                    className="h-8 min-w-0 flex-[1_1_180px] text-sm"
+                  />
+                  <Button
+                    type="submit"
+                    size="sm"
+                    className="h-8"
+                    disabled={isPending || !editContent.trim()}
+                  >
+                    Speichern
+                  </Button>
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="sm"
+                    className="h-8"
+                    disabled={isPending}
+                    onClick={() => setEditingId(null)}
+                  >
+                    Abbrechen
+                  </Button>
+                </form>
+              ) : null}
             </div>
           ))
         )}
       </div>
-
+      <form
-      <div className="flex gap-2 mt-1">
+        className="mt-1 flex gap-2"
+        onSubmit={(event) => {
+          event.preventDefault();
+          handleAdd();
+        }}
+      >
         <Input
+          aria-label="Neuer Mitbringbeitrag"
           placeholder="Was bringst du mit?"
           value={content}
-          onChange={(e) => setContent(e.target.value)}
+          onChange={(event) => setContent(event.target.value)}
-          onKeyDown={(e) => {
+          maxLength={500}
-            if (e.key === "Enter") {
-              e.preventDefault();
-              handleAdd();
-            }
-          }}
           disabled={isPending}
-          className="h-8 text-sm"
+          className="h-8 min-w-0 text-sm"
         />
         <Button
+          type="submit"
           size="sm"
           className="h-8 shrink-0"
-          onClick={handleAdd}
           disabled={!content.trim() || isPending}
         >
-          <Plus className="mr-1 h-4 w-4 [stroke-width:1.7]" />
+          <Plus className="mr-1 h-4 w-4" />
           Hinzufügen
         </Button>
-      </div>
+      </form>
     </div>
   );
 }

src/app/dashboard/kalender/_components/termin-list.tsx

@@ -760,23 +760,18 @@ function NotdienstRow({
               </>
             )}
           </div>
-        ) : notdienst.canRequestSwap ? (
+        ) : null}
+        {notdienst.canRequestSwap ? (
           <NotdienstSwapDialog
             target={notdienst}
             options={notdienstSwapOptions}
             trigger={
-              <Button
+              <Button size="sm" variant="outline" className="h-8 px-2.5 text-xs">
-                size="sm"
-                variant="outline"
-                className="h-8 px-2.5 text-xs"
-              >
                 Tausch anfragen
               </Button>
             }
           />
-        ) : (
+        ) : !isAdmin ? <div className="w-9 h-9" /> : null}
-          <div className="w-9 h-9" />
-        )}
       </div>
     </div>
   );

src/app/dashboard/kalender/actions.ts

@@ -24,6 +24,7 @@ import { serializableTransaction } from "@/lib/transaction";
 import { rateLimit } from "@/lib/rate-limit";
 import { prisma } from "@/lib/prisma";
 import { lockEvent } from "@/lib/event-lock";
+import { canRequestNotdienstSwap } from "@/lib/notdienst-swaps";
 
 // =====================================================================
 // /dashboard/kalender · Server Actions
@@ -127,7 +128,7 @@ async function getSwapAssignment(
             select: {
               name: true,
               users: {
-                where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+                where: { role: { in: [UserRole.ELTERN, UserRole.ADMIN, UserRole.KOORDINATOR] }, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
                 select: {
                   email: true,
                   firstName: true,
@@ -335,11 +336,8 @@ function buildTerminData(
 export async function createNotdienstSwapRequest(rawPayload: unknown) {
   const session = await requireKitaSession();
   if (!(await rateLimit(`createNotdienstSwapRequest:${session.user.kitaId}:${session.user.id}`, 30, 3600)).allowed) return { error: "Zu viele Anfragen. Bitte versuche es später erneut." };
-  if (session.user.role !== UserRole.ELTERN) {
+  if (!canRequestNotdienstSwap(session.user.role, session.user.familyId)) {
-    return { error: "Nur Eltern können Notdienst-Tausche anfragen." };
+    return { error: "Nur Eltern mit einem eigenen Haushalt können Notdienst-Tausche anfragen." };
-  }
-  if (!session.user.familyId) {
-    return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
   }
 
   const parsed = swapRequestSchema.safeParse(rawPayload);
@@ -467,7 +465,7 @@ export async function acceptNotdienstSwapRequest(requestIdRaw: unknown) {
                     select: {
                       name: true,
                       users: {
-                        where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+                        where: { role: { in: [UserRole.ELTERN, UserRole.ADMIN, UserRole.KOORDINATOR] }, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
                         select: { email: true, firstName: true, lastName: true },
                       },
                     },
@@ -493,7 +491,7 @@ export async function acceptNotdienstSwapRequest(requestIdRaw: unknown) {
                     select: {
                       name: true,
                       users: {
-                        where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+                        where: { role: { in: [UserRole.ELTERN, UserRole.ADMIN, UserRole.KOORDINATOR] }, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
                         select: { email: true, firstName: true, lastName: true },
                       },
                     },
@@ -636,7 +634,7 @@ export async function declineNotdienstSwapRequest(requestIdRaw: unknown) {
                   select: {
                     name: true,
                     users: {
-                      where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+                      where: { role: { in: [UserRole.ELTERN, UserRole.ADMIN, UserRole.KOORDINATOR] }, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
                       select: { email: true, firstName: true, lastName: true },
                     },
                   },
@@ -654,7 +652,7 @@ export async function declineNotdienstSwapRequest(requestIdRaw: unknown) {
                   select: {
                     name: true,
                     users: {
-                      where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+                      where: { role: { in: [UserRole.ELTERN, UserRole.ADMIN, UserRole.KOORDINATOR] }, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
                       select: { email: true, firstName: true, lastName: true },
                     },
                   },
@@ -1059,6 +1057,44 @@ export async function addMitbringsel(rawPayload: unknown) {
   }
 }
 
+const updateMitbringselSchema = z.object({
+  itemId: z.string().min(1).max(100),
+  content: mitbringselSchema.shape.content,
+});
+
+export async function updateMitbringsel(rawPayload: unknown) {
+  const session = await requireKitaSession();
+  const parsed = updateMitbringselSchema.safeParse(rawPayload);
+  if (!parsed.success) return { error: "Bitte einen Beitrag mit 1 bis 500 Zeichen eingeben." };
+  if (!(await rateLimit(`updateMitbringsel:${session.user.kitaId}:${session.user.id}`, 30, 3600)).allowed) {
+    return { error: "Zu viele Änderungen. Bitte versuche es später erneut." };
+  }
+
+  try {
+    await serializableTransaction(async (tx) => {
+      const item = await tx.mitbringselItem.findFirst({
+        where: { id: parsed.data.itemId, kitaId: session.user.kitaId, userId: session.user.id },
+        select: { terminId: true },
+      });
+      if (!item) throw new UserFacingError("Du kannst nur eigene Mitbringbeiträge bearbeiten.");
+      await lockEvent(tx, item.terminId, session.user.kitaId);
+      const termin = await tx.termin.findFirst({
+        where: { id: item.terminId, kitaId: session.user.kitaId, status: TerminStatus.CONFIRMED, mitbringselListEnabled: true },
+        select: { id: true },
+      });
+      if (!termin) throw new UserFacingError("Die Mitbring-Liste ist für diesen Termin nicht mehr aktiv.");
+      await tx.mitbringselItem.update({
+        where: { id: parsed.data.itemId, kitaId: session.user.kitaId, userId: session.user.id },
+        data: { content: parsed.data.content },
+      });
+    });
+    revalidatePath("/dashboard/kalender");
+    return { success: true };
+  } catch (error) {
+    return { error: publicActionError(error, "Der Beitrag konnte nicht gespeichert werden.") };
+  }
+}
+
 export async function deleteMitbringsel(itemId: string) {
   const session = await requireKitaSession();
 

src/app/dashboard/kalender/page.tsx

@@ -9,6 +9,7 @@ import { HelpCircle } from "lucide-react";
 
 import { requireKitaSession } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
+import { canRequestNotdienstSwap } from "@/lib/notdienst-swaps";
 import { getRsvpEvents } from "@/lib/rsvp-events";
 import { AdminTerminModal } from "./_components/admin-termin-modal";
 import {
@@ -213,7 +214,7 @@ export default async function KalenderPage({
   });
 
   const pendingSwapRows =
-    !isAdmin && session.user.familyId
+    session.user.familyId && canRequestNotdienstSwap(session.user.role, session.user.familyId)
       ? await prisma.notdienstSwapRequest.findMany({
           where: {
             kitaId: session.user.kitaId,
@@ -306,9 +307,8 @@ export default async function KalenderPage({
     ...notdienstAssignmentRows.map((assignment) => {
       const isOwn = assignment.child.familyId === familyIdForParticipation;
       const canRequestSwap =
-        !isAdmin &&
+        canRequestNotdienstSwap(session.user.role, session.user.familyId) &&
         !isOwn &&
-        !!session.user.familyId &&
         assignment.date >= today;
       return {
         kind: "notdienst" as const,

src/app/dashboard/notdienst/actions.ts

@@ -5,8 +5,10 @@ import { UserRole } from "@prisma/client";
 import { z } from "zod";
 
 import { requireRole } from "@/lib/auth-utils";
-import { prisma } from "@/lib/prisma";
+import { formatUtcDateKey, getTargetMonthData } from "@/lib/date-utils";
-import { getTargetMonthData } from "@/lib/date-utils";
+import { serializableTransaction } from "@/lib/transaction";
+import { UserFacingError, publicActionError } from "@/lib/action-error";
+import { loadNotdienstDays } from "@/lib/notdienst-planning";
 
 // =====================================================================
 // /dashboard/notdienst · Server Actions
@@ -64,90 +66,60 @@ export async function saveNotdienstAvailabilities(payloadRaw: {
     return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
   }
 
-  // ── 2. Validierung (Soll-Tage) ─────────────────────────────────────
-  const kita = await prisma.kita.findUniqueOrThrow({
-    where: { id: kitaId },
-    select: { notdienstMinPerChildPerMonth: true },
-  });
-
-  const requiredTotal = childrenIds.length * kita.notdienstMinPerChildPerMonth;
-  if (dates.length < requiredTotal) {
-    return {
-      error: `Bitte wähle mindestens ${requiredTotal} Tage aus.`,
-    };
-  }
-
-  // Sicherstellen, dass alle Kinder zum Haushalt des angemeldeten Users gehören.
-  const validChildren = await prisma.child.findMany({
-    where: {
-      id: { in: childrenIds },
-      kitaId,
-      familyId: session.user.familyId,
-    },
-    select: { id: true },
-  });
-
-  if (validChildren.length !== childrenIds.length) {
-    return { error: "Ungültige Kinder-Zuordnung erkannt." };
-  }
-
-  // Termine in Date-Objekte wandeln und sortieren
-  const parsedDates = dates.map(dateKeyToUtcDate);
-  const hasOutsideTargetMonth = parsedDates.some(
-    (date) =>
-      date.getUTCFullYear() !== targetYear ||
-      date.getUTCMonth() !== targetMonth - 1,
-  );
-  if (hasOutsideTargetMonth) {
-    return { error: "Bitte wähle Termine im Zielmonat aus." };
-  }
-
-  // Round-Robin Zuweisung
-  const inserts: {
-    kitaId: string;
-    childId: string;
-    userId: string;
-    date: Date;
-  }[] = [];
-
-  for (let i = 0; i < parsedDates.length; i++) {
-    const childId = validChildren[i % validChildren.length].id;
-    inserts.push({
-      kitaId,
-      childId,
-      userId: session.user.id,
-      date: parsedDates[i],
-    });
-  }
-
-  // ── 3. Datenbank-Transaktion ───────────────────────────────────────
   try {
-    await prisma.$transaction(async (tx) => {
+    await serializableTransaction(async (tx) => {
-      // a) Alle bestehenden Haushaltseinträge im Zielmonat für diese Kinder löschen
+      const [kita, children, workingDays] = await Promise.all([
+        tx.kita.findUniqueOrThrow({
+          where: { id: kitaId },
+          select: { notdienstMinPerChildPerMonth: true },
+        }),
+        tx.child.findMany({
+          where: { kitaId, familyId: session.user.familyId!, active: true },
+          select: { id: true },
+          orderBy: { id: "asc" },
+        }),
+        loadNotdienstDays(tx, kitaId, targetYear, targetMonth),
+      ]);
+      const suppliedIds = new Set(childrenIds);
+      if (!children.length || suppliedIds.size !== childrenIds.length ||
+          suppliedIds.size !== children.length || !children.every((child) => suppliedIds.has(child.id))) {
+        throw new UserFacingError("Bitte lade die Seite neu und wähle die Termine für alle aktiven Kinder deines Haushalts aus.");
+      }
+      const validDates = new Set(workingDays.map(formatUtcDateKey));
+      if (dates.some((date) => !validDates.has(date))) {
+        throw new UserFacingError("Bitte wähle nur geöffnete Werktage im Zielmonat aus. Wochenenden und Schließtage sind nicht möglich.");
+      }
+      const requiredTotal = children.length * kita.notdienstMinPerChildPerMonth;
+      if (dates.length < requiredTotal) {
+        throw new UserFacingError(`Bitte wähle mindestens ${requiredTotal} Tage aus.`);
+      }
+      const activeIds = children.map((child) => child.id);
       await tx.notdienstAvailability.deleteMany({
         where: {
           kitaId,
-          childId: { in: childrenIds },
+          child: { kitaId, familyId: session.user.familyId! },
           date: {
             gte: new Date(Date.UTC(targetYear, targetMonth - 1, 1)),
             lt: new Date(Date.UTC(targetYear, targetMonth, 1)),
           },
         },
       });
-
+      await tx.notdienstAvailability.createMany({
-      // b) Neue Einträge setzen
+        data: dates.map((date, index) => ({
-      if (inserts.length > 0) {
+          kitaId,
-        await tx.notdienstAvailability.createMany({
+          childId: activeIds[index % activeIds.length],
-          data: inserts,
+          userId: session.user.id,
-          skipDuplicates: true,
+          date: dateKeyToUtcDate(date),
-        });
+        })),
-      }
+      });
     });
 
     revalidatePath("/dashboard/notdienst");
+    revalidatePath("/dashboard/notdienst/plan");
+    revalidatePath("/dashboard");
     return { success: true, dates };
   } catch (error) {
-    console.error("Fehler beim Speichern der Notdienste:", error);
+    if (!(error instanceof UserFacingError)) console.error("Fehler beim Speichern der Notdienste:", error);
-    return { error: "Ein Fehler ist aufgetreten beim Speichern der Termine." };
+    return { error: publicActionError(error, "Ein Fehler ist aufgetreten beim Speichern der Termine.") };
   }
 }

src/app/dashboard/notdienst/notdienst-form.tsx

@@ -26,7 +26,8 @@ import { de } from "date-fns/locale";
 import { toast } from "sonner";
 
 import { cn } from "@/lib/utils";
-import { formatDateKey, getWorkingDaysOfMonth } from "@/lib/date-utils";
+import { formatDateKey, formatUtcDateKey } from "@/lib/date-utils";
+import { getNotdienstDays } from "@/lib/notdienst-days";
 import { saveNotdienstAvailabilities } from "./actions";
 
 export const notdienstEventCategories = {
@@ -100,23 +101,21 @@ export function NotdienstForm({
 }: NotdienstFormProps) {
   const router = useRouter();
   // Lokaler State für die Auswahl. Ein Datum liegt als stabiler yyyy-MM-dd-Schlüssel vor.
-  const [selectedDates, setSelectedDates] = useState<Set<string>>(
+  const [selection, setSelectedDates] = useState<Set<string>>(
     new Set(initialSelectedDates),
   );
   const [isPending, startTransition] = useTransition();
 
-  const closureDateKeys = useMemo(
+  const selectableDateKeys = useMemo(
-    () => getClosureDateKeys(calendarItems),
+    () => new Set(getNotdienstDays(targetYear, targetMonth,
-    [calendarItems],
+      calendarItems.filter((item) => item.category === "closure" || item.category === "team"),
+    ).map(formatUtcDateKey)),
+    [calendarItems, targetMonth, targetYear],
+  );
+  const selectedDates = useMemo(
+    () => new Set(Array.from(selection).filter((key) => selectableDateKeys.has(key))),
+    [selection, selectableDateKeys],
   );
-  const selectableDateKeys = useMemo(() => {
-    const workingDays = getWorkingDaysOfMonth(targetYear, targetMonth);
-    return new Set(
-      workingDays
-        .map(formatDateKey)
-        .filter((dateKey) => !closureDateKeys.has(dateKey)),
-    );
-  }, [closureDateKeys, targetMonth, targetYear]);
   const monthStart = startOfMonth(new Date(targetYear, targetMonth - 1));
   const selectedCount = selectedDates.size;
   const hasMinimumRequirement = requiredDaysTotal > 0;
@@ -375,12 +374,9 @@ export function NotdienstCalendar({
           const isInTargetMonth = isSameMonth(day, visibleMonthStart);
           const isSelected = selected.has(dateKey);
           const dayEvents = getCalendarItemsForDay(events, day);
-          const hasClosure = dayEvents.some(
-            (event) => event.category === "closure",
-          );
-          const isSelectable =
-            isInTargetMonth && selectableDateKeys.has(dateKey) && !hasClosure;
           const isWeekend = day.getDay() === 0 || day.getDay() === 6;
+          const hasClosure = isInTargetMonth && !isWeekend && !selectableDateKeys.has(dateKey);
+          const isSelectable = isInTargetMonth && selectableDateKeys.has(dateKey);
 
           return (
             <CalendarTile
@@ -603,25 +599,6 @@ function getCalendarItemsForDay(
   });
 }
 
-function getClosureDateKeys(items: NotdienstCalendarItem[]) {
-  const closureKeys = new Set<string>();
-
-  for (const item of items) {
-    if (item.category !== "closure") continue;
-
-    const days = eachDayOfInterval({
-      start: startOfDay(item.startDate),
-      end: startOfDay(item.endDate),
-    });
-
-    for (const day of days) {
-      closureKeys.add(formatDateKey(day));
-    }
-  }
-
-  return closureKeys;
-}
-
 function formatEventDate(event: NotdienstCalendarItem) {
   const date = format(event.startDate, "EEEE, d. MMMM yyyy", { locale: de });
   return event.allDay

src/app/dashboard/notdienst/page.tsx

@@ -5,7 +5,8 @@ import { Manrope } from "next/font/google";
 
 import { requireRole } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
-import { formatDateKey, getTargetMonthData } from "@/lib/date-utils";
+import { formatUtcDateKey, getTargetMonthData } from "@/lib/date-utils";
+import { getNotdienstDays } from "@/lib/notdienst-days";
 import { Button } from "@/components/ui/button";
 import { NotdienstEntry } from "./notdienst-entry";
 
@@ -77,7 +78,7 @@ export default async function NotdienstPage() {
               kitaId,
               status: TerminStatus.CONFIRMED,
               startDate: { lt: targetMonthEnd },
-              endDate: { gte: targetMonthStart },
+              endDate: { gte: new Date(targetMonthStart.getTime() - 86400000) },
             },
             select: {
               id: true,
@@ -93,7 +94,10 @@ export default async function NotdienstPage() {
         ])
       : [[], []];
 
-  const selectedDates = availabilities.map((a) => formatDateKey(a.date));
+  const validDateKeys = new Set(getNotdienstDays(targetYear, targetMonth,
+    termine.filter((termin) => termin.type === TerminType.SCHLIESSTAG || termin.type === TerminType.TEAMTAG),
+  ).map(formatUtcDateKey));
+  const selectedDates = availabilities.map((a) => formatUtcDateKey(a.date)).filter((key) => validDateKeys.has(key));
 
   return (
     <div className={`${manrope.className} mx-auto max-w-7xl px-4 py-8 sm:px-8`}>

src/app/dashboard/notdienst/plan/_components/email-status-card.tsx

@@ -0,0 +1,149 @@
+"use client";
+import { useTransition } from "react";
+import { useRouter } from "next/navigation";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import { Card } from "@/components/ui/card";
+import type { NotdienstEmailStatus } from "@/lib/notdienst-notifications";
+import {
+  retryNotdienstEmailsAction,
+  sendNotdienstRemindersAction,
+} from "../actions";
+
+export function EmailStatusCard({
+  status,
+  year,
+  month,
+  remindersOpen,
+  daysBefore,
+  jobConfigured,
+}: {
+  status: NotdienstEmailStatus;
+  year: number;
+  month: number;
+  remindersOpen: boolean;
+  daysBefore: number;
+  jobConfigured: boolean;
+}) {
+  const router = useRouter();
+  const [pending, startTransition] = useTransition();
+  const run = (retry: boolean) =>
+    startTransition(async () => {
+      const result = retry
+        ? await retryNotdienstEmailsAction(year, month)
+        : await sendNotdienstRemindersAction(year, month);
+      if (result.error) toast.error(result.error);
+      else if ("failed" in result && result.failed)
+        toast.warning(
+          "Einige E-Mails sind noch nicht versendet. Der nächste Versuch erfolgt automatisch oder über diesen Button.",
+        );
+      else if ("sent" in result)
+        toast.success(`${result.sent} E-Mails versendet.`);
+      router.refresh();
+    });
+  const labels = {
+    sent: "Versendet",
+    pending: "Wartet auf Versand",
+    failed: "Versand fehlgeschlagen",
+    skipped: "Nicht mehr erforderlich",
+  };
+  return (
+    <Card className="mb-5 print:hidden p-5">
+      <div className="flex flex-wrap items-start justify-between gap-3">
+        <div>
+          <h2 className="text-base font-medium text-[var(--ink)]">
+            E-Mail-Versand
+          </h2>
+          <p className="mt-1 text-sm text-[var(--ink-soft)]">
+            {daysBefore
+              ? `Automatische Erinnerung ab dem ${Math.max(1, 26 - daysBefore)}. um 9 Uhr. Eintragsfrist: der 26.`
+              : "Automatische Erinnerungen sind ausgeschaltet."}
+          </p>
+          {!jobConfigured ? (
+            <p className="mt-1 text-xs text-[var(--warn)]">
+              Der Hintergrundversand ist noch nicht konfiguriert. Offene E-Mails
+              können hier manuell gesendet werden.
+            </p>
+          ) : null}
+        </div>
+        <div className="flex flex-wrap gap-2">
+          {remindersOpen ? (
+            <Button
+              variant="ghost"
+              size="sm"
+              disabled={pending}
+              onClick={() => run(false)}
+            >
+              An fehlende Verfügbarkeiten erinnern
+            </Button>
+          ) : null}
+          {status.failed + status.pending > 0 ? (
+            <Button size="sm" disabled={pending} onClick={() => run(true)}>
+              Offene E-Mails erneut senden
+            </Button>
+          ) : null}
+          <Button
+            variant="ghost"
+            size="sm"
+            disabled={pending}
+            onClick={() => router.refresh()}
+          >
+            Aktualisieren
+          </Button>
+        </div>
+      </div>
+      <p className="mt-3 text-sm text-[var(--ink-soft)]">
+        {status.sent} versendet · {status.pending} ausstehend · {status.failed}{" "}
+        fehlgeschlagen · {status.skipped} nicht mehr erforderlich
+      </p>
+      {status.entries.length ? (
+        <details className="mt-3 text-sm">
+          <summary className="cursor-pointer font-medium text-[var(--accent-deep)]">
+            Versanddetails ansehen
+          </summary>
+          <ul className="mt-3 max-h-64 overflow-y-auto divide-y divide-[var(--hairline-soft)]">
+            {status.entries.map((entry) => (
+              <li
+                key={entry.id}
+                className="flex flex-wrap justify-between gap-2 py-2"
+              >
+                <div>
+                  <p>
+                    {entry.name} · {entry.familyName}
+                  </p>
+                  <p className="text-xs text-[var(--ink-muted)]">
+                    {entry.kind === "REMINDER"
+                      ? "Verfügbarkeitserinnerung"
+                      : "Planveröffentlichung"}
+                  </p>
+                  {entry.error ? (
+                    <p className="mt-1 text-xs text-[var(--danger)]">
+                      {entry.error}
+                    </p>
+                  ) : null}
+                </div>
+                <span
+                  className={
+                    entry.status === "failed"
+                      ? "text-[var(--danger)]"
+                      : "text-[var(--ink-soft)]"
+                  }
+                >
+                  {labels[entry.status]}
+                </span>
+              </li>
+            ))}
+          </ul>
+        </details>
+      ) : (
+        <p className="mt-2 text-xs text-[var(--ink-muted)]">
+          Für diesen Monat wurden noch keine E-Mails vorbereitet.
+        </p>
+      )}
+      <p className="mt-3 text-xs text-[var(--ink-muted)]">
+        Versendet bedeutet: vom Maildienst angenommen. Die tatsächliche
+        Zustellung ins Postfach kann hier nicht bestätigt werden.
+      </p>
+    </Card>
+  );
+}

src/app/dashboard/notdienst/plan/_components/settings-modal.tsx

@@ -35,8 +35,8 @@ export function SettingsModal({
   const handleSubmit = (event: FormEvent<HTMLFormElement>) => {
     event.preventDefault();
 
-    if (minPerChild < 0 || reminderDays < 0) {
+    if (!Number.isInteger(minPerChild) || minPerChild < 1 || minPerChild > 31 || !Number.isInteger(reminderDays) || reminderDays < 0 || reminderDays > 31) {
-      toast.error("Werte dürfen nicht negativ sein.");
+      toast.error("Bitte ein Soll von 1 bis 31 und eine Erinnerungsfrist von 0 bis 31 Tagen eingeben.");
       return;
     }
 
@@ -74,25 +74,26 @@ export function SettingsModal({
           <div className="grid gap-4 py-4">
             <div className="grid gap-2">
               <Label htmlFor="minPerChild">
-                Mindesteinteilungen pro Kind/Monat
+                Verfügbarkeitstage pro Kind/Monat
               </Label>
               <Input
                 id="minPerChild"
                 name="minPerChild"
                 type="number"
-                min="0"
+                min="1"
+                max="31"
                 required
                 value={minPerChild}
                 onChange={(e) => setMinPerChild(parseInt(e.target.value, 10))}
               />
               <p className="text-xs text-[var(--ink-muted)]">
-                Bestimmt das Richtmaß der automatischen Verteilung für Kinder im jeweiligen Monat.
+                So viele unterschiedliche Tage müssen Eltern je aktivem Kind als Verfügbarkeit eintragen.
               </p>
             </div>
 
             <div className="grid gap-2">
               <Label htmlFor="reminderDays">
-                Erinnerungsfrist (Tage vor Monatsende)
+                Erinnerung (Tage vor Eintragsfrist)
               </Label>
               <Input
                 id="reminderDays"
@@ -100,11 +101,12 @@ export function SettingsModal({
                 type="number"
                 min="0"
                 required
+                max="31"
                 value={reminderDays}
                 onChange={(e) => setReminderDays(parseInt(e.target.value, 10))}
               />
               <p className="text-xs text-[var(--ink-muted)]">
-                Frist, nach der Eltern automatisch per Mail an offene Verfügbarkeiten erinnert werden.
+                Die Eintragsfrist endet am 26. Bei 7 Tagen erfolgt die Erinnerung ab dem 19. um 9 Uhr. 0 deaktiviert automatische Erinnerungen.
               </p>
             </div>
           </div>

src/app/dashboard/notdienst/plan/actions.ts

@@ -11,9 +11,16 @@ import { de } from "date-fns/locale";
 
 import { requireRole } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
-import { getTargetMonthData, getWorkingDaysOfMonth } from "@/lib/date-utils";
+import { getTargetMonthData } from "@/lib/date-utils";
-import { getAppEmailConfigError, sendAppEmail } from "@/lib/mail";
+import { loadNotdienstDays } from "@/lib/notdienst-planning";
-import { NotdienstAvailabilityReminderEmail } from "@/emails/NotdienstAvailabilityReminderEmail";
+import { todayKey } from "@/lib/alarms/format";
+import { serializableTransaction } from "@/lib/transaction";
+import {
+  queueNotdienstPublication,
+  queueNotdienstReminders,
+  deliverDueNotdienstEmails,
+} from "@/lib/notdienst-notifications";
+import { sendAppEmail } from "@/lib/mail";
 import { NotdienstAssignmentChangeEmail } from "@/emails/NotdienstAssignmentChangeEmail";
 import { requireAlarmActor } from "@/lib/alarms/auth";
 import {
@@ -40,77 +47,53 @@ export async function generatePlanAction(year?: number, month?: number) {
     targetMonth = data.targetMonth;
   }
 
-  if (!validPlanMonth(targetYear, targetMonth)) return { error: "Ungültiger Planungsmonat." };
+  if (!validPlanMonth(targetYear, targetMonth))
+    return { error: "Ungültiger Planungsmonat." };
 
-  // Prüfen, ob schon ein Plan existiert
-  const existingPlan = await prisma.notdienstPlan.findUnique({
-    where: {
-      kitaId_year_month: { kitaId, year: targetYear, month: targetMonth },
-    },
-  });
-
-  if (existingPlan) {
-    return { error: "Ein Plan für diesen Monat existiert bereits." };
-  }
-
-  // 1. Alle Verfügbarkeiten der Eltern für diesen Monat holen
-  const availabilities = await prisma.notdienstAvailability.findMany({
-    where: {
-      kitaId,
-      date: {
-        gte: new Date(Date.UTC(targetYear, targetMonth - 1, 1)),
-        lt: new Date(Date.UTC(targetYear, targetMonth, 1)),
-      },
-    },
-    include: { child: { select: { familyId: true } } },
-  });
-
-  // 2. Werktage holen
-  const workingDays = getWorkingDaysOfMonth(targetYear, targetMonth);
-
-  // 3. Algorithmus: Wir verteilen die Slots
-  // Counter für "Gerechtigkeit": wie oft wurde diese Familie schon eingeteilt?
-  const familyUsageCount: Record<string, number> = {};
-
-  const assignmentsToCreate: { childId: string; date: Date }[] = [];
-
-  for (const day of workingDays) {
-    // Alle Verfügbarkeiten für diesen spezifischen Tag
-    const availForDay = availabilities.filter(
-      (a) => a.date.getTime() === day.getTime(),
-    );
-
-    if (availForDay.length === 0) {
-      // Niemand verfügbar -> Bleibt leer ("Unbesetzt")
-      continue;
-    }
-
-    // Finde die Familie, die am wenigsten oft dran war
-    // Zufall einbauen bei Gleichstand
-    const sorted = availForDay.sort((a, b) => {
-      const countA = familyUsageCount[a.child.familyId] || 0;
-      const countB = familyUsageCount[b.child.familyId] || 0;
-      if (countA === countB) {
-        return Math.random() - 0.5; // Zufallsmischung
-      }
-      return countA - countB;
-    });
-
-    const selected = sorted[0];
-
-    assignmentsToCreate.push({
-      childId: selected.childId,
-      date: day,
-    });
-
-    // Usage-Counter erhöhen
-    familyUsageCount[selected.child.familyId] =
-      (familyUsageCount[selected.child.familyId] || 0) + 1;
-  }
-
-  // 4. In der DB speichern
   try {
-    await prisma.$transaction(async (tx) => {
+    await serializableTransaction(async (tx) => {
+      const existingPlan = await tx.notdienstPlan.findUnique({
+        where: {
+          kitaId_year_month: { kitaId, year: targetYear, month: targetMonth },
+        },
+      });
+      if (existingPlan)
+        throw new UserFacingError(
+          "Ein Plan für diesen Monat existiert bereits.",
+        );
+
+      const [availabilities, workingDays] = await Promise.all([
+        tx.notdienstAvailability.findMany({
+          where: {
+            kitaId,
+            child: { kitaId, active: true },
+            date: {
+              gte: new Date(Date.UTC(targetYear, targetMonth - 1, 1)),
+              lt: new Date(Date.UTC(targetYear, targetMonth, 1)),
+            },
+          },
+          include: { child: { select: { familyId: true } } },
+        }),
+        loadNotdienstDays(tx, kitaId, targetYear, targetMonth),
+      ]);
+      const familyUsageCount = new Map<string, number>();
+      const assignments: { childId: string; date: Date }[] = [];
+      for (const day of workingDays) {
+        const candidates = availabilities.filter(
+          (a) => a.date.getTime() === day.getTime(),
+        );
+        if (!candidates.length) continue;
+        const minUsage = Math.min(
+          ...candidates.map((a) => familyUsageCount.get(a.child.familyId) ?? 0),
+        );
+        const leastUsed = candidates.filter(
+          (a) => (familyUsageCount.get(a.child.familyId) ?? 0) === minUsage,
+        );
+        const selected =
+          leastUsed[Math.floor(Math.random() * leastUsed.length)];
+        assignments.push({ childId: selected.childId, date: day });
+        familyUsageCount.set(selected.child.familyId, minUsage + 1);
+      }
       const plan = await tx.notdienstPlan.create({
         data: {
           kitaId,
@@ -120,15 +103,9 @@ export async function generatePlanAction(year?: number, month?: number) {
           createdById: session.user.id,
         },
       });
-
+      if (assignments.length) {
-      if (assignmentsToCreate.length > 0) {
         await tx.notdienstAssignment.createMany({
-          data: assignmentsToCreate.map((a) => ({
+          data: assignments.map((a) => ({ ...a, kitaId, planId: plan.id })),
-            kitaId,
-            planId: plan.id,
-            childId: a.childId,
-            date: a.date,
-          })),
         });
       }
     });
@@ -137,7 +114,9 @@ export async function generatePlanAction(year?: number, month?: number) {
     return { success: true };
   } catch (error) {
     console.error(error);
-    return { error: "Fehler bei der Generierung des Plans." };
+    return {
+      error: publicActionError(error, "Fehler bei der Generierung des Plans."),
+    };
   }
 }
 
@@ -145,17 +124,60 @@ export async function publishPlanAction(planId: string) {
   const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
   const kitaId = session.user.kitaId!;
 
-  await prisma.notdienstPlan.update({
+  try {
-    where: { id: planId, kitaId },
+    await serializableTransaction(async (tx) => {
-    data: {
+      const plan = await tx.notdienstPlan.findUnique({
-      status: NotdienstPlanStatus.PUBLISHED,
+        where: { id: planId, kitaId },
-      publishedAt: new Date(),
+        include: {
-    },
+          assignments: { include: { child: { select: { active: true } } } },
-  });
+        },
-
+      });
-  revalidatePath("/dashboard/notdienst/plan");
+      if (!plan) throw new UserFacingError("Plan nicht gefunden.");
-  revalidatePath("/dashboard/notdienst");
+      if (plan.status === NotdienstPlanStatus.PUBLISHED) return;
-  return { success: true };
+      if (plan.status !== NotdienstPlanStatus.DRAFT)
+        throw new UserFacingError("Nur Entwürfe können veröffentlicht werden.");
+      const days = await loadNotdienstDays(tx, kitaId, plan.year, plan.month);
+      const validDates = new Set(days.map((day) => day.getTime()));
+      if (
+        plan.assignments.some(
+          (a) => !validDates.has(a.date.getTime()) || !a.child.active,
+        )
+      ) {
+        throw new UserFacingError(
+          "Der Entwurf enthält Einteilungen an geschlossenen Tagen, außerhalb des Planungsmonats oder für inaktive Kinder. Bitte zuerst korrigieren.",
+        );
+      }
+      await tx.notdienstPlan.update({
+        where: { id: planId, kitaId },
+        data: {
+          status: NotdienstPlanStatus.PUBLISHED,
+          publishedAt: new Date(),
+        },
+      });
+      await queueNotdienstPublication(
+        tx,
+        kitaId,
+        planId,
+        plan.year,
+        plan.month,
+      );
+    });
+    revalidatePath("/dashboard/notdienst/plan");
+    revalidatePath("/dashboard/notdienst");
+    revalidatePath("/dashboard/kalender");
+    const delivery = await deliverDueNotdienstEmails({ kitaId, planId }).catch(
+      () => ({ sent: 0, failed: 0, skipped: 0, deferred: true }),
+    );
+    revalidatePath("/dashboard/notdienst/plan");
+    return { success: true, ...delivery };
+  } catch (error) {
+    return {
+      error: publicActionError(
+        error,
+        "Der Plan konnte nicht veröffentlicht werden.",
+      ),
+    };
+  }
 }
 
 export async function updateAssignmentAction(
@@ -166,7 +188,8 @@ export async function updateAssignmentAction(
   const actor = await requireAlarmActor();
   const kitaId = actor.kitaId;
 
-  if (!dateOnlySchema.safeParse(date).success) return { error: "Ungültiges Datum." };
+  if (!dateOnlySchema.safeParse(date).success)
+    return { error: "Ungültiges Datum." };
   const [yr, mo, dy] = date.slice(0, 10).split("-").map(Number);
   const parsedDate = new Date(Date.UTC(yr, mo - 1, dy));
 
@@ -189,11 +212,32 @@ export async function updateAssignmentAction(
           throw new UserFacingError("Plan kann nicht bearbeitet werden.");
         }
 
-        if (isPublished) {
+        if (
-          const today = new Date();
+          newChildId &&
-          const todayUtc = new Date(
+          (parsedDate.getUTCFullYear() !== plan.year ||
-            Date.UTC(today.getFullYear(), today.getMonth(), today.getDate()),
+            parsedDate.getUTCMonth() + 1 !== plan.month)
+        ) {
+          throw new UserFacingError(
+            "Das Datum gehört nicht zum Planungsmonat.",
           );
+        }
+        // Clearing obsolete entries remains possible after a new closure.
+        if (newChildId) {
+          const days = await loadNotdienstDays(
+            tx,
+            kitaId,
+            plan.year,
+            plan.month,
+          );
+          if (!days.some((day) => day.getTime() === parsedDate.getTime())) {
+            throw new UserFacingError(
+              "An Wochenenden und Schließtagen kann kein Notdienst eingeteilt werden.",
+            );
+          }
+        }
+
+        if (isPublished) {
+          const todayUtc = new Date(`${todayKey()}T00:00:00Z`);
           if (parsedDate < todayUtc) {
             throw new UserFacingError(
               "Vergangene Notdienste können nicht geändert werden.",
@@ -202,14 +246,25 @@ export async function updateAssignmentAction(
         }
 
         const existingAssignment = await tx.notdienstAssignment.findFirst({
-          where: { planId, date: parsedDate },
+          where: { kitaId, planId, date: parsedDate },
           include: {
             child: {
               include: {
                 family: {
                   include: {
                     users: {
-                      where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+                      where: {
+                        role: {
+                          in: [
+                            UserRole.ELTERN,
+                            UserRole.ADMIN,
+                            UserRole.KOORDINATOR,
+                          ],
+                        },
+                        emailVerifiedAt: { not: null },
+                        disabledAt: null,
+                        privacyPolicyAcceptedAt: { not: null },
+                      },
                       select: { email: true, firstName: true, lastName: true },
                     },
                   },
@@ -237,7 +292,18 @@ export async function updateAssignmentAction(
               family: {
                 include: {
                   users: {
-                    where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+                    where: {
+                      role: {
+                        in: [
+                          UserRole.ELTERN,
+                          UserRole.ADMIN,
+                          UserRole.KOORDINATOR,
+                        ],
+                      },
+                      emailVerifiedAt: { not: null },
+                      disabledAt: null,
+                      privacyPolicyAcceptedAt: { not: null },
+                    },
                     select: { email: true, firstName: true, lastName: true },
                   },
                 },
@@ -412,7 +478,15 @@ export async function updateKitaNotdienstSettingsAction(
     return { error: "Kein Mandant zugeordnet." };
   }
 
-  if (!Number.isInteger(minPerChild) || minPerChild < 1 || minPerChild > 31 || !Number.isInteger(reminderDays) || reminderDays < 0 || reminderDays > 31) return { error: "Ungültige Einstellungen." };
+  if (
+    !Number.isInteger(minPerChild) ||
+    minPerChild < 1 ||
+    minPerChild > 31 ||
+    !Number.isInteger(reminderDays) ||
+    reminderDays < 0 ||
+    reminderDays > 31
+  )
+    return { error: "Ungültige Einstellungen." };
 
   try {
     await prisma.kita.update({
@@ -436,113 +510,56 @@ export async function sendNotdienstRemindersAction(
   month: number,
 ) {
   const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
-  const kitaId = session.user.kitaId;
+  const kitaId = session.user.kitaId!;
-  if (!kitaId) {
+  if (!validPlanMonth(year, month))
-    return { error: "Kein Mandant zugeordnet." };
+    return { error: "Ungültiger Planungsmonat." };
-  }
+  if (!(await rateLimit(`notdienst-reminders:${kitaId}`, 3, 3600)).allowed)
-
+    return { error: "Zu viele Erinnerungen. Bitte später erneut versuchen." };
-  if (!validPlanMonth(year, month)) return { error: "Ungültiger Planungsmonat." };
-  if (!(await rateLimit(`notdienst-reminders:${kitaId}`, 3, 3600)).allowed) return { error: "Zu viele Erinnerungen. Bitte später erneut versuchen." };
-  const mailConfigError = getAppEmailConfigError();
-  if (mailConfigError) {
-    return { error: mailConfigError };
-  }
-
   try {
-    // 1. Get Kita Name
+    const queued = await queueNotdienstReminders(kitaId, year, month);
-    const kita = await prisma.kita.findUnique({
+    const delivery = await deliverDueNotdienstEmails({
-      where: { id: kitaId },
+      kitaId,
-      select: { name: true },
+      year,
-    });
+      month,
-    if (!kita) {
+    }).catch(() => ({ sent: 0, failed: 0, skipped: 0, deferred: true }));
-      return { error: "Kita nicht gefunden." };
+    revalidatePath("/dashboard/notdienst/plan");
-    }
+    return { success: true, queued, count: delivery.sent, ...delivery };
-
-    // 2. Fetch all families in this Kita with at least one active child and retrieve parents
-    const families = await prisma.family.findMany({
-      where: {
-        kitaId,
-        children: { some: { active: true } },
-      },
-      include: {
-        users: {
-          where: { role: UserRole.ELTERN, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
-        },
-      },
-    });
-
-    // 3. For target month, find availability entries
-    const monthStart = new Date(year, month - 1, 1);
-    const monthEnd = new Date(year, month, 1);
-
-    const respondedFamilies = await prisma.notdienstAvailability.findMany({
-      where: {
-        kitaId,
-        date: {
-          gte: monthStart,
-          lt: monthEnd,
-        },
-      },
-      select: {
-        child: {
-          select: {
-            familyId: true,
-          },
-        },
-      },
-    });
-
-    const respondedFamilyIds = new Set(
-      respondedFamilies.map((a) => a.child.familyId),
-    );
-
-    // 4. Find open families (not responded yet)
-    const openFamilies = families.filter((f) => !respondedFamilyIds.has(f.id));
-
-    if (openFamilies.length === 0) {
-      return { success: true, count: 0 };
-    }
-
-    // 5. Build emails list and send
-    const monthDate = new Date(year, month - 1, 1);
-    const monthLabel = format(monthDate, "MMMM yyyy", { locale: de });
-    const BASE_URL =
-      process.env.NEXTAUTH_URL ??
-      process.env.AUTH_URL ??
-      "http://localhost:3000";
-    const link = `${BASE_URL}/dashboard/notdienst`;
-
-    let sentCount = 0;
-    for (const family of openFamilies) {
-      for (const parent of family.users) {
-        if (!parent.email) continue;
-
-        const result = await sendAppEmail({
-          to: parent.email,
-          subject: `Erinnerung: Bitte Verfügbarkeiten für den Notdienst ${monthLabel} eintragen`,
-          react: createElement(NotdienstAvailabilityReminderEmail, {
-            parentName: `${parent.firstName} ${parent.lastName}`,
-            kitaName: kita.name,
-            monthLabel,
-            link,
-          }),
-        });
-
-        if (result.success) {
-          sentCount++;
-        } else {
-          console.error(
-            `E-Mail konnte nicht an ${parent.email} gesendet werden:`,
-            result.error,
-          );
-        }
-      }
-    }
-
-    return { success: true, count: sentCount };
   } catch (error) {
-    console.error("Fehler beim Versenden der Erinnerungen:", error);
+    return {
-    return { error: "Fehler beim Versenden der Erinnerungen." };
+      error: publicActionError(
+        error,
+        "Die Erinnerungen konnten nicht vorbereitet werden.",
+      ),
+    };
+  }
+}
+
+export async function retryNotdienstEmailsAction(year: number, month: number) {
+  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
+  const kitaId = session.user.kitaId!;
+  if (!validPlanMonth(year, month))
+    return { error: "Ungültiger Planungsmonat." };
+  if (!(await rateLimit(`notdienst-mail-retry:${kitaId}`, 3, 3600)).allowed)
+    return { error: "Bitte warte vor einem weiteren Versandversuch." };
+  try {
+    await prisma.notdienstEmail.updateMany({
+      where: {
+        kitaId,
+        year,
+        month,
+        failed: true,
+        sentAt: null,
+        skippedAt: null,
+      },
+      data: { nextAttemptAt: new Date() },
+    });
+    const delivery = await deliverDueNotdienstEmails({ kitaId, year, month });
+    revalidatePath("/dashboard/notdienst/plan");
+    return { success: true, ...delivery };
+  } catch {
+    return {
+      error: "Der Versand bleibt gespeichert und wird erneut versucht.",
+    };
   }
 }
 

src/app/dashboard/notdienst/plan/page.tsx

@@ -1,11 +1,17 @@
 import Link from "next/link";
 import { addMonths, getYear, getMonth, format } from "date-fns";
 import { de } from "date-fns/locale";
-import { TerminType } from "@prisma/client";
 import { ChevronLeft, ChevronRight } from "lucide-react";
 
 import { prisma } from "@/lib/prisma";
-import { getWorkingDaysOfMonth } from "@/lib/date-utils";
+import {
+  formatUtcDateKey,
+  getWorkingDaysOfMonth,
+  getTargetMonthData,
+} from "@/lib/date-utils";
+import { loadNotdienstDays } from "@/lib/notdienst-planning";
+import { getNotdienstEmailStatus } from "@/lib/notdienst-notifications";
+import { EmailStatusCard } from "./_components/email-status-card";
 import { PlanView } from "./plan-view";
 import { SettingsModal } from "./_components/settings-modal";
 import { requireAlarmActor } from "@/lib/alarms/auth";
@@ -23,22 +29,21 @@ export default async function PlanungsZentralePage({
 
   const resolvedSearchParams = await searchParams;
   const now = new Date();
-  const nextMonth = addMonths(now, 1);
+  const defaultTarget = getTargetMonthData(now);
   const targetYear = resolvedSearchParams.year
     ? parseInt(resolvedSearchParams.year, 10)
-    : getYear(nextMonth);
+    : defaultTarget.targetYear;
   const targetMonth = resolvedSearchParams.month
     ? parseInt(resolvedSearchParams.month, 10)
-    : getMonth(nextMonth) + 1;
+    : defaultTarget.targetMonth;
 
   const monthDate = new Date(targetYear, targetMonth - 1, 1);
   const monthName = format(monthDate, "MMMM", { locale: de });
 
-  const workingDays = getWorkingDaysOfMonth(targetYear, targetMonth);
+  const monthStart = new Date(Date.UTC(targetYear, targetMonth - 1, 1));
-  const monthStart = new Date(targetYear, targetMonth - 1, 1);
+  const monthEnd = new Date(Date.UTC(targetYear, targetMonth, 1));
-  const monthEnd = new Date(targetYear, targetMonth, 1);
 
-  const [plan, families, availabilities, closureCount, kita] =
+  const [plan, families, rawAvailabilities, workingDays, kita] =
     await Promise.all([
       prisma.notdienstPlan.findUnique({
         where: {
@@ -80,6 +85,7 @@ export default async function PlanungsZentralePage({
       prisma.notdienstAvailability.findMany({
         where: {
           kitaId,
+          child: { kitaId, active: true },
           date: {
             gte: monthStart,
             lt: monthEnd,
@@ -95,16 +101,7 @@ export default async function PlanungsZentralePage({
         },
         orderBy: { date: "asc" },
       }),
-      prisma.termin.count({
+      loadNotdienstDays(prisma, kitaId, targetYear, targetMonth),
-        where: {
-          kitaId,
-          type: TerminType.SCHLIESSTAG,
-          startDate: {
-            gte: monthStart,
-            lt: monthEnd,
-          },
-        },
-      }),
       prisma.kita.findUniqueOrThrow({
         where: { id: kitaId },
         select: {
@@ -115,8 +112,6 @@ export default async function PlanungsZentralePage({
     ]);
 
   // Wir laden auch alle aktiven Kinder (inkl. Eltern-Namen) für das manuelle Dropdown.
-  // Idealerweise gruppiert man das nach "Verfügbar an diesem Tag" und "Alle",
-  // aber für MVP reichen alle aktiven Kinder.
   const allChildrenRaw = await prisma.child.findMany({
     where: { kitaId, active: true },
     select: {
@@ -152,6 +147,13 @@ export default async function PlanungsZentralePage({
     };
   });
 
+  const validDateKeys = new Set(workingDays.map(formatUtcDateKey));
+  const availabilities = rawAvailabilities.filter((a) =>
+    validDateKeys.has(formatUtcDateKey(a.date)),
+  );
+  const closureCount =
+    getWorkingDaysOfMonth(targetYear, targetMonth).length - workingDays.length;
+
   const availabilityDatesByFamily = new Map<string, Set<string>>();
   availabilities.forEach((availability) => {
     const familyId = availability.child.familyId;
@@ -174,11 +176,12 @@ export default async function PlanungsZentralePage({
         }).format(new Date(date)),
       })),
       childCount: family.children.length,
+      requiredDays: family.children.length * kita.notdienstMinPerChildPerMonth,
     };
   });
 
   const respondedFamilies = familyStatuses.filter(
-    (family) => family.selectedDays.length > 0,
+    (family) => family.selectedDays.length >= family.requiredDays,
   ).length;
   const openFamilies = Math.max(familyStatuses.length - respondedFamilies, 0);
   const totalAvailabilitySlots = availabilities.length;
@@ -187,26 +190,53 @@ export default async function PlanungsZentralePage({
     requiredDays > 0 ? totalAvailabilitySlots / requiredDays : 0;
 
   // Wir mappen die Assignments auf die Werktage
-  const daysWithAssignments = workingDays.map((day) => {
+  // Keep obsolete assignments visible so the coordinator can remove them.
-    const assignment = plan?.assignments.find(
+  const displayedDays = new Map(
-      (a) => a.date.getTime() === day.getTime(),
+    workingDays.map((day) => [formatUtcDateKey(day), day]),
-    );
+  );
-    const isOriginallyUnassigned =
+  for (const assignment of plan?.assignments ?? []) {
-      !assignment ||
+    displayedDays.set(formatUtcDateKey(assignment.date), assignment.date);
-      (plan?.publishedAt && assignment.createdAt > plan.publishedAt);
+  }
+  const activeChildIds = new Set(allChildren.map((child) => child.id));
+  const daysWithAssignments = Array.from(displayedDays.values())
+    .sort((a, b) => a.getTime() - b.getTime())
+    .map((day) => {
+      const assignment = plan?.assignments.find(
+        (a) => a.date.getTime() === day.getTime(),
+      );
+      const isOriginallyUnassigned =
+        !assignment ||
+        (plan?.publishedAt && assignment.createdAt > plan.publishedAt);
 
-    return {
+      const isInvalid =
-      date: day.toISOString(),
+        !validDateKeys.has(formatUtcDateKey(day)) ||
-      assignmentId: assignment?.id || null,
+        (!!assignment && !activeChildIds.has(assignment.childId));
-      childId: assignment?.childId || null,
+      return {
-      isOriginallyUnassigned: !!isOriginallyUnassigned,
+        date: day.toISOString(),
-      activeAlarmId: assignment?.alarms[0]?.id ?? null,
+        isInvalid,
-      canAlarm:
+        assignmentId: assignment?.id || null,
-        !!assignment &&
+        childId: assignment?.childId || null,
-        plan?.status === "PUBLISHED" &&
+        isOriginallyUnassigned: !!isOriginallyUnassigned,
-        day.toISOString().slice(0, 10) >= todayKey(),
+        activeAlarmId: assignment?.alarms[0]?.id ?? null,
-    };
+        canAlarm:
-  });
+          !!assignment &&
+          !isInvalid &&
+          plan?.status === "PUBLISHED" &&
+          day.toISOString().slice(0, 10) >= todayKey(),
+      };
+    });
+
+  const mailStatus = await getNotdienstEmailStatus(
+    kitaId,
+    targetYear,
+    targetMonth,
+  );
+  const target = getTargetMonthData(now);
+  const remindersOpen =
+    !target.isLocked &&
+    target.targetYear === targetYear &&
+    target.targetMonth === targetMonth &&
+    plan?.status !== "PUBLISHED";
 
   return (
     <div className="mx-auto max-w-[1280px] px-11 py-9 pb-16 max-[760px]:px-5">
@@ -226,7 +256,7 @@ export default async function PlanungsZentralePage({
           </p>
         </div>
 
-        <div className="print:hidden flex shrink-0 items-center gap-2">
+        <div className="print:hidden flex flex-wrap items-center gap-2">
           <div className="inline-flex overflow-hidden rounded-full border border-[var(--hairline)] bg-[var(--surface)]">
             <Link
               href={`/dashboard/notdienst/plan?year=${getYear(addMonths(monthDate, -1))}&month=${getMonth(addMonths(monthDate, -1)) + 1}`}
@@ -251,8 +281,18 @@ export default async function PlanungsZentralePage({
         </div>
       </header>
 
+      <EmailStatusCard
+        status={mailStatus}
+        year={targetYear}
+        month={targetMonth}
+        remindersOpen={remindersOpen}
+        daysBefore={kita.notdienstReminderDaysBefore}
+        jobConfigured={(process.env.NOTDIENST_JOB_SECRET?.length ?? 0) >= 32}
+      />
+
       <PlanView
         planId={plan?.id}
+        remindersOpen={remindersOpen}
         status={plan?.status}
         days={daysWithAssignments}
         allChildren={allChildren}

src/app/dashboard/notdienst/plan/plan-view.tsx

@@ -37,6 +37,7 @@ import {
 
 interface PlanViewProps {
   planId?: string;
+  remindersOpen: boolean;
   status?: NotdienstPlanStatus;
   days: {
     date: string;
@@ -45,6 +46,7 @@ interface PlanViewProps {
     canAlarm?: boolean;
     childId: string | null;
     isOriginallyUnassigned?: boolean;
+    isInvalid?: boolean;
   }[];
   allChildren: {
     id: string;
@@ -56,6 +58,7 @@ interface PlanViewProps {
     id: string;
     name: string;
     childCount: number;
+    requiredDays: number;
     selectedDays: {
       iso: string;
       label: string;
@@ -75,6 +78,7 @@ interface PlanViewProps {
 
 export function PlanView({
   planId,
+  remindersOpen,
   status,
   days,
   allChildren,
@@ -116,8 +120,15 @@ export function PlanView({
       const result = await publishPlanAction(planId);
       if ("error" in result && result.error) {
         toast.error(result.error as string);
-      } else {
+      } else if ("success" in result && result.success) {
-        toast.success("Plan veröffentlicht! Er ist nun fix.");
+        if (result.failed || ("deferred" in result && result.deferred))
+          toast.warning(
+            "Plan veröffentlicht. Einige E-Mails stehen noch aus – siehe Versandstatus.",
+          );
+        else
+          toast.success(
+            "Plan veröffentlicht. Die Benachrichtigungen wurden vorbereitet.",
+          );
       }
     });
   };
@@ -127,10 +138,15 @@ export function PlanView({
       const result = await sendNotdienstRemindersAction(year, month);
       if ("error" in result && result.error) {
         toast.error(result.error as string);
-      } else if (result.success) {
+      } else if ("success" in result && result.success) {
-        toast.success(
+        if (result.failed || ("deferred" in result && result.deferred))
-          `${result.count} Erinnerungs-E-Mail(s) erfolgreich versendet.`,
+          toast.warning(
-        );
+            `${result.count} E-Mails versendet. Offene Nachrichten bleiben gespeichert – siehe Versandstatus.`,
+          );
+        else
+          toast.success(
+            `${result.count} E-Mails versendet. Bereits heute erinnerte Haushalte erhalten keine zweite Erinnerung.`,
+          );
       }
     });
   };
@@ -153,7 +169,11 @@ export function PlanView({
     const valueToSet = newChildId === "empty" ? null : newChildId;
 
     startTransition(async () => {
-      const result = await updateAssignmentAction(planId, date, valueToSet);
+      const result = await updateAssignmentAction(
+        planId,
+        date.slice(0, 10),
+        valueToSet,
+      );
       if ("error" in result && result.error) {
         toast.error(result.error as string);
       } else {
@@ -162,7 +182,7 @@ export function PlanView({
     });
   };
 
-  if (!planId && respondedFamilies === 0) {
+  if (!planId && totalAvailabilitySlots === 0) {
     return (
       <Card className="border-dashed">
         <div className="flex min-h-[280px] flex-col items-center justify-center p-8 text-center">
@@ -183,7 +203,7 @@ export function PlanView({
             <Button
               variant="ghost"
               onClick={handleSendReminders}
-              disabled={isPending}
+              disabled={isPending || !remindersOpen}
             >
               {isPending ? (
                 <Loader2 className="h-4 w-4 animate-spin [stroke-width:1.7]" />
@@ -211,7 +231,7 @@ export function PlanView({
                   </h2>
                   <p className="mt-1 text-[13.5px] leading-5 text-[var(--ink-soft)]">
                     {respondedFamilies} von {totalFamilies} Familien haben
-                    geantwortet · noch {openFamilies} offen
+                    vollständig geantwortet · noch {openFamilies} offen
                   </p>
                 </div>
                 <span className="text-sm font-semibold tabular-nums text-[var(--ink-soft)]">
@@ -244,7 +264,10 @@ export function PlanView({
                       {family.childCount === 1 ? "" : "er"}
                     </p>
                   </div>
-                  <FamilyStatusPill selectedDays={family.selectedDays.length} />
+                  <FamilyStatusPill
+                    selectedDays={family.selectedDays.length}
+                    requiredDays={family.requiredDays}
+                  />
                   <div className="pointer-events-none absolute right-6 top-10 z-20 hidden max-w-xs rounded-lg bg-[oklch(0.22_0.015_45)] px-3 py-2 text-xs leading-5 text-white shadow-lg group-hover:block">
                     {family.selectedDays.length > 0
                       ? family.selectedDays.map((day) => day.label).join(" · ")
@@ -258,7 +281,7 @@ export function PlanView({
               <Button
                 variant="ghost"
                 onClick={handleSendReminders}
-                disabled={isPending || openFamilies === 0}
+                disabled={isPending || openFamilies === 0 || !remindersOpen}
               >
                 {isPending ? (
                   <Loader2 className="h-4 w-4 animate-spin [stroke-width:1.7]" />
@@ -314,8 +337,8 @@ export function PlanView({
                   Plan automatisch generieren
                 </h3>
                 <p className="mt-1 text-[13.5px] text-[var(--ink-soft)]">
-                  Verteilt {requiredDays} Notdiensttage fair auf{" "}
+                  Verteilt {requiredDays} Notdiensttage fair auf die verfügbaren
-                  {respondedFamilies} Familien.
+                  Familien.
                 </p>
                 <details className="mt-3 text-xs text-[var(--ink-soft)]">
                   <summary className="cursor-pointer font-semibold text-[var(--accent-deep)]">
@@ -408,6 +431,7 @@ export function PlanView({
         <ManualAssignmentTable
           days={days}
           allChildren={allChildren}
+          familyStatuses={familyStatuses}
           isDraft={isDraft}
           isPending={isPending}
           onAssignmentChange={handleAssignmentChange}
@@ -447,7 +471,13 @@ export function PlanView({
   );
 }
 
-function FamilyStatusPill({ selectedDays }: { selectedDays: number }) {
+function FamilyStatusPill({
+  selectedDays,
+  requiredDays,
+}: {
+  selectedDays: number;
+  requiredDays: number;
+}) {
   if (selectedDays === 0) {
     return (
       <span className="rounded-full border border-[var(--warn)] bg-[var(--warn-soft)] px-2.5 py-1 text-[11px] font-semibold text-[var(--warn)]">
@@ -457,8 +487,14 @@ function FamilyStatusPill({ selectedDays }: { selectedDays: number }) {
   }
 
   return (
-    <span className="rounded-full border border-[var(--good)] bg-[var(--good-soft)] px-2.5 py-1 text-[11px] font-semibold text-[var(--good)]">
+    <span
-      {selectedDays} Tage
+      className={
+        selectedDays >= requiredDays
+          ? "rounded-full border border-[var(--good)] bg-[var(--good-soft)] px-2.5 py-1 text-[11px] font-semibold text-[var(--good)]"
+          : "rounded-full border border-[var(--warn)] bg-[var(--warn-soft)] px-2.5 py-1 text-[11px] font-semibold text-[var(--warn)]"
+      }
+    >
+      {selectedDays} / {requiredDays} Tage
     </span>
   );
 }
@@ -548,7 +584,11 @@ function PlanPreviewTable({
                 {format(dateObj, "EEEE", { locale: de })}
               </div>
               <div className="text-[var(--ink)]">
-                {assignedChild ? assignedChild.parentName : "Unbesetzt"}
+                {assignedChild
+                  ? assignedChild.parentName
+                  : day.childId
+                    ? "Inaktives Kind"
+                    : "Unbesetzt"}
                 {assignedChild && (
                   <span className="ml-1 text-[var(--ink-muted)]">
                     ({assignedChild.name})
@@ -572,8 +612,20 @@ function PlanPreviewTable({
               </div>
               <div className="italic text-[var(--ink-faint)]">Noch offen</div>
               <div>
-                <Badge variant={assignedChild ? "success" : "destructive"}>
+                <Badge
-                  {assignedChild ? "Besetzt" : "Offen"}
+                  variant={
+                    day.isInvalid
+                      ? "warning"
+                      : assignedChild
+                        ? "success"
+                        : "destructive"
+                  }
+                >
+                  {day.isInvalid
+                    ? "Bitte korrigieren"
+                    : assignedChild
+                      ? "Besetzt"
+                      : "Offen"}
                 </Badge>
               </div>
             </div>
@@ -584,17 +636,29 @@ function PlanPreviewTable({
   );
 }
 
-function ManualAssignmentTable({
+export function ManualAssignmentTable({
   days,
   allChildren,
+  familyStatuses,
   isDraft,
   isPending,
   onAssignmentChange,
-}: Pick<PlanViewProps, "days" | "allChildren"> & {
+}: Pick<PlanViewProps, "days" | "allChildren" | "familyStatuses"> & {
   isDraft: boolean;
   isPending: boolean;
   onAssignmentChange: (date: string, newChildId: string) => void;
 }) {
+  const availabilityByFamily = useMemo(
+    () =>
+      new Map(
+        familyStatuses.map((family) => [
+          family.id,
+          new Set(family.selectedDays.map((day) => day.iso.slice(0, 10))),
+        ]),
+      ),
+    [familyStatuses],
+  );
+
   // Map childId to familyId for quick lookup
   const childFamilyMap = useMemo(() => {
     const map = new Map<string, string>();
@@ -622,7 +686,12 @@ function ManualAssignmentTable({
 
   return (
     <Card className="overflow-hidden p-0">
-      <div className="grid grid-cols-[1fr_2fr] border-b border-[var(--hairline-soft)] bg-[var(--surface-2)] p-4 text-[11px] font-semibold uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
+      <div className="border-b border-[var(--hairline-soft)] p-4 text-sm leading-6 text-[var(--ink-soft)]">
+        Verfügbare Familien stehen zuerst. Familien ohne Verfügbarkeit für den
+        Tag bleiben für abgestimmte Sonderfälle auswählbar. Die Einteilungszahl
+        gilt für den gesamten Haushalt.
+      </div>
+      <div className="hidden sm:grid grid-cols-[1fr_2fr] border-b border-[var(--hairline-soft)] bg-[var(--surface-2)] p-4 text-[11px] font-semibold uppercase text-[var(--ink-muted)] [letter-spacing:0.12em]">
         <div>Datum</div>
         <div>Eingeteilte Familie</div>
       </div>
@@ -630,37 +699,83 @@ function ManualAssignmentTable({
         {days.map((day) => {
           const [yr, mo, dy] = day.date.slice(0, 10).split("-").map(Number);
           const dateObj = new Date(yr, mo - 1, dy);
+          const dateKey = day.date.slice(0, 10);
+          const available = allChildren.filter((child) =>
+            availabilityByFamily.get(child.familyId)?.has(dateKey),
+          );
+          const unavailable = allChildren.filter(
+            (child) => !availabilityByFamily.get(child.familyId)?.has(dateKey),
+          );
+          const availableFamilies = new Set(
+            available.map((child) => child.familyId),
+          ).size;
+          const selectedChild = allChildren.find(
+            (child) => child.id === day.childId,
+          );
+          const selectedAvailable =
+            !!selectedChild &&
+            availabilityByFamily.get(selectedChild.familyId)?.has(dateKey);
+          const option = (child: PlanViewProps["allChildren"][number]) => (
+            <option key={child.id} value={child.id} disabled={day.isInvalid}>
+              {child.parentName} ({child.name}) —{" "}
+              {familyAssignmentCounts.get(child.familyId) ?? 0}x
+            </option>
+          );
 
           return (
             <div
               key={day.date}
-              className="grid grid-cols-[1fr_2fr] items-center p-4 transition-colors hover:bg-[var(--surface-2)]"
+              className="grid gap-3 sm:grid-cols-[1fr_2fr] items-center p-4 transition-colors hover:bg-[var(--surface-2)]"
             >
               <div className="font-medium text-[var(--ink)]">
                 {format(dateObj, "EE, dd.MM.", { locale: de })}
               </div>
               <div className="flex flex-wrap items-center gap-2">
-                <select
+                <div className="w-full max-w-sm space-y-2">
-                  className="w-full max-w-sm rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 py-1.5 text-sm text-[var(--ink)] ring-offset-[var(--surface)] hover:border-[var(--accent-mid)] focus-visible:border-[var(--accent)] focus-visible:outline-none focus-visible:ring-[3px] focus-visible:ring-[var(--focus-ring)]"
+                  <select
-                  value={day.childId || "empty"}
+                    aria-label={`Familie für ${format(dateObj, "dd.MM.yyyy")}`}
-                  disabled={isPending || !!day.activeAlarmId}
+                    className="w-full max-w-sm rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 py-1.5 text-sm text-[var(--ink)] ring-offset-[var(--surface)] hover:border-[var(--accent-mid)] focus-visible:border-[var(--accent)] focus-visible:outline-none focus-visible:ring-[3px] focus-visible:ring-[var(--focus-ring)]"
-                  onChange={(event) =>
+                    value={day.childId || "empty"}
-                    onAssignmentChange(day.date, event.target.value)
+                    disabled={isPending || !!day.activeAlarmId}
-                  }
+                    onChange={(event) =>
-                >
+                      onAssignmentChange(day.date, event.target.value)
-                  <option value="empty">-- Unbesetzt --</option>
+                    }
-                  {allChildren.map((child) => {
+                  >
-                    const famId = child.familyId;
+                    <option value="empty">-- Unbesetzt --</option>
-                    const count = famId
+                    {day.childId &&
-                      ? (familyAssignmentCounts.get(famId) ?? 0)
+                    !allChildren.some((child) => child.id === day.childId) ? (
-                      : 0;
+                      <option value={day.childId} disabled>
-                    return (
+                        Inaktives Kind – bitte Einteilung entfernen
-                      <option key={child.id} value={child.id}>
-                        {child.parentName} ({child.name}) — {count}x
                       </option>
-                    );
+                    ) : null}
-                  })}
+                    {available.length > 0 ? (
-                </select>
+                      <optgroup label="Verfügbar an diesem Tag">
+                        {available.map(option)}
+                      </optgroup>
+                    ) : null}
+                    {unavailable.length > 0 ? (
+                      <optgroup label="Keine Verfügbarkeit für diesen Tag">
+                        {unavailable.map(option)}
+                      </optgroup>
+                    ) : null}
+                  </select>
+                  {!day.isInvalid ? (
+                    <p
+                      className={`text-xs leading-5 ${(selectedChild && !selectedAvailable) || availableFamilies === 0 ? "text-[var(--warn)]" : "text-[var(--ink-soft)]"}`}
+                    >
+                      {selectedChild
+                        ? selectedAvailable
+                          ? "Eingeteilte Familie ist verfügbar."
+                          : "Eingeteilte Familie hat für diesen Tag keine Verfügbarkeit angegeben."
+                        : `${availableFamilies} ${availableFamilies === 1 ? "Familie ist" : "Familien sind"} verfügbar.`}
+                    </p>
+                  ) : null}
+                </div>
+                {day.isInvalid ? (
+                  <span className="text-xs text-[var(--danger)]">
+                    Einteilung nicht mehr gültig – bitte entfernen.
+                  </span>
+                ) : null}
                 {!isDraft && (
                   <span className="text-[11px] font-semibold text-[oklch(0.60_0.18_45)] bg-[oklch(0.95_0.02_45)] border border-[oklch(0.85_0.05_45)] px-2 py-0.5 rounded-md shrink-0">
                     Veröffentlicht

src/app/dashboard/page.tsx

@@ -16,6 +16,11 @@ import { UserRole } from "@prisma/client";
 import { requireKitaSession } from "@/lib/auth-utils";
 import { getTargetMonthData } from "@/lib/date-utils";
 import { prisma } from "@/lib/prisma";
+import {
+  absenceDate,
+  absenceToday,
+  canManageKitaAbsences,
+} from "@/lib/absence-policy";
 import { Stat } from "@/components/ui/stat";
 import { OnboardingDialog } from "@/components/OnboardingDialog";
 import { NewsTicker } from "./news-ticker";
@@ -30,8 +35,8 @@ export const metadata = { title: "Übersicht · Kita-Planer" };
 export default async function DashboardPage() {
   const session = await requireKitaSession();
   const now = new Date();
-  const today = new Date(now);
+  const todayKey = absenceToday(now);
-  today.setHours(0, 0, 0, 0);
+  const today = absenceDate(todayKey);
 
   const targetData = getTargetMonthData();
   const targetMonthStart = new Date(
@@ -138,6 +143,7 @@ export default async function DashboardPage() {
             note: true,
             startDate: true,
             endDate: true,
+            updatedAt: true,
             child: {
               select: {
                 firstName: true,
@@ -172,6 +178,7 @@ export default async function DashboardPage() {
     <div className="mx-auto max-w-[1280px] px-11 py-9 pb-16 max-[760px]:px-5">
       <OnboardingDialog
         user={{
+          id: session.user.id,
           phone: onboardingUser.phone,
           street: onboardingUser.street,
           postalCode: onboardingUser.postalCode,
@@ -225,32 +232,27 @@ export default async function DashboardPage() {
           )}
           {canReportAbsences ? (
             <AbsenceCard
-              today={format(today, "yyyy-MM-dd")}
+              today={todayKey}
               childOptions={absenceChildren.map((child) => ({
                 id: child.id,
                 name: `${child.firstName} ${child.lastName}`,
               }))}
-              absences={upcomingAbsences.map((absence) => ({
-                id: absence.id,
-                childName: `${absence.child.firstName} ${absence.child.lastName}`,
-                reason: absence.reason,
-                note: absence.note,
-                startDate: format(absence.startDate, "yyyy-MM-dd"),
-                endDate: format(absence.endDate, "yyyy-MM-dd"),
-              }))}
             />
           ) : null}
         </div>
 
         <aside>
           <UpcomingAbsencesCard
+            today={todayKey}
+            team={canManageKitaAbsences(session.user.role)}
             absences={upcomingAbsences.map((absence) => ({
               id: absence.id,
               childName: `${absence.child.firstName} ${absence.child.lastName}`,
               reason: absence.reason,
               note: absence.note,
-              startDate: format(absence.startDate, "yyyy-MM-dd"),
+              startDate: absence.startDate.toISOString().slice(0, 10),
-              endDate: format(absence.endDate, "yyyy-MM-dd"),
+              endDate: absence.endDate.toISOString().slice(0, 10),
+              updatedAt: absence.updatedAt.toISOString(),
             }))}
           />
         </aside>

src/app/dashboard/personal/forms.tsx

@@ -4,6 +4,7 @@ import { useId, useState, useTransition, type ReactNode } from "react";
 import { useRouter } from "next/navigation";
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
 import { Input } from "@/components/ui/input";
 import {
   Dialog,
@@ -32,6 +33,7 @@ export function Field({
   min,
   max,
   step,
+  autoFocus,
 }: {
   label: string;
   name: string;
@@ -41,6 +43,7 @@ export function Field({
   min?: string | number;
   max?: string | number;
   step?: string | number;
+  autoFocus?: boolean;
 }) {
   const id = useId();
   return (
@@ -57,6 +60,7 @@ export function Field({
         min={min}
         max={max}
         step={step}
+        autoFocus={autoFocus}
       />
     </div>
   );
@@ -123,7 +127,11 @@ function transform(command: string, form: FormData) {
       return {
         kind: text("kind"),
         startDate: text("startDate"),
-        endDate: text("endDate"),
+        endDate:
+          text("kind") === "TIME_OFF" ||
+          (text("kind") === "VACATION" && form.get("halfDay") === "on")
+            ? text("startDate")
+            : text("endDate"),
         halfDay: form.get("halfDay") === "on",
         ...(text("kind") === "TIME_OFF" ? { minutes: hours("hours") } : {}),
         note: text("note"),
@@ -142,13 +150,19 @@ function StaffForm({
   children,
   label = "Speichern",
   onSuccess,
+  anotherLabel,
 }: {
   command: string;
   profileId?: string;
   extra?: Record<string, unknown>;
   children: ReactNode;
   label?: string;
-  onSuccess?: (result: StaffActionResult) => void;
+  anotherLabel?: string;
+  onSuccess?: (
+    result: StaffActionResult,
+    form: FormData,
+    another: boolean,
+  ) => void;
 }) {
   const [pending, start] = useTransition();
   const [error, setError] = useState("");
@@ -159,6 +173,10 @@ function StaffForm({
       onSubmit={(event) => {
         event.preventDefault();
         const form = new FormData(event.currentTarget);
+        const another =
+          (event.nativeEvent as SubmitEvent).submitter?.getAttribute(
+            "value",
+          ) === "another";
         setError("");
         start(async () => {
           try {
@@ -173,7 +191,7 @@ function StaffForm({
             }
             if (result.warning) toast.warning(result.warning);
             else toast.success(result.message ?? "Gespeichert.");
-            onSuccess?.(result);
+            onSuccess?.(result, form, another);
             router.refresh();
           } catch (error) {
             setError(
@@ -187,10 +205,20 @@ function StaffForm({
     >
       <fieldset disabled={pending} className="grid gap-4 disabled:opacity-60">
         {children}
-        <div>
+        <div className="flex flex-wrap gap-2">
           <Button type="submit">
             {pending ? "Wird gespeichert …" : label}
           </Button>
+          {anotherLabel ? (
+            <Button
+              type="submit"
+              variant="outline"
+              name="intent"
+              value="another"
+            >
+              {anotherLabel}
+            </Button>
+          ) : null}
         </div>
       </fieldset>
       {error && (
@@ -333,8 +361,12 @@ export function SetupForm({
 export function TimeForm({
   profileId,
   initial,
+  defaultDate,
+  compact = false,
 }: {
   profileId: string;
+  defaultDate?: string;
+  compact?: boolean;
   initial?: {
     id: string;
     date: string;
@@ -345,14 +377,34 @@ export function TimeForm({
   };
 }) {
   const [open, setOpen] = useState(false);
+  const [date, setDate] = useState(initial?.date ?? defaultDate ?? todayKey());
+  const [blockVersion, setBlockVersion] = useState(0);
+  const [continuation, setContinuation] = useState(false);
   return (
-    <Dialog open={open} onOpenChange={setOpen}>
+    <Dialog
+      open={open}
+      onOpenChange={(next) => {
+        if (next) {
+          setDate(initial?.date ?? defaultDate ?? todayKey());
+          setContinuation(false);
+        }
+        setOpen(next);
+      }}
+    >
       <DialogTrigger asChild>
         <Button
-          variant={initial ? "outline" : "default"}
+          variant={initial || compact ? "outline" : "default"}
-          size={initial ? "sm" : "default"}
+          size={initial || compact ? "sm" : "default"}
+          disabled={!initial && !!defaultDate && defaultDate > todayKey()}
+          aria-label={
+            compact ? `Arbeitszeit für ${defaultDate} erfassen` : undefined
+          }
         >
-          {initial ? "Bearbeiten" : "+ Arbeitszeit erfassen"}
+          {initial
+            ? "Bearbeiten"
+            : compact
+              ? "Zeit erfassen"
+              : "+ Arbeitszeit erfassen"}
         </Button>
       </DialogTrigger>
       <DialogContent>
@@ -366,31 +418,50 @@ export function TimeForm({
           </DialogDescription>
         </DialogHeader>
         <StaffForm
+          key={blockVersion}
           command="time"
           profileId={profileId}
           extra={initial ? { id: initial.id } : {}}
           label="Arbeitszeit speichern"
-          onSuccess={() => setOpen(false)}
+          anotherLabel={
+            !initial ? "Speichern und weiteren Block erfassen" : undefined
+          }
+          onSuccess={(_result, form, another) => {
+            if (another && !initial) {
+              setDate(String(form.get("date")));
+              setContinuation(true);
+              setBlockVersion((version) => version + 1);
+            } else setOpen(false);
+          }}
         >
           <Field
             label="Datum"
             name="date"
             type="date"
-            value={initial?.date ?? todayKey()}
+            value={date}
             max={todayKey()}
           />
           <div className="grid grid-cols-2 gap-4">
             <Field
               label="Beginn"
+              autoFocus={continuation}
               name="start"
               type="time"
-              value={minuteClock(initial?.startMinute ?? 480)}
+              value={
+                continuation
+                  ? undefined
+                  : minuteClock(initial?.startMinute ?? 480)
+              }
             />
             <Field
               label="Ende"
               name="end"
               type="time"
-              value={minuteClock(initial?.endMinute ?? 960)}
+              value={
+                continuation
+                  ? undefined
+                  : minuteClock(initial?.endMinute ?? 960)
+              }
             />
           </div>
           <Field
@@ -399,7 +470,7 @@ export function TimeForm({
             type="number"
             min={0}
             step={1}
-            value={initial?.breakMinutes ?? 30}
+            value={continuation ? 0 : (initial?.breakMinutes ?? 30)}
           />
           <Field
             label="Notiz (optional)"
@@ -431,9 +502,24 @@ export function LeaveForm({
 }) {
   const [open, setOpen] = useState(false);
   const [kind, setKind] = useState(initial?.kind ?? "VACATION");
+  const [startDate, setStartDate] = useState(initial?.startDate ?? todayKey());
+  const [endDate, setEndDate] = useState(initial?.endDate ?? todayKey());
+  const [halfDay, setHalfDay] = useState(initial?.halfDay ?? false);
+  const singleDay = kind === "TIME_OFF" || (kind === "VACATION" && halfDay);
   const id = useId();
   return (
-    <Dialog open={open} onOpenChange={setOpen}>
+    <Dialog
+      open={open}
+      onOpenChange={(next) => {
+        if (next) {
+          setKind(initial?.kind ?? "VACATION");
+          setStartDate(initial?.startDate ?? todayKey());
+          setEndDate(initial?.endDate ?? todayKey());
+          setHalfDay(initial?.halfDay ?? false);
+        }
+        setOpen(next);
+      }}
+    >
       <DialogTrigger asChild>
         <Button size={initial ? "sm" : "default"} variant="outline">
           {initial ? "Ändern" : "+ Abwesenheit beantragen"}
@@ -474,33 +560,51 @@ export function LeaveForm({
               {admin && <option value="SICKNESS">Krankheit</option>}
             </select>
           </div>
-          <div className="grid grid-cols-2 gap-4">
+          {kind === "VACATION" ? (
-            <Field
-              label="Von"
-              name="startDate"
-              type="date"
-              value={initial?.startDate ?? todayKey()}
-            />
-            <Field
-              label="Bis"
-              name="endDate"
-              type="date"
-              value={initial?.endDate ?? todayKey()}
-            />
-          </div>
-          {kind === "VACATION" && (
             <label className="flex items-center gap-2 text-sm">
               <input
                 name="halfDay"
                 type="checkbox"
-                defaultChecked={initial?.halfDay}
+                checked={halfDay}
-              />
+                onChange={(event) => setHalfDay(event.target.checked)}
-              Halber Urlaubstag (Von = Bis)
+              />{" "}
+              Halber Urlaubstag
             </label>
-          )}
+          ) : null}
+          <div className={singleDay ? "grid gap-4" : "grid grid-cols-2 gap-4"}>
+            <div className="grid gap-1.5">
+              <Label htmlFor={`${id}-start`}>
+                {singleDay ? "Datum" : "Von"}
+              </Label>
+              <Input
+                id={`${id}-start`}
+                name="startDate"
+                type="date"
+                value={startDate}
+                onChange={(event) => setStartDate(event.target.value)}
+                required
+              />
+            </div>
+            {singleDay ? (
+              <input type="hidden" name="endDate" value={startDate} />
+            ) : (
+              <div className="grid gap-1.5">
+                <Label htmlFor={`${id}-end`}>Bis</Label>
+                <Input
+                  id={`${id}-end`}
+                  name="endDate"
+                  type="date"
+                  value={endDate}
+                  onChange={(event) => setEndDate(event.target.value)}
+                  required
+                  min={startDate}
+                />
+              </div>
+            )}
+          </div>
           {kind === "TIME_OFF" && (
             <Field
-              label="Freizeitausgleich in Stunden (Von = Bis)"
+              label="Freizeitausgleich in Stunden"
               name="hours"
               type="number"
               min={1 / 60}

src/app/dashboard/personal/page.tsx

@@ -284,7 +284,17 @@ export default async function PersonalPage({
         </div>
         {profile && (
           <div className="flex flex-wrap gap-2">
-            <TimeForm profileId={profile.id} />
+            <TimeForm
+              key={`${profile.id}-${start}`}
+              profileId={profile.id}
+              defaultDate={
+                tab === "zeit"
+                  ? today >= start && today <= end
+                    ? today
+                    : start
+                  : today
+              }
+            />
             <LeaveForm profileId={profile.id} admin={admin} />
           </div>
         )}
@@ -645,6 +655,7 @@ export default async function PersonalPage({
                           "Ist",
                           "Urlaub / Krankheit",
                           "Differenz",
+                          "Erfassen",
                         ].map((s) => (
                           <th key={s} className="pb-3 pr-4 font-medium">
                             {s}
@@ -682,6 +693,15 @@ export default async function PersonalPage({
                           >
                             {formatMinutes(d.balance)}
                           </td>
+                          <td className="py-3 pl-3">
+                            {editable && d.date <= today ? (
+                              <TimeForm
+                                profileId={profile.id}
+                                defaultDate={d.date}
+                                compact
+                              />
+                            ) : null}
+                          </td>
                         </tr>
                       ))}
                     </tbody>
@@ -696,6 +716,7 @@ export default async function PersonalPage({
                         <td className="pt-4">
                           {formatMinutes(totals.balance)}
                         </td>
+                        <td />
                       </tr>
                     </tfoot>
                   </table>

src/app/dashboard/profil/actions.ts

@@ -11,7 +11,13 @@ import {
   parseDateInput,
 } from "@/lib/child-birthdate";
 import { serializableTransaction } from "@/lib/transaction";
+import {
+  assertKitaAdminRemains,
+  lockKitaAccounts,
+} from "@/lib/kita-admin-guard";
 import { prisma } from "@/lib/prisma";
+import { assertChildrenRemovable } from "@/lib/notdienst-planning";
+import { UserFacingError, publicActionError } from "@/lib/action-error";
 
 // Telefonnummern: führendes "+" optional, dann Ziffern, Leerzeichen, Bindestriche,
 // Klammern oder Schrägstriche. Mindestens 6 Ziffern damit es plausibel ist.
@@ -57,7 +63,11 @@ const childSchema = z
   });
 
 const familySchema = z.object({
-  familyName: z.string().min(1, "Familienname ist erforderlich.").max(120).trim(),
+  familyName: z
+    .string()
+    .min(1, "Familienname ist erforderlich.")
+    .max(120)
+    .trim(),
 });
 
 const contactSchema = z.object({
@@ -86,10 +96,7 @@ const contactSchema = z.object({
 
 // Gibt die erste konkrete Field-Error-Message aus einem Zod-Fehler zurück,
 // damit der User nicht nur "Ungültige Eingabedaten" sieht.
-function firstZodMessage(
+function firstZodMessage(error: z.ZodError, fallback: string): string {
-  error: z.ZodError,
-  fallback: string,
-): string {
   const issue = error.issues[0];
   return issue?.message || fallback;
 }
@@ -119,8 +126,13 @@ export async function createMyChild(rawPayload: unknown) {
   }
 
   try {
-    await serializableTransaction(async tx => {
+    await serializableTransaction(async (tx) => {
-      const count = await tx.child.count({ where: { kitaId: session.user.kitaId, familyId: session.user.familyId! } });
+      const count = await tx.child.count({
+        where: {
+          kitaId: session.user.kitaId,
+          familyId: session.user.familyId!,
+        },
+      });
       if (count >= 20) throw new Error("Household child limit reached");
       await tx.child.create({
         data: {
@@ -164,10 +176,17 @@ export async function createMyFamily(rawPayload: unknown) {
       });
 
       const attached = await tx.user.updateMany({
-        where: { id: session.user.id, kitaId: session.user.kitaId, familyId: null, disabledAt: null, sessionVersion: session.user.sessionVersion },
+        where: {
+          id: session.user.id,
+          kitaId: session.user.kitaId,
+          familyId: null,
+          disabledAt: null,
+          sessionVersion: session.user.sessionVersion,
+        },
         data: { familyId: family.id },
       });
-      if (attached.count !== 1) throw new Error("Account already assigned or revoked");
+      if (attached.count !== 1)
+        throw new Error("Account already assigned or revoked");
     });
 
     revalidatePath("/dashboard/profil");
@@ -176,7 +195,12 @@ export async function createMyFamily(rawPayload: unknown) {
     revalidatePath("/dashboard");
     return { success: true };
   } catch (error) {
-    if (!(error instanceof Error && error.message === "Account already assigned or revoked")) {
+    if (
+      !(
+        error instanceof Error &&
+        error.message === "Account already assigned or revoked"
+      )
+    ) {
       console.error("Fehler beim Anlegen des eigenen Haushalts:", error);
     }
     return { error: "Der Haushalt konnte nicht angelegt werden." };
@@ -247,7 +271,11 @@ export async function updateMyChild(childId: string, rawPayload: unknown) {
     }
 
     await prisma.child.update({
-      where: { id: childId, kitaId: session.user.kitaId, familyId: session.user.familyId! },
+      where: {
+        id: childId,
+        kitaId: session.user.kitaId,
+        familyId: session.user.familyId!,
+      },
       data: {
         firstName: parsed.data.firstName,
         lastName: parsed.data.lastName,
@@ -268,107 +296,103 @@ export async function deleteMyChild(childId: string) {
   const session = await requireKitaSession();
 
   try {
-    const child = await requireOwnFamilyChild(
+    await serializableTransaction(async (tx) => {
-      childId,
+      if (!session.user.familyId)
-      session.user.familyId,
+        throw new UserFacingError(
-      session.user.kitaId,
+          "Dieses Kind gehört nicht zu deinem Haushalt.",
-    );
+        );
-
+      const child = await tx.child.findFirst({
-    if (!child) {
+        where: {
-      return { error: "Dieses Kind gehört nicht zu deinem Haushalt." };
+          id: childId,
-    }
+          kitaId: session.user.kitaId,
-
+          familyId: session.user.familyId,
-    await prisma.child.delete({
+        },
-      where: { id: childId, kitaId: session.user.kitaId, familyId: session.user.familyId! },
+        select: { id: true },
+      });
+      if (!child)
+        throw new UserFacingError(
+          "Dieses Kind gehört nicht zu deinem Haushalt.",
+        );
+      await assertChildrenRemovable(
+        tx,
+        session.user.kitaId,
+        session.user.familyId,
+        [childId],
+      );
+      await tx.child.delete({
+        where: {
+          id: childId,
+          kitaId: session.user.kitaId,
+          familyId: session.user.familyId,
+        },
+      });
     });
 
     revalidatePath("/dashboard/profil");
     revalidatePath("/dashboard/families");
     return { success: true };
   } catch (error) {
-    console.error("Fehler beim Entfernen des Kindes:", error);
+    if (!(error instanceof UserFacingError))
-    return { error: "Das Kind konnte nicht entfernt werden." };
+      console.error("Fehler beim Entfernen des Kindes:", error);
+    return {
+      error: publicActionError(error, "Das Kind konnte nicht entfernt werden."),
+    };
   }
 }
 
-export async function deleteMyAccount() {
+export async function deleteMyAccount(): Promise<{
+  success?: boolean;
+  error?: string;
+}> {
   const session = await requireKitaSession();
-  
   try {
-    const user = await prisma.user.findFirst({
+    return await serializableTransaction(async (tx) => {
-      where: {
+      await lockKitaAccounts(tx, session.user.kitaId);
-        id: session.user.id,
+      const user = await tx.user.findFirst({
-        kitaId: session.user.kitaId,
+        where: { id: session.user.id, kitaId: session.user.kitaId },
-      },
+        select: { id: true, familyId: true },
-      select: {
+      });
-        id: true,
+      if (!user) throw new UserFacingError("Account wurde nicht gefunden.");
-        familyId: true,
+      await assertKitaAdminRemains(tx, session.user.kitaId, [user.id]);
-      },
+      const today = new Date();
-    });
+      today.setHours(0, 0, 0, 0);
-
+      const assignments = user.familyId
-    if (!user) {
+        ? await tx.notdienstAssignment.count({
-      return { error: "Account wurde nicht gefunden." };
+            where: {
-    }
+              kitaId: session.user.kitaId,
-
+              date: { gte: today },
-    const today = new Date();
+              plan: { status: NotdienstPlanStatus.PUBLISHED },
-    today.setHours(0, 0, 0, 0);
+              child: { familyId: user.familyId },
-
+            },
-    const activeNotdienstAssignments = user.familyId
+          })
-      ? await prisma.notdienstAssignment.count({
+        : 0;
-          where: {
+      if (assignments)
-            kitaId: session.user.kitaId,
+        throw new UserFacingError(
-            date: { gte: today },
-            plan: { status: NotdienstPlanStatus.PUBLISHED },
-            child: { familyId: user.familyId },
-          },
-        })
-      : 0;
-
-    if (activeNotdienstAssignments > 0) {
-      return {
-        error:
           "Dein Account kann nicht gelöscht werden, solange aktive Notdienst-Verpflichtungen bestehen.",
-      };
+        );
-    }
+      if (user.familyId) {
-
+        const family = await tx.family.findFirst({
-    if (!user.familyId) {
+          where: { id: user.familyId, kitaId: session.user.kitaId },
-      await prisma.user.delete({
+          select: { id: true, users: { select: { id: true } } },
-        where: { id: user.id },
+        });
-      });
+        if (!family)
+          throw new UserFacingError("Haushalt wurde nicht gefunden.");
+        if (family.users.length <= 1) {
+          await tx.family.delete({ where: { id: family.id } });
+          return { success: true };
+        }
+      }
+      await tx.user.delete({ where: { id: user.id } });
       return { success: true };
-    }
-
-    const family = await prisma.family.findFirst({
-      where: {
-        id: user.familyId,
-        kitaId: session.user.kitaId,
-      },
-      select: {
-        id: true,
-        users: {
-          select: { id: true },
-        },
-      },
     });
-
-    if (!family) {
-      return { error: "Haushalt wurde nicht gefunden." };
-    }
-
-    if (family.users.length <= 1) {
-      await prisma.family.delete({
-        where: { id: family.id },
-      });
-      return { success: true };
-    }
-
-    await prisma.user.delete({
-      where: { id: user.id },
-    });
-
-    return { success: true };
   } catch (error) {
-    console.error("Fehler beim Löschen des Accounts:", error);
+    if (!(error instanceof UserFacingError))
-    return { error: "Ein Fehler ist beim Löschen aufgetreten." };
+      console.error("Fehler beim Löschen des Accounts:", error);
+    return {
+      error: publicActionError(
+        error,
+        "Ein Fehler ist beim Löschen aufgetreten.",
+      ),
+    };
   }
 }

src/app/dashboard/profil/page.tsx

@@ -29,6 +29,7 @@ import { DeleteAccountDialog } from "./_components/delete-account-dialog";
 import { MyChildrenManager } from "./_components/my-children-manager";
 import { CreateFamilyDialog } from "./_components/create-family-dialog";
 import { ContactForm } from "./_components/contact-form";
+import { PasswordForm } from "../../passwort-vergessen/password-form";
 import { StaffEmailSettings } from "../personal/forms";
 
 export const metadata = { title: "Mein Profil · Kita-Planer" };
@@ -56,6 +57,7 @@ export default async function ProfilPage() {
         city: true,
         directoryOptInAt: true,
         staffDecisionEmails: true,
+        staffProfile: { select: { id: true } },
         createdAt: true,
         family: {
           select: {
@@ -210,7 +212,19 @@ export default async function ProfilPage() {
             </CardContent>
           </Card>
 
-          {user.role === UserRole.ERZIEHER && (
+          <Card>
+            <CardHeader>
+              <CardTitle>Passwort ändern</CardTitle>
+              <CardDescription>
+                Verwalte dein persönliches Anmeldepasswort.
+              </CardDescription>
+            </CardHeader>
+            <CardContent>
+              <PasswordForm mode="change" />
+            </CardContent>
+          </Card>
+
+          {user.staffProfile && (
             <Card>
               <CardHeader>
                 <CardTitle>E-Mail-Hinweise</CardTitle>

src/app/dashboard/zugriffsrechte/actions.ts

@@ -0,0 +1,37 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { UserRole } from "@prisma/client";
+import { requireRole } from "@/lib/auth-utils";
+import { changeKitaRole } from "@/lib/kita-role-management";
+import { publicActionError, UserFacingError } from "@/lib/action-error";
+
+export async function changeKitaRoleAction(
+  raw: unknown,
+): Promise<{
+  success?: boolean;
+  error?: string;
+  changed?: boolean;
+  ownRoleChanged?: boolean;
+}> {
+  const { user } = await requireRole([UserRole.ADMIN]);
+  if (!user.kitaId) return { error: "Keine Kita zugeordnet." };
+  try {
+    const result = await changeKitaRole(
+      { id: user.id, kitaId: user.kitaId, sessionVersion: user.sessionVersion },
+      raw,
+    );
+    revalidatePath("/dashboard", "layout");
+    revalidatePath("/admin");
+    return { success: true, ...result };
+  } catch (error) {
+    if (!(error instanceof UserFacingError))
+      console.error("Rolle konnte nicht geändert werden:", error);
+    return {
+      error: publicActionError(
+        error,
+        "Rolle konnte nicht geändert werden. Bitte erneut versuchen.",
+      ),
+    };
+  }
+}

src/app/dashboard/zugriffsrechte/page.tsx

@@ -0,0 +1,113 @@
+import { UserRole } from "@prisma/client";
+import { requireRole } from "@/lib/auth-utils";
+import { prisma } from "@/lib/prisma";
+import { getKitaRoleHistory } from "@/lib/kita-role-management";
+import { kitaRoleLabels } from "@/lib/kita-roles";
+import { Card } from "@/components/ui/card";
+import { RoleList } from "./role-list";
+
+export const metadata = { title: "Zugriffsrechte · Kita-Planer" };
+export default async function KitaRolesPage() {
+  const { user } = await requireRole([UserRole.ADMIN]);
+  const kitaId = user.kitaId!;
+  const [people, history] = await Promise.all([
+    prisma.user.findMany({
+      where: { kitaId, role: { not: UserRole.SUPERADMIN } },
+      orderBy: [{ lastName: "asc" }, { firstName: "asc" }],
+      select: {
+        id: true,
+        firstName: true,
+        lastName: true,
+        email: true,
+        role: true,
+        familyId: true,
+        disabledAt: true,
+        lockedUntil: true,
+        emailVerifiedAt: true,
+        family: { select: { name: true } },
+        staffProfile: { select: { id: true } },
+      },
+    }),
+    getKitaRoleHistory(kitaId),
+  ]);
+  const now = new Date();
+  return (
+    <div className="mx-auto max-w-[1280px] px-11 py-9 pb-16 max-[760px]:px-5">
+      <header className="mb-7">
+        <p className="text-[11px] font-semibold uppercase tracking-[0.18em] text-[var(--accent-deep)]">
+          VERWALTUNG · KITA-KONTEN
+        </p>
+        <h1 className="mt-2 text-[36px] font-normal leading-tight tracking-[-0.025em] text-[var(--ink)]">
+          Zugriffsrechte{" "}
+          <em className="font-normal text-[var(--accent-deep)]">verwalten</em>
+        </h1>
+        <p className="mt-3 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
+          Ernenne weitere Kita-Admins oder die Notdienst-Koordination. Rollen
+          gelten sofort; offene Einladungen müssen weiterhin aktiviert werden.
+          Mindestens ein aktiver Kita-Admin bleibt erhalten.
+        </p>
+      </header>
+      <RoleList
+        currentUserId={user.id}
+        people={people.map((person) => ({
+          id: person.id,
+          name: `${person.firstName} ${person.lastName}`,
+          email: person.email,
+          role: person.role,
+          familyId: person.familyId,
+          familyName: person.family?.name ?? null,
+          hasStaffProfile: !!person.staffProfile,
+          status: person.disabledAt
+            ? "Konto deaktiviert"
+            : person.lockedUntil && person.lockedUntil > now
+              ? "Anmeldung gesperrt"
+              : !person.emailVerifiedAt
+                ? "Einladung offen"
+                : "Zugang aktiviert",
+        }))}
+      />
+      <Card className="mt-7 p-5">
+        <h2 className="text-lg font-semibold text-[var(--ink)]">
+          Letzte Rollenänderungen
+        </h2>
+        <p className="mt-1 text-sm leading-6 text-[var(--ink-soft)]">
+          Ämter und Zuständigkeiten verwaltest du weiterhin bei den Familien.
+          Sie verändern die Zugriffsrechte nicht.
+        </p>
+        {history.length ? (
+          <ul className="mt-4 divide-y divide-[var(--hairline-soft)]">
+            {history.map((entry) => {
+              const data = entry.metadata as {
+                previousRole?: UserRole;
+                newRole?: UserRole;
+              } | null;
+              return (
+                <li key={entry.id} className="py-3 text-sm leading-6">
+                  <p className="font-medium text-[var(--ink)]">
+                    {entry.targetLabel}:{" "}
+                    {data?.previousRole
+                      ? kitaRoleLabels[data.previousRole]
+                      : "—"}{" "}
+                    → {data?.newRole ? kitaRoleLabels[data.newRole] : "—"}
+                  </p>
+                  <p className="break-words text-xs text-[var(--ink-muted)]">
+                    {new Intl.DateTimeFormat("de-DE", {
+                      dateStyle: "short",
+                      timeStyle: "short",
+                      timeZone: "Europe/Berlin",
+                    }).format(entry.createdAt)}{" "}
+                    · {entry.actorEmail}
+                  </p>
+                </li>
+              );
+            })}
+          </ul>
+        ) : (
+          <p className="mt-4 text-sm text-[var(--ink-muted)]">
+            Noch keine Rollenänderungen protokolliert.
+          </p>
+        )}
+      </Card>
+    </div>
+  );
+}

src/app/dashboard/zugriffsrechte/role-change-button.tsx

@@ -0,0 +1,166 @@
+"use client";
+
+import { useState, useTransition } from "react";
+import { useRouter } from "next/navigation";
+import type { UserRole } from "@prisma/client";
+import { ShieldCheck } from "lucide-react";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { availableKitaRoles, kitaRoleLabels } from "@/lib/kita-roles";
+import { changeKitaRoleAction } from "./actions";
+
+const descriptions: Record<string, string> = {
+  ELTERN: "Eigener Haushalt, Verfügbarkeiten, Diensttausch und Kita-Alltag.",
+  KOORDINATOR: "Zusätzlich Notdienstpläne, Alarme und Termine koordinieren.",
+  ADMIN:
+    "Familien, Team, Zugriffsrechte und alle Kita-Verwaltungsbereiche verwalten.",
+  ERZIEHER:
+    "Personalbereich, eigene Arbeitszeit und Anträge sowie Kinder-Abwesenheiten.",
+};
+
+export type RolePerson = {
+  id: string;
+  name: string;
+  role: UserRole;
+  familyId: string | null;
+  hasStaffProfile: boolean;
+};
+
+export function RoleChangeButton({
+  person,
+  ownAccount = false,
+}: {
+  person: RolePerson;
+  ownAccount?: boolean;
+}) {
+  const router = useRouter();
+  const [open, setOpen] = useState(false);
+  const [role, setRole] = useState(person.role);
+  const [error, setError] = useState("");
+  const [pending, startTransition] = useTransition();
+  const roles = availableKitaRoles(person);
+  const submit = () => {
+    setError("");
+    startTransition(async () => {
+      try {
+        const result = await changeKitaRoleAction({
+          userId: person.id,
+          role,
+          expectedRole: person.role,
+        });
+        if (result.error) {
+          setError(result.error);
+          return;
+        }
+        toast.success("Zugriffsrolle gespeichert.");
+        setOpen(false);
+        if (result.ownRoleChanged) router.replace("/dashboard");
+        router.refresh();
+      } catch {
+        setError(
+          "Die Änderung konnte nicht gespeichert werden. Bitte erneut versuchen.",
+        );
+      }
+    });
+  };
+  return (
+    <>
+      <Button
+        variant="outline"
+        size="sm"
+        aria-label={`Zugriffsrechte für ${person.name}`}
+        disabled={person.role === "SUPERADMIN"}
+        onClick={() => {
+          setRole(person.role);
+          setError("");
+          setOpen(true);
+        }}
+      >
+        <ShieldCheck className="h-3.5 w-3.5" /> Zugriffsrechte
+      </Button>
+      <Dialog
+        open={open}
+        onOpenChange={(next) => {
+          if (!pending) setOpen(next);
+        }}
+      >
+        <DialogContent className="max-h-[90dvh] overflow-y-auto sm:max-w-lg">
+          <DialogHeader>
+            <DialogTitle>Zugriffsrechte für {person.name}</DialogTitle>
+            <DialogDescription>
+              Die Zugriffsrolle bestimmt, welche Bereiche diese Person nutzen
+              und verwalten kann. Ämter wie „Vorstand“ werden separat vergeben.
+            </DialogDescription>
+          </DialogHeader>
+          <fieldset disabled={pending} className="grid gap-2">
+            <legend className="mb-2 text-sm font-semibold text-[var(--ink)]">
+              Zugriffsrolle
+            </legend>
+            {roles.map((value) => (
+              <label
+                key={value}
+                className={`flex cursor-pointer items-start gap-3 rounded-xl border p-3 transition-colors ${role === value ? "border-[var(--accent-mid)] bg-[var(--accent-soft)]" : "border-[var(--hairline)] hover:bg-[var(--surface-2)]"}`}
+              >
+                <input
+                  type="radio"
+                  name={`role-${person.id}`}
+                  value={value}
+                  checked={role === value}
+                  onChange={() => setRole(value)}
+                  className="mt-1 accent-[var(--accent-deep)]"
+                />
+                <span>
+                  <span className="block text-sm font-semibold text-[var(--ink)]">
+                    {kitaRoleLabels[value]}
+                  </span>
+                  <span className="mt-1 block text-xs leading-5 text-[var(--ink-soft)]">
+                    {descriptions[value]}
+                  </span>
+                </span>
+              </label>
+            ))}
+          </fieldset>
+          <p className="text-xs leading-5 text-[var(--ink-soft)]">
+            {person.hasStaffProfile
+              ? "Das Personalprofil mit Arbeitszeiten und Anträgen bleibt erhalten. Mit Kita-Admin-Rechten ist zusätzlich die Personalverwaltung zugänglich."
+              : person.familyId
+                ? "Haushalt, Kinder und eigene Dienste bleiben erhalten."
+                : "Dieses Konto hat keinen eigenen Haushalt. Deshalb steht die Elternrolle nicht zur Auswahl."}
+          </p>
+          {ownAccount && role !== person.role ? (
+            <p className="rounded-lg bg-[var(--warn-soft)] p-3 text-sm leading-5 text-[var(--warn)]">
+              Du änderst deine eigenen Rechte. Nach dem Speichern gelangst du
+              zur Übersicht; der Zugang zur Verwaltung richtet sich dann nach
+              der neuen Rolle.
+            </p>
+          ) : null}
+          {error ? (
+            <p role="alert" className="text-sm leading-5 text-[var(--danger)]">
+              {error}
+            </p>
+          ) : null}
+          <DialogFooter>
+            <Button
+              variant="outline"
+              disabled={pending}
+              onClick={() => setOpen(false)}
+            >
+              Abbrechen
+            </Button>
+            <Button disabled={pending || role === person.role} onClick={submit}>
+              {pending ? "Wird gespeichert …" : "Rolle speichern"}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </>
+  );
+}

src/app/dashboard/zugriffsrechte/role-list.tsx

@@ -0,0 +1,98 @@
+"use client";
+
+import { useState } from "react";
+import { Input } from "@/components/ui/input";
+import { Card } from "@/components/ui/card";
+import { RoleBadge } from "@/components/ui/role-badge";
+import { kitaRoleLabels } from "@/lib/kita-roles";
+import { RoleChangeButton, type RolePerson } from "./role-change-button";
+
+type Person = RolePerson & {
+  email: string;
+  familyName: string | null;
+  status: string;
+};
+export function RoleList({
+  people,
+  currentUserId,
+}: {
+  people: Person[];
+  currentUserId: string;
+}) {
+  const [query, setQuery] = useState("");
+  const search = query.trim().toLocaleLowerCase("de");
+  const filtered = people.filter((person) =>
+    `${person.name} ${person.email} ${person.familyName ?? ""} ${kitaRoleLabels[person.role]}`
+      .toLocaleLowerCase("de")
+      .includes(search),
+  );
+  return (
+    <div className="space-y-4">
+      <div className="flex flex-wrap items-center justify-between gap-3">
+        <Input
+          type="search"
+          aria-label="Kita-Konten durchsuchen"
+          placeholder="Name, Haushalt oder Rolle suchen …"
+          value={query}
+          onChange={(event) => setQuery(event.target.value)}
+          className="max-w-md"
+        />
+        <span className="text-sm text-[var(--ink-muted)]">
+          {filtered.length} {filtered.length === 1 ? "Konto" : "Konten"}
+        </span>
+      </div>
+      <Card className="overflow-hidden p-0">
+        <div className="hidden gap-6 border-b border-[var(--hairline-soft)] bg-[var(--surface-2)] px-5 py-3 text-[11px] font-semibold uppercase tracking-wider text-[var(--ink-muted)] md:grid md:grid-cols-[minmax(0,1fr)_220px_160px]">
+          <span>Person & Zuordnung</span>
+          <span>Zugriffsrolle</span>
+          <span className="text-right">Verwalten</span>
+        </div>
+        <div className="divide-y divide-[var(--hairline-soft)]">
+          {filtered.map((person) => (
+            <div
+              key={person.id}
+              className="grid items-center gap-4 px-5 py-5 md:grid-cols-[minmax(0,1fr)_220px_160px] md:gap-6"
+            >
+              <div className="min-w-0">
+                <p className="font-semibold text-[var(--ink)]">
+                  {person.name}
+                  {person.id === currentUserId ? (
+                    <span className="ml-2 text-xs font-normal text-[var(--ink-muted)]">
+                      Du
+                    </span>
+                  ) : null}
+                </p>
+                <p className="mt-1 break-words text-sm text-[var(--ink-soft)]">
+                  {person.email}
+                </p>
+                <p className="mt-1 text-xs leading-5 text-[var(--ink-muted)]">
+                  {[
+                    person.familyName
+                      ? `Haushalt ${person.familyName}`
+                      : "Kein eigener Haushalt",
+                    person.hasStaffProfile ? "Personalprofil vorhanden" : null,
+                    person.status,
+                  ]
+                    .filter(Boolean)
+                    .join(" · ")}
+                </p>
+              </div>
+              <RoleBadge role={person.role} />
+              <div className="md:justify-self-end">
+                <RoleChangeButton
+                  person={person}
+                  ownAccount={person.id === currentUserId}
+                />
+              </div>
+            </div>
+          ))}
+          {!filtered.length ? (
+            <p className="p-8 text-center text-sm text-[var(--ink-soft)]">
+              Keine passenden Kita-Konten gefunden.
+            </p>
+          ) : null}
+        </div>
+      </Card>
+    </div>
+  );
+}

src/app/invite/[token]/actions.ts

@@ -153,6 +153,10 @@ export async function acceptInviteAction(
           sessionVersion: { increment: 1 } },
       });
       if (activated.count !== 1) throw new Error("INVITE_USED");
+      await tx.invitation.updateMany({
+        where: { token, userId },
+        data: { status: "ACCEPTED", acceptedAt: now, leaseUntil: null },
+      });
     });
   } catch (error) {
     if (error instanceof Error && error.message === "INVITE_USED") return { attempt, values, errors: { _form: ["Dieser Link kann nicht mehr verwendet werden."] } };

src/app/login/login-form.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import Link from "next/link";
 import { useActionState, useState } from "react";
 
 import { Button } from "@/components/ui/button";
@@ -23,7 +24,10 @@ export function LoginForm({
   devParentEmail?: string;
   devParentPassword?: string;
 }) {
-  const [state, formAction, pending] = useActionState(loginAction, initialState);
+  const [state, formAction, pending] = useActionState(
+    loginAction,
+    initialState,
+  );
   const [email, setEmail] = useState("");
   const [password, setPassword] = useState("");
 
@@ -67,6 +71,13 @@ export function LoginForm({
         )}
       </div>
 
+      <Link
+        href="/passwort-vergessen"
+        className="inline-block text-sm text-[var(--accent-deep)] underline underline-offset-4"
+      >
+        Passwort vergessen?
+      </Link>
+
       {state.errors?._form?.[0] && (
         <p className="rounded-md border border-destructive/50 bg-destructive/10 p-3 text-sm text-destructive">
           {state.errors._form[0]}
@@ -79,7 +90,9 @@ export function LoginForm({
 
       {showDevHelpers && (
         <div className="rounded-lg border border-dashed border-muted-foreground/30 bg-muted/40 p-3 space-y-2 text-xs">
-          <p className="text-center font-medium text-muted-foreground">Dev-Schnellzugriff (nur lokal):</p>
+          <p className="text-center font-medium text-muted-foreground">
+            Dev-Schnellzugriff (nur lokal):
+          </p>
           <div className="grid grid-cols-2 gap-2">
             {devAdminEmail && (
               <Button

src/app/login/page.tsx

@@ -17,7 +17,11 @@ import { LoginForm } from "./login-form";
 export const metadata = { title: "Anmelden · Kita-Planer" };
 
 type LoginPageProps = {
-  searchParams?: Promise<{ callbackUrl?: string | string[]; reauth?: string }>;
+  searchParams?: Promise<{
+    callbackUrl?: string | string[];
+    reauth?: string;
+    passwordChanged?: string;
+  }>;
 };
 
 export default async function LoginPage({ searchParams }: LoginPageProps) {
@@ -31,9 +35,13 @@ export default async function LoginPage({ searchParams }: LoginPageProps) {
 
   const isDev = process.env.NODE_ENV === "development";
   const devAdminEmail = isDev ? process.env.DEV_LOGIN_ADMIN_EMAIL : undefined;
-  const devAdminPassword = isDev ? process.env.DEV_LOGIN_ADMIN_PASSWORD : undefined;
+  const devAdminPassword = isDev
+    ? process.env.DEV_LOGIN_ADMIN_PASSWORD
+    : undefined;
   const devParentEmail = isDev ? process.env.DEV_LOGIN_PARENT_EMAIL : undefined;
-  const devParentPassword = isDev ? process.env.DEV_LOGIN_PARENT_PASSWORD : undefined;
+  const devParentPassword = isDev
+    ? process.env.DEV_LOGIN_PARENT_PASSWORD
+    : undefined;
 
   return (
     <div className="flex min-h-screen items-center justify-center bg-muted/30 px-4 py-12">
@@ -43,6 +51,15 @@ export default async function LoginPage({ searchParams }: LoginPageProps) {
           <CardDescription>Willkommen zurück.</CardDescription>
         </CardHeader>
         <CardContent className="space-y-4">
+          {resolvedSearchParams?.passwordChanged === "1" ? (
+            <p
+              role="status"
+              className="rounded-lg bg-[var(--good-soft)] p-3 text-sm text-[var(--ink)]"
+            >
+              Dein Passwort wurde geändert. Melde dich mit dem neuen Passwort
+              an.
+            </p>
+          ) : null}
           <LoginForm
             callbackUrl={callbackUrl}
             devAdminEmail={devAdminEmail}
@@ -52,7 +69,10 @@ export default async function LoginPage({ searchParams }: LoginPageProps) {
           />
           <p className="text-center text-sm text-muted-foreground">
             Noch keinen Account?{" "}
-            <Link href="/register" className="font-medium text-foreground underline">
+            <Link
+              href="/register"
+              className="font-medium text-foreground underline"
+            >
               Kita registrieren
             </Link>
           </p>

src/app/neues-passwort/[token]/page.tsx

@@ -0,0 +1,52 @@
+import Link from "next/link";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from "@/components/ui/card";
+import { isPasswordResetValid } from "@/lib/password-management";
+import { PasswordForm } from "../../passwort-vergessen/password-form";
+export const metadata = {
+  title: "Neues Passwort · Kita-Planer",
+  robots: { index: false, follow: false },
+};
+export default async function ResetPasswordPage({
+  params,
+}: {
+  params: Promise<{ token: string }>;
+}) {
+  const { token } = await params;
+  const valid = await isPasswordResetValid(token);
+  return (
+    <div className="flex min-h-screen items-center justify-center bg-[var(--bg)] px-5 py-12">
+      <Card className="w-full max-w-md">
+        <CardHeader>
+          <CardTitle>
+            {valid
+              ? "Neues Passwort festlegen"
+              : "Dieser Link ist nicht mehr gültig"}
+          </CardTitle>
+          <CardDescription>
+            {valid
+              ? "Wähle ein neues Passwort für dein Kita-Planer-Konto."
+              : "Der Link ist abgelaufen, wurde bereits verwendet oder ist ungültig. Du kannst einen neuen Link anfordern."}
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          {valid ? (
+            <PasswordForm mode="reset" token={token} />
+          ) : (
+            <Link
+              href="/passwort-vergessen"
+              className="text-sm font-semibold text-[var(--accent-deep)] underline underline-offset-4"
+            >
+              Neuen Link anfordern
+            </Link>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

src/app/passwort-vergessen/actions.ts

@@ -0,0 +1,117 @@
+"use server";
+import { z } from "zod";
+import { after } from "next/server";
+import { limitPublicAction } from "@/lib/rate-limit";
+import {
+  requestPasswordReset,
+  passwordResetMessage,
+  resetPassword,
+  changeOwnPassword,
+} from "@/lib/password-management";
+import { hashToken } from "@/lib/tokens";
+import { requireSession } from "@/lib/auth-utils";
+import { publicActionError } from "@/lib/action-error";
+
+export type PasswordActionState = {
+  error?: string;
+  message?: string;
+  success?: boolean;
+};
+export async function requestResetAction(
+  _previous: PasswordActionState,
+  form: FormData,
+): Promise<PasswordActionState> {
+  const email = z
+    .string()
+    .trim()
+    .max(254)
+    .email()
+    .toLowerCase()
+    .safeParse(form.get("email"));
+  if (!email.success)
+    return { error: "Bitte gib eine gültige E-Mail-Adresse ein." };
+  try {
+    if (await limitPublicAction("password-reset-request", email.data, 3, 3600))
+      after(async () => {
+        try {
+          await requestPasswordReset(email.data);
+        } catch {
+          console.error(
+            "Passwort-Wiederherstellung konnte nicht vorbereitet werden.",
+          );
+        }
+      });
+  } catch {
+    console.error(
+      "Passwort-Wiederherstellung konnte nicht vorbereitet werden.",
+    );
+  }
+  return { success: true, message: passwordResetMessage };
+}
+export async function finishResetAction(
+  _previous: PasswordActionState,
+  form: FormData,
+): Promise<PasswordActionState> {
+  const token = form.get("token");
+  if (typeof token !== "string" || !/^[a-f0-9]{64}$/i.test(token))
+    return {
+      error: "Dieser Link ist ungültig. Bitte fordere einen neuen Link an.",
+    };
+  try {
+    if (
+      !(await limitPublicAction(
+        "password-reset-complete",
+        hashToken(token),
+        5,
+        900,
+      ))
+    )
+      return { error: "Zu viele Versuche. Bitte versuche es später erneut." };
+    await resetPassword({
+      token,
+      password: form.get("password"),
+      confirmation: form.get("confirmation"),
+    });
+    return {
+      success: true,
+      message:
+        "Dein Passwort wurde geändert. Melde dich mit deinem neuen Passwort an.",
+    };
+  } catch (error) {
+    return {
+      error: publicActionError(
+        error,
+        "Das Passwort konnte nicht geändert werden. Bitte versuche es erneut.",
+      ),
+    };
+  }
+}
+export async function changePasswordAction(
+  _previous: PasswordActionState,
+  form: FormData,
+): Promise<PasswordActionState> {
+  const { user } = await requireSession();
+  try {
+    if (!(await limitPublicAction("password-change", user.id, 5, 900)))
+      return { error: "Zu viele Versuche. Bitte versuche es später erneut." };
+    await changeOwnPassword(
+      { id: user.id, sessionVersion: user.sessionVersion },
+      {
+        currentPassword: form.get("currentPassword"),
+        password: form.get("password"),
+        confirmation: form.get("confirmation"),
+      },
+    );
+    return {
+      success: true,
+      message: "Dein Passwort wurde geändert. Bitte melde dich erneut an.",
+    };
+  } catch (error) {
+    return {
+      error: publicActionError(
+        error,
+        "Das Passwort konnte nicht geändert werden. Bitte versuche es erneut.",
+      ),
+    };
+  }
+}

src/app/passwort-vergessen/page.tsx

@@ -0,0 +1,37 @@
+import Link from "next/link";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from "@/components/ui/card";
+import { PasswordForm } from "./password-form";
+export const metadata = {
+  title: "Passwort vergessen · Kita-Planer",
+  robots: { index: false, follow: false },
+};
+export default function ForgotPasswordPage() {
+  return (
+    <div className="flex min-h-screen items-center justify-center bg-[var(--bg)] px-5 py-12">
+      <Card className="w-full max-w-md">
+        <CardHeader>
+          <CardTitle>Passwort vergessen?</CardTitle>
+          <CardDescription>
+            Fordere einen persönlichen Link an, um ein neues Passwort
+            festzulegen. Der Link ist 30 Minuten gültig.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-6">
+          <PasswordForm mode="request" />
+          <Link
+            href="/login"
+            className="inline-block text-sm text-[var(--accent-deep)] underline underline-offset-4"
+          >
+            Zurück zur Anmeldung
+          </Link>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

src/app/passwort-vergessen/password-form.tsx

@@ -0,0 +1,137 @@
+"use client";
+import Link from "next/link";
+import { useActionState, useEffect, useId } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  requestResetAction,
+  finishResetAction,
+  changePasswordAction,
+  type PasswordActionState,
+} from "./actions";
+
+export function PasswordForm({
+  mode,
+  token,
+}: {
+  mode: "request" | "reset" | "change";
+  token?: string;
+}) {
+  const action =
+    mode === "request"
+      ? requestResetAction
+      : mode === "reset"
+        ? finishResetAction
+        : changePasswordAction;
+  const [state, formAction, pending] = useActionState(
+    action,
+    {} as PasswordActionState,
+  );
+  const id = useId();
+  useEffect(() => {
+    if (mode === "change" && state.success)
+      window.location.replace(
+        new URL("/login?passwordChanged=1", window.location.origin).href,
+      );
+  }, [mode, state.success]);
+  if (state.success)
+    return (
+      <div className="space-y-4">
+        <p
+          role="status"
+          className="rounded-xl border border-[var(--hairline)] bg-[var(--good-soft)] p-4 text-sm leading-6 text-[var(--ink)]"
+        >
+          {state.message}
+        </p>
+        {mode !== "request" ? (
+          <Link
+            href="/login"
+            className="text-sm font-semibold text-[var(--accent-deep)] underline underline-offset-4"
+          >
+            Zur Anmeldung
+          </Link>
+        ) : null}
+      </div>
+    );
+  return (
+    <form action={formAction} className="space-y-4">
+      {token ? <input type="hidden" name="token" value={token} /> : null}
+      {mode === "request" ? (
+        <div className="space-y-2">
+          <Label htmlFor={`${id}-email`}>E-Mail-Adresse</Label>
+          <Input
+            id={`${id}-email`}
+            name="email"
+            type="email"
+            autoComplete="email"
+            maxLength={254}
+            required
+            disabled={pending}
+          />
+        </div>
+      ) : (
+        <>
+          {mode === "change" ? (
+            <div className="space-y-2">
+              <Label htmlFor={`${id}-current`}>Aktuelles Passwort</Label>
+              <Input
+                id={`${id}-current`}
+                name="currentPassword"
+                type="password"
+                autoComplete="current-password"
+                required
+                disabled={pending}
+              />
+            </div>
+          ) : null}
+          <div className="space-y-2">
+            <Label htmlFor={`${id}-password`}>Neues Passwort</Label>
+            <Input
+              id={`${id}-password`}
+              name="password"
+              type="password"
+              autoComplete="new-password"
+              minLength={8}
+              required
+              disabled={pending}
+            />
+            <p className="text-xs leading-5 text-[var(--ink-soft)]">
+              Mindestens 8 Zeichen. Verwende ein eigenes Passwort für den
+              Kita-Planer.
+            </p>
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor={`${id}-confirmation`}>
+              Neues Passwort wiederholen
+            </Label>
+            <Input
+              id={`${id}-confirmation`}
+              name="confirmation"
+              type="password"
+              autoComplete="new-password"
+              minLength={8}
+              required
+              disabled={pending}
+            />
+          </div>
+          <p className="text-xs leading-5 text-[var(--ink-soft)]">
+            Nach dem Speichern werden alle bisherigen Anmeldungen beendet.
+          </p>
+        </>
+      )}
+      {state.error ? (
+        <p role="alert" className="text-sm leading-6 text-[var(--danger)]">
+          {state.error}
+        </p>
+      ) : null}
+      <Button type="submit" className="w-full sm:w-auto" disabled={pending}>
+        {pending
+          ? "Wird verarbeitet …"
+          : mode === "request"
+            ? "Link anfordern"
+            : "Passwort speichern"}
+      </Button>
+    </form>
+  );
+}

src/components/OnboardingDialog.tsx

@@ -31,6 +31,7 @@ type UserRoleDto =
 
 type OnboardingDialogProps = {
   user: {
+    id: string;
     phone: string | null;
     street: string | null;
     postalCode: string | null;
@@ -43,7 +44,7 @@ type OnboardingDialogProps = {
   } | null;
 };
 
-const HIDE_ONBOARDING_DIALOG_KEY = "hideOnboardingDialog";
+const onboardingKey = (userId: string) => `hideOnboardingDialog:${userId}`;
 
 export function OnboardingDialog({ user, family }: OnboardingDialogProps) {
   const [open, setOpen] = useState(false);
@@ -79,14 +80,18 @@ export function OnboardingDialog({ user, family }: OnboardingDialogProps) {
   }, [family?.childrenCount, user]);
 
   useEffect(() => {
-    if (status.isComplete) return;
+    let hidden: string | null = null;
-
+    try {
-    const hidden = localStorage.getItem(HIDE_ONBOARDING_DIALOG_KEY);
+      hidden = localStorage.getItem(onboardingKey(user.id));
-    if (hidden !== "true") {
+    } catch {
-      const timer = window.setTimeout(() => setOpen(true), 0);
+      /* Unavailable browser storage does not prevent using the app. */
-      return () => window.clearTimeout(timer);
     }
-  }, [status.isComplete]);
+    const timer = window.setTimeout(
+      () => setOpen(!status.isComplete && hidden !== "true"),
+      0,
+    );
+    return () => window.clearTimeout(timer);
+  }, [status.isComplete, user.id]);
 
   if (status.isComplete) {
     return null;
@@ -97,7 +102,11 @@ export function OnboardingDialog({ user, family }: OnboardingDialogProps) {
     : "Haushalt & Kinder einrichten";
 
   function hidePermanently() {
-    localStorage.setItem(HIDE_ONBOARDING_DIALOG_KEY, "true");
+    try {
+      localStorage.setItem(onboardingKey(user.id), "true");
+    } catch {
+      /* Close for this visit if storage is unavailable. */
+    }
     setOpen(false);
   }
 
@@ -113,8 +122,8 @@ export function OnboardingDialog({ user, family }: OnboardingDialogProps) {
               Dein Kita-Profil ist fast bereit
             </DialogTitle>
             <DialogDescription className="text-emerald-50/80">
-              Vervollständige die wichtigsten Daten, damit Notdienst,
+              Vervollständige die wichtigsten Daten, damit Notdienst, Adressbuch
-              Adressbuch und Familienverwaltung reibungslos funktionieren.
+              und Familienverwaltung reibungslos funktionieren.
             </DialogDescription>
           </DialogHeader>
         </div>

src/components/absence-management-actions.tsx

@@ -0,0 +1,252 @@
+"use client";
+
+import { useState, useTransition } from "react";
+import { useRouter } from "next/navigation";
+import { Pencil, Undo2 } from "lucide-react";
+import { AbsenceReason } from "@prisma/client";
+import { toast } from "sonner";
+import { deleteAbsence, updateAbsence } from "@/actions/absences";
+import { absenceDate, canEditOwnAbsence } from "@/lib/absence-policy";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Textarea } from "@/components/ui/textarea";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+
+export type ManagedAbsence = {
+  id: string;
+  childName: string;
+  startDate: string;
+  endDate: string;
+  reason: AbsenceReason;
+  note: string | null;
+  updatedAt: string;
+};
+
+export function AbsenceManagementActions({
+  absence,
+  today,
+  team = false,
+  onChanged,
+}: {
+  absence: ManagedAbsence;
+  today: string;
+  team?: boolean;
+  onChanged?: () => void;
+}) {
+  const [mode, setMode] = useState<"edit" | "withdraw" | null>(null);
+  const [pending, startTransition] = useTransition();
+  const [error, setError] = useState<string | null>(null);
+  const [startDate, setStartDate] = useState(absence.startDate);
+  const [endDate, setEndDate] = useState(absence.endDate);
+  const router = useRouter();
+  if (!team && !canEditOwnAbsence(absence.startDate, today))
+    return (
+      <p className="mt-2 text-xs text-[var(--ink-muted)]">
+        Bereits begonnene Meldung: Änderungen über die Kita.
+      </p>
+    );
+  const tomorrow = new Date(absenceDate(today).getTime() + 86_400_000)
+    .toISOString()
+    .slice(0, 10);
+  function open(next: "edit" | "withdraw") {
+    setStartDate(absence.startDate);
+    setEndDate(absence.endDate);
+    setError(null);
+    setMode(next);
+  }
+  function submit(data?: FormData) {
+    startTransition(async () => {
+      try {
+        const identity = { id: absence.id, updatedAt: absence.updatedAt };
+        const result =
+          mode === "withdraw"
+            ? await deleteAbsence(identity)
+            : await updateAbsence({
+                ...identity,
+                startDate,
+                endDate,
+                reason: String(data?.get("reason") ?? ""),
+                note: String(data?.get("note") ?? ""),
+              });
+        if (result.error) {
+          setError(result.error);
+          return;
+        }
+        toast.success(
+          mode === "withdraw"
+            ? "Abwesenheitsmeldung zurückgenommen."
+            : "Abwesenheitsmeldung aktualisiert.",
+        );
+        setMode(null);
+        onChanged?.();
+      } catch {
+        setError(
+          "Die Meldung konnte nicht gespeichert werden. Bitte erneut versuchen.",
+        );
+      }
+    });
+  }
+  return (
+    <div className="mt-2 flex flex-wrap gap-2">
+      <Button
+        type="button"
+        variant="outline"
+        size="sm"
+        onClick={() => open("edit")}
+        aria-label={`Abwesenheit bearbeiten: ${absence.childName}`}
+      >
+        <Pencil className="h-3.5 w-3.5" /> Bearbeiten
+      </Button>
+      <Button
+        type="button"
+        variant="ghost"
+        size="sm"
+        onClick={() => open("withdraw")}
+        aria-label={`Abwesenheit zurücknehmen: ${absence.childName}`}
+      >
+        <Undo2 className="h-3.5 w-3.5" /> Zurücknehmen
+      </Button>
+      <Dialog
+        open={mode !== null}
+        onOpenChange={(isOpen) => {
+          if (!isOpen && !pending) setMode(null);
+        }}
+      >
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>
+              {mode === "withdraw"
+                ? "Abwesenheit zurücknehmen"
+                : "Abwesenheit bearbeiten"}
+            </DialogTitle>
+            <DialogDescription>
+              {absence.childName}
+              {mode === "withdraw"
+                ? ": Diese Meldung wird aus der Abwesenheitsübersicht entfernt."
+                : ": Passe den Zeitraum, den Grund oder die Bemerkung an."}
+              {!team && mode === "edit"
+                ? " Änderungen sind nur für zukünftige Tage möglich."
+                : ""}
+            </DialogDescription>
+          </DialogHeader>
+          <form
+            onSubmit={(event) => {
+              event.preventDefault();
+              submit(new FormData(event.currentTarget));
+            }}
+          >
+            {mode === "edit" && (
+              <fieldset disabled={pending} className="grid gap-4 py-4">
+                <div className="grid grid-cols-2 gap-4">
+                  <div className="grid gap-2">
+                    <Label htmlFor={`absence-start-${absence.id}`}>Von</Label>
+                    <Input
+                      id={`absence-start-${absence.id}`}
+                      type="date"
+                      required
+                      min={team ? undefined : tomorrow}
+                      value={startDate}
+                      onChange={(event) => {
+                        const value = event.target.value;
+                        setStartDate(value);
+                        if (value > endDate) setEndDate(value);
+                      }}
+                    />
+                  </div>
+                  <div className="grid gap-2">
+                    <Label htmlFor={`absence-end-${absence.id}`}>Bis</Label>
+                    <Input
+                      id={`absence-end-${absence.id}`}
+                      type="date"
+                      required
+                      min={startDate}
+                      value={endDate}
+                      onChange={(event) => setEndDate(event.target.value)}
+                    />
+                  </div>
+                </div>
+                <div className="grid gap-2">
+                  <Label htmlFor={`absence-reason-${absence.id}`}>Grund</Label>
+                  <select
+                    id={`absence-reason-${absence.id}`}
+                    name="reason"
+                    defaultValue={absence.reason}
+                    className="h-10 rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 text-sm"
+                    required
+                  >
+                    <option value={AbsenceReason.ILLNESS}>Krank</option>
+                    <option value={AbsenceReason.VACATION}>Urlaub</option>
+                    <option value={AbsenceReason.OTHER}>Sonstiges</option>
+                  </select>
+                </div>
+                <div className="grid gap-2">
+                  <Label htmlFor={`absence-note-${absence.id}`}>
+                    Bemerkung (optional)
+                  </Label>
+                  <Textarea
+                    id={`absence-note-${absence.id}`}
+                    name="note"
+                    maxLength={500}
+                    defaultValue={absence.note ?? ""}
+                    rows={3}
+                  />
+                </div>
+              </fieldset>
+            )}
+            {error && (
+              <div
+                role="alert"
+                className="my-4 rounded-lg bg-[var(--danger-soft)] p-3 text-sm text-[var(--danger)]"
+              >
+                {error}
+                {error.includes("aktualisieren") && (
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => {
+                      setMode(null);
+                      onChanged?.();
+                      router.refresh();
+                    }}
+                  >
+                    Ansicht aktualisieren
+                  </Button>
+                )}
+              </div>
+            )}
+            <DialogFooter className="mt-4">
+              <Button
+                type="button"
+                variant="ghost"
+                disabled={pending}
+                onClick={() => setMode(null)}
+              >
+                Abbrechen
+              </Button>
+              <Button
+                type="submit"
+                disabled={pending}
+                variant={mode === "withdraw" ? "destructive" : "default"}
+              >
+                {pending
+                  ? "Wird gespeichert…"
+                  : mode === "withdraw"
+                    ? "Meldung zurücknehmen"
+                    : "Änderungen speichern"}
+              </Button>
+            </DialogFooter>
+          </form>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}

src/components/dashboard/sidebar-nav.tsx

@@ -14,6 +14,7 @@ import {
   Megaphone,
   Clock3,
   BellRing,
+  ShieldCheck,
 } from "lucide-react";
 
 import { NavItem } from "@/components/ui/nav-item";
@@ -21,6 +22,14 @@ import { NavItem } from "@/components/ui/nav-item";
 import { UserRole } from "@prisma/client";
 
 const navItems = [
+  {
+    section: "Verwaltung",
+    href: "/dashboard/zugriffsrechte",
+    label: "Zugriffsrechte",
+    icon: ShieldCheck,
+    exact: true,
+    allowedRoles: [UserRole.ADMIN],
+  },
   {
     section: "Heute",
     href: "/dashboard/notdienst/alarm",
@@ -51,13 +60,20 @@ const navItems = [
     icon: Megaphone,
     exact: false,
   },
+  {
+    section: "Heute",
+    href: "/dashboard/abwesenheiten",
+    label: "Meine Abwesenheiten",
+    icon: Stethoscope,
+    exact: true,
+    allowedRoles: [UserRole.ELTERN, UserRole.ADMIN, UserRole.KOORDINATOR],
+  },
   {
     section: "Heute",
     href: "/dashboard/notdienst",
     label: "Notdienst (Eltern)",
     icon: CalendarCheck2,
     exact: true,
-    badge: "4",
     allowedRoles: [UserRole.ADMIN, UserRole.KOORDINATOR, UserRole.ELTERN],
   },
   {
@@ -157,7 +173,7 @@ export function SidebarNav({ role }: { role: UserRole }) {
           <div className="flex flex-col gap-1">
             {visibleItems
               .filter((item) => item.section === section)
-              .map(({ href, label, icon, exact, badge }) => {
+              .map(({ href, label, icon, exact }) => {
                 const isActive = exact
                   ? pathname === href
                   : pathname.startsWith(href);
@@ -168,7 +184,6 @@ export function SidebarNav({ role }: { role: UserRole }) {
                     label={label}
                     icon={icon}
                     active={isActive}
-                    badge={badge}
                   />
                 );
               })}

src/components/ui/role-badge.tsx

@@ -1,5 +1,7 @@
 import type { UserRole } from "@prisma/client";
 
+import { kitaRoleLabels } from "@/lib/kita-roles";
+
 import { cn } from "@/lib/utils";
 
 type RoleBadgeProps = {
@@ -7,14 +9,6 @@ type RoleBadgeProps = {
   className?: string;
 };
 
-const roleLabels: Record<string, string> = {
-  SUPERADMIN: "Admin",
-  ADMIN: "Vorstand",
-  KOORDINATOR: "Koordinator",
-  ELTERN: "Eltern",
-  ERZIEHER: "Erzieher",
-};
-
 export function RoleBadge({ role, className }: RoleBadgeProps) {
   return (
     <span
@@ -23,7 +17,7 @@ export function RoleBadge({ role, className }: RoleBadgeProps) {
         className,
       )}
     >
-      {roleLabels[role] ?? role}
+      {kitaRoleLabels[role]}
     </span>
   );
 }

src/emails/NotdienstAvailabilityReminderEmail.tsx

@@ -17,6 +17,9 @@ type NotdienstAvailabilityReminderEmailProps = {
   kitaName: string;
   monthLabel: string;
   link: string;
+  selectedDays?: number;
+  requiredDays?: number;
+  deadlineLabel?: string;
 };
 
 export function NotdienstAvailabilityReminderEmail({
@@ -24,6 +27,9 @@ export function NotdienstAvailabilityReminderEmail({
   kitaName,
   monthLabel,
   link,
+  selectedDays,
+  requiredDays,
+  deadlineLabel,
 }: NotdienstAvailabilityReminderEmailProps) {
   return (
     <Html lang="de">
@@ -46,6 +52,8 @@ export function NotdienstAvailabilityReminderEmail({
               Bitte trage deine Verfügbarkeiten im Planer ein, damit wir die Tage fair verteilen können.
             </Text>
 
+            {requiredDays !== undefined ? <Text style={styles.text}>Euer Haushalt hat bisher {selectedDays ?? 0} von {requiredDays} benötigten Tagen eingetragen. Bitte ergänzt die Auswahl{deadlineLabel ? ` bis einschließlich ${deadlineLabel}` : ""}.</Text> : null}
+
             <Button href={link} style={styles.button}>
               Verfügbarkeiten eintragen
             </Button>

src/emails/NotdienstPlanPublishedEmail.tsx

@@ -0,0 +1,98 @@
+import {
+  Body,
+  Button,
+  Container,
+  Head,
+  Heading,
+  Html,
+  Preview,
+  Section,
+  Text,
+} from "@react-email/components";
+import { baseBodyStyle, colors, fontStack } from "./_styles";
+
+export function NotdienstPlanPublishedEmail({
+  parentName,
+  kitaName,
+  monthLabel,
+  dateLabels,
+  link,
+}: {
+  parentName: string;
+  kitaName: string;
+  monthLabel: string;
+  dateLabels: string[];
+  link: string;
+}) {
+  return (
+    <Html lang="de">
+      <Head />
+      <Preview>Deine Notdienste für {monthLabel}</Preview>
+      <Body style={baseBodyStyle}>
+        <Container
+          style={{
+            maxWidth: "600px",
+            padding: "32px 20px",
+            fontFamily: fontStack,
+          }}
+        >
+          <Section
+            style={{
+              backgroundColor: colors.cardBg,
+              padding: "28px",
+              borderRadius: "10px",
+              border: `1px solid ${colors.border}`,
+            }}
+          >
+            <Heading style={{ color: colors.textPrimary, fontSize: "26px" }}>
+              Notdienstplan {monthLabel}
+            </Heading>
+            <Text>Hallo {parentName},</Text>
+            <Text>
+              der Notdienstplan von <strong>{kitaName}</strong> ist
+              veröffentlicht. Euer Haushalt ist an folgenden Tagen eingeteilt:
+            </Text>
+            {dateLabels.map((date) => (
+              <Text
+                key={date}
+                style={{
+                  padding: "10px 14px",
+                  backgroundColor: "#f7f5ef",
+                  borderLeft: `4px solid ${colors.brandGreen}`,
+                  fontWeight: 700,
+                }}
+              >
+                {date}
+              </Text>
+            ))}
+            <Text>
+              Bitte merkt euch diese Termine vor. Den aktuellen Plan und
+              mögliche Änderungen findet ihr im Kalender.
+            </Text>
+            <Button
+              href={link}
+              style={{
+                backgroundColor: colors.brandGreen,
+                color: "#ffffff",
+                borderRadius: "6px",
+                padding: "14px 20px",
+                textDecoration: "none",
+              }}
+            >
+              Zum Kalender
+            </Button>
+            <Text
+              style={{
+                color: colors.textMuted,
+                fontSize: "12px",
+                wordBreak: "break-all",
+              }}
+            >
+              {link}
+            </Text>
+          </Section>
+        </Container>
+      </Body>
+    </Html>
+  );
+}

src/emails/PasswordResetEmail.tsx

@@ -0,0 +1,58 @@
+import {
+  Body,
+  Button,
+  Container,
+  Head,
+  Heading,
+  Html,
+  Preview,
+  Text,
+} from "@react-email/components";
+import { baseBodyStyle, colors } from "./_styles";
+
+export function PasswordResetEmail({
+  name,
+  resetLink,
+}: {
+  name: string;
+  resetLink: string;
+}) {
+  return (
+    <Html lang="de">
+      <Head />
+      <Preview>Dein Link für ein neues Kita-Planer-Passwort</Preview>
+      <Body style={baseBodyStyle}>
+        <Container
+          style={{
+            maxWidth: "520px",
+            padding: "32px",
+            backgroundColor: colors.cardBg,
+          }}
+        >
+          <Heading>Neues Passwort festlegen</Heading>
+          <Text>
+            Hallo {name}, du hast einen Link angefordert, um dein
+            Kita-Planer-Passwort zurückzusetzen.
+          </Text>
+          <Text>
+            Der Link ist 30 Minuten gültig und kann einmal verwendet werden.
+            Wenn du diese Anfrage nicht gestellt hast, kannst du die Nachricht
+            ignorieren. Dein Passwort bleibt dann unverändert.
+          </Text>
+          <Button
+            href={resetLink}
+            style={{
+              backgroundColor: colors.brandGreenAccent,
+              color: "#ffffff",
+              padding: "12px 18px",
+              borderRadius: "8px",
+            }}
+          >
+            Neues Passwort festlegen
+          </Button>
+          <Text>Falls der Button nicht funktioniert: {resetLink}</Text>
+        </Container>
+      </Body>
+    </Html>
+  );
+}

src/lib/absence-policy.ts

@@ -0,0 +1,37 @@
+// Absences are calendar dates stored as UTC dates, independent of the server timezone.
+export function absenceDate(value: string) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) throw new Error("Ungültiges Datum.");
+  const date = new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value)
+    throw new Error("Ungültiges Datum.");
+  return date;
+}
+
+export function isAbsenceDate(value: string) {
+  try {
+    absenceDate(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function absenceToday(now = new Date()) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Europe/Berlin",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(now);
+  const part = (type: string) =>
+    parts.find((item) => item.type === type)!.value;
+  return `${part("year")}-${part("month")}-${part("day")}`;
+}
+
+export function canManageKitaAbsences(role: string) {
+  return ["ADMIN", "KOORDINATOR", "ERZIEHER"].includes(role);
+}
+
+export function canEditOwnAbsence(startDate: string, today: string) {
+  return startDate > today;
+}

src/lib/alarms/email.ts

@@ -39,14 +39,29 @@ export async function deliverAlarmEmails(
         include: { user: true, alarm: { include: { kita: true } } },
       });
       const { user, alarm } = job;
-      let eligible = user.kitaId === alarm.kitaId && !user.disabledAt && !!user.emailVerifiedAt && !!user.privacyPolicyAcceptedAt && (!user.lockedUntil || user.lockedUntil <= now);
+      let eligible =
+        user.kitaId === alarm.kitaId &&
+        !user.disabledAt &&
+        !!user.emailVerifiedAt &&
+        !!user.privacyPolicyAcceptedAt &&
+        (!user.lockedUntil || user.lockedUntil <= now);
       if (job.kind === "MANAGER") eligible &&= managerRoles.includes(user.role);
       else
-        eligible &&= user.role === "ELTERN" && user.familyId === alarm.familyId;
+        eligible &&=
+          ["ELTERN", "ADMIN", "KOORDINATOR"].includes(user.role) &&
+          user.familyId === alarm.familyId;
       if (job.kind === "REQUEST") {
         const token = job.path.split("/").pop();
         const recipient = await prisma.notdienstAlarmRecipient.findFirst({
-          where: { alarmId: alarm.id, userId: user.id, sessionVersion: user.sessionVersion, OR: [{ token: hashToken(token ?? "") }, ...(token?.length === 36 ? [{ token }] : [])] },
+          where: {
+            alarmId: alarm.id,
+            userId: user.id,
+            sessionVersion: user.sessionVersion,
+            OR: [
+              { token: hashToken(token ?? "") },
+              ...(token?.length === 36 ? [{ token }] : []),
+            ],
+          },
         });
         eligible &&=
           !!recipient && alarm.status === "PENDING" && alarm.expiresAt > now;

src/lib/alarms/service.ts

@@ -114,22 +114,30 @@ async function queue(
   const users =
     audience === "managers"
       ? await tx.user.findMany({
-          where: { kitaId: alarm.kitaId, role: { in: managerRoles }, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } },
+          where: {
+            kitaId: alarm.kitaId,
+            role: { in: managerRoles },
+            emailVerifiedAt: { not: null },
+            disabledAt: null,
+            privacyPolicyAcceptedAt: { not: null },
+          },
         })
       : await tx.user.findMany({
           where: {
             kitaId: alarm.kitaId,
             familyId: alarm.familyId,
-            role: "ELTERN",
+            role: { in: ["ELTERN", "ADMIN", "KOORDINATOR"] },
-            emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null },
+            emailVerifiedAt: { not: null },
+            disabledAt: null,
+            privacyPolicyAcceptedAt: { not: null },
             alarmRecipients: { some: { alarmId: alarm.id } },
           },
         });
   const jobs: string[] = [];
   for (const user of users) {
-    const recipient =
+    const recipient = kind === "REQUEST" ? requestTokens?.get(user.id) : null;
-      kind === "REQUEST" ? requestTokens?.get(user.id) : null;
+    if (kind === "REQUEST" && !recipient)
-    if (kind === "REQUEST" && !recipient) throw new Error("Request token missing");
+      throw new Error("Request token missing");
     await tx.notdienstAlarmNotification.create({
       data: { alarmId: alarm.id, userId: user.id, eventKey, message },
     });
@@ -204,7 +212,15 @@ export async function executeAlarmCommand(
             include: {
               family: {
                 include: {
-                  users: { where: { role: "ELTERN", kitaId: actor.kitaId, emailVerifiedAt: { not: null }, disabledAt: null, privacyPolicyAcceptedAt: { not: null } } },
+                  users: {
+                    where: {
+                      role: { in: ["ELTERN", "ADMIN", "KOORDINATOR"] },
+                      kitaId: actor.kitaId,
+                      emailVerifiedAt: { not: null },
+                      disabledAt: null,
+                      privacyPolicyAcceptedAt: { not: null },
+                    },
+                  },
                 },
               },
             },
@@ -221,10 +237,14 @@ export async function executeAlarmCommand(
       if (!assignment.kita.notdienstModuleEnabled)
         throw new UserFacingError("Notdienst ist für diese Kita deaktiviert.");
       if (assignment.plan.status !== "PUBLISHED")
-        throw new UserFacingError("Bitte den Notdienstplan zuerst veröffentlichen.");
+        throw new UserFacingError(
+          "Bitte den Notdienstplan zuerst veröffentlichen.",
+        );
       const date = dateKey(assignment.date);
       if (date < todayKey(now))
-        throw new UserFacingError("Vergangene Notdienste können nicht alarmiert werden.");
+        throw new UserFacingError(
+          "Vergangene Notdienste können nicht alarmiert werden.",
+        );
       const expiresAt = endOfAlarm(date, input.wholeDay, input.endMinute);
       if (expiresAt <= now)
         throw new UserFacingError("Dieser Einsatz ist bereits beendet.");
@@ -245,7 +265,9 @@ export async function executeAlarmCommand(
           "Für diese Einteilung besteht bereits ein aktiver Alarm.",
         );
       const parents = assignment.child.family.users;
-      const requestTokens = new Map(parents.map(parent => [parent.id, newToken()]));
+      const requestTokens = new Map(
+        parents.map((parent) => [parent.id, newToken()]),
+      );
       if (!parents.length)
         throw new UserFacingError(
           "Für diesen Haushalt sind keine Elternkonten hinterlegt.",
@@ -353,7 +375,9 @@ export async function executeAlarmCommand(
         );
       const reason = note.parse(data.reason);
       if (command === "approveLate" && alarm.status !== "LATE_CONFIRMATION")
-        throw new UserFacingError("Es liegt keine verspätete Zusage zur Freigabe vor.");
+        throw new UserFacingError(
+          "Es liegt keine verspätete Zusage zur Freigabe vor.",
+        );
       const approve =
         command === "approveLate" || z.boolean().parse(data.approve);
       const updated = await tx.notdienstAlarm.update({
@@ -401,7 +425,12 @@ export async function executeAlarmCommand(
 
 async function recipientForToken(tx: Tx, token: string) {
   const recipient = await tx.notdienstAlarmRecipient.findFirst({
-    where: { OR: [{ token: hashToken(token) }, ...(token.length === 36 ? [{ token }] : [])] },
+    where: {
+      OR: [
+        { token: hashToken(token) },
+        ...(token.length === 36 ? [{ token }] : []),
+      ],
+    },
     include: {
       user: true,
       alarm: { include: { kita: { select: { name: true } } } },
@@ -409,9 +438,11 @@ async function recipientForToken(tx: Tx, token: string) {
   });
   if (
     !recipient ||
-    recipient.user.role !== "ELTERN" ||
+    !["ELTERN", "ADMIN", "KOORDINATOR"].includes(recipient.user.role) ||
     recipient.sessionVersion !== recipient.user.sessionVersion ||
-    !!recipient.user.disabledAt || !recipient.user.emailVerifiedAt || !recipient.user.privacyPolicyAcceptedAt ||
+    !!recipient.user.disabledAt ||
+    !recipient.user.emailVerifiedAt ||
+    !recipient.user.privacyPolicyAcceptedAt ||
     recipient.alarm.expiresAt <= new Date() ||
     (recipient.user.lockedUntil && recipient.user.lockedUntil > new Date()) ||
     recipient.user.kitaId !== recipient.alarm.kitaId ||
@@ -423,7 +454,12 @@ async function recipientForToken(tx: Tx, token: string) {
 export async function getPublicAlarm(token: string) {
   if (!tokenSchema.safeParse(token).success) return null;
   const legacy = await prisma.notdienstAlert.findFirst({
-    where: { OR: [{ confirmationToken: hashToken(token) }, ...(token.length === 36 ? [{ confirmationToken: token }] : [])] },
+    where: {
+      OR: [
+        { confirmationToken: hashToken(token) },
+        ...(token.length === 36 ? [{ confirmationToken: token }] : []),
+      ],
+    },
     select: { alarmId: true, assignmentId: true },
   });
   if (legacy && !legacy.alarmId)
@@ -591,7 +627,7 @@ export async function importLegacyAlarms(
       const old = assignment.alerts;
       const valid = old.filter(
         (a) =>
-          a.parentUser.role === "ELTERN" &&
+          ["ELTERN", "ADMIN", "KOORDINATOR"].includes(a.parentUser.role) &&
           a.parentUser.familyId === assignment.child.familyId &&
           a.parentUser.kitaId === assignment.kitaId,
       );

src/lib/date-utils.ts

@@ -1,35 +1,52 @@
-import {
+import { format } from "date-fns";
-  addMonths,
-  getDate,
-  getYear,
-  getMonth,
-  format,
-} from "date-fns";
-import { de } from "date-fns/locale";
 
 /**
  * Der Notdienst-Plan wird immer für den nächsten Monat erstellt.
  * Nach dem 26. des aktuellen Monats ist der Plan gesperrt.
  */
-const LOCK_DAY = 26;
+export const NOTDIENST_LOCK_DAY = 26;
+export function berlinDateKey(now = new Date()) {
+  return new Intl.DateTimeFormat("sv-SE", {
+    timeZone: "Europe/Berlin",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).format(now);
+}
 
 export function getTargetMonthData(now = new Date()) {
-  const currentDay = getDate(now);
+  const [year, month, currentDay] = berlinDateKey(now).split("-").map(Number);
-  const nextMonthDate = addMonths(now, 1);
+  const targetYear = month === 12 ? year + 1 : year;
-  const targetYear = getYear(nextMonthDate);
+  const targetMonth = month === 12 ? 1 : month + 1;
-  const targetMonth = getMonth(nextMonthDate) + 1; // 1-12
-
-  // Sperre aktiv, sobald der aktuelle Tag (im aktuellen Monat) > LOCK_DAY ist.
-  const isLocked = currentDay > LOCK_DAY;
-
   return {
     targetYear,
     targetMonth,
-    isLocked,
+    isLocked: currentDay > NOTDIENST_LOCK_DAY,
-    monthName: format(nextMonthDate, "MMMM yyyy", { locale: de }),
+    monthName: new Intl.DateTimeFormat("de-DE", {
+      timeZone: "UTC",
+      year: "numeric",
+      month: "long",
+    }).format(new Date(Date.UTC(targetYear, targetMonth - 1, 1))),
   };
 }
 
+export function isNotdienstReminderDue(daysBefore: number, now = new Date()) {
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone: "Europe/Berlin",
+    day: "2-digit",
+    hour: "2-digit",
+    hourCycle: "h23",
+  }).formatToParts(now);
+  const day = Number(parts.find((part) => part.type === "day")?.value);
+  const hour = Number(parts.find((part) => part.type === "hour")?.value);
+  return (
+    daysBefore > 0 &&
+    day >= Math.max(1, NOTDIENST_LOCK_DAY - daysBefore) &&
+    day <= NOTDIENST_LOCK_DAY &&
+    hour >= 9
+  );
+}
+
 export function getWorkingDaysOfMonth(year: number, month: number) {
   const start = new Date(Date.UTC(year, month - 1, 1));
   const end = new Date(Date.UTC(year, month, 0)); // last day of month

src/lib/family-invitation-view.ts

@@ -0,0 +1,36 @@
+export type FamilyInvitationView = {
+  status: "active" | "open" | "sending" | "sent" | "failed" | "expired";
+  expiresAt: string | null;
+  sentAt: string | null;
+};
+
+export function familyInvitationView(
+  emailVerifiedAt: Date | null,
+  invitation: {
+    expiresAt: Date;
+    sentAt: Date | null;
+    failed: boolean;
+    leaseUntil: Date | null;
+    status: string;
+  } | null,
+  now = new Date(),
+): FamilyInvitationView {
+  let status: FamilyInvitationView["status"] = "open";
+  if (emailVerifiedAt) status = "active";
+  else if (invitation) {
+    if (
+      invitation.expiresAt <= now ||
+      ["EXPIRED", "REVOKED"].includes(invitation.status)
+    )
+      status = "expired";
+    else if (invitation.leaseUntil && invitation.leaseUntil > now)
+      status = "sending";
+    else if (invitation.failed) status = "failed";
+    else if (invitation.sentAt) status = "sent";
+  }
+  return {
+    status,
+    expiresAt: invitation?.expiresAt.toISOString() ?? null,
+    sentAt: invitation?.sentAt?.toISOString() ?? null,
+  };
+}

src/lib/family-invitations.ts

@@ -0,0 +1,224 @@
+import { hashToken, newToken } from "@/lib/tokens";
+import { createElement } from "react";
+import { InvitationStatus, Prisma } from "@prisma/client";
+
+import { InviteEmail } from "@/emails/InviteEmail";
+import { sendAppEmail } from "@/lib/mail";
+import { prisma } from "@/lib/prisma";
+
+const INVITE_LIFETIME_MS = 7 * 24 * 60 * 60_000;
+
+// The account, activation token and delivery status commit together.
+export async function queueFamilyInvitation(
+  tx: Prisma.TransactionClient,
+  userId: string,
+  invitedById: string,
+) {
+  const user = await tx.user.findUniqueOrThrow({ where: { id: userId } });
+  if (!user.kitaId || !user.familyId || user.emailVerifiedAt || user.passwordHash || user.disabledAt)
+    throw new Error("Dieses Konto benötigt keine Familieneinladung.");
+  const existing = await tx.invitation.findFirst({
+    where: {
+      OR: [{ userId }, { kitaId: user.kitaId, email: user.email }],
+    },
+  });
+  if (existing?.userId && existing.userId !== userId)
+    throw new Error("Die Einladung gehört zu einem anderen Konto.");
+  if (existing?.leaseUntil && existing.leaseUntil > new Date())
+    throw new Error("Eine Einladung wird gerade versendet. Bitte kurz warten.");
+  const token = newToken();
+  const expiresAt = new Date(Date.now() + INVITE_LIFETIME_MS);
+  await tx.verificationToken.deleteMany({ where: { identifier: userId } });
+  await tx.verificationToken.create({
+    data: { identifier: userId, token: hashToken(token), expires: expiresAt },
+  });
+  const data = {
+    userId,
+    kitaId: user.kitaId,
+    email: user.email,
+    role: user.role,
+    token,
+    expiresAt,
+    invitedById,
+    status: InvitationStatus.PENDING,
+    acceptedAt: null,
+    sentAt: null,
+    lastAttemptAt: null,
+    leaseUntil: null,
+    attempts: 0,
+    failed: false,
+  };
+  return existing
+    ? tx.invitation.update({ where: { id: existing.id }, data })
+    : tx.invitation.create({ data });
+}
+
+// Tests inject a transport. Every recipient is attempted despite individual failures.
+export async function deliverFamilyInvitations(
+  ids: string[],
+  send = sendAppEmail,
+) {
+  let sent = 0;
+  let failed = 0;
+  for (const id of new Set(ids)) {
+    const now = new Date();
+    const leaseUntil = new Date(now.getTime() + 5 * 60_000);
+    const claim = await prisma.invitation.updateMany({
+      where: {
+        id,
+        userId: { not: null },
+        status: InvitationStatus.PENDING,
+        sentAt: null,
+        expiresAt: { gt: now },
+        OR: [{ leaseUntil: null }, { leaseUntil: { lte: now } }],
+      },
+      data: { leaseUntil, lastAttemptAt: now, attempts: { increment: 1 } },
+    });
+    if (!claim.count) continue;
+    const finish = (data: Prisma.InvitationUpdateManyMutationInput) =>
+      prisma.invitation.updateMany({
+        where: { id, token: jobToken, leaseUntil },
+        data: { ...data, leaseUntil: null },
+      });
+    let jobToken: string | undefined;
+    try {
+      const job = await prisma.invitation.findUniqueOrThrow({
+        where: { id },
+        include: { user: true, kita: { select: { name: true } } },
+      });
+      jobToken = job.token;
+      const token = await prisma.verificationToken.findUnique({
+        where: { token: hashToken(job.token) },
+      });
+      const user = job.user;
+      if (
+        !user ||
+        user.kitaId !== job.kitaId ||
+        !user.familyId ||
+        user.email !== job.email ||
+        user.emailVerifiedAt ||
+        user.disabledAt ||
+        user.passwordHash !== "" ||
+        !token ||
+        token.identifier !== user.id ||
+        token.expires <= now
+      ) {
+        await finish({
+          status: user?.emailVerifiedAt
+            ? InvitationStatus.ACCEPTED
+            : InvitationStatus.REVOKED,
+          failed: false,
+        });
+        continue;
+      }
+      const base =
+        process.env.NEXT_PUBLIC_SITE_URL ||
+        process.env.AUTH_URL ||
+        process.env.NEXTAUTH_URL;
+      if (!base) throw new Error("App-Adresse für Einladungen fehlt.");
+      const site = new URL(base);
+      if (
+        !["https:", "http:"].includes(site.protocol) ||
+        site.username ||
+        site.password
+      )
+        throw new Error("App-Adresse für Einladungen ist ungültig.");
+      const result = await send({
+        to: job.email,
+        subject: `Einladung zu ${job.kita.name} im Kita-Planer`,
+        idempotencyKey: `family-invitation/${job.token}`,
+        react: createElement(InviteEmail, {
+          parentName: `${user.firstName} ${user.lastName}`,
+          kitaName: job.kita.name,
+          inviteLink: new URL(`/invite/${job.token}`, site.origin).toString(),
+        }),
+      });
+      if (result.success) {
+        await finish({ sentAt: new Date(), failed: false });
+        sent++;
+      } else {
+        await finish({ failed: true });
+        failed++;
+      }
+    } catch {
+      await finish({ failed: true });
+      failed++;
+    }
+  }
+  return { sent, failed };
+}
+
+export async function resendFamilyInvitation(
+  kitaId: string,
+  userId: string,
+  actorId: string,
+  expectedEmail?: string,
+) {
+  const outcome = await prisma.$transaction(async (tx) => {
+    const actor = await tx.user.findFirst({
+      where: { id: actorId, kitaId, role: "ADMIN", disabledAt: null },
+      select: { id: true },
+    });
+    if (!actor)
+      return {
+        error: "Nur Kita-Admins dürfen Familieneinladungen erneut senden.",
+      };
+    // Serializes renewal with other renewals for this account.
+    await tx.$queryRaw`SELECT "id" FROM "users" WHERE "id" = ${userId} AND "kitaId" = ${kitaId} FOR UPDATE`;
+    const user = await tx.user.findFirst({
+      where: { id: userId, kitaId, familyId: { not: null } },
+    });
+    if (!user) return { error: "Elternkonto wurde nicht gefunden." };
+    if (user.emailVerifiedAt || user.passwordHash || user.disabledAt)
+      return { error: "Keine offene Einladung gefunden." };
+    if (expectedEmail && user.email !== expectedEmail)
+      return { error: "Die Einladung hat sich geändert. Bitte lade die Seite neu." };
+    const existing = await tx.invitation.findUnique({ where: { userId } });
+    const now = new Date();
+    if (existing?.leaseUntil && existing.leaseUntil > now)
+      return {
+        error: "Die Einladung wird gerade versendet. Bitte kurz warten.",
+      };
+    if (existing?.sentAt && now.getTime() - existing.sentAt.getTime() < 60_000)
+      return {
+        error:
+          "Die Einladung wurde gerade versendet. Bitte nach einer Minute erneut versuchen.",
+      };
+    const token = existing
+      ? await tx.verificationToken.findUnique({
+          where: { token: hashToken(existing.token) },
+        })
+      : null;
+    if (
+      existing &&
+      existing.status === InvitationStatus.PENDING &&
+      !existing.sentAt &&
+      existing.email === user.email &&
+      existing.expiresAt > now &&
+      token?.identifier === user.id &&
+      token.expires > now
+    )
+      return { id: existing.id };
+    const invitation = await queueFamilyInvitation(tx, userId, actorId);
+    return { id: invitation.id };
+  });
+  if (outcome.error || !outcome.id)
+    return {
+      error: outcome.error ?? "Einladung konnte nicht erstellt werden.",
+    };
+  const result = await deliverFamilyInvitations([outcome.id]);
+  return {
+    success: true,
+    ...(result.failed
+      ? {
+          warning:
+            "Einladung ist gespeichert, konnte aber nicht versendet werden. Du kannst den Versand erneut versuchen.",
+        }
+      : !result.sent
+        ? {
+            warning:
+              "Die Einladung ist vorbereitet. Bitte prüfe den aktuellen Versandstatus.",
+          }
+        : {}),
+  };
+}

src/lib/kita-admin-guard.ts

@@ -0,0 +1,41 @@
+import type { Prisma } from "@prisma/client";
+import { UserFacingError } from "@/lib/action-error";
+
+// Serialize role changes, account deletion and support locks for the same Kita.
+export async function lockKitaAccounts(
+  tx: Prisma.TransactionClient,
+  kitaId: string,
+) {
+  const rows = await tx.$queryRaw<
+    { id: string }[]
+  >`SELECT id FROM kitas WHERE id = ${kitaId} FOR UPDATE`;
+  if (!rows.length) throw new UserFacingError("Kita wurde nicht gefunden.");
+}
+
+export async function assertKitaAdminRemains(
+  tx: Prisma.TransactionClient,
+  kitaId: string,
+  excludedUserIds: string[],
+) {
+  const removesAdmin = await tx.user.count({
+    where: { kitaId, id: { in: excludedUserIds }, role: "ADMIN" },
+  });
+  if (!removesAdmin) return;
+  const now = new Date();
+  const remaining = await tx.user.count({
+    where: {
+      kitaId,
+      id: { notIn: excludedUserIds },
+      role: "ADMIN",
+      disabledAt: null,
+      emailVerifiedAt: { not: null },
+      privacyPolicyAcceptedAt: { not: null },
+      passwordHash: { not: "" },
+      OR: [{ lockedUntil: null }, { lockedUntil: { lte: now } }],
+    },
+  });
+  if (!remaining)
+    throw new UserFacingError(
+      "Mindestens ein aktiver Kita-Admin muss erhalten bleiben. Ernenne zuerst eine weitere Person mit aktiviertem Zugang und Datenschutzzustimmung.",
+    );
+}

src/lib/kita-role-management.ts

@@ -0,0 +1,116 @@
+import "server-only";
+import { AuditTargetType } from "@prisma/client";
+import { z } from "zod";
+import { prisma } from "@/lib/prisma";
+import { serializableTransaction } from "@/lib/transaction";
+import { UserFacingError } from "@/lib/action-error";
+import {
+  assertKitaAdminRemains,
+  lockKitaAccounts,
+} from "@/lib/kita-admin-guard";
+import { availableKitaRoles } from "@/lib/kita-roles";
+
+const inputSchema = z.object({
+  userId: z.string().min(1).max(64),
+  role: z.enum(["ADMIN", "KOORDINATOR", "ELTERN", "ERZIEHER"]),
+  expectedRole: z.enum(["ADMIN", "KOORDINATOR", "ELTERN", "ERZIEHER"]),
+});
+
+type Actor = { id: string; kitaId: string; sessionVersion: number };
+export async function changeKitaRole(actor: Actor, raw: unknown) {
+  const input = inputSchema.safeParse(raw);
+  if (!input.success) throw new UserFacingError("Ungültige Rollenänderung.");
+  return serializableTransaction(async (tx) => {
+    await lockKitaAccounts(tx, actor.kitaId);
+    const currentActor = await tx.user.findFirst({
+      where: {
+        id: actor.id,
+        kitaId: actor.kitaId,
+        role: "ADMIN",
+        sessionVersion: actor.sessionVersion,
+        disabledAt: null,
+        emailVerifiedAt: { not: null },
+        privacyPolicyAcceptedAt: { not: null },
+        OR: [{ lockedUntil: null }, { lockedUntil: { lte: new Date() } }],
+      },
+      select: { id: true, email: true },
+    });
+    if (!currentActor)
+      throw new UserFacingError(
+        "Du darfst die Zugriffsrechte nicht mehr ändern. Bitte lade die Seite neu.",
+      );
+    const person = await tx.user.findFirst({
+      where: { id: input.data.userId, kitaId: actor.kitaId },
+      select: {
+        id: true,
+        firstName: true,
+        lastName: true,
+        email: true,
+        role: true,
+        familyId: true,
+        staffProfile: { select: { id: true, kitaId: true } },
+      },
+    });
+    if (!person || person.role === "SUPERADMIN")
+      throw new UserFacingError(
+        "Dieses Kita-Konto kann hier nicht geändert werden.",
+      );
+    if (person.role !== input.data.expectedRole)
+      throw new UserFacingError(
+        "Die Rolle wurde inzwischen geändert. Bitte lade die Seite neu.",
+      );
+    if (person.staffProfile && person.staffProfile.kitaId !== actor.kitaId)
+      throw new UserFacingError(
+        "Das Personalprofil gehört nicht zu dieser Kita.",
+      );
+    if (
+      !availableKitaRoles({
+        familyId: person.familyId,
+        hasStaffProfile: !!person.staffProfile,
+      }).includes(input.data.role)
+    )
+      throw new UserFacingError(
+        person.staffProfile
+          ? "Ein Personalprofil benötigt die Rolle Fachkraft oder Kita-Admin."
+          : "Eltern benötigen einen Haushalt; die Fachkraftrolle benötigt ein Personalprofil.",
+      );
+    if (person.role === input.data.role)
+      return { changed: false, ownRoleChanged: false };
+    if (person.role === "ADMIN")
+      await assertKitaAdminRemains(tx, actor.kitaId, [person.id]);
+    await tx.user.update({
+      where: { id: person.id, kitaId: actor.kitaId },
+      data: { role: input.data.role },
+    });
+    await tx.auditLog.create({
+      data: {
+        actorUserId: currentActor.id,
+        actorEmail: currentActor.email,
+        action: "USER_ROLE_CHANGE",
+        targetType: AuditTargetType.USER,
+        targetId: person.id,
+        targetLabel: `${person.firstName} ${person.lastName}`,
+        targetKitaId: actor.kitaId,
+        metadata: { previousRole: person.role, newRole: input.data.role },
+      },
+    });
+    // Auth reloads the role from the database on every request. Keeping sessionVersion
+    // preserves already-issued household alarm links and existing login sessions.
+    return { changed: true, ownRoleChanged: person.id === actor.id };
+  });
+}
+
+export async function getKitaRoleHistory(kitaId: string) {
+  return prisma.auditLog.findMany({
+    where: { targetKitaId: kitaId, action: "USER_ROLE_CHANGE" },
+    orderBy: { createdAt: "desc" },
+    take: 15,
+    select: {
+      id: true,
+      targetLabel: true,
+      actorEmail: true,
+      metadata: true,
+      createdAt: true,
+    },
+  });
+}

src/lib/kita-roles.ts

@@ -0,0 +1,19 @@
+import type { UserRole } from "@prisma/client";
+
+export const kitaRoleLabels: Record<UserRole, string> = {
+  ADMIN: "Kita-Admin",
+  KOORDINATOR: "Notdienst-Koordination",
+  ELTERN: "Eltern",
+  ERZIEHER: "Fachkraft",
+  SUPERADMIN: "Systemadmin",
+};
+
+export function availableKitaRoles(person: {
+  familyId: string | null;
+  hasStaffProfile: boolean;
+}): UserRole[] {
+  if (person.hasStaffProfile) return ["ERZIEHER", "ADMIN"];
+  return person.familyId
+    ? ["ELTERN", "KOORDINATOR", "ADMIN"]
+    : ["KOORDINATOR", "ADMIN"];
+}

src/lib/mail.ts

@@ -1,4 +1,6 @@
-import type { ReactNode } from "react";
+import { createHash } from "node:crypto";
+import type { ReactNode, ReactElement } from "react";
+import { render } from "@react-email/render";
 import { Resend } from "resend";
 
 let resendClient: Resend | null = null;
@@ -10,6 +12,7 @@ type SendAppEmailInput = {
   from?: string;
   replyTo?: string | string[];
   idempotencyKey?: string;
+  timeoutMs?: number;
 };
 
 type SendAppEmailResult =
@@ -38,11 +41,12 @@ export async function sendAppEmail({
   from = process.env.EMAIL_FROM,
   replyTo,
   idempotencyKey,
+  timeoutMs = 10000,
 }: SendAppEmailInput): Promise<SendAppEmailResult> {
   if (Array.isArray(to)) {
     let id: string | undefined;
     for (const recipient of new Set(to)) {
-      const result = await sendAppEmail({ to: recipient, subject, react, from, replyTo });
+      const result = await sendAppEmail({ to: recipient, subject, react, from, replyTo, idempotencyKey: idempotencyKey ? `${idempotencyKey}/${createHash("sha256").update(recipient).digest("hex").slice(0, 16)}` : undefined, timeoutMs });
       if (!result.success) return result;
       id = result.id;
     }
@@ -74,15 +78,23 @@ export async function sendAppEmail({
 
   try {
     resendClient ??= new Resend(process.env.RESEND_API_KEY);
+    const html = await render(react as ReactElement);
+    // Retries keep the same key for identical payloads, while corrected messages get a new version.
+    const payloadKey = idempotencyKey ? `${idempotencyKey}/${createHash("sha256").update(JSON.stringify({ to, subject, from, replyTo, html })).digest("hex")}` : undefined;
+    // The installed SDK forwards request options to fetch; its types omit signal.
+    const requestOptions: NonNullable<Parameters<typeof resendClient.emails.send>[1]> & { signal: AbortSignal } = {
+      idempotencyKey: payloadKey,
+      signal: AbortSignal.timeout(timeoutMs),
+    };
     const { data, error } = await resendClient.emails.send(
       {
         from: from!,
         to,
         subject,
-        react,
+        html,
         replyTo,
       },
-      { idempotencyKey },
+      requestOptions,
     );
 
     if (error) {

src/lib/notdienst-days.ts

@@ -0,0 +1,26 @@
+import { formatUtcDateKey, getWorkingDaysOfMonth } from "./date-utils";
+
+export type NotdienstClosure = { startDate: Date; endDate: Date };
+const berlinDate = new Intl.DateTimeFormat("sv-SE", {
+  timeZone: "Europe/Berlin",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+});
+
+// Calendar events are instants; assignments are UTC-midnight date values.
+// A closure excludes every Berlin calendar day from start through end, inclusive.
+export function getNotdienstDays(
+  year: number,
+  month: number,
+  closures: NotdienstClosure[],
+) {
+  const ranges = closures.map((closure) => ({
+    start: berlinDate.format(closure.startDate),
+    end: berlinDate.format(closure.endDate),
+  }));
+  return getWorkingDaysOfMonth(year, month).filter((day) => {
+    const key = formatUtcDateKey(day);
+    return !ranges.some((range) => range.start <= key && key <= range.end);
+  });
+}

src/lib/notdienst-notifications.ts

@@ -0,0 +1,529 @@
+import { randomUUID } from "node:crypto";
+import { createElement } from "react";
+import type { Prisma } from "@prisma/client";
+import { prisma } from "@/lib/prisma";
+import { serializableTransaction } from "./transaction";
+import { UserFacingError } from "./action-error";
+import {
+  berlinDateKey,
+  formatUtcDateKey,
+  getTargetMonthData,
+  isNotdienstReminderDue,
+  NOTDIENST_LOCK_DAY,
+} from "./date-utils";
+import { loadNotdienstDays } from "./notdienst-planning";
+import { sendAppEmail } from "@/lib/mail";
+import { NotdienstAvailabilityReminderEmail } from "@/emails/NotdienstAvailabilityReminderEmail";
+import { NotdienstPlanPublishedEmail } from "@/emails/NotdienstPlanPublishedEmail";
+
+type Tx = Prisma.TransactionClient;
+const parentRoles = ["ELTERN", "ADMIN", "KOORDINATOR"] as const;
+const eligibleParents = (now: Date): Prisma.UserWhereInput => ({
+  role: { in: [...parentRoles] },
+  emailVerifiedAt: { not: null },
+  privacyPolicyAcceptedAt: { not: null },
+  disabledAt: null,
+  OR: [{ lockedUntil: null }, { lockedUntil: { lte: now } }],
+});
+const monthLabel = (year: number, month: number) =>
+  new Intl.DateTimeFormat("de-DE", {
+    timeZone: "UTC",
+    month: "long",
+    year: "numeric",
+  }).format(new Date(Date.UTC(year, month - 1, 1)));
+const period = (year: number, month: number) => ({
+  gte: new Date(Date.UTC(year, month - 1, 1)),
+  lt: new Date(Date.UTC(year, month, 1)),
+});
+
+export async function getFamilyNotdienstProgress(
+  db: Pick<Tx, "child" | "notdienstAvailability" | "termin">,
+  kitaId: string,
+  familyId: string,
+  year: number,
+  month: number,
+  minimum: number,
+) {
+  const [children, entries, days] = await Promise.all([
+    db.child.count({ where: { kitaId, familyId, active: true } }),
+    db.notdienstAvailability.findMany({
+      where: {
+        kitaId,
+        child: { kitaId, familyId, active: true },
+        date: period(year, month),
+      },
+      select: { date: true },
+    }),
+    loadNotdienstDays(db, kitaId, year, month),
+  ]);
+  const valid = new Set(days.map(formatUtcDateKey));
+  const selected = new Set(
+    entries
+      .map((a) => formatUtcDateKey(a.date))
+      .filter((key) => valid.has(key)),
+  ).size;
+  return { selected, required: children * minimum };
+}
+
+export async function queueNotdienstReminders(
+  kitaId: string,
+  year: number,
+  month: number,
+  automatic = false,
+  now = new Date(),
+) {
+  return serializableTransaction(async (tx) => {
+    const target = getTargetMonthData(now);
+    if (
+      target.isLocked ||
+      target.targetYear !== year ||
+      target.targetMonth !== month
+    ) {
+      if (automatic) return 0;
+      throw new UserFacingError(
+        "Erinnerungen sind nur während der Eintragsfrist für den Folgemonat möglich.",
+      );
+    }
+    const kita = await tx.kita.findUniqueOrThrow({
+      where: { id: kitaId },
+      select: {
+        notdienstModuleEnabled: true,
+        notdienstMinPerChildPerMonth: true,
+        notdienstReminderDaysBefore: true,
+      },
+    });
+    if (!kita.notdienstModuleEnabled) {
+      if (automatic) return 0;
+      throw new UserFacingError("Das Notdienstmodul ist deaktiviert.");
+    }
+    const plan = await tx.notdienstPlan.findUnique({
+      where: { kitaId_year_month: { kitaId, year, month } },
+      select: { status: true },
+    });
+    if (plan?.status === "PUBLISHED") return 0;
+    if (automatic) {
+      if (!isNotdienstReminderDue(kita.notdienstReminderDaysBefore, now))
+        return 0;
+      const run = await tx.notdienstReminderRun.createMany({
+        data: [{ id: randomUUID(), kitaId, year, month, createdAt: now }],
+        skipDuplicates: true,
+      });
+      if (!run.count) return 0;
+    }
+    const [families, entries, days] = await Promise.all([
+      tx.family.findMany({
+        where: { kitaId, children: { some: { kitaId, active: true } } },
+        select: {
+          id: true,
+          children: { where: { kitaId, active: true }, select: { id: true } },
+          users: {
+            where: { kitaId, ...eligibleParents(now) },
+            select: { id: true },
+          },
+        },
+      }),
+      tx.notdienstAvailability.findMany({
+        where: {
+          kitaId,
+          date: period(year, month),
+          child: { kitaId, active: true },
+        },
+        select: { date: true, child: { select: { familyId: true } } },
+      }),
+      loadNotdienstDays(tx, kitaId, year, month),
+    ]);
+    const valid = new Set(days.map(formatUtcDateKey));
+    const selected = new Map<string, Set<string>>();
+    for (const entry of entries) {
+      const key = formatUtcDateKey(entry.date);
+      if (!valid.has(key)) continue;
+      const dates = selected.get(entry.child.familyId) ?? new Set<string>();
+      dates.add(key);
+      selected.set(entry.child.familyId, dates);
+    }
+    const jobs = families
+      .filter(
+        (family) =>
+          (selected.get(family.id)?.size ?? 0) <
+          family.children.length * kita.notdienstMinPerChildPerMonth,
+      )
+      .flatMap((family) =>
+        family.users.map((user) => ({
+          id: randomUUID(),
+          kitaId,
+          familyId: family.id,
+          userId: user.id,
+          year,
+          month,
+          kind: "REMINDER",
+          eventKey: `reminder:${berlinDateKey(now)}`,
+          createdAt: now,
+          nextAttemptAt: now,
+        })),
+      );
+    if (!jobs.length) return 0;
+    return (
+      await tx.notdienstEmail.createMany({ data: jobs, skipDuplicates: true })
+    ).count;
+  });
+}
+
+// Must run in the same transaction as the first publication.
+export async function queueNotdienstPublication(
+  tx: Tx,
+  kitaId: string,
+  planId: string,
+  year: number,
+  month: number,
+  now = new Date(),
+) {
+  const assigned = await tx.notdienstAssignment.findMany({
+    where: { kitaId, planId, child: { kitaId, active: true } },
+    select: { child: { select: { familyId: true } } },
+  });
+  const families = await tx.family.findMany({
+    where: {
+      kitaId,
+      id: { in: [...new Set(assigned.map((a) => a.child.familyId))] },
+    },
+    select: {
+      id: true,
+      users: {
+        where: { kitaId, ...eligibleParents(now) },
+        select: { id: true },
+      },
+    },
+  });
+  const jobs = families.flatMap((family) =>
+    family.users.map((user) => ({
+      id: randomUUID(),
+      kitaId,
+      familyId: family.id,
+      userId: user.id,
+      planId,
+      year,
+      month,
+      kind: "PUBLICATION",
+      eventKey: `publication:${planId}`,
+      createdAt: now,
+      nextAttemptAt: now,
+    })),
+  );
+  return jobs.length
+    ? (await tx.notdienstEmail.createMany({ data: jobs, skipDuplicates: true }))
+        .count
+    : 0;
+}
+
+export async function deliverNotdienstEmails(
+  ids: string[],
+  send = sendAppEmail,
+  now = new Date(),
+) {
+  const result = { sent: 0, failed: 0, skipped: 0 };
+  const deliver = async (id: string) => {
+    const claimToken = randomUUID();
+    const leaseUntil = new Date(now.getTime() + 5 * 60_000);
+    const claim = await prisma.notdienstEmail.updateMany({
+      where: {
+        id,
+        sentAt: null,
+        skippedAt: null,
+        nextAttemptAt: { lte: now },
+        OR: [{ leaseUntil: null }, { leaseUntil: { lte: now } }],
+      },
+      data: { claimToken, leaseUntil, attempts: { increment: 1 } },
+    });
+    if (!claim.count) return;
+    const finish = (data: Prisma.NotdienstEmailUpdateManyMutationInput) =>
+      prisma.notdienstEmail.updateMany({
+        where: { id, claimToken },
+        data: { ...data, claimToken: null, leaseUntil: null },
+      });
+    try {
+      const job = await prisma.notdienstEmail.findUniqueOrThrow({
+        where: { id },
+        include: { user: true, kita: true, plan: { select: { status: true } } },
+      });
+      const { user, kita } = job;
+      let eligible =
+        kita.notdienstModuleEnabled &&
+        user.kitaId === job.kitaId &&
+        user.familyId === job.familyId &&
+        parentRoles.some((role) => role === user.role) &&
+        !!user.emailVerifiedAt &&
+        !!user.privacyPolicyAcceptedAt &&
+        !user.disabledAt &&
+        (!user.lockedUntil || user.lockedUntil <= now);
+      let progress: { selected: number; required: number } | undefined;
+      let dates: string[] = [];
+      if (job.kind === "REMINDER") {
+        const target = getTargetMonthData(now);
+        const plan = await prisma.notdienstPlan.findUnique({
+          where: {
+            kitaId_year_month: {
+              kitaId: job.kitaId,
+              year: job.year,
+              month: job.month,
+            },
+          },
+          select: { status: true },
+        });
+        eligible &&=
+          !target.isLocked &&
+          target.targetYear === job.year &&
+          target.targetMonth === job.month &&
+          plan?.status !== "PUBLISHED";
+        if (eligible) {
+          progress = await getFamilyNotdienstProgress(
+            prisma,
+            job.kitaId,
+            job.familyId,
+            job.year,
+            job.month,
+            kita.notdienstMinPerChildPerMonth,
+          );
+          eligible &&=
+            progress.required > 0 && progress.selected < progress.required;
+        }
+      } else if (job.kind === "PUBLICATION") {
+        eligible &&= !!job.planId && job.plan?.status === "PUBLISHED";
+        if (eligible) {
+          const [assignments, days] = await Promise.all([
+            prisma.notdienstAssignment.findMany({
+              where: {
+                kitaId: job.kitaId,
+                planId: job.planId!,
+                child: {
+                  kitaId: job.kitaId,
+                  familyId: job.familyId,
+                  active: true,
+                },
+                date: {
+                  ...period(job.year, job.month),
+                },
+              },
+              select: { date: true },
+              orderBy: { date: "asc" },
+            }),
+            loadNotdienstDays(prisma, job.kitaId, job.year, job.month),
+          ]);
+          const valid = new Set(days.map(formatUtcDateKey));
+          dates = assignments
+            .map((a) => formatUtcDateKey(a.date))
+            .filter((key) => key >= berlinDateKey(now) && valid.has(key));
+          eligible &&= dates.length > 0;
+        }
+      } else eligible = false;
+      if (!eligible) {
+        await finish({ skippedAt: now, failed: false, lastError: null });
+        result.skipped++;
+        return;
+      }
+      const base =
+        process.env.NEXT_PUBLIC_SITE_URL ||
+        process.env.AUTH_URL ||
+        process.env.NEXTAUTH_URL;
+      if (!base) throw new Error("App-Adresse für E-Mails fehlt.");
+      const site = new URL(base);
+      if (
+        !["http:", "https:"].includes(site.protocol) ||
+        site.username ||
+        site.password
+      )
+        throw new Error("App-Adresse ungültig.");
+      const label = monthLabel(job.year, job.month);
+      const link = new URL(
+        job.kind === "REMINDER"
+          ? "/dashboard/notdienst"
+          : "/dashboard/kalender",
+        site.origin,
+      ).toString();
+      const response = await send({
+        to: user.email,
+        idempotencyKey: `notdienst-email/${job.id}`,
+        subject:
+          job.kind === "REMINDER"
+            ? `Erinnerung: Notdienst-Verfügbarkeiten für ${label}`
+            : `Notdienstplan ${label} veröffentlicht`,
+        react:
+          job.kind === "REMINDER"
+            ? createElement(NotdienstAvailabilityReminderEmail, {
+                parentName: user.firstName,
+                kitaName: kita.name,
+                monthLabel: label,
+                link,
+                selectedDays: progress!.selected,
+                requiredDays: progress!.required,
+                deadlineLabel: new Intl.DateTimeFormat("de-DE", {
+                  timeZone: "UTC",
+                  day: "2-digit",
+                  month: "2-digit",
+                  year: "numeric",
+                }).format(
+                  new Date(
+                    Date.UTC(job.year, job.month - 2, NOTDIENST_LOCK_DAY),
+                  ),
+                ),
+              })
+            : createElement(NotdienstPlanPublishedEmail, {
+                parentName: user.firstName,
+                kitaName: kita.name,
+                monthLabel: label,
+                dateLabels: dates.map((key) =>
+                  new Intl.DateTimeFormat("de-DE", {
+                    timeZone: "UTC",
+                    weekday: "long",
+                    day: "2-digit",
+                    month: "2-digit",
+                    year: "numeric",
+                  }).format(new Date(`${key}T00:00:00Z`)),
+                ),
+                link,
+              }),
+      });
+      if (!response.success) throw new Error(response.error);
+      await finish({ sentAt: now, failed: false, lastError: null });
+      result.sent++;
+    } catch {
+      const current = await prisma.notdienstEmail.findUnique({
+        where: { id },
+        select: { attempts: true },
+      });
+      const delay = Math.min(
+        6 * 60 * 60_000,
+        60_000 * 2 ** Math.min(current?.attempts ?? 1, 8),
+      );
+      await finish({
+        failed: true,
+        lastError:
+          "E-Mail-Versand fehlgeschlagen. Der Versand wird erneut versucht.",
+        nextAttemptAt: new Date(now.getTime() + delay),
+      });
+      result.failed++;
+    }
+  };
+  const unique = [...new Set(ids)];
+  for (let i = 0; i < unique.length; i += 4)
+    await Promise.all(unique.slice(i, i + 4).map(deliver));
+  return result;
+}
+
+type MailScope = {
+  kitaId?: string;
+  year?: number;
+  month?: number;
+  planId?: string;
+};
+export async function deliverDueNotdienstEmails(
+  scope: MailScope = {},
+  send = sendAppEmail,
+  now = new Date(),
+) {
+  const jobs = await prisma.notdienstEmail.findMany({
+    where: {
+      ...scope,
+      sentAt: null,
+      skippedAt: null,
+      nextAttemptAt: { lte: now },
+      OR: [{ leaseUntil: null }, { leaseUntil: { lte: now } }],
+    },
+    select: { id: true },
+    orderBy: [{ nextAttemptAt: "asc" }, { createdAt: "asc" }],
+    take: 12,
+  });
+  return deliverNotdienstEmails(
+    jobs.map((job) => job.id),
+    send,
+    now,
+  );
+}
+
+export async function runNotdienstNotificationJob(
+  send = sendAppEmail,
+  now = new Date(),
+  kitaId?: string,
+) {
+  const target = getTargetMonthData(now);
+  let queued = 0;
+  if (!target.isLocked && isNotdienstReminderDue(31, now)) {
+    const candidates = await prisma.kita.findMany({
+      where: {
+        ...(kitaId ? { id: kitaId } : {}),
+        notdienstModuleEnabled: true,
+        notdienstPlans: { none: { year: target.targetYear, month: target.targetMonth, status: "PUBLISHED" } },
+        notdienstReminderDaysBefore: {
+          gte: Math.max(
+            1,
+            NOTDIENST_LOCK_DAY - Number(berlinDateKey(now).slice(-2)),
+          ),
+        },
+        notdienstReminderRuns: {
+          none: { year: target.targetYear, month: target.targetMonth },
+        },
+      },
+      select: { id: true, notdienstReminderDaysBefore: true },
+      orderBy: { id: "asc" },
+      take: 100,
+    });
+    for (const kita of candidates)
+      if (isNotdienstReminderDue(kita.notdienstReminderDaysBefore, now))
+        queued += await queueNotdienstReminders(
+          kita.id,
+          target.targetYear,
+          target.targetMonth,
+          true,
+          now,
+        );
+  }
+  return {
+    queued,
+    ...(await deliverDueNotdienstEmails(kitaId ? { kitaId } : {}, send, now)),
+  };
+}
+
+export async function getNotdienstEmailStatus(
+  kitaId: string,
+  year: number,
+  month: number,
+) {
+  const jobs = await prisma.notdienstEmail.findMany({
+    where: { kitaId, year, month },
+    select: {
+      id: true,
+      kind: true,
+      sentAt: true,
+      skippedAt: true,
+      failed: true,
+      lastError: true,
+      user: { select: { firstName: true, lastName: true } },
+      family: { select: { name: true } },
+    },
+    orderBy: { createdAt: "desc" },
+  });
+  const status = (job: (typeof jobs)[number]) =>
+    job.sentAt
+      ? ("sent" as const)
+      : job.skippedAt
+        ? ("skipped" as const)
+        : job.failed
+          ? ("failed" as const)
+          : ("pending" as const);
+  return {
+    sent: jobs.filter((job) => status(job) === "sent").length,
+    failed: jobs.filter((job) => status(job) === "failed").length,
+    pending: jobs.filter((job) => status(job) === "pending").length,
+    skipped: jobs.filter((job) => status(job) === "skipped").length,
+    entries: jobs.slice(0, 30).map((job) => ({
+      id: job.id,
+      kind: job.kind,
+      status: status(job),
+      name: `${job.user.firstName} ${job.user.lastName}`,
+      familyName: job.family.name,
+      error: job.lastError,
+    })),
+  };
+}
+export type NotdienstEmailStatus = Awaited<
+  ReturnType<typeof getNotdienstEmailStatus>
+>;

src/lib/notdienst-planning.ts

@@ -0,0 +1,56 @@
+import { Prisma } from "@prisma/client";
+import { UserFacingError } from "./action-error";
+import { getNotdienstDays } from "./notdienst-days";
+import { todayKey } from "./staff/calculations";
+
+export async function loadNotdienstDays(
+  db: Pick<Prisma.TransactionClient, "termin">,
+  kitaId: string,
+  year: number,
+  month: number,
+) {
+  const closures = await db.termin.findMany({
+    where: {
+      kitaId,
+      status: "CONFIRMED",
+      type: { in: ["SCHLIESSTAG", "TEAMTAG"] },
+      // Include closures crossing the month boundary and Berlin midnight.
+      startDate: { lt: new Date(Date.UTC(year, month, 1)) },
+      endDate: { gte: new Date(Date.UTC(year, month - 1, 1) - 86400000) },
+    },
+    select: { startDate: true, endDate: true },
+  });
+  return getNotdienstDays(year, month, closures);
+}
+
+export async function assertChildrenRemovable(
+  tx: Prisma.TransactionClient,
+  kitaId: string,
+  familyId: string,
+  childIds: string[],
+) {
+  if (childIds.length === 0) return;
+  // Coordinate with the FK locks taken by concurrent assignment writes.
+  await tx.$queryRaw`SELECT id FROM children WHERE "kitaId" = ${kitaId}
+    AND "familyId" = ${familyId} AND id IN (${Prisma.join(childIds)}) ORDER BY id FOR UPDATE`;
+  const obligation = await tx.notdienstAssignment.findFirst({
+    where: {
+      kitaId,
+      childId: { in: childIds },
+      child: { kitaId, familyId },
+      OR: [
+        {
+          date: { gte: new Date(`${todayKey()}T00:00:00Z`) },
+          plan: { kitaId, status: "PUBLISHED" },
+        },
+        { alarms: { some: { kitaId, activeAssignmentId: { not: null } } } },
+      ],
+    },
+    select: { id: true },
+  });
+  if (obligation) {
+    throw new UserFacingError(
+      "Das Kind kann nicht entfernt werden, solange veröffentlichte Notdienste oder aktive Alarme bestehen. Bitte zuerst die Einteilung mit der Koordination klären.",
+    );
+  }
+}

src/lib/notdienst-swaps.ts

@@ -0,0 +1,11 @@
+import type { UserRole } from "@prisma/client";
+
+export function canRequestNotdienstSwap(
+  role: UserRole,
+  familyId: string | null | undefined,
+) {
+  return (
+    !!familyId &&
+    (role === "ELTERN" || role === "ADMIN" || role === "KOORDINATOR")
+  );
+}

src/lib/password-management.ts

@@ -0,0 +1,260 @@
+import { createElement } from "react";
+import { compare, hash } from "bcryptjs";
+import { z } from "zod";
+import { prisma } from "@/lib/prisma";
+import { serializableTransaction } from "@/lib/transaction";
+import { hashToken, newToken } from "@/lib/tokens";
+import { passwordSchema } from "@/lib/password";
+import { sendAppEmail } from "@/lib/mail";
+import { PasswordResetEmail } from "@/emails/PasswordResetEmail";
+import { UserFacingError } from "@/lib/action-error";
+
+const RESET_PREFIX = "password-reset:";
+const resetScope = (userId: string) =>
+  `${RESET_PREFIX}${Buffer.from(userId).toString("base64url")}:`;
+function resetIdentity(identifier: string) {
+  const match = /^password-reset:([a-zA-Z0-9_-]+):(\d+)$/.exec(identifier);
+  if (!match) return null;
+  const sessionVersion = Number(match[2]);
+  if (!Number.isSafeInteger(sessionVersion)) return null;
+  return {
+    id: Buffer.from(match[1], "base64url").toString("utf8"),
+    sessionVersion,
+  };
+}
+const tokenSchema = z.string().regex(/^[a-f0-9]{64}$/i);
+export const passwordResetMessage =
+  "Wenn für diese E-Mail-Adresse ein aktiviertes Konto besteht, erhältst du einen Link für ein neues Passwort. Prüfe auch deinen Spamordner.";
+const newPasswordSchema = z
+  .object({ password: passwordSchema, confirmation: z.string() })
+  .refine((input) => input.password === input.confirmation, {
+    message: "Die neuen Passwörter stimmen nicht überein.",
+    path: ["confirmation"],
+  });
+const resetSchema = newPasswordSchema.and(z.object({ token: tokenSchema }));
+const invalidLink = () =>
+  new UserFacingError(
+    "Dieser Link ist ungültig, abgelaufen oder wurde bereits verwendet. Bitte fordere einen neuen Link an.",
+  );
+
+function siteOrigin() {
+  const base =
+    process.env.NEXT_PUBLIC_SITE_URL ||
+    process.env.AUTH_URL ||
+    process.env.NEXTAUTH_URL;
+  if (!base && process.env.NODE_ENV !== "development")
+    throw new Error("App-Adresse fehlt.");
+  const url = new URL(base || "http://localhost:3000");
+  if (
+    !["http:", "https:"].includes(url.protocol) ||
+    url.username ||
+    url.password
+  )
+    throw new Error("Ungültige App-Adresse.");
+  return url.origin;
+}
+
+export async function requestPasswordReset(email: string, send = sendAppEmail) {
+  const parsed = z
+    .string()
+    .trim()
+    .max(254)
+    .email()
+    .toLowerCase()
+    .safeParse(email);
+  if (!parsed.success) return;
+  const resetToken = newToken();
+  const tokenHash = hashToken(resetToken);
+  const job = await serializableTransaction(async (tx) => {
+    const user = await tx.user.findUnique({ where: { email: parsed.data } });
+    if (!user || user.disabledAt || !user.emailVerifiedAt || !user.passwordHash)
+      return null;
+    await tx.$queryRaw`SELECT id FROM users WHERE id = ${user.id} FOR UPDATE`;
+    const fresh = await tx.user.findUniqueOrThrow({ where: { id: user.id } });
+    if (
+      fresh.email !== parsed.data ||
+      fresh.disabledAt ||
+      !fresh.emailVerifiedAt ||
+      !fresh.passwordHash
+    )
+      return null;
+    const identifier = resetScope(user.id) + fresh.sessionVersion;
+    await tx.verificationToken.deleteMany({
+      where: { identifier: { startsWith: resetScope(user.id) } },
+    });
+    await tx.verificationToken.create({
+      data: {
+        identifier,
+        token: tokenHash,
+        expires: new Date(Date.now() + 30 * 60_000),
+      },
+    });
+    return {
+      id: user.id,
+      email: fresh.email,
+      name: fresh.firstName,
+      identifier,
+    };
+  });
+  if (!job) return;
+  try {
+    const result = await send({
+      to: job.email,
+      subject: "Kita-Planer: Neues Passwort festlegen",
+      react: createElement(PasswordResetEmail, {
+        name: job.name,
+        resetLink: `${siteOrigin()}/neues-passwort/${resetToken}`,
+      }),
+      idempotencyKey: `password-reset/${tokenHash}`,
+    });
+    if (result.success) return;
+  } catch {
+    /* Return the same public response, including transport failure. */
+  }
+  await prisma.verificationToken.deleteMany({
+    where: { identifier: job.identifier, token: tokenHash },
+  });
+}
+
+export async function isPasswordResetValid(token: string) {
+  if (!tokenSchema.safeParse(token).success) return false;
+  const entry = await prisma.verificationToken.findUnique({
+    where: { token: hashToken(token) },
+  });
+  if (!entry || !resetIdentity(entry.identifier) || entry.expires <= new Date())
+    return false;
+  return !!(await prisma.user.findFirst({
+    where: {
+      ...resetIdentity(entry.identifier)!,
+      disabledAt: null,
+      emailVerifiedAt: { not: null },
+      passwordHash: { not: "" },
+    },
+    select: { id: true },
+  }));
+}
+
+export async function resetPassword(raw: unknown) {
+  const input = resetSchema.safeParse(raw);
+  if (!input.success)
+    throw new UserFacingError(
+      input.error.issues[0]?.message ?? "Bitte die Eingaben prüfen.",
+    );
+  if (!(await isPasswordResetValid(input.data.token))) throw invalidLink();
+  const passwordHash = await hash(input.data.password, 12);
+  await serializableTransaction(async (tx) => {
+    const tokenHash = hashToken(input.data.token);
+    const entry = await tx.verificationToken.findUnique({
+      where: { token: tokenHash },
+    });
+    if (
+      !entry ||
+      !resetIdentity(entry.identifier) ||
+      entry.expires <= new Date()
+    )
+      throw invalidLink();
+    const identity = resetIdentity(entry.identifier)!;
+    const userId = identity.id;
+    await tx.$queryRaw`SELECT id FROM users WHERE id = ${userId} FOR UPDATE`;
+    const user = await tx.user.findFirst({
+      where: {
+        ...identity,
+        disabledAt: null,
+        emailVerifiedAt: { not: null },
+        passwordHash: { not: "" },
+      },
+    });
+    if (!user) throw invalidLink();
+    const consumed = await tx.verificationToken.deleteMany({
+      where: {
+        identifier: entry.identifier,
+        token: tokenHash,
+        expires: { gt: new Date() },
+      },
+    });
+    if (consumed.count !== 1) throw invalidLink();
+    await tx.user.update({
+      where: { id: userId },
+      data: {
+        passwordHash,
+        sessionVersion: { increment: 1 },
+        failedLoginAttempts: 0,
+        lockedUntil: null,
+      },
+    });
+    await tx.verificationToken.deleteMany({
+      where: {
+        OR: [
+          { identifier: userId },
+          { identifier: { startsWith: resetScope(userId) } },
+        ],
+      },
+    });
+  });
+}
+
+export async function changeOwnPassword(
+  actor: { id: string; sessionVersion: number },
+  raw: unknown,
+) {
+  const schema = newPasswordSchema.and(
+    z.object({
+      currentPassword: z
+        .string()
+        .min(1)
+        .refine(
+          (value) => Buffer.byteLength(value, "utf8") <= 72,
+          "Aktuelles Passwort ist ungültig.",
+        ),
+    }),
+  );
+  const input = schema.safeParse(raw);
+  if (!input.success)
+    throw new UserFacingError(
+      input.error.issues[0]?.message ?? "Bitte die Eingaben prüfen.",
+    );
+  const user = await prisma.user.findFirst({
+    where: {
+      id: actor.id,
+      sessionVersion: actor.sessionVersion,
+      disabledAt: null,
+      emailVerifiedAt: { not: null },
+    },
+  });
+  if (!user || !(await compare(input.data.currentPassword, user.passwordHash)))
+    throw new UserFacingError(
+      "Das aktuelle Passwort ist nicht korrekt. Bitte melde dich bei Bedarf erneut an.",
+    );
+  if (await compare(input.data.password, user.passwordHash))
+    throw new UserFacingError("Bitte wähle ein anderes neues Passwort.");
+  const passwordHash = await hash(input.data.password, 12);
+  await serializableTransaction(async (tx) => {
+    const changed = await tx.user.updateMany({
+      where: {
+        id: user.id,
+        passwordHash: user.passwordHash,
+        sessionVersion: actor.sessionVersion,
+        disabledAt: null,
+        emailVerifiedAt: { not: null },
+      },
+      data: {
+        passwordHash,
+        sessionVersion: { increment: 1 },
+        failedLoginAttempts: 0,
+        lockedUntil: null,
+      },
+    });
+    if (changed.count !== 1)
+      throw new UserFacingError(
+        "Das Konto wurde inzwischen geändert. Bitte melde dich erneut an.",
+      );
+    await tx.verificationToken.deleteMany({
+      where: {
+        OR: [
+          { identifier: user.id },
+          { identifier: { startsWith: resetScope(user.id) } },
+        ],
+      },
+    });
+  });
+}

src/lib/staff/email.ts

@@ -40,25 +40,29 @@ export async function deliverStaffEmails(ids: string[], send = sendAppEmail) {
         },
       });
       const { user, profile } = job;
-      let eligible = user.kitaId === profile.kitaId && !user.disabledAt && (!user.lockedUntil || user.lockedUntil <= now);
+      let eligible =
+        user.kitaId === profile.kitaId &&
+        !user.disabledAt &&
+        (!user.lockedUntil || user.lockedUntil <= now);
       if (job.inviteToken) {
         const token = await prisma.verificationToken.findUnique({
           where: { token: hashToken(job.inviteToken) },
         });
         eligible &&=
           profile.userId === user.id &&
-          user.role === "ERZIEHER" &&
+          ["ERZIEHER", "ADMIN"].includes(user.role) &&
           !user.emailVerifiedAt &&
           !!token &&
           token.identifier === user.id &&
           token.expires > now;
       } else {
         eligible &&=
-          !!user.emailVerifiedAt && !!user.privacyPolicyAcceptedAt &&
+          !!user.emailVerifiedAt &&
+          !!user.privacyPolicyAcceptedAt &&
           (!user.lockedUntil || user.lockedUntil <= now) &&
           (job.toAdmins
             ? user.role === "ADMIN"
-            : user.role === "ERZIEHER" &&
+            : ["ERZIEHER", "ADMIN"].includes(user.role) &&
               profile.userId === user.id &&
               user.staffDecisionEmails);
       }

src/lib/staff/service.ts

@@ -81,7 +81,11 @@ async function inviteStaff(
   if (
     existingUser &&
     (existingUser.kitaId !== actor.kitaId ||
-      existingUser.role !== UserRole.ERZIEHER ||
+      !(
+        existingUser.role === UserRole.ERZIEHER ||
+        (existingUser.role === UserRole.ADMIN &&
+          existingUser.id === profile.userId)
+      ) ||
       (await tx.staffProfile.count({
         where: { userId: existingUser.id, id: { not: profile.id } },
       })))
@@ -205,7 +209,9 @@ export function assertStaffAccess(
     throw new UserFacingError("Kein Zugriff auf dieses Personalprofil.");
   if (adminOnly) requireAdmin(actor);
   else if (actor.role !== UserRole.ADMIN && profile.userId !== actor.id)
-    throw new UserFacingError("Du kannst nur dein eigenes Personalprofil verwalten.");
+    throw new UserFacingError(
+      "Du kannst nur dein eigenes Personalprofil verwalten.",
+    );
 }
 
 export async function getStaffProfile(actor: StaffActor, profileId?: string) {
@@ -320,8 +326,8 @@ export async function executeStaffCommand(
               kitaId: actor.kitaId,
               role: actor.role,
               privacyPolicyAcceptedAt: { not: null },
-      emailVerifiedAt: { not: null },
+              emailVerifiedAt: { not: null },
-      disabledAt: null,
+              disabledAt: null,
             },
           });
           if (
@@ -419,7 +425,9 @@ export async function executeStaffCommand(
             if (
               profile.user &&
               (profile.user.kitaId !== actor.kitaId ||
-                profile.user.role !== UserRole.ERZIEHER)
+                !([UserRole.ERZIEHER, UserRole.ADMIN] as UserRole[]).includes(
+                  profile.user.role,
+                ))
             )
               throw new UserFacingError(
                 "Der verknüpfte Account gehört nicht zum Fachpersonal dieser Kita.",
@@ -440,7 +448,11 @@ export async function executeStaffCommand(
             return { ...invitation, educatorId: educator.id };
           }
           if (command === "emailPreference") {
-            if (actor.role !== UserRole.ERZIEHER)
+            if (
+              !(await tx.staffProfile.count({
+                where: { userId: actor.id, kitaId: actor.kitaId },
+              }))
+            )
               throw new UserFacingError(
                 "Diese Einstellung ist für Fachkräfte vorgesehen.",
               );
@@ -534,7 +546,9 @@ export async function executeStaffCommand(
               input.employmentEnd &&
               input.employmentEnd < input.employmentStart
             )
-              throw new UserFacingError("Das Beschäftigungsende liegt vor dem Beginn.");
+              throw new UserFacingError(
+                "Das Beschäftigungsende liegt vor dem Beginn.",
+              );
             if (
               input.trackingStart < input.employmentStart ||
               (input.employmentEnd && input.trackingStart > input.employmentEnd)
@@ -545,7 +559,8 @@ export async function executeStaffCommand(
             const educator = await tx.educator.findFirst({
               where: { id: input.educatorId, kitaId: actor.kitaId },
             });
-            if (!educator) throw new UserFacingError("Fachkraft nicht gefunden.");
+            if (!educator)
+              throw new UserFacingError("Fachkraft nicht gefunden.");
             const existing = await tx.staffProfile.findFirst({
               where: { educatorId: educator.id, kitaId: actor.kitaId },
               include: profileInclude,
@@ -591,7 +606,8 @@ export async function executeStaffCommand(
             where: { id: profileId, kitaId: actor.kitaId },
             include: profileInclude,
           });
-          if (!profile) throw new UserFacingError("Personalprofil nicht gefunden.");
+          if (!profile)
+            throw new UserFacingError("Personalprofil nicht gefunden.");
           assertStaffAccess(actor, profile);
           const holidays = new Set(
             (
@@ -631,7 +647,10 @@ export async function executeStaffCommand(
               for (const user of recipients) {
                 if (
                   !toAdmins &&
-                  (user.role !== UserRole.ERZIEHER || !user.staffDecisionEmails)
+                  (!(
+                    [UserRole.ERZIEHER, UserRole.ADMIN] as UserRole[]
+                  ).includes(user.role) ||
+                    !user.staffDecisionEmails)
                 )
                   continue;
                 const job = await tx.staffEmail.create({
@@ -719,7 +738,9 @@ export async function executeStaffCommand(
               input.employmentEnd &&
               input.employmentEnd < dateKey(profile.employmentStart)
             )
-              throw new UserFacingError("Das Beschäftigungsende liegt vor dem Beginn.");
+              throw new UserFacingError(
+                "Das Beschäftigungsende liegt vor dem Beginn.",
+              );
             if (
               input.employmentEnd &&
               (input.employmentEnd < dateKey(profile.trackingStart) ||
@@ -786,7 +807,9 @@ export async function executeStaffCommand(
               (profile.employmentEnd &&
                 input.date > dateKey(profile.employmentEnd))
             )
-              throw new UserFacingError("Der Tag liegt außerhalb der Beschäftigung.");
+              throw new UserFacingError(
+                "Der Tag liegt außerhalb der Beschäftigung.",
+              );
             if (input.remove)
               await tx.staffDayOverride.deleteMany({
                 where: { profileId, date: dateOnly(input.date) },
@@ -859,7 +882,9 @@ export async function executeStaffCommand(
               })
               .parse(data);
             if (input.date < dateKey(profile.trackingStart))
-              throw new UserFacingError("Korrekturen müssen ab Erfassungsbeginn liegen.");
+              throw new UserFacingError(
+                "Korrekturen müssen ab Erfassungsbeginn liegen.",
+              );
             await tx.staffAdjustment.create({
               data: {
                 profileId,
@@ -887,7 +912,8 @@ export async function executeStaffCommand(
               throw new UserFacingError("Zeiteintrag nicht gefunden.");
             if (existing) ensureDayEditable(profile, dateKey(existing.date));
             if (command === "deleteTime") {
-              if (!existing) throw new UserFacingError("Zeiteintrag nicht gefunden.");
+              if (!existing)
+                throw new UserFacingError("Zeiteintrag nicht gefunden.");
               await tx.staffTimeEntry.delete({ where: { id: existing.id } });
               await history(
                 "Arbeitszeit gelöscht",
@@ -1135,7 +1161,8 @@ export async function executeStaffCommand(
             const existing = data.id
               ? profile.leaves.find((l) => l.id === idSchema.parse(data.id))
               : undefined;
-            if (data.id && !existing) throw new UserFacingError("Antrag nicht gefunden.");
+            if (data.id && !existing)
+              throw new UserFacingError("Antrag nicht gefunden.");
             if (command === "leaveCancel") {
               if (
                 !existing ||
@@ -1182,7 +1209,9 @@ export async function executeStaffCommand(
                 !existing ||
                 !["PENDING", "CANCEL_REQUESTED"].includes(existing.status)
               )
-                throw new UserFacingError("Dieser Antrag ist nicht mehr offen.");
+                throw new UserFacingError(
+                  "Dieser Antrag ist nicht mehr offen.",
+                );
               const cancelling = existing.status === "CANCEL_REQUESTED";
               if (input.approve)
                 ensureRangeEditable(
@@ -1284,7 +1313,9 @@ export async function executeStaffCommand(
               .parse(data);
             if (input.kind === "SICKNESS") requireAdmin(actor);
             if (existing && existing.status !== "PENDING")
-              throw new UserFacingError("Nur offene Anträge können bearbeitet werden.");
+              throw new UserFacingError(
+                "Nur offene Anträge können bearbeitet werden.",
+              );
             if (input.startDate < dateKey(profile.trackingStart))
               throw new UserFacingError(
                 "Abwesenheiten bitte ab Erfassungsbeginn erfassen.",

tests/absence-policy.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  absenceDate,
+  absenceToday,
+  canEditOwnAbsence,
+  canManageKitaAbsences,
+} from "../src/lib/absence-policy";
+import { familyInvitationView } from "../src/lib/family-invitation-view";
+
+test("Abwesenheitsdatum akzeptiert echte Kalendertage und lehnt Überläufe ab", () => {
+  assert.equal(
+    absenceDate("2028-02-29").toISOString(),
+    "2028-02-29T00:00:00.000Z",
+  );
+  for (const value of [
+    "2026-02-29",
+    "2026-04-31",
+    "2026-13-01",
+    "2026-1-09",
+    "2026-10-09T12:00:00",
+    "invalid",
+  ])
+    assert.throws(() => absenceDate(value));
+});
+
+test("Die Datumsgrenze folgt Berlin auch über Mitternacht und die Zeitumstellung", () => {
+  assert.equal(absenceToday(new Date("2026-10-09T21:59:59Z")), "2026-10-09");
+  assert.equal(absenceToday(new Date("2026-10-09T22:00:00Z")), "2026-10-10");
+  assert.equal(absenceToday(new Date("2026-10-25T22:59:59Z")), "2026-10-25");
+  assert.equal(absenceToday(new Date("2026-10-25T23:00:00Z")), "2026-10-26");
+  assert.equal(canEditOwnAbsence("2026-10-09", "2026-10-09"), false);
+  assert.equal(canEditOwnAbsence("2026-10-10", "2026-10-09"), true);
+  assert.equal(canManageKitaAbsences("ELTERN"), false);
+  for (const role of ["ADMIN", "KOORDINATOR", "ERZIEHER"])
+    assert.equal(canManageKitaAbsences(role), true);
+});
+
+test("Einladungsanzeige unterscheidet Aktivierung, Fehler, Ablauf und laufenden Versand", () => {
+  const now = new Date("2026-10-09T12:00:00Z");
+  const base = {
+    expiresAt: new Date("2026-10-16T12:00:00Z"),
+    sentAt: null,
+    failed: false,
+    leaseUntil: null,
+    status: "PENDING",
+  };
+  assert.equal(familyInvitationView(null, null, now).status, "open");
+  assert.equal(
+    familyInvitationView(null, { ...base, failed: true }, now).status,
+    "failed",
+  );
+  assert.equal(
+    familyInvitationView(null, { ...base, expiresAt: now }, now).status,
+    "expired",
+  );
+  assert.equal(
+    familyInvitationView(null, { ...base, sentAt: now }, now).status,
+    "sent",
+  );
+  assert.equal(
+    familyInvitationView(
+      null,
+      { ...base, leaseUntil: new Date(now.getTime() + 1000) },
+      now,
+    ).status,
+    "sending",
+  );
+  assert.equal(
+    familyInvitationView(now, { ...base, failed: true }, now).status,
+    "active",
+  );
+});

tests/calendar-actions.integration.test.cjs

@@ -0,0 +1,193 @@
+/* eslint-disable @typescript-eslint/no-require-imports -- Test real actions with isolated request and mail boundaries. */
+const { test, before, beforeEach, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const ts = require('typescript');
+const { PrismaClient } = require('@prisma/client');
+const { randomUUID } = require('node:crypto');
+let prisma, current, fixture, edit, swap, accept;
+const tenants = [], emails = [];
+function loader(overrides = {}) {
+  const cache = new Map();
+  function load(file) {
+    file = path.resolve(file);
+    if (cache.has(file)) return cache.get(file).exports;
+    const mod = { exports: {} }; cache.set(file, mod);
+    const code = ts.transpileModule(fs.readFileSync(file, 'utf8'), {
+      compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS, jsx: ts.JsxEmit.ReactJSX, esModuleInterop: true },
+      fileName: file,
+    }).outputText;
+    const req = spec => {
+      if (Object.hasOwn(overrides, spec)) return overrides[spec];
+      if (spec === 'server-only') return {};
+      if (spec === '@/lib/prisma') return { prisma };
+      if (spec === 'next/headers') return { headers: async () => new Headers() };
+      if (spec === 'next/cache') return { revalidatePath() {} };
+      if (spec === 'next/navigation') return { redirect(url) { throw new Error(`REDIRECT:${url}`); }, notFound() { throw new Error('NOT_FOUND'); } };
+      if (spec.startsWith('@/') || spec.startsWith('.')) {
+        const target = spec.startsWith('@/') ? path.resolve('src', spec.slice(2)) : path.resolve(path.dirname(file), spec);
+        for (const suffix of ['.ts', '.tsx', '/index.ts']) if (fs.existsSync(target + suffix)) return load(target + suffix);
+      }
+      return require(spec);
+    };
+    vm.runInThisContext(`(function(require,module,exports){${code}\n})`, { filename: file })(req, mod, mod.exports);
+    return mod.exports;
+  }
+  return load;
+}
+
+before(async () => {
+  const raw = process.env.TEST_DATABASE_URL;
+  if (!raw) throw new Error('TEST_DATABASE_URL muss ausdrücklich auf die lokale kita_quickwins_test zeigen.');
+  const url = new URL(raw);
+  assert.ok(['127.0.0.1','localhost'].includes(url.hostname));
+  assert.equal(url.pathname,'/kita_quickwins_test');
+  prisma = new PrismaClient({ datasourceUrl: raw });
+  const load = loader({
+    '@/lib/auth-utils': {
+      requireKitaSession: async () => ({ user: current }),
+      requireRole: async roles => { assert.ok(roles.includes(current.role)); return { user: current }; },
+    },
+    '@/lib/mail': { sendAppEmail: async input => { emails.push(input); return { success: true }; } },
+  });
+  ({ updateMitbringsel: edit, createNotdienstSwapRequest: swap, acceptNotdienstSwapRequest: accept } = load('src/app/dashboard/kalender/actions.ts'));
+});
+after(async () => {
+  if (!prisma) return;
+  await prisma.kita.deleteMany({ where: { id: { in: tenants } } });
+  await prisma.$disconnect();
+});
+beforeEach(async () => {
+  emails.length = 0;
+  const kita = await prisma.kita.create({ data: { name: 'Kalender-Test', slug: `calendar-test-${randomUUID()}` } }); tenants.push(kita.id);
+  const family = await prisma.family.create({ data: { kitaId: kita.id, name: 'Eigener Haushalt' } });
+  const targetFamily = await prisma.family.create({ data: { kitaId: kita.id, name: 'Angefragter Haushalt' } });
+  const makeUser = (role, familyId) => prisma.user.create({ data: { kitaId: kita.id, familyId, role, email: `${randomUUID()}@example.invalid`, firstName: 'Test', lastName: role, passwordHash: 'test', emailVerifiedAt: new Date(), privacyPolicyAcceptedAt: new Date() } });
+  const owner = await makeUser('ELTERN',family.id);
+  const targetAdmin = await makeUser('ADMIN',targetFamily.id);
+  const targetCoord = await makeUser('KOORDINATOR',targetFamily.id);
+  const event = await prisma.termin.create({ data: { kitaId: kita.id, title: 'Sommerfest', type: 'KITA_FEST', status: 'CONFIRMED', mitbringselListEnabled: true, startDate: new Date('2030-11-04T10:00:00Z'), endDate: new Date('2030-11-04T16:00:00Z') } });
+  const item = await prisma.mitbringselItem.create({ data: { kitaId: kita.id, terminId: event.id, userId: owner.id, content: 'Nudelsalat' } });
+  const child = await prisma.child.create({ data: { kitaId: kita.id, familyId: family.id, firstName: 'Eigenes Kind', lastName: 'Test' } });
+  const targetChild = await prisma.child.create({ data: { kitaId: kita.id, familyId: targetFamily.id, firstName: 'Anderes Kind', lastName: 'Test' } });
+  const plan = await prisma.notdienstPlan.create({ data: { kitaId: kita.id, year: 2030, month: 11, status: 'PUBLISHED' } });
+  const offered = await prisma.notdienstAssignment.create({ data: { kitaId: kita.id, planId: plan.id, childId: child.id, date: new Date('2030-11-04T00:00:00Z') } });
+  const target = await prisma.notdienstAssignment.create({ data: { kitaId: kita.id, planId: plan.id, childId: targetChild.id, date: new Date('2030-11-05T00:00:00Z') } });
+  fixture = { kita, family, targetFamily, owner, targetAdmin, targetCoord, event, item, child, targetChild, plan, offered, target };
+  current = owner;
+});
+const edited = content => edit({ itemId: fixture.item.id, content });
+const swapPayload = () => ({ targetAssignmentId: fixture.target.id, offeredAssignmentId: fixture.offered.id, message: 'Kannst du tauschen?' });
+const storedItem = () => prisma.mitbringselItem.findUniqueOrThrow({ where: { id: fixture.item.id } });
+async function setRole(role) { current = await prisma.user.update({ where: { id: fixture.owner.id }, data: { role } }); }
+
+test('Eigener Beitrag wird direkt bearbeitet und behält Autor, Termin und ID', async () => {
+  assert.equal((await edited('  Kartoffelsalat  ')).success,true);
+  const item = await storedItem();
+  assert.equal(item.content,'Kartoffelsalat');
+  assert.equal(item.userId,fixture.owner.id);
+  assert.equal(item.terminId,fixture.event.id);
+  assert.equal(await prisma.mitbringselItem.count({ where: { terminId: fixture.event.id } }),1);
+});
+for (const [label,content] of [['leer',''],['Leerzeichen','   '],['zu lang','a'.repeat(501)]]) {
+  test(`Ungültiger Beitrag (${label}) erhält den alten Inhalt`, async () => {
+    assert.ok((await edited(content)).error);
+    assert.equal((await storedItem()).content,'Nudelsalat');
+  });
+}
+test('500 Zeichen werden vollständig gespeichert', async () => {
+  assert.equal((await edited('a'.repeat(500))).success,true);
+  assert.equal((await storedItem()).content.length,500);
+});
+for (const role of ['ELTERN','ADMIN','KOORDINATOR']) {
+  test(`${role} kann fremde Mitbringbeiträge nicht bearbeiten`, async () => {
+    current = { ...fixture.targetAdmin, role };
+    assert.match((await edited('Fremde Änderung')).error,/nur eigene/);
+    assert.equal((await storedItem()).content,'Nudelsalat');
+  });
+}
+for (const role of ['ADMIN','KOORDINATOR']) {
+  test(`${role} kann einen eigenen Mitbringbeitrag bearbeiten`, async () => {
+    await setRole(role);
+    assert.equal((await edited('Gemüsesalat')).success,true);
+  });
+}
+test('Mitbringbeiträge einer anderen Kita sind nicht bearbeitbar', async () => {
+  const kita = await prisma.kita.create({ data: { name: 'Andere Kita', slug: randomUUID() } }); tenants.push(kita.id);
+  current = { ...fixture.owner, kitaId: kita.id };
+  assert.ok((await edited('Tenant-Wechsel')).error);
+  assert.equal((await storedItem()).content,'Nudelsalat');
+});
+for (const status of ['PENDING','REJECTED']) {
+  test(`Ein ${status}-Termin erlaubt keine Bearbeitung`, async () => {
+    await prisma.termin.update({ where: { id: fixture.event.id }, data: { status } });
+    assert.match((await edited('Brot')).error,/nicht mehr aktiv/);
+    assert.equal((await storedItem()).content,'Nudelsalat');
+  });
+}
+test('Deaktivierte Mitbringliste schützt vorhandene Beiträge', async () => {
+  await prisma.termin.update({ where: { id: fixture.event.id }, data: { mitbringselListEnabled: false } });
+  assert.ok((await edited('Brot')).error);
+  assert.equal((await storedItem()).content,'Nudelsalat');
+});
+test('Gelöschter Beitrag wird nicht neu angelegt', async () => {
+  await prisma.mitbringselItem.delete({ where: { id: fixture.item.id } });
+  assert.ok((await edited('Brot')).error);
+  assert.equal(await prisma.mitbringselItem.count({ where: { id: fixture.item.id } }),0);
+});
+for (const role of ['ELTERN','ADMIN','KOORDINATOR']) {
+  test(`${role} fragt mit eigenem Haushalt einen Diensttausch an und benachrichtigt Eltern mit Verwaltungsrolle`, async () => {
+    await setRole(role);
+    assert.equal((await swap(swapPayload())).success,true);
+    const request = await prisma.notdienstSwapRequest.findFirstOrThrow({ where: { kitaId: fixture.kita.id } });
+    assert.equal(request.requesterUserId,current.id);
+    assert.equal(request.requesterFamilyId,fixture.family.id);
+    assert.deepEqual(emails.map(e => e.to).sort(),[fixture.targetAdmin.email,fixture.targetCoord.email].sort());
+    current = fixture.targetCoord;
+    assert.equal((await accept(request.id)).success,true);
+    assert.equal((await prisma.notdienstAssignment.findUniqueOrThrow({ where: { id: fixture.target.id } })).childId,fixture.child.id);
+    assert.equal((await prisma.notdienstAssignment.findUniqueOrThrow({ where: { id: fixture.offered.id } })).childId,fixture.targetChild.id);
+    assert.ok(emails.some(e => e.to === fixture.owner.email && e.subject === 'Notdienst-Tausch bestätigt'));
+  });
+}
+for (const role of ['ADMIN','KOORDINATOR']) {
+  test(`${role} ohne eigenen Haushalt erhält kein Tauschrecht`, async () => {
+    await setRole(role); current = { ...current, familyId: null };
+    assert.ok((await swap(swapPayload())).error);
+    assert.equal(await prisma.notdienstSwapRequest.count({ where: { kitaId: fixture.kita.id } }),0);
+  });
+}
+test('Erzieherrolle erhält auch mit einem Haushalt kein Tauschrecht', async () => {
+  await setRole('ERZIEHER');
+  assert.ok((await swap(swapPayload())).error);
+});
+test('Admin kann keine fremde Einteilung als eigenes Angebot verwenden', async () => {
+  await setRole('ADMIN');
+  assert.match((await swap({ targetAssignmentId: fixture.offered.id, offeredAssignmentId: fixture.target.id })).error,/nur eigene/);
+  assert.equal(await prisma.notdienstSwapRequest.count({ where: { kitaId: fixture.kita.id } }),0);
+});
+test('Koordination kann keinen Tausch innerhalb des eigenen Haushalts starten', async () => {
+  await setRole('KOORDINATOR');
+  await prisma.notdienstAssignment.update({ where: { id: fixture.target.id }, data: { childId: fixture.child.id } });
+  assert.match((await swap(swapPayload())).error,/eigenen Haushalt/);
+});
+test('Aktiver Notdienstalarm blockiert auch einen Admin-Tausch', async () => {
+  await setRole('ADMIN');
+  await prisma.notdienstAlarm.create({ data: { kitaId: fixture.kita.id, assignmentId: fixture.offered.id, activeAssignmentId: fixture.offered.id, familyId: fixture.family.id, familyName: fixture.family.name, childName: 'Eigenes Kind', date: fixture.offered.date, expiresAt: new Date('2030-11-04T18:00:00Z'), deadline: new Date('2030-11-04T10:00:00Z') } });
+  assert.match((await swap(swapPayload())).error,/aktiver Alarmierung/);
+});
+test('Unverifizierte und deaktivierte Konten bleiben vom Tausch-Mailversand ausgeschlossen', async () => {
+  await prisma.user.update({ where: { id: fixture.targetAdmin.id }, data: { emailVerifiedAt: null } });
+  await prisma.user.update({ where: { id: fixture.targetCoord.id }, data: { disabledAt: new Date() } });
+  await setRole('ADMIN');
+  assert.equal((await swap(swapPayload())).success,true);
+  assert.equal(emails.length,0);
+});
+test('Doppelte offene Anfrage bleibt auch für Koordination gesperrt', async () => {
+  await setRole('KOORDINATOR');
+  assert.equal((await swap(swapPayload())).success,true);
+  assert.match((await swap(swapPayload())).error,/offene Tauschanfrage/);
+  assert.equal(await prisma.notdienstSwapRequest.count({ where: { kitaId: fixture.kita.id } }),1);
+});

tests/family-absence-flows.integration.test.ts

@@ -0,0 +1,786 @@
+import assert from "node:assert/strict";
+import { mock, test } from "node:test";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { PrismaClient, UserRole } from "@prisma/client";
+import { hashToken } from "../src/lib/tokens";
+import { absenceDate, absenceToday } from "../src/lib/absence-policy";
+
+test(
+  "Familieneinladungen und Abwesenheiten gegen isoliertes PostgreSQL",
+  { skip: !process.env.TEST_DATABASE_URL },
+  async (t) => {
+    const url = new URL(process.env.TEST_DATABASE_URL!);
+    assert.ok(["127.0.0.1", "localhost"].includes(url.hostname));
+    assert.ok(
+      /test/.test(url.pathname),
+      "Nur ausdrücklich bezeichnete Testdatenbanken",
+    );
+    process.env.DATABASE_URL = url.toString();
+    process.env.NEXT_PUBLIC_SITE_URL = "http://127.0.0.1:3010";
+    const db = new PrismaClient();
+    const suffix = randomUUID();
+    const kitaId = `flow-test-${suffix}`,
+      otherKitaId = `other-flow-${suffix}`;
+    let actor: {
+      id: string;
+      kitaId: string;
+      familyId: string | null;
+      role: UserRole;
+    };
+    const deliveries: { to: string; key: string | undefined }[] = [];
+    const fail = new Set<string>();
+    let throwTransport = false;
+    const refreshed: string[] = [];
+    const moduleMock = mock as typeof mock & {
+      module: (
+        name: string,
+        options: { namedExports: Record<string, unknown> },
+      ) => unknown;
+    };
+    moduleMock.module("../src/lib/auth-utils.ts", {
+      namedExports: {
+        requireKitaSession: async () => ({ user: actor }),
+        requireRole: async (roles: UserRole[]) => {
+          assert.ok(roles.includes(actor.role), "Rolle muss erlaubt sein");
+          return { user: actor };
+        },
+      },
+    });
+    moduleMock.module("next/cache", {
+      namedExports: { revalidatePath: (path: string) => refreshed.push(path) },
+    });
+    moduleMock.module("../src/auth.ts", {
+      namedExports: { signIn: async () => {} },
+    });
+    moduleMock.module("../src/lib/mail.ts", {
+      namedExports: {
+        sendAppEmail: async (input: {
+          to: string;
+          idempotencyKey?: string;
+        }) => {
+          deliveries.push({ to: input.to, key: input.idempotencyKey });
+          if (throwTransport) throw new Error("Simulierter Transportfehler");
+          return fail.has(input.to)
+            ? { success: false, error: "Simulierter Mailfehler" }
+            : { success: true, id: "test-only" };
+        },
+        getAppEmailConfigError: () => "Test ohne echte Mail-Konfiguration",
+      },
+    });
+    const load = createRequire(
+      resolve("tests/family-absence-flows.integration.test.ts"),
+    );
+    const familyActions = load(
+      "../src/app/dashboard/families/actions",
+    ) as typeof import("../src/app/dashboard/families/actions");
+    const absences = load(
+      "../src/actions/absences",
+    ) as typeof import("../src/actions/absences");
+    const { acceptInviteAction } = load(
+      "../src/app/invite/[token]/actions",
+    ) as typeof import("../src/app/invite/[token]/actions");
+    const { prisma } = load(
+      "../src/lib/prisma",
+    ) as typeof import("../src/lib/prisma");
+    const today = absenceToday();
+    const day = (offset: number) =>
+      new Date(absenceDate(today).getTime() + offset * 86_400_000)
+        .toISOString()
+        .slice(0, 10);
+    const actorOf = (user: {
+      id: string;
+      kitaId: string | null;
+      familyId: string | null;
+      role: UserRole;
+    }) => ({ ...user, kitaId: user.kitaId! });
+    const createUser = (
+      role: UserRole,
+      tenant = kitaId,
+      familyId: string | null = null,
+    ) =>
+      db.user.create({
+        data: {
+          kitaId: tenant,
+          familyId,
+          role,
+          email: `${randomUUID()}@example.test`,
+          passwordHash: "",
+          firstName: "Test",
+          lastName: role,
+          privacyPolicyAcceptedAt: new Date(),
+        },
+      });
+    const form = (name: string, emails: string[]) => {
+      const data = new FormData();
+      for (const [key, value] of Object.entries({
+        familyName: name,
+        parent1FirstName: "Eva",
+        parent1LastName: "Test",
+        parent1Email: emails[0],
+        childCount: "1",
+        childFirstName_0: "Kind",
+        childLastName_0: "Test",
+      }))
+        data.set(key, value);
+      if (emails[1])
+        for (const [key, value] of Object.entries({
+          parent2FirstName: "Jan",
+          parent2LastName: "Test",
+          parent2Email: emails[1],
+        }))
+          data.set(key, value);
+      return data;
+    };
+    const createAbsence = (
+      childId: string,
+      start: number,
+      end = start,
+      tenant = kitaId,
+    ) =>
+      db.absence.create({
+        data: {
+          kitaId: tenant,
+          childId,
+          startDate: absenceDate(day(start)),
+          endDate: absenceDate(day(end)),
+          reason: "ILLNESS",
+        },
+      });
+    const identity = (row: { id: string; updatedAt: Date }) => ({
+      id: row.id,
+      updatedAt: row.updatedAt.toISOString(),
+    });
+    try {
+      await db.kita.createMany({
+        data: [
+          { id: kitaId, name: "Ablauftest", slug: kitaId },
+          { id: otherKitaId, name: "Andere Kita", slug: otherKitaId },
+        ],
+      });
+      const admin = await createUser("ADMIN");
+      actor = actorOf(admin);
+      const emails = [
+        `failure-${suffix}@example.test`,
+        `success-${suffix}@example.test`,
+      ];
+      fail.add(emails[0]);
+      let invitedUsers: Awaited<ReturnType<typeof db.user.findMany>> = [];
+
+      await t.test(
+        "Mailfehler lässt Familie erfolgreich gespeichert; alle Empfänger werden versucht",
+        async () => {
+          const result = await familyActions.addFamilyAction(
+            {},
+            form("Eingeladen", emails),
+          );
+          assert.equal(result.success, true);
+          assert.ok(result.warning);
+          assert.equal(result.errors, undefined);
+          assert.equal(
+            await db.family.count({ where: { kitaId, name: "Eingeladen" } }),
+            1,
+          );
+          assert.ok(refreshed.includes("/dashboard/families"));
+          invitedUsers = await db.user.findMany({
+            where: { email: { in: emails } },
+          });
+          assert.equal(invitedUsers.length, 2);
+          const jobs = await db.invitation.findMany({
+            where: { userId: { in: invitedUsers.map((user) => user.id) } },
+          });
+          assert.equal(jobs.length, 2);
+          assert.equal(
+            jobs.find((job) => job.email === emails[0])!.failed,
+            true,
+          );
+          assert.ok(jobs.find((job) => job.email === emails[1])!.sentAt);
+          assert.equal(deliveries.length, 2);
+          const repeated = await familyActions.addFamilyAction(
+            {},
+            form("Eingeladen", emails),
+          );
+          assert.ok(repeated.errors);
+          assert.equal(
+            await db.family.count({ where: { kitaId, name: "Eingeladen" } }),
+            1,
+          );
+        },
+      );
+
+      await t.test(
+        "Gezielte Wiederholung behält den gültigen fehlgeschlagenen Link und erstellt keine Person erneut",
+        async () => {
+          const user = invitedUsers.find((user) => user.email === emails[0])!;
+          const before = await db.invitation.findUniqueOrThrow({
+            where: { userId: user.id },
+          });
+          fail.clear();
+          const result = await familyActions.resendFamilyInvitationAction(
+            user.id,
+          );
+          assert.equal(result.success, true);
+          assert.equal(result.warning, undefined);
+          const after = await db.invitation.findUniqueOrThrow({
+            where: { userId: user.id },
+          });
+          assert.equal(after.token, before.token);
+          assert.equal(after.attempts, 2);
+          assert.equal(after.failed, false);
+          assert.ok(after.sentAt);
+          assert.equal(deliveries.length, 3);
+          assert.equal(deliveries[2].key, deliveries[0].key);
+          assert.equal(
+            await db.user.count({ where: { email: user.email } }),
+            1,
+          );
+          const again = await familyActions.resendFamilyInvitationAction(
+            user.id,
+          );
+          assert.ok(again.error);
+          assert.equal(deliveries.length, 3);
+        },
+      );
+
+      await t.test(
+        "Abgelaufener Link wird erneuert und alter Token ungültig",
+        async () => {
+          const user = invitedUsers[0];
+          const before = await db.invitation.update({
+            where: { userId: user.id },
+            data: {
+              expiresAt: absenceDate(day(-1)),
+              sentAt: absenceDate(day(-2)),
+            },
+          });
+          await db.verificationToken.update({
+            where: { token: hashToken(before.token) },
+            data: { expires: absenceDate(day(-1)) },
+          });
+          assert.equal(
+            (await familyActions.resendFamilyInvitationAction(user.id)).success,
+            true,
+          );
+          const after = await db.invitation.findUniqueOrThrow({
+            where: { userId: user.id },
+          });
+          assert.notEqual(after.token, before.token);
+          assert.ok(after.expiresAt > new Date());
+          assert.equal(
+            await db.verificationToken.findUnique({
+              where: { token: hashToken(before.token) },
+            }),
+            null,
+          );
+        },
+      );
+
+      await t.test(
+        "Aktivierte und kita-fremde Konten werden nicht angeschrieben",
+        async () => {
+          const user = invitedUsers[0];
+          await db.user.update({
+            where: { id: user.id },
+            data: { emailVerifiedAt: new Date() },
+          });
+          const before = deliveries.length;
+          assert.ok(
+            (await familyActions.resendFamilyInvitationAction(user.id)).error,
+          );
+          const foreignFamily = await db.family.create({
+            data: { kitaId: otherKitaId, name: "Fremd" },
+          });
+          const foreign = await createUser(
+            "ELTERN",
+            otherKitaId,
+            foreignFamily.id,
+          );
+          assert.ok(
+            (await familyActions.resendFamilyInvitationAction(foreign.id))
+              .error,
+          );
+          assert.equal(deliveries.length, before);
+        },
+      );
+
+      await t.test(
+        "Hinzufügen eines Elternteils bei Mailfehler ist abgeschlossen und wiederholbar",
+        async () => {
+          const first = `${randomUUID()}@example.test`;
+          assert.equal(
+            (await familyActions.addFamilyAction({}, form("Ergänzen", [first])))
+              .success,
+            true,
+          );
+          const family = await db.family.findFirstOrThrow({
+            where: { kitaId, name: "Ergänzen" },
+            include: { users: true, children: true },
+          });
+          const second = `${randomUUID()}@example.test`;
+          fail.add(second);
+          const result = await familyActions.updateFamilyAction({
+            familyId: family.id,
+            familyName: family.name,
+            parents: family.users,
+            children: family.children,
+            newParents: [{ firstName: "Neu", lastName: "Test", email: second }],
+          });
+          assert.equal(result.success, true);
+          assert.ok(result.warning);
+          assert.equal(result.error, undefined);
+          assert.equal(
+            await db.user.count({ where: { familyId: family.id } }),
+            2,
+          );
+          fail.clear();
+          const parent = await db.user.findUniqueOrThrow({
+            where: { email: second },
+          });
+          assert.equal(
+            (await familyActions.resendFamilyInvitationAction(parent.id))
+              .success,
+            true,
+          );
+        },
+      );
+
+      await t.test(
+        "Adresskorrektur eines offenen Kontos erneuert die Einladung für die neue Adresse",
+        async () => {
+          const family = await db.family.findFirstOrThrow({
+            where: { kitaId, name: "Eingeladen" },
+            include: { users: true, children: true },
+          });
+          const pending = family.users.find((user) => !user.emailVerifiedAt)!;
+          const old = await db.invitation.findUniqueOrThrow({
+            where: { userId: pending.id },
+          });
+          const email = `${randomUUID()}@example.test`;
+          const result = await familyActions.updateFamilyAction({
+            familyId: family.id,
+            familyName: family.name,
+            parents: family.users.map((user) => ({
+              ...user,
+              email: user.id === pending.id ? email : user.email,
+            })),
+            children: family.children,
+          });
+          assert.equal(result.success, true);
+          const renewed = await db.invitation.findUniqueOrThrow({
+            where: { userId: pending.id },
+          });
+          assert.equal(renewed.email, email);
+          assert.notEqual(renewed.token, old.token);
+          assert.equal(
+            await db.verificationToken.findUnique({
+              where: { token: hashToken(old.token) },
+            }),
+            null,
+          );
+          assert.equal(deliveries.at(-1)!.to, email);
+        },
+      );
+
+      await t.test(
+        "Transportausnahme wird gespeichert statt den Familienvorgang zurückzuwerfen",
+        async () => {
+          throwTransport = true;
+          const result = await familyActions.addFamilyAction(
+            {},
+            form("Transportfehler", [`${randomUUID()}@example.test`]),
+          );
+          assert.equal(result.success, true);
+          assert.ok(result.warning);
+          throwTransport = false;
+        },
+      );
+
+      await t.test(
+        "Alte Einladungen werden übernommen; paralleles erneutes Senden verschickt nur einmal und Aktivierung schließt den Status ab",
+        async () => {
+          const household = await db.family.create({
+            data: { kitaId, name: "Alte Einladung" },
+          });
+          const user = await createUser("ELTERN", kitaId, household.id);
+          const oldToken = randomUUID();
+          await db.verificationToken.create({
+            data: {
+              identifier: user.id,
+              token: hashToken(oldToken),
+              expires: absenceDate(day(-1)),
+            },
+          });
+          await db.invitation.create({
+            data: {
+              kitaId,
+              email: user.email,
+              token: oldToken,
+              expiresAt: absenceDate(day(-1)),
+            },
+          });
+          const before = deliveries.length;
+          const results = await Promise.all([
+            familyActions.resendFamilyInvitationAction(user.id),
+            familyActions.resendFamilyInvitationAction(user.id),
+          ]);
+          assert.ok(results.some((result) => result.success));
+          assert.equal(deliveries.length, before + 1);
+          assert.equal(
+            await db.invitation.count({ where: { userId: user.id } }),
+            1,
+          );
+          const job = await db.invitation.findUniqueOrThrow({
+            where: { userId: user.id },
+          });
+          assert.equal(
+            await db.verificationToken.findUnique({
+              where: { token: hashToken(oldToken) },
+            }),
+            null,
+          );
+          const activation = new FormData();
+          activation.set("token", job.token);
+          activation.set("password", "Test-only-password-2026");
+          activation.set("confirmPassword", "Test-only-password-2026");
+          activation.set("acceptPrivacyPolicy", "on");
+          await acceptInviteAction({ attempt: 0 }, activation);
+          assert.ok(
+            (await db.user.findUniqueOrThrow({ where: { id: user.id } }))
+              .emailVerifiedAt,
+          );
+          assert.equal(
+            (
+              await db.invitation.findUniqueOrThrow({
+                where: { userId: user.id },
+              })
+            ).status,
+            "ACCEPTED",
+          );
+          assert.equal(
+            await db.verificationToken.findUnique({
+              where: { token: hashToken(job.token) },
+            }),
+            null,
+          );
+        },
+      );
+
+      const ownFamily = await db.family.create({
+        data: { kitaId, name: "Eigener Haushalt" },
+      });
+      const otherFamily = await db.family.create({
+        data: { kitaId, name: "Anderer Haushalt" },
+      });
+      const parent = await createUser("ELTERN", kitaId, ownFamily.id);
+      const child = await db.child.create({
+        data: {
+          kitaId,
+          familyId: ownFamily.id,
+          firstName: "Eigen",
+          lastName: "Kind",
+        },
+      });
+      const otherChild = await db.child.create({
+        data: {
+          kitaId,
+          familyId: otherFamily.id,
+          firstName: "Fremd",
+          lastName: "Kind",
+        },
+      });
+      actor = actorOf(parent);
+      let future = await createAbsence(child.id, 3, 4);
+
+      await t.test(
+        "Eltern bearbeiten zukünftige Meldungen und die eigene Tagesgrenze wird eingehalten",
+        async () => {
+          const result = await absences.updateAbsence({
+            ...identity(future),
+            startDate: day(5),
+            endDate: day(6),
+            reason: "VACATION",
+            note: "Korrigiert",
+          });
+          assert.equal(result.success, true);
+          future = await db.absence.findUniqueOrThrow({
+            where: { id: future.id },
+          });
+          assert.equal(future.startDate.toISOString().slice(0, 10), day(5));
+          assert.equal(future.note, "Korrigiert");
+          assert.ok(refreshed.includes("/dashboard/abwesenheiten"));
+          assert.ok(
+            (
+              await absences.updateAbsence({
+                ...identity(future),
+                startDate: today,
+                endDate: day(6),
+                reason: "VACATION",
+              })
+            ).error,
+          );
+        },
+      );
+
+      await t.test(
+        "Begonnene Mehrtagesmeldungen bleiben für Eltern vollständig unveränderbar",
+        async () => {
+          const running = await createAbsence(child.id, -1, 1);
+          assert.ok(
+            (
+              await absences.updateAbsence({
+                ...identity(running),
+                startDate: day(1),
+                endDate: day(2),
+                reason: "OTHER",
+              })
+            ).error,
+          );
+          assert.ok((await absences.deleteAbsence(identity(running))).error);
+          assert.equal(
+            await db.absence.count({ where: { id: running.id } }),
+            1,
+          );
+        },
+      );
+
+      await t.test(
+        "Andere Haushalte und Kitas bleiben bei Änderungen und Rücknahmen geschützt",
+        async () => {
+          const other = await createAbsence(otherChild.id, 10);
+          assert.ok((await absences.deleteAbsence(identity(other))).error);
+          assert.ok(
+            (
+              await absences.updateAbsence({
+                ...identity(other),
+                startDate: day(11),
+                endDate: day(11),
+                reason: "OTHER",
+              })
+            ).error,
+          );
+          actor = { ...actor, kitaId: otherKitaId };
+          assert.ok((await absences.deleteAbsence(identity(future))).error);
+          actor = actorOf(parent);
+          await assert.rejects(() =>
+            absences.getDailyAbsences({ date: today }),
+          );
+        },
+      );
+
+      await t.test(
+        "Ungültige Daten, Überschneidungen und veraltete Bearbeitungsstände werden abgewiesen",
+        async () => {
+          await createAbsence(child.id, 8, 9);
+          assert.ok(
+            (
+              await absences.updateAbsence({
+                ...identity(future),
+                startDate: day(8),
+                endDate: day(8),
+                reason: "OTHER",
+              })
+            ).error,
+          );
+          assert.ok(
+            (
+              await absences.updateAbsence({
+                ...identity(future),
+                startDate: "2026-02-30",
+                endDate: day(8),
+                reason: "OTHER",
+              })
+            ).error,
+          );
+          assert.ok(
+            (
+              await absences.updateAbsence({
+                ...identity(future),
+                startDate: day(7),
+                endDate: day(6),
+                reason: "OTHER",
+              })
+            ).error,
+          );
+          assert.ok(
+            (
+              await absences.deleteAbsence({
+                id: future.id,
+                updatedAt: "2000-01-01T00:00:00.000Z",
+              })
+            ).error,
+          );
+          assert.equal(await db.absence.count({ where: { id: future.id } }), 1);
+        },
+      );
+
+      await t.test(
+        "Gleichzeitige Abmeldungen erzeugen höchstens eine überlappende Meldung",
+        async () => {
+          const payload = {
+            childId: child.id,
+            startDate: day(20),
+            endDate: day(22),
+            reason: "ILLNESS",
+          };
+          const results = await Promise.all([
+            absences.reportAbsence(payload),
+            absences.reportAbsence(payload),
+          ]);
+          assert.equal(results.filter((result) => result.success).length, 1);
+          assert.equal(results.filter((result) => result.error).length, 1);
+          assert.equal(
+            await db.absence.count({
+              where: { childId: child.id, startDate: absenceDate(day(20)) },
+            }),
+            1,
+          );
+          assert.ok(
+            (
+              await absences.reportAbsence({
+                ...payload,
+                startDate: day(-2),
+                endDate: day(-2),
+              })
+            ).error,
+          );
+          assert.ok(
+            (
+              await absences.reportAbsence({
+                ...payload,
+                childId: otherChild.id,
+              })
+            ).error,
+          );
+        },
+      );
+
+      await t.test(
+        "Kita-Team korrigiert laufende Meldungen ohne eigenen Haushalt; Eltern ziehen zukünftige zurück",
+        async () => {
+          const running = await db.absence.findFirstOrThrow({
+            where: { childId: child.id, startDate: absenceDate(day(-1)) },
+          });
+          for (const role of [
+            "ADMIN",
+            "KOORDINATOR",
+            "ERZIEHER",
+          ] as UserRole[]) {
+            const team = role === "ADMIN" ? admin : await createUser(role);
+            actor = actorOf(team);
+            const latest = await db.absence.findUniqueOrThrow({
+              where: { id: running.id },
+            });
+            assert.equal(
+              (
+                await absences.updateAbsence({
+                  ...identity(latest),
+                  startDate: day(-1),
+                  endDate: day(2),
+                  reason: "OTHER",
+                  note: role,
+                })
+              ).success,
+              true,
+            );
+            assert.equal(
+              (await absences.getDailyAbsences({ date: today })).absences![0]
+                .startDate,
+              day(-1),
+            );
+          }
+          actor = actorOf(parent);
+          assert.equal(
+            (await absences.deleteAbsence(identity(future))).success,
+            true,
+          );
+          assert.equal(
+            await db.absence.findUnique({ where: { id: future.id } }),
+            null,
+          );
+        },
+      );
+
+      await t.test(
+        "Ein veraltetes Rollen-Token verleiht keine Teamrechte",
+        async () => {
+          actor = { ...actorOf(parent), role: "ADMIN" };
+          const running = await db.absence.findFirstOrThrow({
+            where: { childId: child.id, startDate: absenceDate(day(-1)) },
+          });
+          assert.ok((await absences.deleteAbsence(identity(running))).error);
+          assert.ok(
+            (
+              await familyActions.resendFamilyInvitationAction(
+                invitedUsers[1].id,
+              )
+            ).error,
+          );
+        },
+      );
+      await t.test(
+        "Additives Upgrade funktioniert auf leerem und bestehendem Schema und ist wiederholbar",
+        async () => {
+          const sql = await readFile(
+            resolve("deploy/sql/familieneinladungen.sql"),
+            "utf8",
+          );
+          const schema = `upgrade_test_${suffix.replaceAll("-", "")}`;
+          await db.$executeRawUnsafe(`CREATE SCHEMA "${schema}"`);
+          try {
+            await db.$transaction(async (tx) => {
+              await tx.$executeRawUnsafe(
+                `SET LOCAL search_path TO "${schema}"`,
+              );
+              await tx.$executeRawUnsafe(sql);
+              const fresh = await tx.$queryRawUnsafe<
+                { relation: string | null }[]
+              >("SELECT to_regclass('invitations')::text AS relation");
+              assert.equal(fresh[0].relation, null);
+              await tx.$executeRawUnsafe(
+                'CREATE TABLE "users" ("id" TEXT PRIMARY KEY)',
+              );
+              await tx.$executeRawUnsafe(
+                'CREATE TABLE "invitations" ("id" TEXT PRIMARY KEY, "token" TEXT NOT NULL)',
+              );
+              await tx.$executeRawUnsafe(
+                "INSERT INTO \"invitations\" (\"id\", \"token\") VALUES ('a', 'old-a'), ('b', 'old-b')",
+              );
+              await tx.$executeRawUnsafe(sql);
+              await tx.$executeRawUnsafe(sql);
+              const rows = await tx.$queryRawUnsafe<
+                {
+                  token: string;
+                  userId: string | null;
+                  failed: boolean;
+                  attempts: number;
+                }[]
+              >(
+                'SELECT "token", "userId", "failed", "attempts" FROM "invitations" ORDER BY "id"',
+              );
+              assert.deepEqual(rows, [
+                { token: "old-a", userId: null, failed: false, attempts: 0 },
+                { token: "old-b", userId: null, failed: false, attempts: 0 },
+              ]);
+            });
+          } finally {
+            await db.$executeRawUnsafe(`DROP SCHEMA "${schema}" CASCADE`);
+          }
+        },
+      );
+    } finally {
+      const users = await db.user.findMany({
+        where: { kitaId: { in: [kitaId, otherKitaId] } },
+        select: { id: true },
+      });
+      await db.verificationToken.deleteMany({
+        where: { identifier: { in: users.map((user) => user.id) } },
+      });
+      await db.kita.deleteMany({
+        where: { id: { in: [kitaId, otherKitaId] } },
+      });
+      await Promise.all([db.$disconnect(), prisma.$disconnect()]);
+    }
+  },
+);

tests/kita-roles.integration.test.cjs

@@ -0,0 +1,599 @@
+/* eslint-disable @typescript-eslint/no-require-imports -- Test real server code with isolated request and transport boundaries. */
+const { test, before, after, beforeEach } = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+const ts = require("typescript");
+const { PrismaClient } = require("@prisma/client");
+const { randomUUID } = require("node:crypto");
+let prisma,
+  current,
+  f,
+  change,
+  changeAction,
+  remove,
+  support,
+  updateFamily,
+  alarms,
+  alarmMail,
+  staff,
+  staffMail,
+  assign;
+const emails = [];
+const tenants = [],
+  looseUsers = [];
+function loader(overrides = {}) {
+  const cache = new Map();
+  function load(file) {
+    file = path.resolve(file);
+    if (cache.has(file)) return cache.get(file).exports;
+    const mod = { exports: {} };
+    cache.set(file, mod);
+    const code = ts.transpileModule(fs.readFileSync(file, "utf8"), {
+      compilerOptions: {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.CommonJS,
+        jsx: ts.JsxEmit.ReactJSX,
+        esModuleInterop: true,
+      },
+      fileName: file,
+    }).outputText;
+    const req = (spec) => {
+      if (Object.hasOwn(overrides, spec)) return overrides[spec];
+      if (spec === "server-only") return {};
+      if (spec === "@/lib/prisma") return { prisma };
+      if (spec === "next/headers")
+        return { headers: async () => new Headers() };
+      if (spec === "next/cache") return { revalidatePath() {} };
+      if (spec === "next/navigation")
+        return {
+          redirect(url) {
+            throw new Error(`REDIRECT:${url}`);
+          },
+          notFound() {
+            throw new Error("NOT_FOUND");
+          },
+        };
+      if (spec.startsWith("@/") || spec.startsWith(".")) {
+        const target = spec.startsWith("@/")
+          ? path.resolve("src", spec.slice(2))
+          : path.resolve(path.dirname(file), spec);
+        for (const suffix of [".ts", ".tsx", "/index.ts"])
+          if (fs.existsSync(target + suffix)) return load(target + suffix);
+      }
+      return require(spec);
+    };
+    vm.runInThisContext(`(function(require,module,exports){${code}\n})`, {
+      filename: file,
+    })(req, mod, mod.exports);
+    return mod.exports;
+  }
+  return load;
+}
+
+before(async () => {
+  const raw = process.env.TEST_DATABASE_URL;
+  assert.ok(
+    raw,
+    "TEST_DATABASE_URL muss ausdrücklich auf die separate lokale kita_roles_test zeigen.",
+  );
+  const url = new URL(raw);
+  assert.ok(["127.0.0.1", "localhost"].includes(url.hostname));
+  assert.equal(url.pathname, "/kita_roles_test");
+  prisma = new PrismaClient({ datasourceUrl: raw });
+  const load = loader({
+    "@/lib/auth-utils": {
+      requireKitaSession: async () => ({ user: current }),
+      requireRole: async (roles) => {
+        assert.ok(roles.includes(current.role));
+        return { user: current };
+      },
+    },
+    "@/lib/mail": {
+      getAppEmailConfigError: () => null,
+      sendAppEmail: async (input) => {
+        emails.push(input);
+        return { success: true };
+      },
+    },
+  });
+  change = load("src/lib/kita-role-management.ts").changeKitaRole;
+  changeAction = load(
+    "src/app/dashboard/zugriffsrechte/actions.ts",
+  ).changeKitaRoleAction;
+  remove = load("src/app/dashboard/profil/actions.ts").deleteMyAccount;
+  support = load("src/app/admin/actions.ts");
+  updateFamily = load(
+    "src/app/dashboard/families/actions.ts",
+  ).updateFamilyAction;
+  alarms = load("src/lib/alarms/service.ts");
+  alarmMail = load("src/lib/alarms/email.ts");
+  staff = load("src/lib/staff/service.ts");
+  staffMail = load("src/lib/staff/email.ts");
+  assign = load(
+    "src/app/dashboard/notdienst/plan/actions.ts",
+  ).updateAssignmentAction;
+  process.env.AUTH_URL = "http://127.0.0.1:3008";
+});
+async function user(role, extra = {}, kitaId = f.kita.id) {
+  return prisma.user.create({
+    data: {
+      kitaId,
+      email: `${randomUUID()}@example.invalid`,
+      firstName: "Test",
+      lastName: role,
+      passwordHash: "test-only",
+      emailVerifiedAt: new Date(),
+      privacyPolicyAcceptedAt: new Date(),
+      role,
+      ...extra,
+    },
+  });
+}
+const actor = (u) => ({
+  id: u.id,
+  kitaId: u.kitaId,
+  sessionVersion: u.sessionVersion,
+});
+const changeTo = (u, role, by = f.admin) =>
+  change(actor(by), { userId: u.id, role, expectedRole: u.role });
+beforeEach(async () => {
+  const kita = await prisma.kita.create({
+    data: { name: "Rollen-Test", slug: `roles-${randomUUID()}` },
+  });
+  tenants.push(kita.id);
+  f = { kita };
+  f.admin = await user("ADMIN");
+  f.family = await prisma.family.create({
+    data: { kitaId: kita.id, name: "Beispiel" },
+  });
+  f.parent = await user("ELTERN", { familyId: f.family.id });
+  f.child = await prisma.child.create({
+    data: {
+      kitaId: kita.id,
+      familyId: f.family.id,
+      firstName: "Kind",
+      lastName: "Test",
+    },
+  });
+  current = f.admin;
+  emails.length = 0;
+});
+after(async () => {
+  if (!prisma) return;
+  await prisma.kita.deleteMany({ where: { id: { in: tenants } } });
+  await prisma.user.deleteMany({ where: { id: { in: looseUsers } } });
+  await prisma.auditLog.deleteMany({
+    where: { targetKitaId: { in: tenants } },
+  });
+  await prisma.$disconnect();
+});
+
+test("Eltern werden Koordination und Kita-Admin; Haushalt und Kind bleiben erhalten", async () => {
+  assert.equal(
+    (
+      await changeAction({
+        userId: f.parent.id,
+        expectedRole: "ELTERN",
+        role: "KOORDINATOR",
+      })
+    ).success,
+    true,
+  );
+  const coord = await prisma.user.findUniqueOrThrow({
+    where: { id: f.parent.id },
+  });
+  await changeTo(coord, "ADMIN");
+  const updated = await prisma.user.findUniqueOrThrow({
+    where: { id: coord.id },
+  });
+  assert.equal(updated.familyId, f.family.id);
+  assert.equal(updated.sessionVersion, coord.sessionVersion);
+  assert.equal(
+    await prisma.child.count({ where: { familyId: f.family.id } }),
+    1,
+  );
+});
+test("Rollenänderung protokolliert Akteur, Kita und vorherige/neue Rolle genau einmal", async () => {
+  await changeTo(f.parent, "ADMIN");
+  const jobs = await prisma.auditLog.findMany({
+    where: { targetKitaId: f.kita.id, action: "USER_ROLE_CHANGE" },
+  });
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].actorUserId, f.admin.id);
+  assert.deepEqual(jobs[0].metadata, {
+    previousRole: "ELTERN",
+    newRole: "ADMIN",
+  });
+  assert.equal(
+    (await changeTo({ ...f.parent, role: "ADMIN" }, "ADMIN")).changed,
+    false,
+  );
+  assert.equal(
+    await prisma.auditLog.count({
+      where: { targetKitaId: f.kita.id, action: "USER_ROLE_CHANGE" },
+    }),
+    1,
+  );
+});
+test("Konto ohne Haushalt darf Koordination werden, aber nicht Eltern oder Fachkraft", async () => {
+  const person = await user("KOORDINATOR");
+  await assert.rejects(changeTo(person, "ELTERN"), /Haushalt/);
+  await assert.rejects(changeTo(person, "ERZIEHER"), /Personalprofil/);
+  assert.equal((await changeTo(person, "ADMIN")).changed, true);
+});
+test("Superadmin-Rolle kann weder vergeben noch verändert werden", async () => {
+  await assert.rejects(changeTo(f.parent, "SUPERADMIN"), /Ungültige/);
+  const root = await user("SUPERADMIN");
+  await assert.rejects(
+    change(actor(f.admin), {
+      userId: root.id,
+      expectedRole: "ADMIN",
+      role: "KOORDINATOR",
+    }),
+    /nicht geändert/,
+  );
+});
+test("Fremde Kita ist bei Zielkonto und Akteur ausgeschlossen", async () => {
+  const foreign = await prisma.kita.create({
+    data: { name: "Andere", slug: `roles-${randomUUID()}` },
+  });
+  tenants.push(foreign.id);
+  const outsider = await user("ADMIN", {}, foreign.id);
+  await assert.rejects(changeTo(outsider, "KOORDINATOR"), /nicht geändert/);
+  await assert.rejects(
+    change(
+      { ...actor(f.admin), kitaId: foreign.id },
+      { userId: outsider.id, expectedRole: "ADMIN", role: "KOORDINATOR" },
+    ),
+    /nicht mehr ändern/,
+  );
+});
+test("Eltern, gesperrte Admins und veraltete Sessions dürfen keine Rollen ändern", async () => {
+  await assert.rejects(
+    change(actor(f.parent), {
+      userId: f.admin.id,
+      expectedRole: "ADMIN",
+      role: "KOORDINATOR",
+    }),
+    /nicht mehr ändern/,
+  );
+  await assert.rejects(
+    change(
+      { ...actor(f.admin), sessionVersion: 9 },
+      { userId: f.parent.id, expectedRole: "ELTERN", role: "ADMIN" },
+    ),
+    /nicht mehr ändern/,
+  );
+  await prisma.user.update({
+    where: { id: f.admin.id },
+    data: { disabledAt: new Date() },
+  });
+  await assert.rejects(changeTo(f.parent, "ADMIN"), /nicht mehr ändern/);
+});
+test("Veralteter Dialog überschreibt keine zwischenzeitliche Rollenänderung", async () => {
+  await changeTo(f.parent, "KOORDINATOR");
+  await assert.rejects(changeTo(f.parent, "ADMIN"), /inzwischen geändert/);
+  assert.equal(
+    (await prisma.user.findUnique({ where: { id: f.parent.id } })).role,
+    "KOORDINATOR",
+  );
+});
+test("Letzter Admin kann seine Rolle nicht abgeben", async () => {
+  await assert.rejects(
+    changeTo(f.admin, "KOORDINATOR"),
+    /Mindestens ein aktiver/,
+  );
+});
+for (const [label, extra] of [
+  ["offene Einladung", { emailVerifiedAt: null, passwordHash: "" }],
+  ["deaktiviert", { disabledAt: new Date() }],
+  ["gesperrt", { lockedUntil: new Date("2099-01-01") }],
+  ["ohne Zustimmung", { privacyPolicyAcceptedAt: null }],
+]) {
+  test(`Ein weiterer Admin ${label} reicht nicht als Ersatz`, async () => {
+    await user("ADMIN", extra);
+    await assert.rejects(
+      changeTo(f.admin, "KOORDINATOR"),
+      /Mindestens ein aktiver/,
+    );
+  });
+}
+test("Mit zweitem aktivierten Admin ist eigene Herabstufung möglich und stale Admin-Rechte sind unwirksam", async () => {
+  await user("ADMIN");
+  assert.equal((await changeTo(f.admin, "KOORDINATOR")).ownRoleChanged, true);
+  await assert.rejects(changeTo(f.parent, "ADMIN"), /nicht mehr ändern/);
+});
+test("Parallele Herabstufung zweier Admins lässt genau einen Admin bestehen", async () => {
+  const second = await user("ADMIN");
+  const results = await Promise.allSettled([
+    changeTo(f.admin, "KOORDINATOR", f.admin),
+    changeTo(second, "KOORDINATOR", second),
+  ]);
+  assert.equal(results.filter((r) => r.status === "fulfilled").length, 1);
+  assert.equal(
+    await prisma.user.count({ where: { kitaId: f.kita.id, role: "ADMIN" } }),
+    1,
+  );
+});
+test("Eigene Kontolöschung ist für letzten Admin gesperrt", async () => {
+  assert.match((await remove()).error, /Mindestens ein aktiver/);
+  assert.ok(await prisma.user.findUnique({ where: { id: f.admin.id } }));
+});
+test("Eigene Kontolöschung mit zweitem aktivem Admin funktioniert weiterhin", async () => {
+  await user("ADMIN");
+  assert.equal((await remove()).success, true);
+  assert.equal(
+    await prisma.user.findUnique({ where: { id: f.admin.id } }),
+    null,
+  );
+});
+test("Superadmin kann den letzten Kita-Admin weder löschen noch sperren", async () => {
+  current = await user("SUPERADMIN", {}, null);
+  looseUsers.push(current.id);
+  current.authenticatedAt = Date.now();
+  assert.match(
+    (
+      await support.deleteUser({
+        userId: f.admin.id,
+        confirmationEmail: f.admin.email,
+      })
+    ).error,
+    /Mindestens ein aktiver/,
+  );
+  assert.match(
+    (await support.lockUser(f.admin.id)).error,
+    /Mindestens ein aktiver/,
+  );
+});
+test("Support darf zusätzlichen Admin sperren und löschen", async () => {
+  const second = await user("ADMIN");
+  current = await user("SUPERADMIN", {}, null);
+  looseUsers.push(current.id);
+  current.authenticatedAt = Date.now();
+  assert.equal((await support.lockUser(second.id)).ok, true);
+  assert.equal(
+    (
+      await support.deleteUser({
+        userId: second.id,
+        confirmationEmail: second.email,
+      })
+    ).ok,
+    true,
+  );
+});
+test("Gleichzeitige Admin-Löschung und Herabstufung lässt einen Admin bestehen", async () => {
+  const second = await user("ADMIN");
+  const results = await Promise.allSettled([
+    remove(),
+    changeTo(second, "KOORDINATOR"),
+  ]);
+  const successful =
+    results.filter((r) => r.status === "fulfilled" && r.value.success).length +
+    results.filter((r) => r.status === "fulfilled" && r.value.changed).length;
+  assert.equal(successful, 1);
+  assert.equal(
+    await prisma.user.count({ where: { kitaId: f.kita.id, role: "ADMIN" } }),
+    1,
+  );
+});
+test("E-Mail-Änderung darf letzten aktivierten Admin nicht deaktivieren", async () => {
+  await prisma.user.update({
+    where: { id: f.admin.id },
+    data: { familyId: f.family.id },
+  });
+  const payload = {
+    familyId: f.family.id,
+    familyName: f.family.name,
+    parents: [
+      f.parent,
+      { ...f.admin, email: `${randomUUID()}@example.invalid` },
+    ],
+    children: [f.child],
+  };
+  assert.match((await updateFamily(payload)).error, /Mindestens ein aktiver/);
+  assert.equal(
+    (await prisma.user.findUnique({ where: { id: f.admin.id } })).email,
+    f.admin.email,
+  );
+});
+
+test("Fachkraft wird Admin; Personalprofil bleibt bearbeitbar und eigene Mailpräferenz erhalten", async () => {
+  const person = await user("ERZIEHER");
+  const educator = await prisma.educator.create({
+    data: { kitaId: f.kita.id, firstName: "Team", lastName: "Test" },
+  });
+  const profile = await prisma.staffProfile.create({
+    data: {
+      kitaId: f.kita.id,
+      educatorId: educator.id,
+      userId: person.id,
+      employmentStart: new Date("2030-01-01"),
+      trackingStart: new Date("2030-01-01"),
+    },
+  });
+  await assert.rejects(changeTo(person, "KOORDINATOR"), /Personalprofil/);
+  await changeTo(person, "ADMIN");
+  await staff.executeStaffCommand(
+    { id: person.id, kitaId: f.kita.id, role: "ADMIN" },
+    { command: "emailPreference", data: { enabled: false } },
+  );
+  await staff.executeStaffCommand(
+    { id: f.admin.id, kitaId: f.kita.id, role: "ADMIN" },
+    {
+      command: "educatorUpdate",
+      data: {
+        educatorId: educator.id,
+        firstName: "Team",
+        lastName: "Geändert",
+        active: true,
+        email: person.email,
+      },
+    },
+  );
+  assert.equal(
+    (await prisma.staffProfile.findUnique({ where: { id: profile.id } }))
+      .userId,
+    person.id,
+  );
+  assert.equal(
+    (await prisma.user.findUnique({ where: { id: person.id } }))
+      .staffDecisionEmails,
+    false,
+  );
+  await changeTo({ ...person, role: "ADMIN" }, "ERZIEHER");
+});
+test("Offene Fachkraft-Einladung lässt sich auch nach Admin-Ernennung erneut senden", async () => {
+  const person = await user("ERZIEHER", {
+    emailVerifiedAt: null,
+    passwordHash: "",
+  });
+  const educator = await prisma.educator.create({
+    data: { kitaId: f.kita.id, firstName: "Team", lastName: "Test" },
+  });
+  await prisma.staffProfile.create({
+    data: {
+      kitaId: f.kita.id,
+      educatorId: educator.id,
+      userId: person.id,
+      employmentStart: new Date("2030-01-01"),
+      trackingStart: new Date("2030-01-01"),
+    },
+  });
+  await changeTo(person, "ADMIN");
+  const queued = await staff.executeStaffCommand(
+    { id: f.admin.id, kitaId: f.kita.id, role: "ADMIN" },
+    { command: "educatorInvite", data: { educatorId: educator.id } },
+  );
+  assert.equal(
+    (
+      await staffMail.deliverStaffEmails(queued.emailIds, async () => ({
+        success: true,
+      }))
+    ).sent,
+    1,
+  );
+});
+for (const role of ["ADMIN", "KOORDINATOR"])
+  test(`Haushaltsalarme erreichen und akzeptieren Eltern mit Rolle ${role}`, async () => {
+    await changeTo(f.parent, role);
+    const plan = await prisma.notdienstPlan.create({
+      data: {
+        kitaId: f.kita.id,
+        year: 2030,
+        month: 11,
+        status: "PUBLISHED",
+        assignments: {
+          create: {
+            kitaId: f.kita.id,
+            childId: f.child.id,
+            date: new Date("2030-11-04"),
+          },
+        },
+      },
+      include: { assignments: true },
+    });
+    const job = await alarms.executeAlarmCommand(
+      { id: f.admin.id, kitaId: f.kita.id, role: "ADMIN" },
+      "create",
+      { assignmentId: plan.assignments[0].id, wholeDay: true },
+    );
+    const request = await prisma.notdienstAlarmEmail.findFirstOrThrow({
+      where: { alarmId: job.alarmId, userId: f.parent.id, kind: "REQUEST" },
+    });
+    const token = request.path.split("/").pop();
+    assert.ok(await alarms.getPublicAlarm(token));
+    assert.equal(
+      (
+        await alarmMail.deliverAlarmEmails([request.id], async () => ({
+          success: true,
+        }))
+      ).sent,
+      1,
+    );
+    await alarms.respondToAlarm(token, true);
+    assert.equal(
+      (await prisma.notdienstAlarm.findUnique({ where: { id: job.alarmId } }))
+        .status,
+      "CONFIRMED",
+    );
+  });
+test("Bereits ausgestellter Haushalts-Alarmlink bleibt nach Ernennung gültig", async () => {
+  const plan = await prisma.notdienstPlan.create({
+    data: {
+      kitaId: f.kita.id,
+      year: 2030,
+      month: 11,
+      status: "PUBLISHED",
+      assignments: {
+        create: {
+          kitaId: f.kita.id,
+          childId: f.child.id,
+          date: new Date("2030-11-04"),
+        },
+      },
+    },
+    include: { assignments: true },
+  });
+  const job = await alarms.executeAlarmCommand(
+    { id: f.admin.id, kitaId: f.kita.id, role: "ADMIN" },
+    "create",
+    { assignmentId: plan.assignments[0].id, wholeDay: true },
+  );
+  const request = await prisma.notdienstAlarmEmail.findFirstOrThrow({
+    where: { alarmId: job.alarmId, userId: f.parent.id, kind: "REQUEST" },
+  });
+  await changeTo(f.parent, "ADMIN");
+  assert.ok(await alarms.getPublicAlarm(request.path.split("/").pop()));
+});
+
+test("Letzter Admin im Ein-Personen-Haushalt bleibt auch vor kaskadierender Familienlöschung geschützt", async () => {
+  await prisma.user.update({
+    where: { id: f.parent.id },
+    data: { role: "ADMIN" },
+  });
+  await prisma.user.update({
+    where: { id: f.admin.id },
+    data: { role: "KOORDINATOR" },
+  });
+  current = { ...f.parent, role: "ADMIN" };
+  assert.match((await remove()).error, /Mindestens ein aktiver/);
+  assert.ok(await prisma.family.findUnique({ where: { id: f.family.id } }));
+  assert.ok(await prisma.child.findUnique({ where: { id: f.child.id } }));
+});
+
+test("Veröffentlichte Umteilung informiert auch den Admin im betroffenen Elternhaushalt", async () => {
+  await changeTo(f.parent, "ADMIN");
+  const family = await prisma.family.create({
+    data: { kitaId: f.kita.id, name: "Ersatz" },
+  });
+  const parent = await user("ELTERN", { familyId: family.id });
+  const child = await prisma.child.create({
+    data: {
+      kitaId: f.kita.id,
+      familyId: family.id,
+      firstName: "Ersatz",
+      lastName: "Test",
+    },
+  });
+  const plan = await prisma.notdienstPlan.create({
+    data: {
+      kitaId: f.kita.id,
+      year: 2030,
+      month: 11,
+      status: "PUBLISHED",
+      assignments: {
+        create: {
+          kitaId: f.kita.id,
+          childId: f.child.id,
+          date: new Date("2030-11-04"),
+        },
+      },
+    },
+  });
+  const result = await assign(plan.id, "2030-11-04", child.id);
+  assert.equal(result.success, true);
+  assert.ok(emails.some((email) => [email.to].flat().includes(f.parent.email)));
+  assert.ok(emails.some((email) => [email.to].flat().includes(parent.email)));
+});

tests/mail-transport.test.cjs

@@ -0,0 +1,55 @@
+/* eslint-disable @typescript-eslint/no-require-imports -- Execute the installed SDK and real TypeScript mail adapter. */
+const { test, before, after }=require('node:test');const assert=require('node:assert/strict');
+const fs=require('node:fs'),path=require('node:path'),vm=require('node:vm'),ts=require('typescript');
+let prisma; // The mail adapter never accesses a database.
+function loader(overrides = {}) {
+  const cache = new Map();
+  function load(file) {
+    file = path.resolve(file);
+    if (cache.has(file)) return cache.get(file).exports;
+    const mod = { exports: {} }; cache.set(file, mod);
+    const code = ts.transpileModule(fs.readFileSync(file, 'utf8'), {
+      compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS, jsx: ts.JsxEmit.ReactJSX, esModuleInterop: true },
+      fileName: file,
+    }).outputText;
+    const req = spec => {
+      if (Object.hasOwn(overrides, spec)) return overrides[spec];
+      if (spec === 'server-only') return {};
+      if (spec === '@/lib/prisma') return { prisma };
+      if (spec === 'next/headers') return { headers: async () => new Headers() };
+      if (spec === 'next/cache') return { revalidatePath() {} };
+      if (spec === 'next/navigation') return { redirect(url) { throw new Error(`REDIRECT:${url}`); }, notFound() { throw new Error('NOT_FOUND'); } };
+      if (spec.startsWith('@/') || spec.startsWith('.')) {
+        const target = spec.startsWith('@/') ? path.resolve('src', spec.slice(2)) : path.resolve(path.dirname(file), spec);
+        for (const suffix of ['.ts', '.tsx', '/index.ts']) if (fs.existsSync(target + suffix)) return load(target + suffix);
+      }
+      return require(spec);
+    };
+    vm.runInThisContext(`(function(require,module,exports){${code}\n})`, { filename: file })(req, mod, mod.exports);
+    return mod.exports;
+  }
+  return load;
+}
+
+const originalFetch=global.fetch;const saved=Object.fromEntries(['RESEND_API_KEY','EMAIL_FROM','NODE_ENV'].map(k=>[k,process.env[k]]));let send;
+before(()=>{process.env.RESEND_API_KEY='re_test_not_real';process.env.EMAIL_FROM='Test <test@example.invalid>';process.env.NODE_ENV='test';send=loader()('src/lib/mail.ts').sendAppEmail;});
+after(()=>{global.fetch=originalFetch;for(const [k,v] of Object.entries(saved)){if(v===undefined)delete process.env[k];else process.env[k]=v;}});
+const input={to:'recipient@example.invalid',subject:'Test',react:'Test',idempotencyKey:'stable-job'};
+test('SDK receives the stable key and an AbortSignal on the actual fetch call',async()=>{
+ let captured;global.fetch=async(_url,options)=>{captured=options;return new Response(JSON.stringify({id:'test-id'}),{status:200});};
+ assert.equal((await send(input)).success,true);assert.ok(captured.signal instanceof AbortSignal);assert.match(new Headers(captured.headers).get('Idempotency-Key'),/^stable-job\/[a-f0-9]{64}$/);
+});
+test('Transport timeout aborts the pending fetch rather than merely abandoning its promise',async()=>{
+ let aborted=false;global.fetch=async(_url,options)=>new Promise((_resolve,reject)=>options.signal.addEventListener('abort',()=>{aborted=true;reject(options.signal.reason);},{once:true}));
+ const keepAlive=setTimeout(()=>{},1000);try{assert.equal((await send({...input,timeoutMs:20})).success,false);assert.equal(aborted,true);}finally{clearTimeout(keepAlive);}
+});
+test('Array recipients have distinct stable keys and duplicate addresses are removed',async()=>{
+ const keys=[];global.fetch=async(_url,options)=>{keys.push(new Headers(options.headers).get('Idempotency-Key'));return new Response(JSON.stringify({id:'test'}),{status:200});};
+ const message={...input,to:['one@example.invalid','two@example.invalid','one@example.invalid']};await send(message);await send(message);
+ assert.equal(keys.length,4);assert.notEqual(keys[0],keys[1]);assert.equal(keys[0],keys[2]);assert.equal(keys[1],keys[3]);
+});
+
+test('Corrected message payload receives a new version without changing stable retries',async()=>{
+ const keys=[];global.fetch=async(_url,options)=>{keys.push(new Headers(options.headers).get('Idempotency-Key'));return new Response(JSON.stringify({id:'test'}),{status:200});};
+ await send(input);await send(input);await send({...input,react:'Corrected dates'});assert.equal(keys[0],keys[1]);assert.notEqual(keys[1],keys[2]);
+});

tests/notdienst-assignment-view.test.cjs

@@ -0,0 +1,139 @@
+/* eslint-disable @typescript-eslint/no-require-imports -- Render the actual client component through the TypeScript loader. */
+const { test } = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+const ts = require("typescript");
+const React = require("react");
+const { renderToStaticMarkup } = require("react-dom/server");
+function loader(overrides = {}) {
+  const cache = new Map();
+  function load(file) {
+    file = path.resolve(file);
+    if (cache.has(file)) return cache.get(file).exports;
+    const mod = { exports: {} };
+    cache.set(file, mod);
+    const code = ts.transpileModule(fs.readFileSync(file, "utf8"), {
+      compilerOptions: {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.CommonJS,
+        jsx: ts.JsxEmit.ReactJSX,
+        esModuleInterop: true,
+      },
+      fileName: file,
+    }).outputText;
+    const req = (spec) => {
+      if (Object.hasOwn(overrides, spec)) return overrides[spec];
+      if (spec === "server-only") return {};
+      if (spec === "@/lib/prisma")
+        throw new Error("No database in component render tests");
+      if (spec === "next/headers")
+        return { headers: async () => new Headers() };
+      if (spec === "next/cache") return { revalidatePath() {} };
+      if (spec === "next/navigation")
+        return {
+          redirect(url) {
+            throw new Error(`REDIRECT:${url}`);
+          },
+          notFound() {
+            throw new Error("NOT_FOUND");
+          },
+        };
+      if (spec.startsWith("@/") || spec.startsWith(".")) {
+        const target = spec.startsWith("@/")
+          ? path.resolve("src", spec.slice(2))
+          : path.resolve(path.dirname(file), spec);
+        for (const suffix of [".ts", ".tsx", "/index.ts"])
+          if (fs.existsSync(target + suffix)) return load(target + suffix);
+      }
+      return require(spec);
+    };
+    vm.runInThisContext(`(function(require,module,exports){${code}\n})`, {
+      filename: file,
+    })(req, mod, mod.exports);
+    return mod.exports;
+  }
+  return load;
+}
+
+const load = loader({ "./actions": {} });
+const { ManualAssignmentTable } = load(
+  "src/app/dashboard/notdienst/plan/plan-view.tsx",
+);
+const children = [
+  { id: "a", name: "Alex", parentName: "Haushalt A", familyId: "family-a" },
+  { id: "b", name: "Ben", parentName: "Haushalt B", familyId: "family-b" },
+  { id: "a2", name: "Anna", parentName: "Haushalt A", familyId: "family-a" },
+];
+const day = {
+  date: "2030-11-04T00:00:00.000Z",
+  assignmentId: null,
+  childId: null,
+};
+const familyStatuses = [
+  { id: "family-a", selectedDays: [{ iso: day.date }] },
+  { id: "family-b", selectedDays: [{ iso: "2030-11-05T00:00:00.000Z" }] },
+];
+const render = (overrides = {}) =>
+  renderToStaticMarkup(
+    React.createElement(ManualAssignmentTable, {
+      days: [day],
+      allChildren: children,
+      familyStatuses,
+      isDraft: true,
+      isPending: false,
+      onAssignmentChange() {},
+      ...overrides,
+    }),
+  );
+test("Verfügbare Haushalte stehen zuerst; Geschwister zählen als eine verfügbare Familie", () => {
+  const html = render();
+  assert.ok(
+    html.indexOf("Verfügbar an diesem Tag") <
+      html.indexOf("Keine Verfügbarkeit für diesen Tag"),
+  );
+  assert.match(html, /1 Familie ist verfügbar/);
+  assert.match(html, /value="a2"/);
+  assert.match(html, /value="b"/);
+  assert.match(html, /aria-label="Familie für 04.11.2030"/);
+});
+test("Bestehende Einteilung ohne Rückmeldung bleibt auswählbar und wird kenntlich gemacht", () => {
+  const html = render({ days: [{ ...day, childId: "b" }] });
+  assert.match(html, /value="b" selected/);
+  assert.match(
+    html,
+    /Eingeteilte Familie hat für diesen Tag keine Verfügbarkeit angegeben/,
+  );
+});
+test("Eingeteilte verfügbare Familie und Haushaltseinteilungszahl werden angezeigt", () => {
+  const html = render({
+    days: [
+      { ...day, childId: "a" },
+      { ...day, date: "2030-11-05T00:00:00.000Z", childId: "a2" },
+    ],
+  });
+  assert.match(html, /Eingeteilte Familie ist verfügbar/);
+  assert.match(html, /Haushalt A \(Alex\) — 2x/);
+});
+test("Fehlende Verfügbarkeiten erzeugen eine klare Angabe ohne Familien auszublenden", () => {
+  const html = render({ familyStatuses: [] });
+  assert.match(html, /0 Familien sind verfügbar/);
+  assert.match(html, /value="a"/);
+  assert.match(html, /value="b"/);
+});
+test("Aktiver Alarm sperrt die Auswahl weiterhin", () => {
+  const html = render({
+    days: [{ ...day, childId: "a", activeAlarmId: "alarm" }],
+  });
+  assert.match(html, /<select[^>]*disabled/);
+});
+test("Ungültige alte Einteilung bleibt entfernbar; neue Kinder sind dafür gesperrt", () => {
+  const html = render({
+    days: [{ ...day, childId: "inactive", isInvalid: true }],
+  });
+  assert.match(html, /value="empty"/);
+  assert.match(html, /value="inactive" disabled/);
+  assert.match(html, /value="a" disabled/);
+  assert.match(html, /Einteilung nicht mehr gültig/);
+});

tests/notdienst-days.test.ts

@@ -0,0 +1,55 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { getNotdienstDays } from "../src/lib/notdienst-days";
+
+const keys = (year: number, month: number, start: string, end: string) =>
+  getNotdienstDays(year, month, [
+    { startDate: new Date(start), endDate: new Date(end) },
+  ]).map((d) => d.toISOString().slice(0, 10));
+
+test("Schließtage schließen inklusive beider Randtage aus", () => {
+  const days = keys(2030, 11, "2030-11-04T10:00:00Z", "2030-11-06T12:00:00Z");
+  for (const key of ["2030-11-04", "2030-11-05", "2030-11-06"])
+    assert.ok(!days.includes(key));
+  assert.ok(days.includes("2030-11-07"));
+  assert.ok(days.every((key) => ![0, 6].includes(new Date(key).getUTCDay())));
+});
+
+test("Berliner Mitternacht am Monatsanfang zählt zum richtigen Monat", () => {
+  const days = keys(2030, 11, "2030-10-31T23:00:00Z", "2030-11-01T22:59:00Z");
+  assert.ok(!days.includes("2030-11-01"));
+  assert.ok(days.includes("2030-11-04"));
+});
+
+test("Sommerzeit und Schließzeiten über Monatsgrenzen", () => {
+  const days = keys(2030, 7, "2030-06-28T22:00:00Z", "2030-07-02T21:59:00Z");
+  assert.ok(!days.includes("2030-07-01"));
+  assert.ok(!days.includes("2030-07-02"));
+  assert.ok(days.includes("2030-07-03"));
+});
+
+test("Überlappende Schließtermine erzeugen keine doppelten Tage", () => {
+  const closures = [
+    { startDate: new Date("2030-11-04"), endDate: new Date("2030-11-05") },
+    { startDate: new Date("2030-11-05"), endDate: new Date("2030-11-06") },
+  ];
+  const days = getNotdienstDays(2030, 11, closures);
+  assert.equal(new Set(days.map(Number)).size, days.length);
+  assert.equal(days.length, getNotdienstDays(2030, 11, []).length - 3);
+});
+
+
+test("Berliner Monatswechsel bestimmt Zielmonat und Sperrfrist", async () => {
+  const { getTargetMonthData } = await import("../src/lib/date-utils");
+  assert.equal(getTargetMonthData(new Date("2030-10-26T22:00:00Z")).isLocked, true);
+  const data = getTargetMonthData(new Date("2030-12-31T23:00:00Z"));
+  assert.equal(data.targetYear, 2031); assert.equal(data.targetMonth, 2);
+});
+
+test("Automatische Erinnerung beginnt um 9 Uhr vor der Eintragsfrist", async () => {
+  const { isNotdienstReminderDue } = await import("../src/lib/date-utils");
+  assert.equal(isNotdienstReminderDue(7, new Date("2030-10-18T07:00:00Z")), false);
+  assert.equal(isNotdienstReminderDue(7, new Date("2030-10-19T06:59:00Z")), false);
+  assert.equal(isNotdienstReminderDue(7, new Date("2030-10-19T07:00:00Z")), true);
+  assert.equal(isNotdienstReminderDue(0, new Date("2030-10-19T07:00:00Z")), false);
+});

tests/notdienst-notifications.integration.test.cjs

@@ -0,0 +1,217 @@
+/* eslint-disable @typescript-eslint/no-require-imports -- Load real server actions with isolated request and mail transport boundaries. */
+const { test, before, beforeEach, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs'); const path = require('node:path'); const vm = require('node:vm');
+const ts = require('typescript'); const { randomUUID } = require('node:crypto');
+const { PrismaClient } = require('@prisma/client');
+const { render } = require('@react-email/render');
+let prisma, current, f, service, publish, retry;
+let failMail = false; const emails = [], tenants = [];
+function loader(overrides = {}) {
+  const cache = new Map();
+  function load(file) {
+    file = path.resolve(file);
+    if (cache.has(file)) return cache.get(file).exports;
+    const mod = { exports: {} }; cache.set(file, mod);
+    const code = ts.transpileModule(fs.readFileSync(file, 'utf8'), {
+      compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS, jsx: ts.JsxEmit.ReactJSX, esModuleInterop: true },
+      fileName: file,
+    }).outputText;
+    const req = spec => {
+      if (Object.hasOwn(overrides, spec)) return overrides[spec];
+      if (spec === 'server-only') return {};
+      if (spec === '@/lib/prisma') return { prisma };
+      if (spec === 'next/headers') return { headers: async () => new Headers() };
+      if (spec === 'next/cache') return { revalidatePath() {} };
+      if (spec === 'next/navigation') return { redirect(url) { throw new Error(`REDIRECT:${url}`); }, notFound() { throw new Error('NOT_FOUND'); } };
+      if (spec.startsWith('@/') || spec.startsWith('.')) {
+        const target = spec.startsWith('@/') ? path.resolve('src', spec.slice(2)) : path.resolve(path.dirname(file), spec);
+        for (const suffix of ['.ts', '.tsx', '/index.ts']) if (fs.existsSync(target + suffix)) return load(target + suffix);
+      }
+      return require(spec);
+    };
+    vm.runInThisContext(`(function(require,module,exports){${code}\n})`, { filename: file })(req, mod, mod.exports);
+    return mod.exports;
+  }
+  return load;
+}
+
+const now = new Date('2030-10-19T07:00:00Z');
+const sender = async input => { emails.push(input); return failMail ? { success: false, error: 'Test mail failure' } : { success: true, id: 'simulated' }; };
+before(async () => {
+  const raw=process.env.TEST_DATABASE_URL;
+  if (!raw) throw new Error('TEST_DATABASE_URL muss auf die separate lokale kita_notifications_test zeigen.');
+  const url=new URL(raw); assert.ok(['127.0.0.1','localhost'].includes(url.hostname)); assert.equal(url.pathname,'/kita_notifications_test');
+  process.env.AUTH_URL='http://127.0.0.1:3014'; prisma=new PrismaClient({datasourceUrl:raw});
+  const load=loader({ '@/lib/auth-utils': { requireKitaSession:async()=>({user:current}), requireRole:async roles=>{assert.ok(roles.includes(current.role));return {user:current};} }, '@/lib/mail':{sendAppEmail:sender} });
+  service=load('src/lib/notdienst-notifications.ts');
+  ({publishPlanAction:publish,retryNotdienstEmailsAction:retry}=load('src/app/dashboard/notdienst/plan/actions.ts'));
+});
+after(async()=>{if(prisma){await prisma.kita.deleteMany({where:{id:{in:tenants}}});await prisma.$disconnect();}});
+beforeEach(async()=>{
+  failMail=false;emails.length=0;
+  const kita=await prisma.kita.create({data:{name:'Benachrichtigungen Test',slug:randomUUID(),notdienstMinPerChildPerMonth:3,notdienstReminderDaysBefore:7}});tenants.push(kita.id);
+  const family=await prisma.family.create({data:{kitaId:kita.id,name:'Testhaushalt'}});
+  const parent=await prisma.user.create({data:{kitaId:kita.id,familyId:family.id,role:'ADMIN',email:`${randomUUID()}@example.invalid`,firstName:'Test',lastName:'Admin',passwordHash:'test',emailVerifiedAt:new Date(),privacyPolicyAcceptedAt:new Date()}});
+  const children=await Promise.all(['A','B'].map(firstName=>prisma.child.create({data:{kitaId:kita.id,familyId:family.id,firstName,lastName:'Test'}})));
+  f={kita,family,parent,children};current=parent;
+});
+const jobs=()=>prisma.notdienstEmail.findMany({where:{kitaId:f.kita.id},orderBy:{createdAt:'asc'}});
+const manual=(time=now)=>service.queueNotdienstReminders(f.kita.id,2030,11,false,time);
+const auto=(time=now)=>service.runNotdienstNotificationJob(sender,time,f.kita.id);
+async function availability(keys,child=f.children[0]){await prisma.notdienstAvailability.createMany({data:keys.map(key=>({kitaId:f.kita.id,childId:child.id,userId:f.parent.id,date:new Date(key)})),skipDuplicates:true});}
+async function draft(){return prisma.notdienstPlan.create({data:{kitaId:f.kita.id,year:2030,month:11,assignments:{create:[{kitaId:f.kita.id,childId:f.children[0].id,date:new Date('2030-11-04')},{kitaId:f.kita.id,childId:f.children[1].id,date:new Date('2030-11-05')}]}}});}
+async function partner(role='KOORDINATOR'){return prisma.user.create({data:{kitaId:f.kita.id,familyId:f.family.id,role,email:`${randomUUID()}@example.invalid`,firstName:'Partner',lastName:role,passwordHash:'test',emailVerifiedAt:new Date(),privacyPolicyAcceptedAt:new Date()}});}
+
+test('Automatik erinnert den fehlenden Haushalt genau einmal im Monat',async()=>{
+  const first=await auto();assert.equal(first.queued,1);assert.equal(first.sent,1);
+  assert.equal((await auto()).queued,0);assert.equal((await auto(new Date('2030-10-20T07:00:00Z'))).queued,0);
+  assert.equal(emails.length,1);assert.equal(await prisma.notdienstReminderRun.count({where:{kitaId:f.kita.id}}),1);
+});
+test('Zu wenige gültige Tage werden als unvollständig erkannt; Mail enthält Soll und Frist',async()=>{
+  await availability(['2030-11-04','2030-11-05']);assert.equal((await auto()).sent,1);
+  const html=(await render(emails[0].react)).replace(/<!--.*?-->/g,'');assert.ok(html.includes('2 von 6'));assert.ok(html.includes('26.10.2030'));
+});
+test('Vollständige sechs Tage werden nicht erinnert',async()=>{
+  await availability(['2030-11-04','2030-11-05','2030-11-06','2030-11-07','2030-11-08','2030-11-11']);
+  assert.equal((await auto()).queued,0);assert.equal(emails.length,0);
+});
+test('Geschwister-Doppelbuchungen und alte Wochenenddaten reduzieren das Soll nicht',async()=>{
+  await availability(['2030-11-04','2030-11-05','2030-11-02']);await availability(['2030-11-04','2030-11-05','2030-11-03'],f.children[1]);
+  const progress=await service.getFamilyNotdienstProgress(prisma,f.kita.id,f.family.id,2030,11,3);assert.deepEqual(progress,{selected:2,required:6});
+  assert.equal((await auto()).sent,1);
+});
+test('Vor 9 Uhr Berliner Zeit und vor Erinnerungstag wird nichts vorbereitet',async()=>{
+  assert.equal((await auto(new Date('2030-10-19T06:59:00Z'))).queued,0);
+  assert.equal((await auto(new Date('2030-10-18T07:00:00Z'))).queued,0);assert.equal((await jobs()).length,0);
+});
+test('Verpasster Erinnerungstag wird bis zum 26. nachgeholt',async()=>{assert.equal((await auto(new Date('2030-10-25T07:00:00Z'))).sent,1);});
+test('Nach der Sperrfrist werden keine Erinnerungen vorbereitet',async()=>{
+  assert.equal((await auto(new Date('2030-10-27T09:00:00Z'))).queued,0);
+  await assert.rejects(manual(new Date('2030-10-27T09:00:00Z')),/Eintragsfrist/);
+});
+test('0 schaltet automatische Erinnerungen ab; manueller Versand bleibt möglich',async()=>{
+  await prisma.kita.update({where:{id:f.kita.id},data:{notdienstReminderDaysBefore:0}});
+  assert.equal((await auto()).queued,0);assert.equal(await manual(),1);
+});
+test('Deaktiviertes Modul wird weder vorbereitet noch versendet',async()=>{
+  await manual();await prisma.kita.update({where:{id:f.kita.id},data:{notdienstModuleEnabled:false}});
+  assert.equal((await auto()).sent,0);assert.equal(emails.length,0);assert.ok((await jobs())[0].skippedAt);
+});
+test('Admin- und Koordinationskonten desselben Haushalts erhalten die Erinnerung',async()=>{
+  const p=await partner();assert.equal((await auto()).sent,2);assert.deepEqual(emails.map(e=>e.to).sort(),[p.email,f.parent.email].sort());
+});
+test('Unverifizierte, gesperrte, deaktivierte und Erzieherkonten werden nicht angeschrieben',async()=>{
+  await partner('ERZIEHER');await prisma.user.update({where:{id:f.parent.id},data:{lockedUntil:new Date('2031-01-01')}});
+  assert.equal((await auto()).sent,0);assert.equal(emails.length,0);
+});
+test('Manuell und automatisch am selben Tag erzeugen nur einen Auftrag je Konto',async()=>{
+  assert.equal(await manual(),1);assert.equal(await manual(),0);assert.equal((await auto()).queued,0);assert.equal(emails.length,1);
+});
+test('Parallele automatische Läufe erzeugen nur eine Mailrunde',async()=>{
+  const results=await Promise.all([auto(),auto()]);assert.equal(results.reduce((n,r)=>n+r.queued,0),1);assert.equal(emails.length,1);
+});
+test('Bei inzwischen vollständiger Auswahl wird ein gespeicherter Reminder übersprungen',async()=>{
+  await manual();await availability(['2030-11-04','2030-11-05','2030-11-06','2030-11-07','2030-11-08','2030-11-11']);
+  assert.equal((await service.deliverDueNotdienstEmails({kitaId:f.kita.id},sender,now)).skipped,1);assert.equal(emails.length,0);
+});
+test('Haushaltswechsel und fehlende Mailbestätigung machen einen Auftrag ungültig',async()=>{
+  await manual();await prisma.user.update({where:{id:f.parent.id},data:{emailVerifiedAt:null}});
+  assert.equal((await service.deliverDueNotdienstEmails({kitaId:f.kita.id},sender,now)).skipped,1);assert.equal(emails.length,0);
+});
+test('Versandfehler bleibt sichtbar; Wiederholung verwendet denselben Idempotenzschlüssel',async()=>{
+  await manual();failMail=true;const first=await service.deliverDueNotdienstEmails({kitaId:f.kita.id},sender,now);assert.equal(first.failed,1);
+  const failed=(await jobs())[0];assert.equal(failed.failed,true);assert.ok(failed.nextAttemptAt>now);assert.equal(failed.sentAt,null);
+  assert.equal((await service.getNotdienstEmailStatus(f.kita.id,2030,11)).failed,1);
+  assert.equal((await service.deliverDueNotdienstEmails({kitaId:f.kita.id},sender,now)).sent,0);
+  failMail=false;assert.equal((await service.deliverDueNotdienstEmails({kitaId:f.kita.id},sender,failed.nextAttemptAt)).sent,1);
+  assert.equal(emails[0].idempotencyKey,emails[1].idempotencyKey);assert.equal((await jobs())[0].failed,false);
+});
+test('Paralleler Versand reserviert einen Auftrag nur einmal',async()=>{
+  await manual();const id=(await jobs())[0].id;let count=0;
+  const slow=async()=>{count++;await new Promise(r=>setTimeout(r,20));return {success:true};};
+  await Promise.all([service.deliverNotdienstEmails([id],slow,now),service.deliverNotdienstEmails([id],slow,now)]);assert.equal(count,1);
+});
+test('Abgelaufene Reservierung nach Worker-Abbruch wird wieder aufgenommen',async()=>{
+  await manual();const id=(await jobs())[0].id;await prisma.notdienstEmail.update({where:{id},data:{leaseUntil:new Date(now.getTime()-1000),claimToken:'old'}});
+  assert.equal((await service.deliverDueNotdienstEmails({kitaId:f.kita.id},sender,now)).sent,1);
+});
+test('Eine fehlerhafte Adresse blockiert die zweite Person nicht',async()=>{
+  await partner();await manual();const result=await service.deliverDueNotdienstEmails({kitaId:f.kita.id},async input=>{emails.push(input);return input.to===f.parent.email?{success:false,error:'failure'}:{success:true};},now);
+  assert.equal(result.failed,1);assert.equal(result.sent,1);
+});
+test('Veröffentlichung fasst Geschwisterdienste pro Konto in einer Mail zusammen',async()=>{
+  const p=await partner();const plan=await draft();assert.equal((await publish(plan.id)).success,true);assert.equal(emails.length,2);
+  const html=await render(emails[0].react);assert.ok(html.includes('04.11.2030'));assert.ok(html.includes('05.11.2030'));
+  assert.deepEqual(emails.map(e=>e.to).sort(),[p.email,f.parent.email].sort());assert.equal((await jobs()).filter(j=>j.kind==='PUBLICATION').length,2);
+});
+test('Mehrfaches und paralleles Veröffentlichen erzeugt keine doppelten Mails',async()=>{
+  const plan=await draft();const result=await Promise.all([publish(plan.id),publish(plan.id)]);assert.ok(result.every(r=>r.success));
+  assert.equal((await jobs()).length,1);assert.equal(emails.length,1);assert.equal((await publish(plan.id)).success,true);assert.equal(emails.length,1);
+});
+test('Mailfehler macht einen veröffentlichten Plan nicht rückgängig',async()=>{
+  const plan=await draft();failMail=true;const result=await publish(plan.id);assert.equal(result.success,true);assert.equal(result.failed,1);
+  assert.equal((await prisma.notdienstPlan.findUniqueOrThrow({where:{id:plan.id}})).status,'PUBLISHED');assert.equal((await jobs())[0].failed,true);
+  failMail=false;assert.equal((await retry(2030,11)).sent,1);assert.equal((await jobs())[0].sentAt!==null,true);
+});
+test('Beim Speichern der Mailaufträge fehlgeschlagene Veröffentlichung bleibt Entwurf',async()=>{
+  const plan=await draft();const load=loader({'@/lib/auth-utils':{requireRole:async()=>({user:current})},'@/lib/notdienst-notifications':{queueNotdienstPublication:async()=>{throw new Error('Test storage failure');}}});
+  const action=load('src/app/dashboard/notdienst/plan/actions.ts').publishPlanAction;assert.ok((await action(plan.id)).error);
+  assert.equal((await prisma.notdienstPlan.findUniqueOrThrow({where:{id:plan.id}})).status,'DRAFT');
+});
+test('Veröffentlichter Plan verhindert weitere automatische Erinnerungen',async()=>{
+  const plan=await draft();await publish(plan.id);emails.length=0;assert.equal((await auto()).queued,0);assert.equal(emails.length,0);
+});
+test('Einteilung wird vor einem Wiederholungsversuch erneut geprüft',async()=>{
+  const plan=await draft();failMail=true;await publish(plan.id);const job=(await jobs())[0];
+  await prisma.notdienstAssignment.deleteMany({where:{planId:plan.id}});failMail=false;
+  assert.equal((await service.deliverNotdienstEmails([job.id],sender,job.nextAttemptAt)).skipped,1);assert.equal(emails.length,1);
+});
+test('Empfänger sehen bei Wiederholung die aktuelle eigene Einteilung',async()=>{
+  const plan=await draft();failMail=true;await publish(plan.id);const job=(await jobs())[0];
+  await prisma.notdienstAssignment.deleteMany({where:{planId:plan.id,date:new Date('2030-11-04')}});failMail=false;
+  await service.deliverNotdienstEmails([job.id],sender,job.nextAttemptAt);const html=await render(emails[1].react);
+  assert.ok(!html.includes('04.11.2030'));assert.ok(html.includes('05.11.2030'));
+});
+test('Kein Auftrag für Haushalte ohne eigene Einteilung',async()=>{
+  const plan=await prisma.notdienstPlan.create({data:{kitaId:f.kita.id,year:2030,month:11}});await publish(plan.id);assert.equal((await jobs()).length,0);
+});
+test('Datenbank verhindert Empfängerbeziehungen zu einer fremden Kita',async()=>{
+  const other=await prisma.kita.create({data:{name:'Andere Kita',slug:randomUUID()}});tenants.push(other.id);
+  await assert.rejects(prisma.notdienstEmail.create({data:{kitaId:other.id,familyId:f.family.id,userId:f.parent.id,year:2030,month:11,kind:'REMINDER',eventKey:'cross-tenant'}}));
+});
+test('Wiederholungsaktion begrenzt den Versand auf die eigene Kita',async()=>{
+  const own=await draft();failMail=true;await publish(own.id);const other=await prisma.kita.create({data:{name:'Andere Kita',slug:randomUUID()}});tenants.push(other.id);
+  const beforeCount=emails.length;current={...current,kitaId:other.id};failMail=false;assert.equal((await retry(2030,11)).sent,0);assert.equal(emails.length,beforeCount);
+});
+test('Monatswechsel und Jahreswechsel verwenden Berliner Kalenderdaten',async()=>{
+  const dateUtils=loader()('src/lib/date-utils.ts');const target=dateUtils.getTargetMonthData(new Date('2030-12-31T23:00:00Z'));
+  assert.equal(target.targetYear,2031);assert.equal(target.targetMonth,2);
+  assert.equal(dateUtils.isNotdienstReminderDue(7,new Date('2030-10-26T22:00:00Z')),false);
+});
+
+test('Noch nicht fällige Kitas verdrängen fällige Erinnerungen nicht aus dem Batch',async()=>{
+ const rows=Array.from({length:101},(_,i)=>({id:`000-not-due-${randomUUID()}-${i}`,name:'Noch nicht fällig',slug:randomUUID(),notdienstReminderDaysBefore:1}));
+ await prisma.kita.createMany({data:rows});tenants.push(...rows.map(r=>r.id));
+ await service.runNotdienstNotificationJob(sender,now);
+ assert.equal(await prisma.notdienstReminderRun.count({where:{kitaId:f.kita.id,year:2030,month:11}}),1);
+ assert.equal((await jobs()).filter(j=>j.kind==='REMINDER').length,1);
+});
+test('Geschützter Job startet ohne gültiges Secret keine Verarbeitung',async()=>{
+ const authorization=loader()('src/lib/alarms/job.ts').authorizeAlarmJob;let called=0;
+ const route=loader({'@/lib/alarms/job':{authorizeAlarmJob:authorization,runAlarmJob:async()=>{called++;return {};}},'@/lib/notdienst-notifications':{runNotdienstNotificationJob:async()=>{called++;return {};}}})('src/app/api/jobs/notdienstalarme/route.ts').POST;
+ const old=process.env.NOTDIENST_JOB_SECRET;
+ try{delete process.env.NOTDIENST_JOB_SECRET;assert.equal((await route(new Request('http://127.0.0.1/api/jobs/notdienstalarme',{method:'POST'}))).status,503);
+ process.env.NOTDIENST_JOB_SECRET='test-only-secret-32-characters-long';assert.equal((await route(new Request('http://127.0.0.1/api/jobs/notdienstalarme',{method:'POST',headers:{authorization:'Bearer wrong'}}))).status,401);assert.equal(called,0);
+ const result=await route(new Request('http://127.0.0.1/api/jobs/notdienstalarme',{method:'POST',headers:{authorization:`Bearer ${process.env.NOTDIENST_JOB_SECRET}`}}));assert.equal(result.status,200);assert.equal(called,2);
+ }finally{if(old===undefined)delete process.env.NOTDIENST_JOB_SECRET;else process.env.NOTDIENST_JOB_SECRET=old;}
+});
+
+test('Zusammengesetzte Mail-Fremdschlüssel schützen auch Nutzer und Plan separat',async()=>{
+ const other=await prisma.kita.create({data:{name:'Fremde Kita',slug:randomUUID()}});tenants.push(other.id);
+ const foreignUser=await prisma.user.create({data:{kitaId:other.id,email:`${randomUUID()}@example.invalid`,firstName:'Foreign',lastName:'Test',passwordHash:'test'}});
+ const foreignPlan=await prisma.notdienstPlan.create({data:{kitaId:other.id,year:2030,month:11}});
+ const base={kitaId:f.kita.id,familyId:f.family.id,userId:f.parent.id,year:2030,month:11,kind:'REMINDER',eventKey:'tenant-check'};
+ await assert.rejects(prisma.notdienstEmail.create({data:{...base,userId:foreignUser.id}}),e=>e.code==='P2003');
+ await assert.rejects(prisma.notdienstEmail.create({data:{...base,kind:'PUBLICATION',planId:foreignPlan.id}}),e=>e.code==='P2003');
+});