docs: explain deployment, Resend setup and mail operations

deploy/DEPLOYMENT_UND_MAILVERSAND.md

@@ -0,0 +1,176 @@
+# Deployment und Mailversand – Anleitung für den Kita-Planer
+
+Stand: 09.10.2026. Grundlage sind die aktuelle Docker-/Coolify-Konfiguration und die umgesetzten Funktionen für Personal und Notdienstalarm.
+
+## 1. Vor dem Deployment festlegen
+
+- **App-Adresse:** eine feste HTTPS-Adresse, zum Beispiel `https://app.example.org`.
+- **Datenbank:** entweder PostgreSQL aus dem mitgelieferten Compose-Stack oder eine bereits bestehende Datenbank.
+- **Versanddomain:** eine eigene bei Resend verifizierte Domain, zum Beispiel `notify.example.org`.
+- **Absender:** zum Beispiel `Kita-Planer <noreply@notify.example.org>`.
+- **Kontaktpostfach:** eine tatsächlich erreichbare Adresse für `ADMIN_EMAIL`.
+- **Sicherung:** Datenbank und Upload-Dateien vor einem Update sichern; die Wiederherstellung sollte bekannt sein.
+
+Die Beispieladressen und Platzhalter in dieser Anleitung müssen durch deine Werte ersetzt werden. Zugangsdaten werden in der Hosting-Konfiguration hinterlegt und nicht ins Repository geschrieben.
+
+## 2. Coolify und Datenbank richtig verbinden
+
+In Coolify den gewünschten Release-Branch aus Gitea auswählen, **Docker Compose** als Build Pack und `docker-compose.coolify.yml` als Compose-Datei verwenden. Die aktuelle Implementierung des Notdienstalarms liegt auf `codex/notdienstalarm`; der ausgewählte Deployment-Stand muss diese Änderungen enthalten. Die öffentliche Domain dem Dienst **app**, internem Port **3000**, zuordnen und HTTPS aktivieren.
+
+### Variante A: Datenbank des mitgelieferten Compose-Stacks
+
+Die vorhandene Compose-Datei startet `postgres`, `app` und `pgadmin`. Für die Datenbank werden `POSTGRES_DB`, `POSTGRES_USER` und `POSTGRES_PASSWORD` gesetzt. Der App-Dienst erhält daraus automatisch:
+
+```text
+postgresql://POSTGRES_USER:POSTGRES_PASSWORD@postgres:5432/POSTGRES_DB?schema=public
+```
+
+`postgres` ist hier der interne Dienstname. Eine zusätzlich in Coolify eingetragene Variable `DATABASE_URL` wird von der aktuellen Compose-Datei **nicht** verwendet, weil die URL dort direkt zusammengesetzt wird. Bei Sonderzeichen im Datenbankpasswort muss die URL korrekt kodiert sein; alternativ die Compose-Konfiguration auf eine ausdrücklich bereitgestellte, korrekt kodierte `DATABASE_URL` umstellen.
+
+### Variante B: Bereits vorhandene Coolify-PostgreSQL-Datenbank
+
+Die Compose-Datei muss vor dem Deployment angepasst werden: Der App-Dienst soll die hinterlegte `DATABASE_URL` übernehmen, beispielsweise über `DATABASE_URL: ${DATABASE_URL:?}`. Die Abhängigkeit von dem bisherigen `postgres`-Dienst ist entsprechend anzupassen; einen unbenötigten separaten Datenbankdienst vermeiden. Falls pgAdmin weiter genutzt wird, dessen Konfiguration und Abhängigkeit ebenfalls prüfen.
+
+Die App muss die bestehende Datenbank über das interne Coolify-Netzwerk erreichen können. `localhost` in der App-URL würde auf den App-Container zeigen. Vor dem Start verifizieren, dass die URL wirklich auf die gewünschte Datenbank zeigt; der Start wendet das Anwendungsschema auf genau diese Datenbank an.
+
+## 3. Umgebungsvariablen
+
+Die ausfüllbare Vorlage ist [production.env.example](production.env.example). In Coolify werden Werte normalerweise ohne die Anführungszeichen einer `.env`-Datei eingetragen.
+
+| Variable | Was du eintragen bzw. prüfen musst |
+| --- | --- |
+| `POSTGRES_DB`, `POSTGRES_USER`, `POSTGRES_PASSWORD` | Für den mitgelieferten Datenbankdienst. Bestehende Zugangsdaten bei Updates beibehalten; Werte mit der tatsächlichen Datenbank abgleichen. |
+| `DATABASE_URL` | Bei einer angepassten Compose-Datei bzw. anderem Hosting: interne PostgreSQL-URL einschließlich Zugangsdaten und Schema. |
+| `AUTH_SECRET` | Einmalig zufällig erzeugen und dauerhaft speichern; nicht bei jedem Deployment ersetzen. Ein Wechsel beendet bestehende Sessions. |
+| `AUTH_URL` | Die öffentliche HTTPS-App-Adresse. |
+| `NEXTAUTH_URL` | Dieselbe öffentliche Adresse; bestehende Einladungsabläufe verwenden auch diesen Namen. |
+| `NEXT_PUBLIC_SITE_URL` | Dieselbe öffentliche Adresse, ohne abschließenden Slash und ohne Unterpfad. Für Mail-Links und öffentliche URLs erforderlich. |
+| `RESEND_API_KEY` | Gültiger Resend-Schlüssel mit Versandberechtigung für die gewählte Domain. |
+| `EMAIL_FROM` | Anzeigename und Adresse der verifizierten Versanddomain, beispielsweise `Kita-Planer <noreply@notify.example.org>`. |
+| `ADMIN_EMAIL` | Empfänger der Kontaktformular-Anfragen. Diese Variable ersetzt nicht die Kita-Admin-Konten für Personal- oder Notdiensthinweise. |
+| `NOTDIENST_JOB_SECRET` | Eigenes zufälliges Secret mit mindestens 32 Zeichen für die automatische Notdienst-Fristprüfung. |
+| `UPLOAD_DIR` | Dauerhaft gespeichertes Verzeichnis für Anhänge; im aktuellen Compose-Stack `/app/uploads/announcements`. |
+| `PGADMIN_DEFAULT_EMAIL`, `PGADMIN_DEFAULT_PASSWORD` | Nur erforderlich, wenn der mitgelieferte pgAdmin-Dienst genutzt wird. |
+| `NEXT_PUBLIC_UMAMI_*` | Optional. Ohne Analytics leer lassen. |
+
+Zwei getrennte Secrets lassen sich lokal erzeugen:
+
+```sh
+# AUTH_SECRET
+openssl rand -base64 32
+
+# NOTDIENST_JOB_SECRET – einen anderen Wert verwenden
+openssl rand -hex 32
+```
+
+Die ausgegebenen Werte sicher in Coolify hinterlegen. `NEXT_PUBLIC_SITE_URL` muss im aktuellen Docker-Ablauf sowohl beim **Build** als auch zur **Laufzeit** vorhanden sein. Nach einer Domainänderung neu bauen und deployen. Nach Änderungen an Mail-Schlüssel oder Absender die App neu starten, damit die neue Konfiguration verwendet wird.
+
+Für Produktion gilt `NODE_ENV=production`. `TEST_MODE` und `ALLOW_DATABASE_SEED` bleiben ungesetzt. Der vorhandene Befehl `npm run dev` führt einen Schemaabgleich und Demo-Seeding aus und ist deshalb kein Produktionsstart.
+
+## 4. Schema, Start und dauerhafte Dateien
+
+Der Docker-Build installiert Abhängigkeiten, generiert den Prisma-Client und erstellt den Produktionsbuild. Beim Container-Start führt `scripts/start-production.sh` aus:
+
+```sh
+npx prisma db push --skip-generate
+```
+
+Danach startet es den Notdienst-Worker und die App. Das Projekt besitzt weiterhin keine vollständige versionierte Prisma-Migrationshistorie. Vor Updates Schemaänderungen und Startlogs prüfen; bei einem fehlgeschlagenen Schemaabgleich die Ursache klären, bevor das Deployment fortgesetzt wird.
+
+Für kontrollierte, einmalige SQL-Upgrades gibt es diese Alternativen:
+
+| Ausgangsstand | Passendes SQL-Upgrade |
+| --- | --- |
+| Personalbereich noch nicht vorhanden, Stand passend zur Einführung | [personalbereich.sql](sql/personalbereich.sql) führt den vollständigen Personalbereich **einschließlich** Mail-Erweiterung ein. |
+| Personalbereich bereits auf `043fed2`, Mail-Erweiterung noch nicht vorhanden | Nur [personalbereich-email.sql](sql/personalbereich-email.sql). |
+| Personalbereich einschließlich Mail-Erweiterung vorhanden, Notdienstalarm noch nicht vorhanden | [notdienstalarm.sql](sql/notdienstalarm.sql). |
+
+`personalbereich.sql` und `personalbereich-email.sql` sind **keine** aufeinanderfolgende Skriptfolge: Das erste enthält die Mail-Erweiterung bereits. Die SQL-Skripte sind nicht für wiederholte Ausführung gedacht. Hat `db push` die betreffende Erweiterung schon angewandt, das entsprechende SQL nicht zusätzlich ausführen.
+
+Im Compose-Stack sichern die Volumes `kita_planer_postgres_data` und `kita_planer_uploads` Datenbank und Anhänge über Containerwechsel hinweg. Bei Nutzung von pgAdmin kommt dessen eigenes Volume hinzu. Die Anwendung hängt `announcements` an `UPLOAD_DIR` an; im aktuellen Compose-Setup liegen Dateien deshalb unter `/app/uploads/announcements/announcements`. Dieser Pfad ist vom Volume `/app/uploads` abgedeckt. Bei einem Wechsel des Speicherpfads bestehende Dateien und Sicherungen berücksichtigen.
+
+Bei anderem Hosting sind Build, Schemaabgleich, App-Start und Worker separat sicherzustellen. `npm run start` bzw. `npm run start:prod` allein starten nur die App, wenden kein Schema an und starten keinen Notdienst-Worker.
+
+## 5. Mailversand mit Resend einrichten
+
+Die Anwendung versendet über die **Resend-API**. SMTP-Host, SMTP-Port oder ein normales Postfachpasswort werden dafür nicht verwendet.
+
+1. Im Resend-Dashboard eine eigene Versanddomain hinzufügen. Eine Subdomain wie `notify.example.org` hält den Transaktionsversand übersichtlich getrennt; auch Resend empfiehlt Subdomains für den Versand.
+2. Die von Resend angezeigten DNS-Einträge für SPF/DKIM einschließlich der dort verlangten TXT-, MX- oder CNAME-Einträge exakt beim DNS-Anbieter übernehmen. Resend-CNAMEs als DNS-Einträge ohne Proxy konfigurieren. Keine generischen DNS-Werte aus dieser Anleitung einsetzen.
+3. Im Resend-Dashboard die erfolgreiche Verifizierung abwarten.
+4. `EMAIL_FROM` auf eine Adresse genau dieser Versanddomain setzen. Bei Verifizierung von `notify.example.org` beispielsweise `noreply@notify.example.org` verwenden.
+
+Die aktuellen Schritte beschreibt die offizielle [Resend-Anleitung zur Domain-Verifizierung](https://resend.com/docs/add-a-domain).
+
+5. DMARC passend zum bestehenden Mailbetrieb konfigurieren. Die [Resend-DMARC-Anleitung](https://resend.com/docs/dashboard/domains/dmarc) erklärt die Einrichtung; bestehende Postfach- und DNS-Konfiguration berücksichtigen.
+6. Einen Versand-API-Schlüssel anlegen, `RESEND_API_KEY` in Coolify setzen und die App neu starten.
+7. Für Einladungs- und Rückmeldelinks Open-/Click-Tracking ausgeschaltet lassen. Das ist unsere Betriebsempfehlung für diese Transaktionsmails. Tracking ist bei Resend standardmäßig deaktiviert und kann Domains separat zugeordnet werden. Siehe [Resend: Open and Click Tracking](https://resend.com/docs/dashboard/domains/tracking).
+
+`onboarding@resend.dev` ist für den regulären Versand an Familien ungeeignet: Mit der Testdomain darf nur an die zum Resend-Konto gehörende Adresse gesendet werden. Für andere Empfänger braucht es die eigene verifizierte Domain. Siehe [Resend: Testdomain und 403-Fehler](https://resend.com/docs/knowledge-base/403-error-resend-dev-domain).
+
+`ADMIN_EMAIL` sollte ein betreutes Postfach sein. Für andere Absenderadressen separat entscheiden, ob Antworten empfangen werden sollen; die Versandkonfiguration allein richtet in der Anwendung kein betreutes Postfach ein. Im Kontaktformular setzt die App Reply-To für Anfrage und Eingangsbestätigung. Die aktuellen Personal- und Notdienstmails setzen kein eigenes Reply-To und führen die Empfänger über die Links in die App.
+
+In Entwicklung ohne API-Schlüssel simuliert der Mailtransport den Versand und meldet Erfolg. Ein funktionierender lokaler Ablauf belegt daher noch keine echte Zustellung. In Produktion bleibt fehlgeschlagener Versand als Fehler bzw. ausstehender Auftrag sichtbar. Mit einem vorhandenen echten API-Schlüssel kann auch die Entwicklungsumgebung echte E-Mails verschicken.
+
+## 6. Wer erhält welche E-Mails?
+
+| Anlass | Empfänger / Verhalten |
+| --- | --- |
+| Kontaktformular | `ADMIN_EMAIL` erhält die Anfrage; die anfragende Person erhält eine Eingangsbestätigung. |
+| Eltern-Einladung | Hinterlegte Elternadresse mit persönlichem Einladungslink. |
+| Fachkraft aktivieren | Hinterlegte Fachkraftadresse; der Aktivierungslink gilt sieben Tage. Ein neuer Link ersetzt den alten. |
+| Personal-Antrag / eingereichte Arbeitswoche | Alle zuständigen Kita-Admins derselben Kita. |
+| Personal-Entscheidung | Betroffene Fachkraft, sofern Entscheidungsmails im Profil eingeschaltet sind. Aktivierungsmails bleiben davon unabhängig. |
+| Notdienstalarm auslösen | Elternkonten der eingeteilten Familie; jedes Konto erhält einen eigenen Link. |
+| Notdienst-Rückmeldung / Absage / Fristablauf | Kita-Admins und Notdienst-Koordination derselben Kita. |
+| Notdienst-Stornierung / dokumentierte Statusänderung | Betroffener Haushalt; bei dokumentierter Rückmeldung erhalten auch Admins und Koordination einen Hinweis. |
+
+Private Personalnotizen, Kontostände und interne Begründungen sowie interne Notdienst-Fachkraftdaten werden nicht in diese Personal-/Notdienstmails übernommen. Die Auswahl der Kita-Empfänger erfolgt anhand der Konten und Rollen in der Datenbank; `ADMIN_EMAIL` ist hierfür kein Sammelverteiler.
+
+## 7. Automatische Notdienst-Fristprüfung und Wiederholungen
+
+Mit gültigem `NOTDIENST_JOB_SECRET` startet der Docker-Produktionsstart `scripts/notdienst-alarm-worker.mjs`. Dieser ruft nach fünf Sekunden und danach ungefähr jede Minute die lokale Route `POST /api/jobs/notdienstalarme` auf. Die voreingestellte Antwortfrist beträgt 30 Minuten; die Meldung erfolgt beim nächsten erfolgreichen Joblauf nach Fristende, nicht sekundengenau.
+
+Bei anderem Hosting den Worker dauerhaft und mit automatischem Neustart betreiben oder einen Scheduler mindestens einmal pro Minute die Jobroute per POST mit `Authorization: Bearer <NOTDIENST_JOB_SECRET>` aufrufen lassen. Der Prozess darf nicht davon abhängen, dass ein Browser geöffnet ist. Ein gesetztes Secret allein beweist keinen laufenden Worker.
+
+| Bereich | Was passiert nach einem Versandfehler? |
+| --- | --- |
+| Notdienstalarm | Auftrag bleibt erhalten; der Job versucht den Versand erneut. In der Alarmansicht ist zusätzlich ein manueller erneuter Versuch möglich. Die Antwortfrist startet dabei nicht neu. |
+| Personalbereich | Auftrag bleibt erhalten; über **Versand erneut versuchen** in der Oberfläche wiederholen. Aktuell gibt es hierfür keinen eigenen Hintergrundjob; der Notdienst-Worker bearbeitet keine Personalmails. |
+| Andere bestehende Mailabläufe | Nicht alle besitzen eine dauerhafte Versandwarteschlange. Den konkreten Fehler und den Stand von Einladung/Aktion prüfen, bevor der Ablauf erneut ausgelöst wird. |
+
+Ein Alarm-Job verarbeitet höchstens 100 Fristfälle und 100 ausstehende E-Mail-Aufträge pro Lauf. Bei größerem Rückstand sind weitere Läufe nötig. Die gespeicherte Aktion bleibt bei einem Mailfehler erhalten. Resend-Annahme bedeutet nicht, dass die Nachricht bereits im Postfach angekommen ist; eine automatische Auswertung von Zustell-/Bounce-Webhooks ist im geprüften Anwendungscode nicht angebunden.
+
+## 8. Nach dem Deployment prüfen
+
+Die Mailprüfung mit eigens dafür eingerichteten Konten und Postfächern durchführen. Bei einer Notdienstprüfung eine Test-Kita und eine Test-Einteilung verwenden, damit keine regulären Familien versehentlich alarmiert werden.
+
+- [ ] HTTPS, Startseite, Anmeldung und Dashboard erreichbar.
+- [ ] Build- und Startlogs ohne Schemafehler; App verwendet die richtige Datenbank.
+- [ ] Anhänge nach einem Containerneustart weiterhin verfügbar.
+- [ ] Kontaktformular: Anfrage kommt bei `ADMIN_EMAIL` an und Eingangsbestätigung im Testpostfach.
+- [ ] Eltern- und Fachkrafteinladung: korrekte öffentliche Domain im Link; Aktivierung funktioniert.
+- [ ] Personal-Antrag: Kita-Admins erhalten den Hinweis; Entscheidung erreicht die Fachkraft. Abschalteinstellung im Profil geprüft.
+- [ ] Test-Notdienstalarm: nur die eingeteilte Testfamilie erhält die Anfrage; eine Haushaltsantwort aktualisiert den gemeinsamen Status.
+- [ ] Test-Fristablauf bei geschlossenem Browser: genau ein Hinweis pro zuständigem Admin/Koordinator, beim nächsten Joblauf nach Fristende.
+- [ ] Stornierung informiert den Testhaushalt; alter Link kann keine Antwort mehr speichern.
+- [ ] Resend-Dashboard und echte Postfächer einschließlich Spamordner geprüft; keine ausstehenden fehlgeschlagenen Aufträge übersehen.
+- [ ] Resend-Kontingente, API-Fehler und Bounces im laufenden Betrieb überwacht.
+
+## 9. Häufige Fehler
+
+| Beobachtung | Zuerst prüfen |
+| --- | --- |
+| Mail fehlt trotz lokaler Erfolgsmeldung | War es Entwicklungsmodus ohne API-Schlüssel? Dann wurde nur simuliert. |
+| Link zeigt auf localhost oder die falsche Domain | Alle drei App-URLs angleichen, `NEXT_PUBLIC_SITE_URL` auch beim Build setzen und neu deployen. Schon versendete Links ändern sich dadurch nicht rückwirkend. |
+| Resend lehnt Versand ab | API-Schlüssel, verifizierte Domain, `EMAIL_FROM`, Versandberechtigung und Kontingente prüfen. Bei 403 auch die Testdomain prüfen. |
+| Resend hat angenommen, Postfach bleibt leer | Resend-Zustellstatus, Bounce/Suppression, Empfängeradresse und Spamordner prüfen. |
+| Personalaktion gespeichert, Mail ausstehend | Konfiguration beheben, dann im Personalbereich den Versand erneut versuchen. |
+| Notdienst-Frist ist abgelaufen, kein Hinweis kommt | Worker/Scheduler, Logs und `NOTDIENST_JOB_SECRET` prüfen; Browseranzeige und tatsächliche Jobausführung sind getrennt. |
+| Jobroute liefert 401 | Bearer-Header fehlt oder Secret stimmt nicht. |
+| Jobroute liefert 503 | Secret fehlt oder ist kürzer als 32 Zeichen. |
+| Jobroute liefert 500 | Joblauf fehlgeschlagen; Serverlogs und Datenbank prüfen. |
+| Jobroute liefert 200, dennoch fehlen Mails | Das Ergebnis kann fehlgeschlagene Versandaufträge enthalten. Versandübersicht und Resend-Konfiguration prüfen. |
+| Deployment startet nicht | Required-Variablen der Compose-Datei, Datenbankzugriff, Schemaabgleich und Secret-Länge prüfen. |
+
+Ergänzende Details: [Notdienstalarm](../docs/NOTDIENSTALARM.md), [Personalbereich](../docs/PERSONALBEREICH.md), [Produktionscheckliste](production-checklist.md). Die produktive Hosting- und Resend-Konfiguration wurde für diese Anleitung nicht verändert; sie dokumentiert die noch auszuführenden Einrichtungsschritte.

deploy/README.md

@@ -2,6 +2,8 @@
 
 Dieses Verzeichnis enthaelt die ausfuellbaren Vorlagen fuer das Production-Deployment.
 
+Die zentrale Schritt-für-Schritt-Anleitung steht in [DEPLOYMENT_UND_MAILVERSAND.md](DEPLOYMENT_UND_MAILVERSAND.md). Sie erklärt die Datenbankvarianten, alle benötigten Variablen, Resend und DNS, Fristprüfung, Versandwiederholungen und die Prüfung nach dem Deployment.
+
 ## Dateien
 
 - `production.env.example`: Vorlage fuer alle benoetigten Environment Variables.
@@ -15,7 +17,7 @@ Dieses Verzeichnis enthaelt die ausfuellbaren Vorlagen fuer das Production-Deplo
 2. In Coolify eine neue Application aus diesem Gitea-Repository anlegen.
 3. Als Build Pack `Docker Compose` waehlen.
 4. Als Compose-Datei `docker-compose.coolify.yml` eintragen.
-5. Die bestehende Coolify-Postgres-Datenbank ueber ihre interne `DATABASE_URL` verbinden.
+5. Datenbankvariante wählen: Die aktuelle Compose-Datei bringt PostgreSQL mit und setzt daraus die App-URL zusammen. Für eine bestehende Coolify-Datenbank zuerst die Compose-Konfiguration auf deren `DATABASE_URL` und Netzwerkverbindung anpassen; siehe zentrale Anleitung.
 6. Environment Variables aus `production.env.example` in Coolify eintragen.
 7. Domain auf den `app`-Service mit internem Port `3000` zeigen lassen.
 8. Deploy starten.
@@ -23,13 +25,17 @@ Dieses Verzeichnis enthaelt die ausfuellbaren Vorlagen fuer das Production-Deplo
 Beim Container-Start fuehrt `scripts/start-production.sh` automatisch aus:
 
 ```bash
-npx prisma db push
+npx prisma db push --skip-generate
 ```
 
 Coolify erkennt Variablen aus `docker-compose.coolify.yml` und zeigt required Variablen
 wie `DATABASE_URL`, `AUTH_SECRET`, `AUTH_URL`, `NEXTAUTH_URL`, `NEXT_PUBLIC_SITE_URL`,
 `RESEND_API_KEY`, `EMAIL_FROM` und `ADMIN_EMAIL` in der UI an.
 
+## Notdienstalarm
+
+Die Compose-Vorlage benötigt zusätzlich `NOTDIENST_JOB_SECRET` (zufällig, mindestens 32 Zeichen). Der Produktionsstart führt die Fristprüfung über einen lokalen Hintergrundprozess ungefähr jede Minute aus. Ein alleiniger Start mit `npm run start` benötigt einen separat gestarteten Worker oder einen Scheduler. Details, Versandprüfung und das additive SQL-Upgrade stehen in [docs/NOTDIENSTALARM.md](../docs/NOTDIENSTALARM.md).
+
 ## Welche Coolify-Postgres-URL?
 
 Wenn die App und die Postgres-DB im selben Coolify-Projekt/Netzwerk laufen, nimm

deploy/production-checklist.md

@@ -9,8 +9,8 @@
 
 ## 2. Datenbank
 
-- [ ] Interne `DATABASE_URL` der bestehenden Coolify-Postgres-DB kopieren
+- [ ] Datenbankvariante wählen: mitgelieferter Compose-Dienst oder vorhandene Datenbank
-- [ ] `DATABASE_URL` in der Coolify-App eintragen
+- [ ] Bei vorhandener Datenbank Compose-Konfiguration und Netzwerkverbindung auf deren interne `DATABASE_URL` anpassen; die unveränderte Vorlage verwendet den eigenen `postgres`-Dienst
 - [ ] Beim ersten App-Start wird das Schema automatisch mit `npx prisma db push --skip-generate` angewendet
 - [ ] Fuer spaetere Releases idealerweise Prisma-Migrationen einfuehren
 
@@ -46,7 +46,7 @@
 
 - [ ] Dependencies installieren: `npm ci`
 - [ ] Production Build erstellen: `npm run build:prod`
-- [ ] App starten: `npm run start:prod`
+- [ ] Produktionsstart mit Schemaabgleich und Notdienst-Worker verwenden: `scripts/start-production.sh`; bei anderem Hosting diese Schritte separat sicherstellen
 - [ ] Startseite, Login, Dashboard und Kontaktformular testen
 
 ## 8. Coolify
@@ -58,3 +58,12 @@
 - [ ] Environment Variables in Coolify eintragen, nicht ins Repo committen
 - [ ] Domain auf den `app`-Service und Container-Port `3000` routen
 - [ ] Upload-Volume `kita_planer_uploads` bleibt zwischen Deployments erhalten
+
+## Notdienstalarm – ergänzende Betriebsprüfung
+
+- [ ] `NOTDIENST_JOB_SECRET` zufällig erzeugt, mindestens 32 Zeichen, nur als Runtime-Secret gespeichert.
+- [ ] Schema-Upgrade gesichert und angewandt; `db push` oder einmaliges SQL-Upgrade, nicht beides hintereinander.
+- [ ] Worker bzw. Scheduler startet nach Neustart automatisch und ruft die geschützte Jobroute jede Minute auf.
+- [ ] Fristablauf mit geschlossenem Browser geprüft: einmaliger Hinweis an Admins und Koordination.
+- [ ] Versanddienst und öffentliche App-Adresse geprüft; Rückmeldelinks erreichen die tatsächliche Domain.
+- [ ] Versandübersicht auf Fehler geprüft; Annahme durch den Maildienst und Postfachzustellung getrennt geprüft.

deploy/production.env.example

@@ -36,6 +36,10 @@ 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.
+# Eigenes Secret, mindestens 32 Zeichen; generieren mit: openssl rand -hex 32
+NOTDIENST_JOB_SECRET="[GENERATE_ME]"
+
 # Persistenter Upload-Speicher fuer Anhaenge vom Schwarzen Brett.
 # Muss auf dem Server dauerhaft erhalten bleiben und darf nicht im Repo liegen.
 UPLOAD_DIR="/var/lib/kita-planer/uploads/announcements"

deploy/sql/notdienstalarm.sql

@@ -0,0 +1,160 @@
+-- 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.
+BEGIN;
+
+-- CreateEnum
+CREATE TYPE "NotdienstAlarmStatus" AS ENUM ('PENDING', 'CONFIRMED', 'DECLINED', 'LATE_CONFIRMATION', 'REVIEW_REQUIRED', 'CANCELLED');
+
+-- AlterTable
+ALTER TABLE "notdienst_alerts" ADD COLUMN     "alarmId" TEXT;
+
+-- CreateTable
+CREATE TABLE "notdienst_alarms" (
+    "id" TEXT NOT NULL,
+    "kitaId" TEXT NOT NULL,
+    "assignmentId" TEXT,
+    "activeAssignmentId" TEXT,
+    "familyId" TEXT NOT NULL,
+    "familyName" TEXT NOT NULL,
+    "childName" TEXT NOT NULL,
+    "date" DATE NOT NULL,
+    "wholeDay" BOOLEAN NOT NULL DEFAULT true,
+    "startMinute" INTEGER,
+    "endMinute" INTEGER,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "deadline" TIMESTAMP(3) NOT NULL,
+    "status" "NotdienstAlarmStatus" NOT NULL DEFAULT 'PENDING',
+    "triggeredById" TEXT,
+    "triggeredAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "respondedById" TEXT,
+    "respondedAt" TIMESTAMP(3),
+    "responseSource" TEXT,
+    "escalatedAt" TIMESTAMP(3),
+    "educatorId" TEXT,
+    "notes" TEXT,
+    "cancelledAt" TIMESTAMP(3),
+    "cancelReason" TEXT,
+
+    CONSTRAINT "notdienst_alarms_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "notdienst_alarm_recipients" (
+    "id" TEXT NOT NULL,
+    "alarmId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "token" TEXT NOT NULL,
+
+    CONSTRAINT "notdienst_alarm_recipients_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "notdienst_alarm_notifications" (
+    "id" TEXT NOT NULL,
+    "alarmId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "eventKey" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "readAt" TIMESTAMP(3),
+
+    CONSTRAINT "notdienst_alarm_notifications_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "notdienst_alarm_emails" (
+    "id" TEXT NOT NULL,
+    "alarmId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "eventKey" TEXT NOT NULL,
+    "kind" TEXT NOT NULL,
+    "subject" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "sentAt" TIMESTAMP(3),
+    "skippedAt" TIMESTAMP(3),
+    "leaseUntil" TIMESTAMP(3),
+    "failed" BOOLEAN NOT NULL DEFAULT false,
+    "attempts" INTEGER NOT NULL DEFAULT 0,
+
+    CONSTRAINT "notdienst_alarm_emails_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "notdienst_alarm_history" (
+    "id" TEXT NOT NULL,
+    "alarmId" TEXT NOT NULL,
+    "actorId" TEXT,
+    "action" TEXT NOT NULL,
+    "details" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "notdienst_alarm_history_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "notdienst_alarms_activeAssignmentId_key" ON "notdienst_alarms"("activeAssignmentId");
+
+-- CreateIndex
+CREATE INDEX "notdienst_alarms_kitaId_date_idx" ON "notdienst_alarms"("kitaId", "date");
+
+-- CreateIndex
+CREATE INDEX "notdienst_alarms_status_deadline_idx" ON "notdienst_alarms"("status", "deadline");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "notdienst_alarm_recipients_token_key" ON "notdienst_alarm_recipients"("token");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "notdienst_alarm_recipients_alarmId_userId_key" ON "notdienst_alarm_recipients"("alarmId", "userId");
+
+-- CreateIndex
+CREATE INDEX "notdienst_alarm_notifications_userId_readAt_idx" ON "notdienst_alarm_notifications"("userId", "readAt");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "notdienst_alarm_notifications_alarmId_userId_eventKey_key" ON "notdienst_alarm_notifications"("alarmId", "userId", "eventKey");
+
+-- CreateIndex
+CREATE INDEX "notdienst_alarm_emails_sentAt_skippedAt_createdAt_idx" ON "notdienst_alarm_emails"("sentAt", "skippedAt", "createdAt");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "notdienst_alarm_emails_alarmId_userId_eventKey_key" ON "notdienst_alarm_emails"("alarmId", "userId", "eventKey");
+
+-- CreateIndex
+CREATE INDEX "notdienst_alarm_history_alarmId_createdAt_idx" ON "notdienst_alarm_history"("alarmId", "createdAt");
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarms" ADD CONSTRAINT "notdienst_alarms_kitaId_fkey" FOREIGN KEY ("kitaId") REFERENCES "kitas"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarms" ADD CONSTRAINT "notdienst_alarms_assignmentId_fkey" FOREIGN KEY ("assignmentId") REFERENCES "notdienst_assignments"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarms" ADD CONSTRAINT "notdienst_alarms_familyId_fkey" FOREIGN KEY ("familyId") REFERENCES "families"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarm_recipients" ADD CONSTRAINT "notdienst_alarm_recipients_alarmId_fkey" FOREIGN KEY ("alarmId") REFERENCES "notdienst_alarms"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarm_recipients" ADD CONSTRAINT "notdienst_alarm_recipients_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarm_notifications" ADD CONSTRAINT "notdienst_alarm_notifications_alarmId_fkey" FOREIGN KEY ("alarmId") REFERENCES "notdienst_alarms"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarm_notifications" ADD CONSTRAINT "notdienst_alarm_notifications_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarm_emails" ADD CONSTRAINT "notdienst_alarm_emails_alarmId_fkey" FOREIGN KEY ("alarmId") REFERENCES "notdienst_alarms"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarm_emails" ADD CONSTRAINT "notdienst_alarm_emails_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alarm_history" ADD CONSTRAINT "notdienst_alarm_history_alarmId_fkey" FOREIGN KEY ("alarmId") REFERENCES "notdienst_alarms"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notdienst_alerts" ADD CONSTRAINT "notdienst_alerts_alarmId_fkey" FOREIGN KEY ("alarmId") REFERENCES "notdienst_alarms"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+
+COMMIT;

deploy/sql/personalbereich-email.sql

@@ -0,0 +1,37 @@
+-- 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.
+BEGIN;
+
+-- AlterTable
+ALTER TABLE "users" ADD COLUMN     "staffDecisionEmails" BOOLEAN NOT NULL DEFAULT true;
+
+-- CreateTable
+CREATE TABLE "staff_emails" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "toAdmins" BOOLEAN NOT NULL DEFAULT false,
+    "subject" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "inviteToken" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "sentAt" TIMESTAMP(3),
+    "skippedAt" TIMESTAMP(3),
+    "leaseUntil" TIMESTAMP(3),
+    "attempts" INTEGER NOT NULL DEFAULT 0,
+    "failed" BOOLEAN NOT NULL DEFAULT false,
+
+    CONSTRAINT "staff_emails_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "staff_emails_profileId_sentAt_skippedAt_idx" ON "staff_emails"("profileId", "sentAt", "skippedAt");
+
+-- AddForeignKey
+ALTER TABLE "staff_emails" ADD CONSTRAINT "staff_emails_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_emails" ADD CONSTRAINT "staff_emails_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+COMMIT;

deploy/sql/personalbereich.sql

@@ -0,0 +1,286 @@
+-- Einmalige Einführung des vollständigen Personalbereichs inklusive E-Mails ab ec3f4f9.
+-- Alternative zu prisma db push, nicht zusätzlich oder mehrfach ausführen.
+BEGIN;
+
+-- CreateEnum
+CREATE TYPE "StaffRequestStatus" AS ENUM ('PENDING', 'APPROVED', 'REJECTED', 'CANCEL_REQUESTED', 'CANCELLED');
+
+-- CreateEnum
+CREATE TYPE "StaffLeaveKind" AS ENUM ('VACATION', 'TIME_OFF', 'SICKNESS');
+
+-- CreateEnum
+CREATE TYPE "StaffWeekStatus" AS ENUM ('DRAFT', 'SUBMITTED', 'APPROVED');
+
+-- AlterTable
+ALTER TABLE "users" ADD COLUMN     "staffDecisionEmails" BOOLEAN NOT NULL DEFAULT true;
+
+-- CreateTable
+CREATE TABLE "staff_profiles" (
+    "id" TEXT NOT NULL,
+    "kitaId" TEXT NOT NULL,
+    "educatorId" TEXT NOT NULL,
+    "userId" TEXT,
+    "employmentStart" DATE NOT NULL,
+    "employmentEnd" DATE,
+    "trackingStart" DATE NOT NULL,
+    "openingMinutes" INTEGER NOT NULL DEFAULT 0,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "staff_profiles_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_emails" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "toAdmins" BOOLEAN NOT NULL DEFAULT false,
+    "subject" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "inviteToken" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "sentAt" TIMESTAMP(3),
+    "skippedAt" TIMESTAMP(3),
+    "leaseUntil" TIMESTAMP(3),
+    "attempts" INTEGER NOT NULL DEFAULT 0,
+    "failed" BOOLEAN NOT NULL DEFAULT false,
+
+    CONSTRAINT "staff_emails_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_work_patterns" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "effectiveFrom" DATE NOT NULL,
+    "dailyMinutes" INTEGER[],
+
+    CONSTRAINT "staff_work_patterns_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_day_overrides" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "date" DATE NOT NULL,
+    "minutes" INTEGER NOT NULL,
+    "reason" TEXT NOT NULL,
+
+    CONSTRAINT "staff_day_overrides_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_holidays" (
+    "id" TEXT NOT NULL,
+    "kitaId" TEXT NOT NULL,
+    "date" DATE NOT NULL,
+    "name" TEXT NOT NULL,
+
+    CONSTRAINT "staff_holidays_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_leave_accounts" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "year" INTEGER NOT NULL,
+    "entitlementUnits" INTEGER NOT NULL,
+    "carryUnits" INTEGER NOT NULL DEFAULT 0,
+
+    CONSTRAINT "staff_leave_accounts_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_leaves" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "kind" "StaffLeaveKind" NOT NULL,
+    "status" "StaffRequestStatus" NOT NULL DEFAULT 'PENDING',
+    "startDate" DATE NOT NULL,
+    "endDate" DATE NOT NULL,
+    "halfDay" BOOLEAN NOT NULL DEFAULT false,
+    "minutes" INTEGER,
+    "note" TEXT,
+    "decisionNote" TEXT,
+    "requestedById" TEXT NOT NULL,
+    "reviewedById" TEXT,
+    "reviewedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "staff_leaves_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_leave_days" (
+    "id" TEXT NOT NULL,
+    "leaveId" TEXT NOT NULL,
+    "date" DATE NOT NULL,
+    "vacationUnits" INTEGER NOT NULL DEFAULT 0,
+    "creditMinutes" INTEGER NOT NULL,
+
+    CONSTRAINT "staff_leave_days_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_time_entries" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "date" DATE NOT NULL,
+    "startMinute" INTEGER NOT NULL,
+    "endMinute" INTEGER NOT NULL,
+    "breakMinutes" INTEGER NOT NULL DEFAULT 0,
+    "note" TEXT,
+
+    CONSTRAINT "staff_time_entries_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_weeks" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "weekStart" DATE NOT NULL,
+    "status" "StaffWeekStatus" NOT NULL DEFAULT 'DRAFT',
+    "submittedAt" TIMESTAMP(3),
+    "reviewedAt" TIMESTAMP(3),
+    "reviewedById" TEXT,
+    "decisionNote" TEXT,
+    "dailySnapshot" JSONB,
+
+    CONSTRAINT "staff_weeks_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_adjustments" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "date" DATE NOT NULL,
+    "minutes" INTEGER NOT NULL,
+    "reason" TEXT NOT NULL,
+    "actorId" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "staff_adjustments_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_history" (
+    "id" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "actorId" TEXT NOT NULL,
+    "action" TEXT NOT NULL,
+    "details" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "staff_history_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "staff_notifications" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "profileId" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "readAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "staff_notifications_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_profiles_educatorId_key" ON "staff_profiles"("educatorId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_profiles_userId_key" ON "staff_profiles"("userId");
+
+-- CreateIndex
+CREATE INDEX "staff_profiles_kitaId_idx" ON "staff_profiles"("kitaId");
+
+-- CreateIndex
+CREATE INDEX "staff_emails_profileId_sentAt_skippedAt_idx" ON "staff_emails"("profileId", "sentAt", "skippedAt");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_work_patterns_profileId_effectiveFrom_key" ON "staff_work_patterns"("profileId", "effectiveFrom");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_day_overrides_profileId_date_key" ON "staff_day_overrides"("profileId", "date");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_holidays_kitaId_date_key" ON "staff_holidays"("kitaId", "date");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_leave_accounts_profileId_year_key" ON "staff_leave_accounts"("profileId", "year");
+
+-- CreateIndex
+CREATE INDEX "staff_leaves_profileId_status_startDate_idx" ON "staff_leaves"("profileId", "status", "startDate");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_leave_days_leaveId_date_key" ON "staff_leave_days"("leaveId", "date");
+
+-- CreateIndex
+CREATE INDEX "staff_time_entries_profileId_date_idx" ON "staff_time_entries"("profileId", "date");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "staff_weeks_profileId_weekStart_key" ON "staff_weeks"("profileId", "weekStart");
+
+-- CreateIndex
+CREATE INDEX "staff_adjustments_profileId_date_idx" ON "staff_adjustments"("profileId", "date");
+
+-- CreateIndex
+CREATE INDEX "staff_history_profileId_createdAt_idx" ON "staff_history"("profileId", "createdAt");
+
+-- CreateIndex
+CREATE INDEX "staff_notifications_userId_readAt_createdAt_idx" ON "staff_notifications"("userId", "readAt", "createdAt");
+
+-- AddForeignKey
+ALTER TABLE "staff_profiles" ADD CONSTRAINT "staff_profiles_kitaId_fkey" FOREIGN KEY ("kitaId") REFERENCES "kitas"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_profiles" ADD CONSTRAINT "staff_profiles_educatorId_fkey" FOREIGN KEY ("educatorId") REFERENCES "educators"("id") ON DELETE NO ACTION ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_profiles" ADD CONSTRAINT "staff_profiles_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_emails" ADD CONSTRAINT "staff_emails_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_emails" ADD CONSTRAINT "staff_emails_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_work_patterns" ADD CONSTRAINT "staff_work_patterns_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_day_overrides" ADD CONSTRAINT "staff_day_overrides_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_holidays" ADD CONSTRAINT "staff_holidays_kitaId_fkey" FOREIGN KEY ("kitaId") REFERENCES "kitas"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_leave_accounts" ADD CONSTRAINT "staff_leave_accounts_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_leaves" ADD CONSTRAINT "staff_leaves_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_leave_days" ADD CONSTRAINT "staff_leave_days_leaveId_fkey" FOREIGN KEY ("leaveId") REFERENCES "staff_leaves"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_time_entries" ADD CONSTRAINT "staff_time_entries_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_weeks" ADD CONSTRAINT "staff_weeks_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_adjustments" ADD CONSTRAINT "staff_adjustments_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_history" ADD CONSTRAINT "staff_history_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_notifications" ADD CONSTRAINT "staff_notifications_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "staff_notifications" ADD CONSTRAINT "staff_notifications_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+COMMIT;

docker-compose.coolify.yml

@@ -38,6 +38,7 @@ services:
       RESEND_API_KEY: ${RESEND_API_KEY:?}
       EMAIL_FROM: ${EMAIL_FROM:?}
       ADMIN_EMAIL: ${ADMIN_EMAIL:?}
+      NOTDIENST_JOB_SECRET: ${NOTDIENST_JOB_SECRET:?}
       UPLOAD_DIR: /app/uploads/announcements
     volumes:
       - kita_planer_uploads:/app/uploads

docs/FUNKTIONSUEBERSICHT.md

@@ -0,0 +1,448 @@
+# Kita-Planer – Funktionsübersicht und aktueller Stand
+
+## 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.
+
+Die folgende ursprüngliche Bestandsaufnahme bleibt als historischer Stand erhalten; darin als offen bezeichnete Alarmfunktionen sind durch diese Ergänzung überholt.
+
+Stand: **07.10.2026**
+
+Geprüfter Ausgangsbranch: `codex/notdienst-swaps`
+
+Geprüfter Commit: `ec3f4f933d42068c9d8446dc95de9815d5779238`
+
+Dokumentationsbranch: `codex/funktionsinventar`
+
+**Ergänzung vom 07.10.2026:** Auf `codex/personalbereich` wurde anschließend der Personalbereich für Arbeitszeit, Urlaub und Freizeitausgleich umgesetzt. Diese Bestandsaufnahme bleibt als Beschreibung des Ausgangsstands erhalten; der neue Umfang, Berechnungsregeln, Einrichtung und aktuelle Prüfungen stehen in [PERSONALBEREICH.md](PERSONALBEREICH.md). Die Aussagen unten zu fehlender Zeiterfassung, Accountverknüpfung und Tests beziehen sich auf den Ausgangscommit.
+
+**Ergänzung vom 08.10.2026:** Der Personalbereich enthält jetzt auch Aktivierungsmails, Antrags- und Entscheidungshinweise sowie eine Abschalteinstellung im Fachkraftprofil. Der aktuelle Umfang und die Versandkonfiguration stehen ebenfalls in [PERSONALBEREICH.md](PERSONALBEREICH.md).
+
+## 1. Grundlage der Prüfung
+
+Diese Bestandsaufnahme beschreibt die im Repository vorhandenen Produktfunktionen. Geprüft wurden Seiten und Navigation, Formulare und Dialoge, Server Actions, API-Routen, Datenmodell, E-Mail-Anbindung und Betriebsdateien. Die Planung in `planung.md`, die UI-Liste in `UI-TODO.md` und der frühere Live-Testplan wurden mit dem aktuellen Code abgeglichen.
+
+**„Vorhanden“ bedeutet hier: Oberfläche und zugehörige Verarbeitung sind im Code angebunden. Es bedeutet keine Bestätigung durch einen aktuellen Live-Test.** Es wurden keine Produktionsdaten verändert, keine E-Mails verschickt und keine Datenbankänderungen ausgeführt. Die tatsächliche Zustellung von E-Mails, das Verhalten im Browser und die produktive Konfiguration bleiben gesondert zu prüfen.
+
+Status:
+
+| Kennzeichnung | Bedeutung |
+| --- | --- |
+| Vorhanden | Im aktuellen Code als erreichbarer Ablauf umgesetzt. |
+| Teilweise | Funktion vorhanden, aber mit konkreten Einschränkungen oder fehlender Anbindung. |
+| Vorbereitet | Datenmodell, Komponente oder Aktion vorhanden; vollständiger Nutzerablauf fehlt. |
+| Offen | In der Planung vorgesehen, im geprüften Code nicht umgesetzt. |
+
+## 2. Gesamtüberblick
+
+Die Anwendung besitzt bereits eine breite MVP-Grundlage für mehrere unabhängige Kitas: Registrierung, Einrichtung, Familien und Kinder, Notdienst-Verfügbarkeiten und Planung, Diensttausch, Kalender, Mitbringlisten, Abwesenheiten, Kontaktdaten und Superadmin-Support. Einige beworbene Abläufe sind jedoch noch nicht vollständig nutzbar, insbesondere Alarmierung, Eltern-Rückmeldungen zu Events und die Anzeige des Schwarzen Bretts für Eltern.
+
+| Bereich | Stand | Wichtigste Einschränkung |
+| --- | --- | --- |
+| Öffentliche Website und Kontakt | Vorhanden | Impressum und Datenschutz enthalten Platzhalter. |
+| Registrierung, Login, Kita-Einrichtung | Vorhanden | Kein selbstständiger Passwort-Reset; Modulschalter wirken nur teilweise. |
+| Dashboard | Vorhanden | News-, RSVP- und Alarm-Komponenten sind nicht eingebunden. |
+| Profil und eigene Kinder | Vorhanden | Persönlicher Name, E-Mail und Rolle sind im Profil nur lesbar. |
+| Familienverwaltung und feste Ämter | Vorhanden | Kein vollständiger Einladungs-Support mit erneutem Versand/Widerruf. |
+| Notdienst-Verfügbarkeiten | Vorhanden | Wochenenden und Schließtage werden nur in der Oberfläche ausgeschlossen. |
+| Notdienst-Planung | Vorhanden | Keine automatische Erinnerung und keine E-Mail bei Erstveröffentlichung. |
+| Notdienst-Tausch | Vorhanden | Nur Elternrolle kann neue Tauschanfragen starten. |
+| Notdienst-Alarmierung | Vorbereitet | Auslösebutton ist auf keiner Seite eingebunden. |
+| Kalender und Mitbringlisten | Vorhanden | Keine Kollisionsprüfung für Raumbuchungen; Mitbringsel nicht direkt bearbeitbar. |
+| Event-Teilnahme/RSVP | Teilweise | Verwaltung vorhanden, Eltern-Eingabe nicht in eine Seite eingebunden. |
+| Abwesenheiten | Vorhanden | Gruppenfilter verwendet eine künstliche Zuordnung. |
+| Schwarzes Brett | Teilweise | Veröffentlichung vorhanden, Elternanzeige und Lesestatus fehlen im aktuellen Dashboard. |
+| Adressbuch | Vorhanden | Opt-in gilt für Kontaktdaten; weitere Haushaltsdaten bleiben sichtbar. |
+| ErzieherInnen-Stammdaten | Vorhanden | Stammdatensatz und Benutzerrolle `ERZIEHER` sind getrennte Konzepte. |
+| Superadmin-Verwaltung | Vorhanden | Einladungszähler verwenden ein anderes Modell als der reale Einladungsablauf. |
+| Betrieb und Qualität | Teilweise | TypeScript erfolgreich, ESLint mit Fehlern; keine automatisierte Testsuite gefunden. |
+
+## 3. Rollen und Zugriffsbereiche
+
+| Rolle | Aktuelle Möglichkeiten |
+| --- | --- |
+| `SUPERADMIN` | Systemweite Kita-Übersicht, Kita-Diagnosen, Support-Aktionen und Audit-Protokoll. Standardmäßig ohne Kita-Zuordnung und mit eigener Oberfläche unter `/admin`. |
+| `ADMIN` | Verwaltung der eigenen Kita: Familien, Ämter, ErzieherInnen, Dienste, Meldungen, Kalender und Notdienst. Mit eigenem Haushalt auch Elternfunktionen nutzbar. |
+| `KOORDINATOR` | Notdienstplanung, Kalenderverwaltung, Event-Anmeldungen und Abwesenheitsübersicht. Mit eigenem Haushalt auch Verfügbarkeiten eintragbar. |
+| `ERZIEHER` | Dashboard, Kalender, Adressbuch, Profil und Abwesenheitsübersicht. Kein Zugriff auf die Notdienst-Eingabeseite. |
+| `ELTERN` | Eigener Haushalt/Kinder, Verfügbarkeiten, Kalender, Terminanfragen, Mitbringsel, Diensttausch, Abwesenheitsmeldungen und Adressbuch. |
+
+Navigation und serverseitige Rollenprüfungen sind vorhanden. Die Rolle `ERZIEHER` existiert im Datenmodell und wird in Berechtigungen verwendet. Die ErzieherInnen-Verwaltung erstellt jedoch nur Namen als Stammdaten und keine Benutzerkonten. Ein regulärer Dialog zur Einladung von Erzieher-Accounts oder zur Vergabe von Admin-/Koordinatorrollen wurde nicht gefunden.
+
+Quellen: [Navigation](../src/components/dashboard/sidebar-nav.tsx), [Zugriffsprüfungen](../src/lib/auth-utils.ts), [Datenmodell](../prisma/schema.prisma).
+
+## 4. Funktionsinventar nach Bereich
+
+### 4.1 Öffentliche Website und Kontakt
+
+- Startseite mit Produktbeschreibung, Funktionsvorschauen, Rollenbeschreibung, Einstieg in Registrierung und Login sowie Kontaktbereich.
+- Fünf öffentliche Detailseiten: Notdienst-Planer, Kita-Kalender, Eltern-Adressbuch, Krankmeldung und Schwarzes Brett.
+- Kontaktformular für allgemeine Fragen, Demo-Anfragen und individuelles Setup.
+- Eingaben: Name, optionale Kita, E-Mail-Adresse, Anfrageart und Nachricht.
+- Versand einer Anfrage an den konfigurierten Kontakt-Empfänger und einer Bestätigung an die anfragende Person; passende Antwortadressen werden gesetzt.
+- Bot-Schutz durch ein unsichtbares Zusatzfeld und ein Limit von fünf Kontaktanfragen je IP-Adresse pro Stunde. Das Limit liegt im Arbeitsspeicher des jeweiligen Prozesses.
+- Sitemap, Robots-Datei und Metadaten für öffentliche Seiten.
+- Optionales Umami-Tracking über Umgebungsvariablen, auf eine Liste öffentlicher Seiten beschränkt. Suchparameter und URL-Fragmente werden ausgeschlossen; Do-Not-Track wird berücksichtigt.
+- Impressum und Datenschutzerklärung sind als Seiten vorhanden, enthalten aber noch Betreiber-, Hosting- und weitere Platzhalter.
+
+Quellen: [Startseite](../src/app/page.tsx), [Feature-Inhalte](../src/lib/marketing/features.ts), [Kontaktaktion](../src/actions/contact.ts), [Analytics](../src/components/analytics/umami-analytics.tsx), [Impressum](../src/app/impressum/page.tsx), [Datenschutz](../src/app/datenschutz/page.tsx).
+
+### 4.2 Registrierung, Anmeldung und Einrichtung
+
+- Gründerregistrierung mit Vorname, Nachname, E-Mail-Adresse, Passwort und verpflichtender Datenschutzannahme.
+- Prüfung auf bereits verwendete E-Mail-Adressen und Passwort-Hashing mit bcrypt.
+- Gründer erhält zunächst die Adminrolle ohne Kita-Zuordnung und wird direkt angemeldet.
+- Kita-Einrichtung mit Name, eindeutigem Slug, Aktivierung von Notdienst/Kalender/Adressbuch und Mindestzahl an Verfügbarkeiten pro Kind.
+- Bei aktivem Notdienstmodul ist mindestens ein Verfügbarkeitstag erforderlich; die Einrichtung erlaubt höchstens 31.
+- Kita-Anlage und Zuordnung des Gründers erfolgen in einer Datenbanktransaktion; erneute Einrichtung desselben Kontos wird abgefangen.
+- Login mit E-Mail und Passwort, Rückleitung zu einer internen Zielseite und allgemeine Fehlermeldung bei falschen Zugangsdaten.
+- Abmeldung über Desktop-Navigation und mobiles Menü.
+- Nach zehn Fehlversuchen wird das betreffende Konto für 15 Minuten gesperrt; erfolgreicher Login setzt den Zähler zurück.
+- JWT-basierte Sessions mit Benutzer-, Kita-, Familien- und Rolleninformationen. Rolle und Zuordnungen werden bei weiteren Session-Aufrufen mit der Datenbank abgeglichen.
+- Geschützte Seiten leiten nicht angemeldete Personen zum Login und Gründer ohne Kita zur Einrichtung weiter.
+- Datenschutzannahme wird mit Zeitpunkt und Versionskennung gespeichert. Die Sonderseite für fehlende Zustimmung verweist auf Support; sie enthält kein Formular zum Nachholen der Zustimmung.
+
+**Einschränkungen:** Kein Passwort-vergessen-/Passwort-ändern-Ablauf. Die Gründerregistrierung setzt `emailVerifiedAt` unmittelbar, ohne Bestätigungsmail. Ein allgemeines IP-Limit für Login oder Registrierung ist nicht angebunden; das Kontaktformular hat sein eigenes Limit.
+
+Quellen: [Registrierung](../src/app/register/actions.ts), [Einrichtung](../src/app/onboarding/actions.ts), [Login](../src/app/login/actions.ts), [Authentifizierung](../src/auth.ts), [Proxy](../src/proxy.ts), [Consent-Seite](../src/app/onboarding/consent/page.tsx).
+
+### 4.3 Dashboard und Navigation
+
+- Begrüßung mit Kita-Namen, Benutzernamen und aktuellem Datum.
+- Kennzahlen zu Familien, aktiven Kindern, eingetragenen Notdienst-Verfügbarkeiten des Folgemonats und rechnerisch heute anwesenden Kindern.
+- Direktes Melden einer Kinderabwesenheit und Übersicht der laufenden/bevorstehenden eigenen Abwesenheiten.
+- Schnellzugriffe auf Familienverwaltung, Kalender, Notdienstplanung und Adressbuch. Die drei letztgenannten berücksichtigen die Modulschalter bei der Anzeige.
+- Hinweisdialog bei unvollständigem Profil: Telefon, Adresse sowie gegebenenfalls Haushalt und Kinder. Fortschritt wird angezeigt; der Hinweis kann im lokalen Browser dauerhaft ausgeblendet werden.
+- Rollenabhängige Seitenleiste und ein auf kleinen Bildschirmen aufklappbares Menü.
+
+**Einschränkungen:** Die Notdienstkennzahl zählt Verfügbarkeitseinträge, keine tatsächlich besetzten Plantage. Schnellzugriffe auf Verwaltung werden nicht vollständig nach Rolle ausgeblendet; die Zielseiten besitzen Rollenprüfungen. Die Notdienst-Badge `4` in der Seitenleiste ist fest hinterlegt.
+
+Quellen: [Dashboard](../src/app/dashboard/page.tsx), [Profilhinweis](../src/components/OnboardingDialog.tsx), [Dashboard-Rahmen](../src/components/dashboard/dashboard-shell.tsx).
+
+### 4.4 Profil, Haushalt und eigene Kinder
+
+- Anzeige von Name, E-Mail-Adresse, Rolle, Kita, Haushalt, angelegtem Konto und zugewiesenen festen Ämtern.
+- Bearbeiten von Telefonnummer, Straße, Postleitzahl und Ort.
+- Adressbuchfreigabe erteilen oder zurückziehen; Zeitpunkt der Freigabe wird gespeichert.
+- Eigenen Haushalt anlegen, wenn noch keiner zugeordnet ist.
+- Eigene Kinder anlegen, bearbeiten und löschen; Vor-/Nachname sowie optionales Geburtsdatum.
+- Bei Eingabe eines Geburtsdatums: gültiges Datum, nicht in der Zukunft, höchstens sieben Jahre zurück.
+- Datenänderungen an Kindern werden auf den eigenen Haushalt und die eigene Kita begrenzt.
+- Eigenes Konto nach Bestätigung löschen. Bestehen aktuelle oder zukünftige veröffentlichte Notdienstpflichten des Haushalts, wird die Selbstlöschung abgelehnt.
+- Beim letzten Benutzer eines Haushalts wird die Familie samt abhängigen Kindern gelöscht; bei weiteren Benutzern bleibt der Haushalt bestehen.
+
+**Einschränkungen:** Name, E-Mail und Rolle lassen sich im persönlichen Profil nicht ändern. Eine Sperre der Kinderlöschung bei bestehenden Notdienstpflichten ist in `deleteMyChild` nicht vorhanden, obwohl die Kontolöschung diese Pflichten prüft.
+
+Quellen: [Profilseite](../src/app/dashboard/profil/page.tsx), [Profilaktionen](../src/app/dashboard/profil/actions.ts).
+
+### 4.5 Familienverwaltung, Eltern-Einladungen und feste Ämter
+
+- Adminübersicht aller Familien mit Eltern und Kindern; Suche nach Familie, Eltern, E-Mail und Kindern.
+- Umschalten zwischen Tabelle und Karten.
+- Neue Familie mit einem oder zwei Elternteilen sowie einem bis zehn Kindern anlegen.
+- Familienname, Namen/E-Mail-Adressen der Eltern und Kindernamen bearbeiten.
+- Zweiten Elternteil ergänzen, neue Kinder hinzufügen und Kinder entfernen. Der Bearbeitungsablauf verlangt mindestens ein verbleibendes Kind und höchstens zwei Elternteile.
+- Neue Elternkonten erhalten die Rolle `ELTERN` und einen Einladungslink zur Passwortvergabe mit sieben Tagen Gültigkeit.
+- Aktivierung prüft Link, Ablaufdatum, Passwortlänge, Passwortbestätigung und Datenschutzannahme; optionales Adressbuch-Opt-in.
+- Nach Aktivierung werden Passwort und Zustimmungen gespeichert, der Token gelöscht und die Person direkt angemeldet.
+- Die Familienliste zeigt anhand der Kontoverifikation, ob eine Einladung noch offen ist.
+- Feste Ämter mit Name und optionaler Beschreibung anlegen und löschen.
+- Ein oder mehrere Ämter an einzelne Benutzer vergeben und Zuordnungen entfernen; doppelte identische Zuordnungen werden verhindert.
+- Ämter sind im Profil und Adressbuch sichtbar.
+
+**Einschränkungen:** Kein regulärer Dialog zum erneuten Versand oder Widerruf einer Einladung. Einladungen werden im tatsächlichen Ablauf in `VerificationToken` gespeichert. Das separate Modell `Invitation` ist dafür nicht angebunden. Scheitert der Mailversand nach der Datenanlage, bleibt die Familie angelegt und eine Fehlermeldung wird zurückgegeben. Eine vollständige Familienlöschung durch Kita-Admins ist nicht angeboten.
+
+Quellen: [Familienaktionen](../src/app/dashboard/families/actions.ts), [Familienliste](../src/app/dashboard/families/_components/families-list-client.tsx), [Einladungsaktivierung](../src/app/invite/%5Btoken%5D/actions.ts), [Ämter](../src/app/dashboard/families/duty-actions.ts).
+
+### 4.6 Notdienst-Verfügbarkeiten für Eltern
+
+- Eingabe für den Folgemonat, bezogen auf aktive Kinder des eigenen Haushalts.
+- Mindestzahl an ausgewählten Tagen entspricht Anzahl der Kinder × Kita-Einstellung.
+- Bereits gespeicherte Haushaltseinträge werden geladen und können erneut gespeichert werden.
+- Monatskalender mit Terminen, Kategorien, Veranstaltungsdetails und auswählbaren Verfügbarkeitstagen.
+- Die Oberfläche lässt Montag bis Freitag zu und sperrt bestätigte Schließtage.
+- Auswahlfortschritt und Rückmeldung bei zu wenigen Tagen.
+- Die ausgewählten verschiedenen Tage werden beim Speichern reihum auf die angegebenen Kinder verteilt; bestehende Einträge dieser Kinder im Zielmonat werden ersetzt.
+- Eingabefrist ist im Code fest: bis einschließlich 26. des aktuellen Monats, gesperrt ab dem 27.
+- Ohne aktive eigene Kinder erscheint ein Hinweis mit Verweis zum Profil.
+
+**Einschränkungen:** Die Server Action prüft Datumsformat, Zielmonat, Mindestzahl und Haushaltszugehörigkeit, aber keine Wochenenden oder Schließtage. Die Frist ist nicht im Einstellungsdialog konfigurierbar. Abwesenheitsmeldungen werden bei den Verfügbarkeiten nicht automatisch berücksichtigt.
+
+Quellen: [Elternseite](../src/app/dashboard/notdienst/page.tsx), [Kalendereingabe](../src/app/dashboard/notdienst/notdienst-form.tsx), [Speichern](../src/app/dashboard/notdienst/actions.ts), [Fristregel](../src/lib/date-utils.ts).
+
+### 4.7 Notdienst-Planungszentrale
+
+- Admins und Koordinatoren können über Monat/Jahr navigieren; Vorgabe ist der Folgemonat.
+- Übersicht von Haushalten, Kindern, Verfügbarkeitstagen, Haushalten mit/ohne Rückmeldung und Planstatus.
+- Automatische Erzeugung eines monatlichen Entwurfs; ein bestehender Monatsplan verhindert erneute Generierung.
+- Für jeden Montag bis Freitag wird aus verfügbaren Kindern ein Haushalt ausgewählt, der im bisherigen Monatsdurchlauf möglichst selten eingeteilt wurde. Bei Gleichstand kommt Zufall zum Einsatz; der Zähler startet jeden Monat neu.
+- Tage ohne Verfügbarkeiten bleiben unbesetzt.
+- Vorschau und manuelle Zuordnung zu einem aktiven Kind der Kita; Tage können auch geleert werden.
+- Entwurf veröffentlichen; veröffentlichte Einteilungen erscheinen im Kalender.
+- Veröffentlichte Pläne nachbearbeiten, solange der betreffende Tag nicht vergangen ist.
+- Nach manuellen Änderungen eines veröffentlichten Plans werden E-Mails an betroffene Elternkonten der Rolle `ELTERN` angestoßen; betroffene offene Tauschanfragen werden ungültig.
+- Entwurfsplan mit Bestätigungsdialog zurücksetzen und löschen. Veröffentlichte Pläne werden serverseitig vom Reset ausgeschlossen.
+- Kita-Einstellungen für Mindestverfügbarkeiten und Erinnerungs-Vorlauf speichern.
+- Manuell Erinnerungen an Haushalte versenden, die im ausgewählten Monat gar keinen Verfügbarkeitseintrag haben.
+- „Als PDF exportieren“ öffnet den Browser-Druckdialog (`window.print()`); die PDF-Datei entsteht über die Druckfunktion des Browsers.
+
+**Einschränkungen:** Keine garantierte optimale oder über mehrere Monate ausgeglichene Verteilung. Die Generierung berücksichtigt keine Feiertage, Schließtage, Teamtage oder Kinderabwesenheiten. Ein Erinnerungs-Vorlauf wird gespeichert, aber kein zeitgesteuerter Job verwendet ihn. Haushalte mit zu wenigen Einträgen erhalten über diese Erinnerungsaktion keine Erinnerung, sobald wenigstens ein Eintrag vorliegt. Beim erstmaligen Veröffentlichen wird keine Zuteilungsmail versendet; die entsprechende E-Mail-Vorlage allein ist kein angebundener Versand.
+
+Quellen: [Planungsseite](../src/app/dashboard/notdienst/plan/page.tsx), [Planaktionen](../src/app/dashboard/notdienst/plan/actions.ts), [Planoberfläche](../src/app/dashboard/notdienst/plan/plan-view.tsx).
+
+### 4.8 Notdienst-Tausch zwischen Familien
+
+- Eltern können im Kalender einen fremden Notdienst anfragen und einen eigenen veröffentlichten Dienst zum Tausch anbieten; optionale Nachricht bis 500 Zeichen.
+- Beide Dienste müssen derselben Kita angehören, veröffentlicht und heute oder zukünftig sein. Ein Tausch im eigenen Haushalt wird abgewiesen.
+- Dienste mit wartender oder bestätigter Alarmierung sind vom Tausch ausgeschlossen.
+- Bereits beteiligte Dienste mit offenen Tauschanfragen können keine weitere offene Anfrage erhalten.
+- Der angefragte Haushalt erhält eine E-Mail und sieht die offene Anfrage im Kalender.
+- Angefragter Haushalt kann annehmen oder ablehnen; anfragender Haushalt kann zurückziehen.
+- Annahme vertauscht beide Kinder-Zuordnungen in einer Transaktion, speichert die Entscheidung und storniert weitere betroffene offene Anfragen.
+- Annahme und Ablehnung lösen Benachrichtigungen an beide Familien aus; Rücknahme speichert den Status ohne eigenen Mailversand.
+- Kalender und Notdienstansichten werden nach Änderungen neu validiert.
+
+**Einschränkungen:** Neue Anfragen sind auf die exakte Rolle `ELTERN` beschränkt; Eltern mit Admin-/Koordinatorrolle können sie nicht starten. Die Oberfläche zeigt offene Anfragen, keine vollständige abgeschlossene Tauschhistorie. Eine erneute Verfügbarkeitsprüfung für die getauschten Tage erfolgt nicht.
+
+Quellen: [Tauschaktionen](../src/app/dashboard/kalender/actions.ts), [Kalender und Anfragen](../src/app/dashboard/kalender/_components/calendar-overview-client.tsx), [Tauschdialog](../src/app/dashboard/kalender/_components/termin-list.tsx).
+
+### 4.9 Notdienst-Alarmierung
+
+Die am 09.10.2026 abgestimmte Erweiterung ist in [NOTDIENSTALARM_PLAN.md](NOTDIENSTALARM_PLAN.md) beschrieben. Sie ist zunächst geplant; der folgende Abschnitt beschreibt den vorhandenen Code.
+
+Vorbereitet sind:
+
+- Server Action zum Auslösen eines Alarms durch Admin/Koordinator für eine Einteilung.
+- Kita-Prüfung und Abweisung einer bereits alarmierten Einteilung.
+- Eigene Alarmdatensätze und E-Mails für die Elternkonten der eingeteilten Familie mit Rolle `ELTERN`.
+- Bestätigungsseite unter `/alert/[token]`; der Link erlaubt die Bestätigung ohne Login.
+- Statuswechsel von `PENDING` auf `CONFIRMED` mit Zeitstempel; erneute Bestätigung wird abgewiesen.
+- Vorbereitete Button-Komponente für das Auslösen.
+
+**Aktueller Stand:** `AlertButton` wird von keiner Seite eingebunden. Ein erreichbarer Auslöseablauf und eine laufende Statusübersicht für die Koordination fehlen damit in der aktuellen Oberfläche. Das Datenmodell kann eine erkrankte Fachkraft und Notizen speichern, aber die Aktion nimmt nur die Einteilungs-ID entgegen. Eine Auswahl der Fachkraft, Alarmstornierung, Eskalation oder zeitliche Token-Gültigkeit ist nicht angebunden.
+
+Quellen: [Alarmaktion](../src/app/dashboard/actions.ts), [ungebundener Alarmbutton](../src/app/dashboard/alert-button.tsx), [Bestätigung](../src/app/alert/%5Btoken%5D/actions.ts).
+
+### 4.10 Kalender, Terminanfragen und Mitbringlisten
+
+- Gemeinsamer Kalender für bestätigte Termine, eigene ausstehende Terminanfragen, geplante Elterndienste und veröffentlichte Notdienste.
+- Listen-, Monats- und Agendaansicht; Monatsnavigation und Sprung zu heute.
+- Tagesdialog mit Termindetails, Diensten und Mitbringlisten.
+- Suche nach Titel/Beschreibung und bei Diensten nach Familie beziehungsweise Kind.
+- Kategorienfilter und Umschaltung zwischen eigenen und allen Diensten; reguläre Kita-Termine bleiben auch im eigenen Filter sichtbar.
+- Kategorien: Kita-Fest, Schließtag, Teamtag, Mitmach-Tag, Elternabend, Mitgliederversammlung, Elterncafé, interner/externer Geburtstag und Sonstiges.
+- Terminanfrage mit Titel, Beschreibung, Kategorie, Anfang/Ende und Ganztagsangabe.
+- Eigene Anfragen werden als ausstehend angezeigt; Admins/Koordinatoren können ausstehende Anfragen bestätigen oder mit Begründung ablehnen.
+- Admins/Koordinatoren können bestätigte Termine direkt anlegen, bearbeiten und endgültig löschen.
+- Datumsprüfung: Beginn nicht in der Vergangenheit, Ende nicht vor Beginn.
+- Mitbringliste je Termin aktivieren/deaktivieren; Textbeiträge hinzufügen.
+- Eigene Beiträge löschen; Admins/Koordinatoren können auch fremde Beiträge löschen.
+- Verweise aus Dienst-/Notdienstterminen in die entsprechenden Verwaltungsseiten; Diensttausch über den Kalender.
+
+**Einschränkungen:** Ausstehende Anfragen blockieren keinen Zeitraum durch eine serverseitige Kollisionsprüfung. Eine Anfrage ist für andere Eltern nicht allgemein als reservierter Slot sichtbar. Mitbringbeiträge lassen sich nicht direkt bearbeiten, sondern nur löschen und neu anlegen. Es wurde kein Kalenderabo, ICS-Export oder Serientermin-Ablauf gefunden.
+
+Quellen: [Kalenderseite](../src/app/dashboard/kalender/page.tsx), [Kalenderansichten](../src/app/dashboard/kalender/_components/calendar-overview-client.tsx), [Terminaktionen](../src/app/dashboard/kalender/actions.ts), [Mitbringliste](../src/app/dashboard/kalender/_components/mitbringsel-list.tsx).
+
+### 4.11 Event-Anmeldungen und RSVP
+
+- Admins/Koordinatoren können Termine mit Teilnahmeabfrage, optionaler Rückmeldefrist und Hinweisen für Teilnehmende anlegen/bearbeiten.
+- Verwaltungsseite listet Termine samt Status und zeigt pro Event Zusagen, Absagen und ausstehende Antworten.
+- Kindbezogene Teilnehmerliste über alle aktiven Kinder der Kita.
+- Server Action für Zu-/Absage eines eigenen aktiven Kindes, inklusive Prüfung von Kita, Haushalt, bestätigtem Termin und Frist.
+- Fehlt eine eigene Frist, gilt der Eventbeginn als Rückmeldeschluss. Eine bestehende Antwort kann bis dahin überschrieben werden.
+- Teilnehmerhinweise werden im Kalender bei Admin/Koordinator und bei einem Haushalt mit mindestens einer Zusage angezeigt.
+
+**Aktueller Stand:** Die Eltern-Eingabekomponente `RsvpActionCard` existiert, wird aber von keiner Seite verwendet. Eltern besitzen deshalb im aktuellen Seitenaufbau keinen eingebundenen Zu-/Absagedialog. Außerdem wird `participantInfo` bereits an den Kalender-Client übertragen und nur bei der Darstellung ausgeblendet; die Anzeigeprüfung ist keine serverseitige Zugriffsbeschränkung für diese Information.
+
+Quellen: [RSVP-Aktionen](../src/actions/rsvp.ts), [Event-Verwaltung](../src/app/dashboard/admin/kalender/admin-calendar-manager.tsx), [ungebundene Elternkomponente](../src/app/dashboard/rsvp-action-card.tsx), [Kalenderdaten](../src/app/dashboard/kalender/page.tsx).
+
+### 4.12 Krank- und Abwesenheitsmeldungen
+
+- Eigenes aktives Kind aus dem Haushalt auswählen und für einen Tag oder Zeitraum abmelden.
+- Gründe: Krankheit, Urlaub und Sonstiges; optionale Notiz bis 500 Zeichen.
+- Ende darf nicht vor dem Beginn liegen; sich überschneidende Meldungen desselben Kindes werden abgewiesen.
+- Eigene laufende/bevorstehende Meldungen anzeigen und löschen.
+- Tagesübersicht für Admin, Koordinator und Erzieherrolle mit Kind, Familie, Grund, Zeitraum und Notiz.
+- Tagesnavigation zurück/vor/heute und freie Datumswahl.
+- Grundfilter, Kennzahlen und Hinweise zu Wochenende, Schließtag/Teamtag sowie Tagen mehr als 30 Tage in der Zukunft.
+- Abwesenheiten sind nicht als echte Anwesenheitserfassung mit Check-in/Check-out implementiert; „anwesend“ ist aus Kinderzahl minus Meldungen abgeleitet.
+
+**Einschränkungen:** Gruppen „Krippe“ und „Elementar“ werden aus dem ersten Zeichen des Kindernamens künstlich abgeleitet (`mockGroup`). Das Datenmodell hat keine echte Gruppenzuordnung. Die Anwesenheitszahl dieser Ansicht verwendet die gefilterten Fehlmeldungen bei weiterhin gesamter Kinderzahl und kann deshalb bei aktivem Filter irreführend sein. Eine bestehende Abwesenheit kann nur gelöscht und neu gemeldet, nicht direkt bearbeitet werden.
+
+Quellen: [Abwesenheitsaktionen](../src/actions/absences.ts), [Elternformular](../src/app/dashboard/absence-card.tsx), [Tagesübersicht](../src/app/dashboard/admin/abwesenheiten/page.tsx), [Filter](../src/app/dashboard/admin/abwesenheiten/_components/absences-client.tsx).
+
+### 4.13 Wöchentlicher Dienstplan
+
+- Separater Dienstplan für Haushalte, unabhängig von festen personenbezogenen Ämtern und Notdienst.
+- Diensttypen mit Name/Beschreibung anlegen und löschen.
+- Wochenraster mit wählbarem Beginn und Zeitraum; Standard zwölf Wochen, maximal 104 Wochen.
+- Haushalt je Diensttyp/Kalenderwoche auswählen oder Zuordnung entfernen; Änderungen werden direkt gespeichert.
+- Kita-Zugehörigkeit von Diensttyp und Familie wird geprüft.
+- Einteilungen erscheinen im gemeinsamen Kalender.
+- Manuelle Erinnerungsaktion für noch nicht erinnerte geplante Dienste, deren Beginn in der aktuellen Woche liegt.
+- Versand an verifizierte Benutzer der Familie; erfolgreicher Versand wird mit `reminderSentAt` gespeichert. Erneute Zuordnung setzt diesen Wert zurück.
+
+**Einschränkungen:** Kein automatisch laufender Erinnerungsjob. Status `DONE` und `CANCELLED` existieren im Datenmodell, aber ein regulärer Abschluss-/Stornoablauf ist nicht eingebunden. Eine Änderung setzt den Dienst wieder auf `PLANNED`. Das Löschen eines Diensttyps löscht durch die Datenrelationen auch dessen Einteilungen.
+
+Quellen: [Dienstplanseite](../src/app/dashboard/admin/dienste/page.tsx), [Raster](../src/app/dashboard/admin/dienste/duty-planner.tsx), [Dienstaktionen](../src/app/dashboard/admin/dienste/actions.ts).
+
+### 4.14 Schwarzes Brett, E-Mail und Anhänge
+
+- Admins können eine Ankündigung mit Titel und Markdown-Inhalt erstellen; Vorschau ist im Formular vorhanden.
+- PDF-, JPG- und PNG-Anhänge bis zehn MB je Datei.
+- Speicherung der Anhangdateien auf dem Server und der Metadaten in der Datenbank.
+- Abruf über geschützte API mit Prüfung auf angemeldeten Benutzer und dieselbe Kita; keine Auslieferung über ein öffentliches Uploadverzeichnis.
+- Optionaler E-Mail-Versand an verifizierte Haushaltskonten, Erzieherkonten oder beide Gruppen. Die Auswahl betrifft E-Mail-Empfänger und wird nicht als Sichtbarkeitsgruppe der Meldung gespeichert.
+- Adminseite zeigt die letzten acht veröffentlichten Meldungen mit Autor, Zeitpunkt und Anhanganzahl.
+- Bei Dateischreibfehlern werden die neue Meldung und angefangene Dateien zurückgenommen; bei Mailfehlern bleibt die Meldung gespeichert und eine Warnung wird zurückgegeben.
+- Lesestatusmodell und Aktion zum Markieren als gelesen sind vorhanden; `NewsTicker` enthält einen vorbereiteten Meldungsdialog.
+
+**Aktueller Stand:** `NewsTicker` ist nicht in das Dashboard oder eine andere Seite eingebunden. Eltern können neue Meldungen daher derzeit über den optionalen Mailversand erhalten, besitzen aber keine eingebundene Meldungsliste in der App. Eine Adminauswertung der Lesebestätigungen sowie Bearbeiten/Löschen von Meldungen sind nicht umgesetzt.
+
+Quellen: [Meldungsaktionen](../src/actions/announcements.ts), [Adminseite](../src/app/dashboard/admin/news/page.tsx), [Formular](../src/app/dashboard/admin/news/news-form.tsx), [ungebundener Ticker](../src/app/dashboard/news-ticker.tsx), [Anhang-API](../src/app/api/announcements/attachments/%5Bid%5D/route.ts).
+
+### 4.15 Adressbuch
+
+- Interne Übersicht der Haushalte, bei denen mindestens ein Benutzer der Kontaktfreigabe zugestimmt hat.
+- Anzeige von Haushaltsname, Kindern, Elternnamen und festen Ämtern; alphabetische Gruppierung nach Haushaltsnamen.
+- E-Mail, Telefon und Adresse werden nur für den jeweiligen Benutzer mit Opt-in geladen.
+- Suche nach Familienname, Eltern-/Kindernamen oder sichtbarer E-Mail.
+- Filter für Telefonnummer, Ämter und Haushalte mit Opt-in aller zugeordneten Benutzer.
+- Detaildialog je Familie; E-Mail- und Telefonlinks starten den jeweiligen Mail-/Telefonhandler.
+- Sichtbarkeitsdialog erklärt die Freigabe und führt zum eigenen Profil.
+- Optionales Geburtsdatum eines Kindes ist im Detaildialog sichtbar.
+
+**Einschränkung:** Namen und Ämter eines zweiten Elternteils ohne Kontaktfreigabe sowie Kinderinformationen sind innerhalb eines sichtbaren Haushalts weiterhin sichtbar. Die Freigabe ist technisch kein Opt-in für sämtliche Haushaltsinformationen.
+
+Quellen: [Adressbuchdaten](../src/app/dashboard/adressbuch/page.tsx), [Adressbuchoberfläche](../src/app/dashboard/adressbuch/_components/directory-client.tsx).
+
+### 4.16 ErzieherInnen-Stammdaten
+
+- Admins können Fachkräfte mit Vor- und Nachname anlegen, bearbeiten und löschen.
+- Aktivstatus wird gepflegt und dargestellt.
+- Diese Datensätze sind keine Login-Konten; die separate Benutzerrolle `ERZIEHER` ist hiervon unabhängig.
+- Referenz für Notdienstalarme im Datenmodell vorhanden, aber derzeit keine Fachkraftauswahl im Alarmauslöser.
+
+Quellen: [Erzieheraktionen](../src/app/dashboard/erzieher/actions.ts), [Erzieheroberfläche](../src/app/dashboard/erzieher/_components/erzieher-list.tsx).
+
+### 4.17 Systemweite Superadmin-Verwaltung
+
+- Übersicht aller Kitas mit Slug, Modulstatus, Benutzer-/Familien-/Kinderzahlen, Terminen, Abwesenheiten, Meldungen, offenen Einladungen und letztem Login.
+- Hinweise auf Benutzer ohne Kita, Kontosperren, fehlende Datenschutzzustimmung und Familien ohne Benutzer.
+- Kita-Diagnose mit Benutzerliste, Rollen, Familien, Verifikationsstatus, Consent, Fehlversuchen und Sperren; zusätzlich Zähler für Konten ohne Passwort und abgelaufene Einladungen.
+- Diagnoseaufrufe werden im Audit-Protokoll gespeichert.
+- Kita endgültig löschen nach exakter Namensbestätigung, mit kaskadierender Löschung abhängiger Datenbankdatensätze.
+- Kita-gebundene Benutzer löschen nach Bestätigung ihrer E-Mail-Adresse; dabei zugehörige Verifikationstokens entfernen.
+- Benutzer für weitere Logins sperren, entsperren oder Fehlversuche zurücksetzen. Sperrung setzt `lockedUntil` weit in die Zukunft; Entsperren löscht die Sperre und setzt den Zähler zurück.
+- Eigene und andere Superadmin-Konten sowie Konten ohne Kita werden durch diese Support-Aktionen nicht verändert.
+- Auditansicht zeigt die neuesten 200 Einträge samt Akteur, Ziel, Zeitpunkt, Aktion und Metadaten. Protokolle können auch nach Löschung der Zielobjekte bestehen bleiben.
+
+**Einschränkungen:** Offene und abgelaufene Einladungen werden über `Invitation` gezählt, während die tatsächlichen Familien-Einladungen `VerificationToken` nutzen. Eine Superadmin-Benutzerlöschung entfernt nicht automatisch einen nun leeren Haushalt. Eine Sperre wird bei der Anmeldung geprüft; das sofortige Beenden bereits bestehender Sessions ist nicht umgesetzt.
+
+Quellen: [Adminübersicht und Diagnose-Daten](../src/app/admin/_lib/data.ts), [Support-Aktionen](../src/app/admin/actions.ts), [Auditseite](../src/app/admin/audit/page.tsx).
+
+## 5. Datenmodell und technische Querschnittsfunktionen
+
+- PostgreSQL mit Prisma. Eine Kita ist ein Mandant; fachliche Daten sind über `kitaId` zugeordnet.
+- Datenmodelle für Kitas, Benutzer, Haushalte, Kinder, Fachkräfte, feste Ämter, Diensttypen/-einteilungen, Abwesenheiten, Meldungen, Anhänge, Lesestatus, Termine, Teilnahme, Mitbringsel, Notdienstpläne/-verfügbarkeiten/-einteilungen/-alarme/-tausche sowie Auditprotokolle und Tokens.
+- Eindeutigkeitsregeln unter anderem für E-Mail, Kita-Slug, Monatsplan, Einteilung je Plantag, Verfügbarkeit je Kind/Tag, Teilnahme je Event/Kind und Amt je Benutzer.
+- Eingabeprüfung überwiegend mit Zod, Schreibabläufe teilweise als Datenbanktransaktionen, Aktualisierung von Seiten nach Änderungen.
+- Gemeinsamer E-Mail-Versand über Resend mit Fehlerbehandlung. Ohne API-Key werden E-Mails nur in der Entwicklungsumgebung simuliert; diese Simulation bestätigt keine Zustellung.
+- Vorlagen für Einladung, Alarm, Verfügbarkeitserinnerung, Einteilungsänderung, Diensttausch, Wochen-Diensterinnerung, News und Kontakt. Eine weitere Vorlage für erstmalige Notdienst-Zuteilung ist vorhanden, aber nicht an die Veröffentlichung angebunden.
+- Rollen-, Kita- und Consent-Prüfungen über gemeinsame Helfer. Geschützte Dashboard-/Adminlayouts, Seiten und Aktionen setzen Zugriffsprüfungen ein; nicht jede Aktion verwendet denselben Consent-Helfer.
+- Viele Datenbankrelationen löschen abhängige Datensätze mit. Das ist nicht gleichbedeutend mit vollständiger Bereinigung von Dateien, allgemeinen Verifikationstokens oder Audit-Snapshots.
+- Der Hilfsmodus `TEST_MODE=true` liefert in `requireRole` und `requireKitaSession` künstliche Sessions und umgeht dort die regulären Prüfungen. Er ist nicht auf die Entwicklungsumgebung begrenzt.
+
+Quelle: [Schema](../prisma/schema.prisma), [Mail](../src/lib/mail.ts), [Auth-Helfer](../src/lib/auth-utils.ts).
+
+## 6. Seiten- und Schnittstellenverzeichnis
+
+| Route | Zweck/Zugriff |
+| --- | --- |
+| `/` | Öffentliche Startseite und Kontakt. |
+| `/features/notdienst-planer` | Öffentliche Notdienst-Beschreibung. |
+| `/features/kita-kalender` | Öffentliche Kalender-Beschreibung. |
+| `/features/eltern-adressbuch` | Öffentliche Adressbuch-Beschreibung. |
+| `/features/krankmeldung` | Öffentliche Abwesenheits-Beschreibung. |
+| `/features/schwarzes-brett` | Öffentliche Meldungs-Beschreibung. |
+| `/impressum`, `/datenschutz` | Öffentliche Informationsseiten mit noch offenen Platzhaltern. |
+| `/register`, `/login` | Gründerregistrierung und Anmeldung. |
+| `/onboarding` | Kita einrichten nach Anmeldung. |
+| `/onboarding/consent` | Hinweis bei fehlender Datenschutzannahme. |
+| `/invite/[token]` | Elternkonto über Einladungslink aktivieren. |
+| `/alert/[token]` | Notdienstalarm über Link bestätigen. |
+| `/forbidden` | Hinweis bei verweigertem Zugriff. |
+| `/dashboard` | Kita-Übersicht und eigene Abwesenheiten. |
+| `/dashboard/profil` | Eigener Haushalt, Kinder, Kontakte und Kontolöschung. |
+| `/dashboard/notdienst` | Verfügbarkeiten; Eltern, Admin, Koordinator. |
+| `/dashboard/notdienst/plan` | Planung; Admin, Koordinator. |
+| `/dashboard/kalender` | Kita-Kalender und Diensttausch. |
+| `/dashboard/adressbuch` | Internes Adressbuch. |
+| `/dashboard/families` | Familien und feste Ämter; Admin. |
+| `/dashboard/erzieher` | Fachkraft-Stammdaten; Admin. |
+| `/dashboard/admin/dienste` | Wochen-Dienstplan; Kita-Admin. Die Aktion erlaubt zusätzlich Superadmin mit Kita-Kontext. |
+| `/dashboard/admin/news` | Meldungen veröffentlichen; Admin. |
+| `/dashboard/admin/kalender` | Termine und Event-Anmeldungen; Admin, Koordinator. |
+| `/dashboard/admin/abwesenheiten` | Tagesübersicht; Admin, Koordinator, Erzieherrolle. |
+| `/admin` | Systemweite Kita-Übersicht; Superadmin. |
+| `/admin/kitas/[kitaId]` | Kita-Diagnose und Benutzersupport; Superadmin. |
+| `/admin/audit` | Systemweites Audit-Protokoll; Superadmin. |
+| `/api/auth/[...nextauth]` | Auth.js-Endpunkte. |
+| `/api/announcements/attachments/[id]` | Geschützter Anhangdownload. |
+| `/sitemap.xml`, `/robots.txt` | Suchmaschinensteuerung. |
+
+## 7. Betrieb, Entwicklung und Prüfstand
+
+- Stack laut `package.json`: Next.js 16.2.4, React 19.2.4, TypeScript, Prisma 6, Auth.js/NextAuth v5 beta, PostgreSQL, Tailwind CSS und Resend.
+- Lokaler Entwicklungsstart führt vor Next.js automatisch `prisma db push` und den Seed aus.
+- Seed legt Demonstrationsdaten mit mehreren Rollen und fachlichen Beispielen an; regulärer Seed ist bei bereits befüllter Datenbank zurückhaltend. Ein separater Reset-Modus existiert.
+- Docker-Build und Produktionsstart sind vorhanden; Produktionsstart wendet das Schema über `prisma db push --skip-generate` an. Versionierte Prisma-Migrationen liegen nicht im geprüften Dateibestand.
+- Lokale Compose-Datei stellt PostgreSQL bereit; Coolify-Compose enthält App, PostgreSQL, pgAdmin und persistente Datenbank-/Uploadvolumes.
+- Umgebungsvariablen-Vorlage und Produktionscheckliste sind vorhanden; ihre tatsächliche Erfüllung wurde nicht auf einem Server geprüft.
+- `UPLOAD_DIR` ist persistent vorgesehen. Die Dateihilfsfunktionen hängen noch `announcements` an diesen Pfad an; bei der aktuellen Compose-Konfiguration ergibt sich `/app/uploads/announcements/announcements`.
+- Kein Testskript und keine automatisierte Testdateisuite im geprüften Repository gefunden. Demo-Seed und manueller Live-Testplan ersetzen keine automatisierten Tests.
+
+### Ausgeführte technische Prüfungen
+
+Die Prüfungen liefen auf dem unveränderten Ausgangscheckout mit den dort bereits installierten Abhängigkeiten. Es wurden keine Bibliotheken installiert und keine Builds oder Datenbankoperationen ausgeführt.
+
+| Prüfung | Ergebnis |
+| --- | --- |
+| `./node_modules/.bin/tsc --noEmit --incremental false` | Erfolgreich, Exit-Code 0. |
+| `npm run lint` | Fehlgeschlagen, Exit-Code 1: zwei Fehler und neun Warnungen. |
+| Quellenprüfung von Seiten, Aktionen, Komponenten und Schema | Durchführung für die oben beschriebenen Funktionsbereiche. |
+| Aktueller Browser-/End-to-End-Test | Nicht durchgeführt. |
+| Mailzustellung und produktives Deployment | Nicht geprüft. |
+
+Beide ESLint-Fehler betreffen `as any` im Testmodus von `src/lib/auth-utils.ts` (Zeilen 57 und 91). Die Warnungen betreffen ungenutzte Variablen/Imports im Seed, Kalender, Adressbuch und Abwesenheiten. Diese Bestandsaufnahme ändert keinen Anwendungscode.
+
+Der vorhandene [Live-Testplan](live-testplan.md) vom 17.05.2026 dokumentiert erfolgreiche Tests von Landingpage/Kontakt, Gründerregistrierung, Einrichtung, Dashboard, Familienanlage und Teilen des Login-Ablaufs. Eltern-Einladungsaktivierung und anschließende Bereinigung sind dort noch offen. Dies sind historische Einträge, keine aktuellen Testnachweise für den geprüften Commit. Die abgehakten Punkte in [UI-TODO.md](../UI-TODO.md) sind ebenfalls historische Angaben; viele der dort ehemals fehlenden Handler sind inzwischen im Code vorhanden.
+
+Quellen: [Paket und Skripte](../package.json), [Deployment](../deploy/README.md), [Produktionscheckliste](../deploy/production-checklist.md), [Seed](../prisma/seed.ts), [Coolify-Compose](../docker-compose.coolify.yml).
+
+## 8. Konkrete offene Punkte für die weitere Arbeit
+
+Die Reihenfolge ist ein Vorschlag aus der Bestandsaufnahme; es wurde nichts davon umgesetzt.
+
+| Reihenfolge | Thema | Konkreter nächster Schritt |
+| --- | --- | --- |
+| 1 | Fehlende Elternabläufe | NewsTicker und RSVP-Eingabe an eine erreichbare Seite anbinden; Daten dafür laden. |
+| 2 | Notdienstalarm | Auslösebutton, Fachkraftauswahl und Statusanzeige in den aktuellen Seitenaufbau integrieren. |
+| 3 | Moduldeaktivierung | Modulschalter in Navigation, Seiten und Server Actions einheitlich prüfen; spätere Einstellungen anbieten. |
+| 4 | Notdienstregeln | Wochenenden/Schließtage serverseitig ausschließen und Generierung um Schließtage ergänzen; Abwesenheitsregel festlegen. |
+| 5 | Erinnerungen | Automatische Ausführung ergänzen und unterscheiden, ob gar keine oder zu wenige Verfügbarkeiten vorliegen. |
+| 6 | Erstveröffentlichung | Zuteilungsmails beim Veröffentlichen anbinden und Mailfehler sichtbar behandeln. |
+| 7 | Einladungssupport | Tokenmodell und Superadmin-Zähler vereinheitlichen; erneuten Versand, Ablauf und Widerruf erreichbar machen. |
+| 8 | Rechtevergabe | Regulären Ablauf für Koordinator-/Erzieherkonten und Rollenänderungen ergänzen. |
+| 9 | Abwesenheitsgruppen | Echte Gruppenzuordnung einführen oder den künstlichen Gruppenfilter entfernen; Kennzahlen konsistent berechnen. |
+| 10 | Buchungskonflikte | Fachliche Reservierungsregeln definieren und Überschneidungen serverseitig prüfen. |
+| 11 | Selbstverwaltung | Passwort-Reset/-Änderung und direkte Bearbeitung von Abwesenheiten/Mitbringbeiträgen ergänzen. |
+| 12 | Löschabläufe | Kinderlöschung bei bestehenden Verpflichtungen prüfen; Anhangdateien und Tokens bei Kita-/Kontolöschungen bereinigen; Audit-Aufbewahrung gesondert definieren. |
+| 13 | Zugriffsprüfungen | Testmodus an Entwicklungsumgebung binden; Consent-/Session-Prüfungen und Teilnehmerhinweise serverseitig vereinheitlichen. |
+| 14 | Technischer Zustand | Zwei ESLint-Fehler beheben, Migrationsablauf einführen und aussagekräftige Tests für die zentralen Abläufe ergänzen. |
+| 15 | Aktuelle Abnahme | Rollenbasierte Browserprüfung, Mailzustellung, Elternaktivierung und Bereinigung anhand eines aktualisierten Testplans durchführen. |
+| 16 | Öffentliche Texte | Platzhalter in Impressum/Datenschutz mit den tatsächlichen Betriebsangaben vervollständigen und Marketingversprechen mit dem implementierten Verhalten abgleichen. |
+
+## 9. Nicht als fertige Produktfunktion vorhanden
+
+Im geprüften Code wurden kein Abonnement-/Zahlungsablauf, keine Import-/Exportverwaltung für Familien, kein externer Kalenderabgleich, keine Push-/SMS-Alarmierung, keine echte Kita-Gruppenverwaltung und keine Zeiterfassung/Check-in-Funktion gefunden. Vorhandene Planungs- oder Marketingtexte sind dafür kein Umsetzungsnachweis.

docs/NOTDIENSTALARM.md

@@ -0,0 +1,65 @@
+# Notdienstalarm
+
+Stand: 09.10.2026 · Umsetzung auf `codex/notdienstalarm`
+
+## Bedienung
+
+Kita-Admins und Notdienst-Koordination finden den Alarm in der Navigation und bei eingeteilten Tagen eines veröffentlichten Notdienstplans. Der Dialog zeigt die betroffene Familie und ihre Elternadressen vor dem Auslösen. Er umfasst einen ganzen Kita-Tag oder ein Zeitfenster, eine Antwortfrist (standardmäßig 30 Minuten), eine optionale interne Fachkraftzuordnung und eine interne Notiz.
+
+Nur die eingeteilte Familie wird angefragt. Jedes Elternkonto erhält einen eigenen persönlichen Rückmeldelink und einen Hinweis in der App. Die Antwort „Wir übernehmen“ oder „Wir können nicht“ muss ausdrücklich gespeichert werden und gilt für den gesamten Haushalt. Das Öffnen des Links speichert keine Antwort. Die erste gespeicherte Antwort entscheidet auch bei gleichzeitigen Antworten; Änderungen dokumentiert die Koordination.
+
+| Anzeige | Bedeutung / nächster Schritt |
+| --- | --- |
+| Antwort ausstehend | Haushalt hat noch nicht geantwortet. |
+| Übernahme bestätigt | Rechtzeitige Zusage oder dokumentierte Freigabe durch Koordination. |
+| Absage – Klärung erforderlich | Alle Admins und KoordinatorInnen der Kita erhalten sofort einen Hinweis. Ersatz manuell organisieren. |
+| Klärung erforderlich – Frist abgelaufen | Nach Ablauf informiert der Hintergrundjob einmalig die Admins und KoordinatorInnen. |
+| Verspätete Zusage | Muss durch Koordination freigegeben werden; keine automatische sichere Besetzung. |
+| Klärung erforderlich | Uneindeutige frühere Einzelantworten wurden übernommen. Haushalt kontaktieren. |
+| Storniert | Haushalt wird informiert; der Link kann keine Antwort mehr speichern. |
+
+Telefonische Rückmeldungen, Korrekturen, verspätete Freigaben und Stornierungen benötigen eine interne Begründung. Interne Fachkraftdaten, Notizen und Verlauf erscheinen ausschließlich in der Verwaltungsansicht und werden nicht per E-Mail übermittelt. Eltern sehen ihre eigenen Alarme; andere Haushalte und Fachkräfte haben keinen Zugriff.
+
+Aktive Alarme sperren manuelle Umzuordnung und Diensttausche. Für einen Ersatz zuerst den Alarm stornieren, dann die Einteilung ändern und neu alarmieren. Ein ausstehender E-Mail-Versand lässt sich erneut versuchen, ohne die Antwortfrist neu zu starten. Die Anzeige „vom Maildienst angenommen“ bestätigt die Annahme durch den Versanddienst, nicht die Zustellung im Postfach.
+
+## Zeiten und Grenzen
+
+- Kita-Zeitzone: `Europe/Berlin`, einschließlich Sommer-/Winterzeit. Nicht existierende Uhrzeiten bei der Zeitumstellung werden abgelehnt.
+- Ganze Tage enden um Mitternacht zum Folgetag. Zeitfenster müssen am selben Tag liegen; Ende nach Beginn.
+- Die Antwortfrist startet beim Auslösen, beträgt 1–1440 Minuten und endet spätestens mit dem Einsatz. Alarme sind für heute und zukünftige veröffentlichte Einteilungen möglich.
+- Nach Einsatzende können Rückmeldelinks keine Antwort mehr speichern. Der letzte Status bleibt lesbar.
+- Die Übersicht zeigt bis zu 100 Alarme seit 30 Tagen vor heute. Direkte Detail-Links öffnen auch ältere Vorgänge. Im Dialog stehen Einteilungen der nächsten 93 Tage zur Wahl; das Dashboard zeigt bis zu zehn aktuelle Alarme.
+- Kein SMS-/Push-Versand und keine automatische Alarmierung anderer Familien. Notdienstmails gehören zum Alarmablauf und verwenden nicht die persönliche Einstellung für Personal-Antragsmails.
+
+## Betrieb und Hintergrundjob
+
+Benötigt werden die vorhandene Resend-Konfiguration (`RESEND_API_KEY`, `EMAIL_FROM`), die korrekte öffentliche App-Adresse (`NEXT_PUBLIC_SITE_URL`, alternativ `AUTH_URL`/`NEXTAUTH_URL`) und neu `NOTDIENST_JOB_SECRET` mit mindestens 32 Zeichen. Ein zufälliges Secret kann beispielsweise mit `openssl rand -hex 32` erzeugt und in der Hosting-Konfiguration gespeichert werden. Das Secret gehört nicht in Git oder ins Browser-Frontend.
+
+Der bestehende Docker-Produktionsstart startet `scripts/notdienst-alarm-worker.mjs`. Dieser ruft nach fünf Sekunden und danach ungefähr jede Minute lokal `POST /api/jobs/notdienstalarme` auf. Fristmeldungen entstehen dadurch auch ohne geöffneten Browser, normalerweise innerhalb einer Minute nach Fristende, zuzüglich Laufzeit und möglicher Ausfälle. Bei fehlendem Secret startet der allgemeine Produktionsstart ohne Fristjob und die Verwaltungsseite zeigt einen Hinweis; die Coolify-Vorlage verlangt das Secret. Ein zu kurzes gesetztes Secret stoppt den Produktionsstart.
+
+Bei einem anderen Hosting-Verfahren muss der Worker als eigener dauerhaft überwachter Prozess gestartet werden oder ein externer Scheduler die Route mindestens einmal pro Minute per POST und `Authorization: Bearer <NOTDIENST_JOB_SECRET>` aufrufen. Nur `npm run start` startet den Worker nicht. Der Scheduler/Host muss auch nach Neustarts laufen; ein gesetztes Secret allein belegt keine laufende Fristprüfung.
+
+Der Job bearbeitet bis zu 100 Fristfälle und 100 E-Mail-Aufträge je Lauf. Wiederholte und gleichzeitige Aufrufe werden abgefangen: Fristmeldungen besitzen einen eindeutigen Ereignisschlüssel, Mailaufträge eine Versandreservierung und einen stabilen Idempotenzschlüssel. Versandfehler bleiben gespeichert und werden bei späteren Läufen erneut versucht; bereits angenommene Aufträge werden nicht erneut angefragt. Rollen- und Haushaltszuordnungen werden vor dem Versand erneut geprüft. Überholte Anfragen werden übersprungen. Provider-Garantien zur Idempotenz und tatsächliche Postfachzustellung bleiben Grenzen außerhalb der Anwendung.
+
+HTTP 401 bedeutet fehlende/falsche Berechtigung, 503 fehlendes/zu kurzes Job-Secret, 500 einen fehlgeschlagenen Lauf. HTTP 200 enthält die Bearbeitungszahlen einschließlich fehlgeschlagener E-Mails; die Versandübersicht und Server-/Worker-Logs sind für die Betriebsprüfung heranzuziehen. Bei Ausfall wird die Fristüberschreitung schon anhand der Uhrzeit in der Oberfläche angezeigt; E-Mail-Eskalation und Reservierungsfreigabe benötigen den nächsten erfolgreichen Joblauf.
+
+## Datenbank und vorhandene Alarme
+
+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).
+
+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.
+
+## Prüfung
+
+Abschließender Prüfstand: 20 Alarmtests, 17 Personal-Service-Tests und neun Berechnungstests erfolgreich; TypeScript, ESLint der betroffenen Dateien und Produktionsbuild erfolgreich. Das additive SQL-Upgrade wurde auf einem separaten Schema der isolierten Datenbank angewandt und per Prisma mit dem Zielmodell verglichen: keine Abweichungen. Worker und Jobroute wurden lokal geprüft (401 ohne Secret, 200 mit Secret, Fristmeldung je zuständigem Konto einmalig). Die vorhandenen globalen ESLint-Fehler in `auth-utils.ts` liegen außerhalb dieser Änderung.
+
+Automatisierte Alarmtests prüfen Rollen und Mandanten, gemeinsame und konkurrierende Antworten, Fristprüfung, Absagen, verspätete Freigaben, Stornierung, Tokens, Versandfehler/erneuten Versand, Altbestände sowie die Sperre vorhandener Plan- und Diensttausch-Aktionen. Sie benötigen ausdrücklich die isolierte lokale Testdatenbank `127.0.0.1:55439/kita_staff_test` und bereinigen nur ihre eigenen Test-Kitas.
+
+```sh
+DATABASE_URL='postgresql://USER@127.0.0.1:55439/kita_staff_test' npm run test:alarms
+npm run test:staff
+```
+
+Die Browserprüfung verwendet ausschließlich Demo-Daten und deaktivierten tatsächlichen E-Mail-Versand. Geprüft wurden Auslösen aus der Einteilung, Zeitfenster, Eltern-Dashboard-Hinweis, persönliche Rückmeldeseite mit expliziter Bestätigung und eine mobile Ansicht ohne horizontalen Überlauf. Produktive Zustellung und Deployment sind separat durchzuführen.

docs/NOTDIENSTALARM_PLAN.md

@@ -0,0 +1,109 @@
+# Notdienstalarm – abgestimmter Funktionsplan
+
+Stand: 09.10.2026 · Branch `codex/notdienstalarm`
+
+Status: Umgesetzt. Dieser Plan hält die abgestimmten Entscheidungen fest. Bedienung, Betriebsanforderungen und Prüfungen stehen in [NOTDIENSTALARM.md](NOTDIENSTALARM.md).
+
+## Festgelegter Umfang
+
+| Thema | Entscheidung |
+| --- | --- |
+| Zuständigkeit | Nur Kita-Admins und Notdienst-Koordination (`ADMIN`, `KOORDINATOR`) lösen Alarme aus und verwalten sie. |
+| Erste Empfänger | Ausschließlich die für das Datum im veröffentlichten Notdienstplan eingeteilte Familie. Alle Elternkonten dieses Haushalts werden einzeln angeschrieben. |
+| Rückmeldung | „Wir übernehmen“ oder „Wir können nicht“. Eine Antwort gilt für den gesamten Haushalt. |
+| Kanäle | E-Mail und ein deutlich sichtbarer Hinweis in der App. |
+| Antwortfrist | Standardmäßig 30 Minuten ab Auslösung; beim Auslösen anpassbar. |
+| Einsatzdauer | Wahl zwischen „Ganzer Kita-Tag“ und „Bestimmte Uhrzeiten“ mit Beginn und Ende. |
+| Fehlende Übernahme | Absage sofort, ausbleibende Antwort nach Fristablauf: „Klärung erforderlich“. Koordination informieren; Ersatz manuell organisieren. |
+
+## Ablauf in der Oberfläche
+
+### 1. Alarm auslösen
+
+Im veröffentlichten Notdienstplan erhält die Einteilung eine Aktion **Notdienstalarm auslösen**. Eine aktuelle Alarmübersicht ist zusätzlich über das Dashboard erreichbar.
+
+Der Dialog zeigt Datum, eingeteilte Familie und deren Empfängeradressen. Die auslösende Person wählt die Einsatzdauer, prüft die Antwortfrist und bestätigt den Versand. Bei **Bestimmte Uhrzeiten** sind Beginn und Ende Pflicht; Ende liegt nach Beginn. Bei **Ganzer Kita-Tag** sind keine künstlichen Uhrzeitangaben nötig. Die gewählte Dauer erscheint in der E-Mail und auf der Rückmeldeseite.
+
+Ein Alarm ist nur für heutige oder zukünftige Einteilungen eines veröffentlichten Plans der eigenen Kita möglich. Notdienst muss für die Kita aktiviert sein. Fehlende Elternkonten werden vor der Auslösung deutlich angezeigt. Eine aktive Alarmierung verhindert einen zweiten Alarm für dieselbe Einteilung.
+
+Optional kann die ausgefallene Fachkraft intern zugeordnet werden. Dies dient der Zuordnung und erzeugt keine automatische Krankheitsbuchung im Personalbereich. Private interne Notizen und Namen ausgefallener Fachkräfte gehören nicht in die Eltern-E-Mail.
+
+### 2. Familie informieren und Antwort erfassen
+
+Jedes Elternkonto erhält eine eigene E-Mail mit Kita, Datum, Einsatzdauer, Antwortfrist und persönlichem Rückmeldelink. Die Nachricht fragt eindeutig nach einer Übernahme. Alle Elternkonten des Haushalts sehen in der App denselben aktiven Alarm.
+
+Die Rückmeldeseite funktioniert wie bisher ohne Login über einen persönlichen Token. Das Öffnen des Links löst keine Zusage aus. Erst die ausdrückliche Auswahl von **Wir übernehmen** oder **Wir können nicht** mit Bestätigung schreibt die Antwort.
+
+Die Antwort wird am gemeinsamen Haushaltseinsatz gespeichert, einschließlich Zeitpunkt und antwortendem Elternkonto. Alle anderen Links zeigen anschließend die gemeinsame Antwort. Gleichzeitige gegensätzliche Antworten dürfen nicht beide wirksam werden. Eine bereits gespeicherte Antwort lässt sich nicht versehentlich durch einen zweiten Klick überschreiben.
+
+### 3. Stand verfolgen und Ersatz klären
+
+Die Alarmübersicht zeigt Datum, Dauer, Familie, Antwortfrist, gemeinsamen Rückmeldestatus und den Versandstand je Empfänger. Offene Alarme für heute werden besonders hervorgehoben.
+
+| Anzeige | Bedeutung und nächste Aktion |
+| --- | --- |
+| Antwort ausstehend | Familie wurde angefragt; die Antwortfrist läuft. |
+| Übernahme bestätigt | Der Haushalt hat rechtzeitig zugesagt. Koordination und Admins sehen die Zusage. |
+| Klärung erforderlich – Absage | Der Haushalt kann nicht übernehmen. Koordination organisiert Ersatz. |
+| Klärung erforderlich – Frist abgelaufen | Es liegt keine Antwort vor. Koordination fasst nach oder organisiert Ersatz. |
+| Storniert | Einsatz entfällt; Rückmeldelinks erlauben keine weitere Antwort. |
+
+Versandfehler sind ein eigener Zustand und dürfen nicht als Absage der Familie erscheinen. Eine fehlgeschlagene E-Mail wird deutlich angezeigt und kann erneut versendet werden; andere Empfänger werden trotzdem bedient.
+
+Bei Absage oder Fristablauf erhalten zuständige Koordinations- und Admin-Konten derselben Kita einen Hinweis in der App und eine E-Mail. Die Fristmeldung wird je Alarm einmal erzeugt. Die Koordination organisiert Ersatz in dieser Version manuell; weitere Familien werden nicht automatisch alarmiert.
+
+## Vorgeschlagene Ausgestaltung für Sonderfälle
+
+Diese Details ergänzen die Nutzerentscheidungen als Umsetzungsvorschlag:
+
+- **Verspätete Zusage:** Nach Fristablauf bleibt eine Rückmeldung möglich, solange der Einsatz läuft und der Alarm nicht storniert ist. Eine verspätete Zusage wird als solche angezeigt und muss von der Koordination bestätigt werden, damit sie nicht mit bereits organisiertem Ersatz kollidiert.
+- **Telefonische Rückmeldung:** Admin oder Koordination kann eine Zusage bzw. Absage für den Haushalt dokumentieren. Herkunft, handelndes Konto und Zeitpunkt bleiben nachvollziehbar.
+- **Antwort ändern:** Eine bereits dokumentierte Antwort wird nur durch Admin oder Koordination korrigiert. Eltern erhalten auf der Rückmeldeseite einen Hinweis, die Kita bei Änderungen zu kontaktieren.
+- **Stornieren:** Admin oder Koordination storniert mit einer internen Begründung. Alle angeschriebenen Elternkonten werden informiert; offene Links werden unwirksam. Eine neue Alarmierung derselben Einteilung ist danach als neuer Vorgang möglich.
+- **Token-Ende:** Für einen ganzen Kita-Tag endet die Rückmeldemöglichkeit spätestens mit dem Datum in Europe/Berlin; bei bestimmten Uhrzeiten mit dem Einsatzende. Die 30-Minuten-Frist für Eskalation ist davon unabhängig.
+- **Planänderungen und Tausch:** Aktive Alarme schützen die zugehörige Einteilung vor einem unbemerkten Familienwechsel oder Diensttausch. Ersatz darf nicht durch Änderung eines noch aktiven Alarms auf eine andere Familie übertragen werden.
+- **Erinnerung und erneuter Versand:** Eine Wiederholung startet die Antwortfrist nicht automatisch neu. E-Mail-Annahme durch den Versanddienst, Rückmeldung und tatsächliche Anwesenheit bleiben getrennte Informationen.
+
+## Technische Umsetzung
+
+Der bestehende `NotdienstAlert` speichert pro Elternkonto einen unabhängigen Status. Für die gemeinsame Haushaltsantwort wird ein übergeordneter Alarmvorgang benötigt; Empfänger, Tokens und Versandversuche sind untergeordnet. Bestehende Datensätze müssen bei der Schemaumstellung berücksichtigt werden, ohne widersprüchliche Einzelantworten als sichere Haushaltszusage zu übernehmen.
+
+Am Vorgang werden Einteilung und Haushalt, auslösendes Konto, Zeitpunkt, Einsatzart, gegebenenfalls Uhrzeiten, Antwortfrist, gemeinsame Antwort, interne Zuordnung und Stornierungsdaten festgehalten. Empfängerdatensätze führen persönliche Tokens und deren Gültigkeit. Historie und Versandaufträge erlauben Wiederholung und nachvollziehbare Änderungen.
+
+Alle Aktionen prüfen aktuelle Datenbankrolle, Kita-Zugehörigkeit und Zugriff serverseitig. Auslösung und gemeinsame Rückmeldung laufen transaktional. Eine Datenbanksicherung verhindert mehrere aktive Alarme für dieselbe Einteilung sowie widersprüchliche parallele Antworten.
+
+Der Versand verwendet die vorhandene Resend-Anbindung mit persistenten Versandaufträgen. Elternmails enthalten ausschließlich notwendige Einsatzdaten. Interne Begründungen, Krankheitsdetails und Daten aus Personalzeitkonten werden nicht übernommen. Alarm-E-Mails sind unabhängig von der Abschalteinstellung für Personal-Entscheidungsmails.
+
+Die Fristüberwachung braucht eine regelmäßig aufgerufene serverseitige Prüfung, auch wenn niemand die App geöffnet hat. Vorgesehen ist ein geschützter, einmal pro Minute aufgerufener Serverjob. Die Anzeige berechnet Fristablauf zusätzlich direkt aus der gespeicherten Antwortfrist. Die Benachrichtigung kann durch das Prüfintervall und den Mailtransport etwas nach Ablauf eintreffen. Für die Einführung muss der Job in der Hosting-Umgebung eingerichtet werden.
+
+## Umsetzungsschritte
+
+1. Gemeinsamen Alarmvorgang, Empfänger, Tokens, Verlauf und Schemaumstellung ergänzen.
+2. Auslösung, Haushaltsantwort, Korrektur, Stornierung und erneuten Versand absichern.
+3. E-Mail-Vorlagen, Versandaufträge und Benachrichtigung der Koordination anbinden.
+4. Alarmdialog, Rückmeldeseite, Dashboard-Hinweise und Statusübersicht umsetzen.
+5. Fristprüfung, Hosting-Konfiguration und Einführungsdokumentation ergänzen.
+6. Gemeinsame Haushaltsantworten, Fristen, Rollen, Versandfehler und Browserabläufe prüfen.
+
+## Abnahmefälle
+
+- Admin und Koordination dürfen auslösen; Eltern, Fachkräfte und Konten anderer Kitas dürfen es nicht.
+- Nur die im veröffentlichten Plan eingeteilte Familie wird zunächst angeschrieben.
+- Ganzer Kita-Tag und bestimmte Uhrzeiten erscheinen in E-Mail, App und Rückmeldeseite konsistent.
+- Eine Zusage oder Absage wirkt auf den gesamten Haushalt; weitere persönliche Links zeigen denselben Stand.
+- Zwei gleichzeitige Antworten, doppelte Auslösung und Fristprüfung erzeugen keine doppelten Vorgänge oder widersprüchlichen Zusagen.
+- Absage erzeugt sofort Klärungsbedarf; Fristablauf nach 30 Minuten erzeugt ihn auch bei geschlossener App.
+- Versandfehler verhindern keine Speicherung, unterbrechen nicht den Versand an weitere Empfänger und lassen sich gezielt wiederholen.
+- Verspätete Antwort, telefonisch dokumentierte Antwort und Stornierung bleiben nachvollziehbar.
+- Stornierte und zeitlich abgelaufene Links können keinen aktiven Einsatz zusagen.
+- Aktive Alarme schützen Einteilungen vor unbemerktem Tausch oder Familienwechsel.
+
+## Vorhandene Grundlage
+
+- `src/app/dashboard/actions.ts`: Auslösung und E-Mail-Versand, bisher ein separater Alarm pro Elternkonto.
+- `src/app/dashboard/alert-button.tsx`: Vorbereiteter, noch nicht eingebundener Auslösebutton.
+- `src/app/alert/[token]/`: Rückmeldeseite und Bestätigung, bisher nur Zusage und ohne zeitliche Token-Gültigkeit.
+- `src/app/dashboard/kalender/actions.ts`: Bestehender Tauschausschluss für aktive Alarmierungen.
+- `src/lib/mail.ts` und `src/lib/staff/email.ts`: Mailtransport sowie Vorlage für persistente, wiederholbare Versandaufträge.
+
+Die Planung löst keine Alarme aus und versendet keine E-Mails.

docs/PERSONALBEREICH.md

@@ -0,0 +1,104 @@
+# Personalbereich: Arbeitszeit, Urlaub und Zeitkonto
+
+Stand: 08.10.2026 · Branch `codex/personalbereich`
+
+## Einstieg und Zuständigkeiten
+
+Der Bereich liegt unter `/dashboard/personal`. Kita-Admins (einschließlich Vorstand mit Rolle `ADMIN`) verwalten alle Personalprofile ihrer Kita. ErzieherInnen bearbeiten eigene Zeiten und Anträge. Eltern und Koordination haben keinen Zugriff. Der interne Teamkalender ist nur für Admins und ErzieherInnen zugänglich.
+
+Bestehende ErzieherInnen-Stammdaten bleiben erhalten. Ein Admin öffnet beim Personalstamm das **Personalprofil** und hinterlegt:
+
+1. Beschäftigungsbeginn, optionales Ende, Beginn der Zeiterfassung und Anfangssaldo.
+2. Ein datiertes Wochenmodell mit Netto-Sollstunden für Montag bis Sonntag; 0 bedeutet frei.
+3. Jahresurlaub und ausdrücklich festgelegten Übertrag, individuell für die Arbeitstage dieser Person.
+4. Einen passenden ErzieherInnen-Account. Bestehende verifizierte Accounts derselben Kita können verknüpft werden. Für neue Accounts wird ein persönlicher, einmal verwendbarer Aktivierungslink mit sieben Tagen Gültigkeit erzeugt. Ein neuer Link ersetzt den alten.
+5. Die örtlichen Feiertage unter **Teamkalender**. Feiertage gelten separat von den Schließtagen des allgemeinen Kalenders.
+
+Der Aktivierungsablauf verwendet die bestehende Passwort- und Consent-Einrichtung unter `/invite/[token]`. Neue Accounts erhalten den Aktivierungslink per E-Mail; der berechtigte Admin erhält ihn zusätzlich zum Kopieren. Ein vorhandener verifizierter Account wird verknüpft, ohne eine Aktivierungsmail zu verschicken.
+
+## Arbeitszeit und Überstunden
+
+Pro Tag sind mehrere Arbeitsblöcke mit Beginn, Ende und Pause möglich. Zeitblöcke dürfen nicht überlappen. Die Pause wird in Minuten vom Block abgezogen. Zeiten werden für heutige oder vergangene Tage innerhalb der Beschäftigung und ab Erfassungsbeginn erfasst. Blöcke über Mitternacht werden auf zwei Tage aufgeteilt.
+
+Die Tagesbilanz ist **Istzeit + Urlaub/Krankheit − Sollzeit**. Arbeit an einem freien Tag oder Feiertag zählt als zusätzliche Istzeit. Die Wochenansicht zeigt alle sieben Tage; in einer laufenden Woche fehlen zukünftige Arbeitszeiten noch, deshalb ist ihre Differenz vorläufig.
+
+Die Fachkraft reicht ihre Woche nach dem letzten vorgesehenen Arbeitstag ein. Offene Abwesenheiten im Zeitraum müssen zuerst geklärt sein. Der Admin prüft die einzelnen Zeiten, genehmigt die Woche oder gibt sie mit Rückmeldung zurück. Eingereichte und genehmigte Wochen sperren Zeitänderungen. Eigene Wochen und eigene Anträge können nicht selbst freigegeben werden.
+
+Beim Genehmigen wird die Tagesberechnung gespeichert. Nur genehmigte Wochen, der Anfangssaldo und wirksame manuelle Korrekturen zählen zum bestätigten Zeitkonto. Offene oder eingereichte Wochen wirken noch nicht auf dieses Konto. Eine Rückgabe entfernt die Wochenbuchung bis zur erneuten Freigabe. Fehler in manuellen Korrekturen werden durch eine begründete Gegenbuchung behoben.
+
+## Feste Wochentage und seltene Wechsel
+
+Wochenmodelle gelten ab ihrem Datum. Eine spätere Änderung überschreibt kein früheres Modell. Seltene Tausche werden über zwei Tagesausnahmen erfasst: der bisherige Arbeitstag erhält 0 Sollstunden, der Ersatztermin die vorgesehenen Stunden.
+
+Genehmigte Abwesenheiten sowie eingereichte oder genehmigte Wochen schützen ihren Zeitraum auch vor Änderungen an Modellen, Ausnahmen und Feiertagen. Betroffene Freigaben müssen vor einer solchen Änderung zurückgegeben bzw. storniert werden. Grunddaten und Anfangssaldo werden nach der ersten Erfassung geschützt; das Beschäftigungsende bleibt über einen eigenen Ablauf verwaltbar, sofern bestehende Zeiten und Anträge nicht verletzt werden.
+
+## Urlaub
+
+Urlaub ist ganztägig oder für einen einzelnen halben Tag möglich. Nur vorgesehene Arbeitstage verbrauchen Urlaub. Wochenenden sind nicht pauschal frei: Entscheidend sind Wochenmodell und Tagesausnahmen. Feiertage verbrauchen keinen Urlaub und erzeugen keine Sollzeit. Ein halber Urlaubstag schreibt die Hälfte der Tages-Sollzeit gut; bei ungerader Minutenzahl wird auf eine ganze Minute gerundet.
+
+Ein Jahreskonto führt Anspruch plus Übertrag, genommenen Urlaub, genehmigten geplanten Urlaub, offene Anträge und verfügbaren Rest. Offene Anträge werden bei weiteren Anträgen berücksichtigt. Abgelehnte und stornierte Anträge verbrauchen nichts. Zeiträume über den Jahreswechsel werden auf die jeweiligen Jahreskonten verteilt. Anspruch und Übertrag werden nicht automatisch anteilig berechnet oder zum Jahreswechsel übertragen.
+
+Offene Anträge können geändert oder zurückgezogen werden. Bei genehmigten Anträgen wird eine Stornierung beantragt. Bis zur Entscheidung bleibt die Abwesenheit gebucht. Krankheit hinterlegt der Admin; sie entlastet die Sollzeit, ohne Urlaub zu verbrauchen. KollegInnen sehen Krankheit im Teamkalender nur als **Abwesend**, ohne persönliche Notizen oder Kontodaten.
+
+## Freizeitausgleich
+
+Freizeitausgleich wird für einen einzelnen vorgesehenen Arbeitstag in Stunden beantragt. Das bestätigte verfügbare Guthaben muss ausreichen; weitere offene Anträge werden dabei berücksichtigt.
+
+Nach Genehmigung wird die Zeit reserviert. Freizeitausgleich erzeugt keine zusätzliche Istzeit oder Urlaubsgutschrift. Beispiel: 6 Stunden Soll, 5 Stunden Arbeit und 1 Stunde Freizeitausgleich ergeben eine Tagesbilanz von −1 Stunde. Mit der Wochenfreigabe wird diese Stunde im Zeitkonto gebucht und die Reservierung entfällt. Dadurch wird die Stunde genau einmal abgezogen. Bei offenen Stornierungen bleibt die Reservierung erhalten.
+
+## Hinweise und Nachvollziehbarkeit
+
+Neue Anträge und eingereichte Wochen erzeugen interne Hinweise für Kita-Admins. Entscheidungen und Rückgaben erzeugen Hinweise für die betroffene Fachkraft. Hinweise lassen sich als gelesen markieren; jede Person kann ausschließlich eigene Hinweise quittieren. Das Personalprofil zeigt die letzten 30 Änderungen. Im Datenmodell werden sämtliche Änderungen mit Zeitpunkt und handelnder User-ID gespeichert.
+
+Parallele Änderungen laufen in serialisierbaren Datenbanktransaktionen mit Wiederholung bei Schreibkonflikten. Rollen, Accountstatus, Eigentümer und Kita-Zugehörigkeit werden serverseitig geprüft. Das Löschen von Fachkräften mit Personalprofil wird verhindert; sie können auf inaktiv gesetzt werden. Bei Accountlöschung bleiben Personalaufzeichnungen ohne Accountverknüpfung erhalten. Die Löschung einer Kita entfernt auch ihren Personalbereich.
+
+## 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.
+
+- Lokal: Abhängigkeiten installieren, Prisma-Client generieren, Schema gegen eine dafür vorgesehene Datenbank anwenden, App starten und Profile einrichten.
+- 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.
+
+## Prüfungen
+
+- `npm run test:staff`: Berechnungstests für Teilzeit, halbe Tage, Feiertage, Jahreswechsel, Statuswechsel, Pausen, Snapshots und Freizeitausgleich.
+- `npm run test:staff:integration`: echte Datenbankabläufe für Mandantentrennung, Rollen und Eigentümer, Anträge, Freigaben, parallele Änderungen, Sperren, Rückgaben, Aktivierungslinks und Beschäftigungsende.
+- Integrationstests akzeptieren ausschließlich `127.0.0.1:55439/kita_staff_test`. Beispiel: `DATABASE_URL=postgresql://USER@127.0.0.1:55439/kita_staff_test npm run test:staff:integration`. Die leere Testdatenbank vorher mit dem aktuellen Schema einrichten. Tests bereinigen nur ihre eigens erzeugten Testkitas.
+- Browserprüfung: Admin richtet Profil, 18-Stunden-Woche und 18 Urlaubstage ein; Erzieherin erfasst drei Blöcke mit Pausen, reicht eine 19-Stunden-Woche ein und beantragt einen Urlaubstag. Nach Adminfreigabe zeigt das Zeitkonto 11 Stunden (10 Stunden Anfangssaldo + 1 Stunde Wochenplus) und das Urlaubskonto 17 Tage. Der Urlaub erscheint im Teamkalender.
+
+Ergebnisse der abschließenden Prüfung:
+
+| Prüfung                                                        | Ergebnis                                                                                                                                                                                                                                                            |
+| -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Berechnungstests                                               | 9 bestanden.                                                                                                                                                                                                                                                        |
+| Integrationstests                                              | 17 bestanden; einschließlich Empfänger, Opt-out, Versandfehler, Token-Erneuerung und paralleler Versandversuche. Testkitas danach bereinigt.                                                                                                                        |
+| TypeScript                                                     | Erfolgreich.                                                                                                                                                                                                                                                        |
+| ESLint für sämtliche geänderten Anwendungsteile und neue Tests | Erfolgreich, ohne Warnungen.                                                                                                                                                                                                                                        |
+| Projektweites ESLint                                           | Die bereits vorhandenen zwei `as any`-Fehler in `src/lib/auth-utils.ts` und neun Warnungen bestehen weiterhin.                                                                                                                                                      |
+| Endgültiger Produktionsbuild                                   | Erfolgreich, einschließlich `/dashboard/personal`.                                                                                                                                                                                                                  |
+| Vollständiges und inkrementelles SQL-Skript                    | Erfolgreich in isolierten Prüfschemata; anschließend jeweils kein Unterschied zum Prisma-Schema.                                                                                                                                                                    |
+| Browser                                                        | Admin- und ErzieherInnen-Ablauf einschließlich Freigaben erfolgreich. Mobile Ansicht und Arbeitszeitdialog ohne Seitenüberlauf geprüft. Abschalten der E-Mail-Hinweise im Demo-Profil gespeichert und nach Neuladen verifiziert; anschließend wieder eingeschaltet. |
+
+Die vom bestehenden Build gemeldete Warnung zu mehreren Lockfiles bzw. dem Turbopack-Arbeitsverzeichnis und die bestehende Prisma-Konfigurationswarnung sind unabhängig vom Personalbereich. Eine produktive Bereitstellung oder Mailzustellung wurde nicht durchgeführt.
+
+## E-Mail-Hinweise
+
+Die E-Mail-Erweiterung wurde am 08.10.2026 ausdrücklich beauftragt. Sie verwendet die vorhandene Resend-Anbindung:
+
+| Nachricht                                                     | Empfänger                                                | Inhalt                                                                 |
+| ------------------------------------------------------------- | -------------------------------------------------------- | ---------------------------------------------------------------------- |
+| Accountaktivierung                                            | Vom Kita-Admin eingetragene E-Mail-Adresse der Fachkraft | Kita, Name, persönlicher Aktivierungslink mit sieben Tagen Gültigkeit. |
+| Antrag / Änderung / Stornierung oder Arbeitswoche eingereicht | Alle Kita-Admins derselben Kita, einzeln angeschrieben   | Name, Zeitraum und Hinweis auf Prüfung im geschützten Personalbereich. |
+| Entscheidung / Rückgabe                                       | Account-Adresse der betroffenen Fachkraft                | Art, Zeitraum und Status mit Link in den geschützten Personalbereich.  |
+
+Fachkräfte können Entscheidungsmails unter **Mein Profil → E-Mail-Hinweise** abschalten. Aktivierungslinks und interne App-Hinweise bleiben davon unabhängig. Krankheitsbuchungen erzeugen keine E-Mail. Private Notizen, Entscheidungsbegründungen und Zeit- oder Urlaubskontostände werden nicht per E-Mail übertragen.
+
+Versandaufträge werden innerhalb derselben Datenbanktransaktion wie die Personalaktion gespeichert. Der Versand erfolgt anschließend; ein Fehler macht den gespeicherten Antrag nicht rückgängig. Ausstehende Mails erscheinen im Personalbereich mit **Versand erneut versuchen**. Admins dürfen die Aufträge ihrer Kita wiederholen, Fachkräfte nur eigene. Pro Aktion werden bis zu 50 ausstehende Aufträge verarbeitet. Es gibt keinen zusätzlichen Hintergrundjob.
+
+Vor jedem Versand werden Kita-Zugehörigkeit, aktuelle Rolle, Accountverknüpfung und gegebenenfalls die Abschalteinstellung geprüft. Ersetzte, abgelaufene oder bereits verwendete Aktivierungslinks werden übersprungen. Eine fünfminütige Versandsperre verhindert parallele Versuche für denselben Auftrag; ein stabiler Resend-Idempotenzschlüssel vermindert doppelte Zustellungen bei Wiederholungen. Eine Zustellbestätigung des Empfängerpostfachs wird nicht erfasst.
+
+Benötigt werden `RESEND_API_KEY`, `EMAIL_FROM` und eine öffentliche App-Adresse über `NEXT_PUBLIC_SITE_URL`, alternativ `AUTH_URL` oder `NEXTAUTH_URL`. Ohne Konfiguration bleibt ein Produktionsversand ausstehend und wird als Warnung angezeigt. Im Entwicklungsmodus ohne Resend-Schlüssel wird der bestehende lokale Mailtransport simuliert. Die Tests verwenden ausschließlich einen eingesetzten Testtransport; es wurden keine echten E-Mails verschickt.

package.json

@@ -9,6 +9,9 @@
     "start": "next start",
     "start:prod": "next start",
     "lint": "eslint",
+    "test:staff": "tsx --test tests/staff-calculations.test.ts",
+    "test:staff:integration": "tsx --test tests/staff-service.test.ts",
+    "test:alarms": "tsx --test tests/notdienst-alarm.test.ts",
     "prisma:generate": "prisma generate",
     "prisma:migrate": "prisma migrate dev",
     "prisma:studio": "prisma studio",

prisma/schema.prisma

@@ -84,6 +84,22 @@ enum NotdienstAlertStatus {
   CANCELLED
 }
 
+enum NotdienstAlarmStatus {
+  PENDING
+  CONFIRMED
+  DECLINED
+  LATE_CONFIRMATION
+  REVIEW_REQUIRED
+  CANCELLED
+}
+
+enum NotdienstSwapStatus {
+  PENDING
+  ACCEPTED
+  DECLINED
+  CANCELLED
+}
+
 enum DutyAssignmentStatus {
   PLANNED
   DONE
@@ -136,6 +152,10 @@ model Kita {
   notdienstAvailabilities NotdienstAvailability[]
   notdienstAssignments    NotdienstAssignment[]
   notdienstAlerts         NotdienstAlert[]
+  notdienstAlarms         NotdienstAlarm[]
+  notdienstSwapRequests   NotdienstSwapRequest[]
+  staffProfiles           StaffProfile[]
+  staffHolidays           StaffHoliday[]
 
   @@map("kitas")
 }
@@ -150,14 +170,16 @@ model Family {
   kitaId String
   kita   Kita   @relation(fields: [kitaId], references: [id], onDelete: Cascade)
 
-  name String
+  name            String
+  notdienstAlarms NotdienstAlarm[]
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  users           User[]
+  users                        User[]
-  children        Child[]
+  children                     Child[]
-  dutyAssignments DutyAssignment[]
+  dutyAssignments              DutyAssignment[]
+  notdienstSwapRequestsStarted NotdienstSwapRequest[] @relation("NotdienstSwapRequesterFamily")
 
   @@index([kitaId])
   @@map("families")
@@ -202,6 +224,7 @@ model User {
   privacyPolicyVersion    String?
   /// Zeitstempel des Opt-Ins für das interne Kita-Adressbuch (Modul 3).
   directoryOptInAt        DateTime?
+  staffDecisionEmails     Boolean   @default(true)
 
   // Auth-Bookkeeping
   emailVerifiedAt     DateTime?
@@ -215,19 +238,27 @@ model User {
   // Relations
   dutyAssignments ParentDutyAssignment[]
 
-  notdienstAvailabilities  NotdienstAvailability[]
+  notdienstAvailabilities        NotdienstAvailability[]
-  notdienstAlertsAssigned  NotdienstAlert[]        @relation("NotdienstAlertParent")
+  notdienstAlertsAssigned        NotdienstAlert[]        @relation("NotdienstAlertParent")
-  notdienstAlertsTriggered NotdienstAlert[]        @relation("NotdienstAlertTrigger")
+  notdienstAlertsTriggered       NotdienstAlert[]        @relation("NotdienstAlertTrigger")
-  notdienstPlansCreated    NotdienstPlan[]         @relation("NotdienstPlanCreator")
+  notdienstPlansCreated          NotdienstPlan[]         @relation("NotdienstPlanCreator")
-  announcementsAuthored    Announcement[]          @relation("AnnouncementAuthor")
+  notdienstSwapRequestsStarted   NotdienstSwapRequest[]  @relation("NotdienstSwapRequester")
-  announcementReads        AnnouncementRead[]
+  notdienstSwapRequestsResponded NotdienstSwapRequest[]  @relation("NotdienstSwapResponder")
+  announcementsAuthored          Announcement[]          @relation("AnnouncementAuthor")
+  announcementReads              AnnouncementRead[]
 
   termineCreated  Termin[] @relation("TerminCreator")
   termineApproved Termin[] @relation("TerminApprover")
 
   mitbringselItems   MitbringselItem[]
-  invitationsCreated Invitation[]      @relation("InvitationCreator")
+  invitationsCreated Invitation[]                 @relation("InvitationCreator")
-  auditLogsAuthored  AuditLog[]        @relation("AuditLogActor")
+  auditLogsAuthored  AuditLog[]                   @relation("AuditLogActor")
+  staffProfile       StaffProfile?
+  staffNotifications StaffNotification[]
+  staffEmails        StaffEmail[]
+  alarmRecipients    NotdienstAlarmRecipient[]
+  alarmNotifications NotdienstAlarmNotification[]
+  alarmEmails        NotdienstAlarmEmail[]
 
   @@index([kitaId])
   @@index([familyId])
@@ -284,11 +315,237 @@ model Educator {
   updatedAt DateTime @updatedAt
 
   notdienstAlerts NotdienstAlert[]
+  staffProfile    StaffProfile?
 
   @@index([kitaId])
   @@map("educators")
 }
 
+// Personalbereich: Tage als UTC-Datum, Zeiten als Minuten, Anspruch in halben Tagen.
+enum StaffRequestStatus {
+  PENDING
+  APPROVED
+  REJECTED
+  CANCEL_REQUESTED
+  CANCELLED
+}
+
+enum StaffLeaveKind {
+  VACATION
+  TIME_OFF
+  SICKNESS
+}
+
+enum StaffWeekStatus {
+  DRAFT
+  SUBMITTED
+  APPROVED
+}
+
+model StaffProfile {
+  id              String              @id @default(cuid())
+  kitaId          String
+  kita            Kita                @relation(fields: [kitaId], references: [id], onDelete: Cascade)
+  educatorId      String              @unique
+  educator        Educator            @relation(fields: [educatorId], references: [id], onDelete: NoAction)
+  userId          String?             @unique
+  user            User?               @relation(fields: [userId], references: [id], onDelete: SetNull)
+  employmentStart DateTime            @db.Date
+  employmentEnd   DateTime?           @db.Date
+  trackingStart   DateTime            @db.Date
+  openingMinutes  Int                 @default(0)
+  createdAt       DateTime            @default(now())
+  workPatterns    StaffWorkPattern[]
+  dayOverrides    StaffDayOverride[]
+  leaveAccounts   StaffLeaveAccount[]
+  leaves          StaffLeave[]
+  timeEntries     StaffTimeEntry[]
+  weeks           StaffWeek[]
+  adjustments     StaffAdjustment[]
+  history         StaffHistory[]
+  notifications   StaffNotification[]
+  emails          StaffEmail[]
+
+  @@index([kitaId])
+  @@map("staff_profiles")
+}
+
+// Persisted in the same transaction as the staff action; delivered after commit.
+model StaffEmail {
+  id          String       @id @default(cuid())
+  profileId   String
+  profile     StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  userId      String
+  user        User         @relation(fields: [userId], references: [id], onDelete: Cascade)
+  toAdmins    Boolean      @default(false)
+  subject     String
+  message     String
+  path        String
+  inviteToken String?
+  createdAt   DateTime     @default(now())
+  sentAt      DateTime?
+  skippedAt   DateTime?
+  leaseUntil  DateTime?
+  attempts    Int          @default(0)
+  failed      Boolean      @default(false)
+
+  @@index([profileId, sentAt, skippedAt])
+  @@map("staff_emails")
+}
+
+model StaffWorkPattern {
+  id            String       @id @default(cuid())
+  profileId     String
+  profile       StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  effectiveFrom DateTime     @db.Date
+  // Montag bis Sonntag; 0 bedeutet arbeitsfrei.
+  dailyMinutes  Int[]
+
+  @@unique([profileId, effectiveFrom])
+  @@map("staff_work_patterns")
+}
+
+model StaffDayOverride {
+  id        String       @id @default(cuid())
+  profileId String
+  profile   StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  date      DateTime     @db.Date
+  minutes   Int
+  reason    String
+
+  @@unique([profileId, date])
+  @@map("staff_day_overrides")
+}
+
+model StaffHoliday {
+  id     String   @id @default(cuid())
+  kitaId String
+  kita   Kita     @relation(fields: [kitaId], references: [id], onDelete: Cascade)
+  date   DateTime @db.Date
+  name   String
+
+  @@unique([kitaId, date])
+  @@map("staff_holidays")
+}
+
+model StaffLeaveAccount {
+  id               String       @id @default(cuid())
+  profileId        String
+  profile          StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  year             Int
+  entitlementUnits Int
+  carryUnits       Int          @default(0)
+
+  @@unique([profileId, year])
+  @@map("staff_leave_accounts")
+}
+
+model StaffLeave {
+  id            String             @id @default(cuid())
+  profileId     String
+  profile       StaffProfile       @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  kind          StaffLeaveKind
+  status        StaffRequestStatus @default(PENDING)
+  startDate     DateTime           @db.Date
+  endDate       DateTime           @db.Date
+  halfDay       Boolean            @default(false)
+  minutes       Int?
+  note          String?
+  decisionNote  String?
+  requestedById String
+  reviewedById  String?
+  reviewedAt    DateTime?
+  createdAt     DateTime           @default(now())
+  days          StaffLeaveDay[]
+
+  @@index([profileId, status, startDate])
+  @@map("staff_leaves")
+}
+
+model StaffLeaveDay {
+  id            String     @id @default(cuid())
+  leaveId       String
+  leave         StaffLeave @relation(fields: [leaveId], references: [id], onDelete: Cascade)
+  date          DateTime   @db.Date
+  vacationUnits Int        @default(0)
+  creditMinutes Int
+
+  @@unique([leaveId, date])
+  @@map("staff_leave_days")
+}
+
+model StaffTimeEntry {
+  id           String       @id @default(cuid())
+  profileId    String
+  profile      StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  date         DateTime     @db.Date
+  startMinute  Int
+  endMinute    Int
+  breakMinutes Int          @default(0)
+  note         String?
+
+  @@index([profileId, date])
+  @@map("staff_time_entries")
+}
+
+model StaffWeek {
+  id            String          @id @default(cuid())
+  profileId     String
+  profile       StaffProfile    @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  weekStart     DateTime        @db.Date
+  status        StaffWeekStatus @default(DRAFT)
+  submittedAt   DateTime?
+  reviewedAt    DateTime?
+  reviewedById  String?
+  decisionNote  String?
+  // Snapshot von Soll-, Ist- und Abwesenheitsminuten bei Genehmigung.
+  dailySnapshot Json?
+
+  @@unique([profileId, weekStart])
+  @@map("staff_weeks")
+}
+
+model StaffAdjustment {
+  id        String       @id @default(cuid())
+  profileId String
+  profile   StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  date      DateTime     @db.Date
+  minutes   Int
+  reason    String
+  actorId   String
+  createdAt DateTime     @default(now())
+
+  @@index([profileId, date])
+  @@map("staff_adjustments")
+}
+
+model StaffHistory {
+  id        String       @id @default(cuid())
+  profileId String
+  profile   StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  actorId   String
+  action    String
+  details   String
+  createdAt DateTime     @default(now())
+
+  @@index([profileId, createdAt])
+  @@map("staff_history")
+}
+
+model StaffNotification {
+  id        String       @id @default(cuid())
+  userId    String
+  user      User         @relation(fields: [userId], references: [id], onDelete: Cascade)
+  profileId String
+  profile   StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  message   String
+  readAt    DateTime?
+  createdAt DateTime     @default(now())
+
+  @@index([userId, readAt, createdAt])
+  @@map("staff_notifications")
+}
+
 // =====================================================================
 // PARENT DUTIES (Feste Ämter / Elterndienste, Modul 3)
 // =====================================================================
@@ -646,20 +903,165 @@ model NotdienstAssignment {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  alerts NotdienstAlert[]
+  alerts                NotdienstAlert[]
+  alarms                NotdienstAlarm[]
+  swapRequestsAsTarget  NotdienstSwapRequest[] @relation("NotdienstSwapTargetAssignment")
+  swapRequestsAsOffered NotdienstSwapRequest[] @relation("NotdienstSwapOfferedAssignment")
 
   @@unique([planId, date])
   @@index([kitaId, date])
   @@map("notdienst_assignments")
 }
 
-/// Aktive Alarmierung — wird bei Krankmeldung einer Fachkraft
+/// Tauschanfrage zwischen Eltern fuer zwei bereits veroeffentlichte
-/// vom Koordinator ausgelöst. Bestätigung via Magic-Link (Token).
+/// zukuenftige Notdienst-Zuteilungen.
-model NotdienstAlert {
+model NotdienstSwapRequest {
   id     String @id @default(cuid())
   kitaId String
   kita   Kita   @relation(fields: [kitaId], references: [id], onDelete: Cascade)
 
+  requesterUserId String
+  requesterUser   User   @relation("NotdienstSwapRequester", fields: [requesterUserId], references: [id], onDelete: Cascade)
+
+  requesterFamilyId String
+  requesterFamily   Family @relation("NotdienstSwapRequesterFamily", fields: [requesterFamilyId], references: [id], onDelete: Cascade)
+
+  targetAssignmentId String
+  targetAssignment   NotdienstAssignment @relation("NotdienstSwapTargetAssignment", fields: [targetAssignmentId], references: [id], onDelete: Cascade)
+
+  offeredAssignmentId String
+  offeredAssignment   NotdienstAssignment @relation("NotdienstSwapOfferedAssignment", fields: [offeredAssignmentId], references: [id], onDelete: Cascade)
+
+  status  NotdienstSwapStatus @default(PENDING)
+  message String?
+
+  respondedById String?
+  respondedBy   User?     @relation("NotdienstSwapResponder", fields: [respondedById], references: [id], onDelete: SetNull)
+  respondedAt   DateTime?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([kitaId, status])
+  @@index([requesterFamilyId, status])
+  @@index([targetAssignmentId, status])
+  @@index([offeredAssignmentId, status])
+  @@map("notdienst_swap_requests")
+}
+
+/// Aktive Alarmierung — wird bei Krankmeldung einer Fachkraft
+/// vom Koordinator ausgelöst. Bestätigung via Magic-Link (Token).
+model NotdienstAlarm {
+  id                 String                       @id @default(cuid())
+  kitaId             String
+  kita               Kita                         @relation(fields: [kitaId], references: [id], onDelete: Cascade)
+  assignmentId       String?
+  assignment         NotdienstAssignment?         @relation(fields: [assignmentId], references: [id], onDelete: SetNull)
+  // Nullable unique reservation: cancelled or ended alarms release the assignment.
+  activeAssignmentId String?                      @unique
+  familyId           String
+  family             Family                       @relation(fields: [familyId], references: [id], onDelete: Cascade)
+  familyName         String
+  childName          String
+  date               DateTime                     @db.Date
+  wholeDay           Boolean                      @default(true)
+  startMinute        Int?
+  endMinute          Int?
+  expiresAt          DateTime
+  deadline           DateTime
+  status             NotdienstAlarmStatus         @default(PENDING)
+  triggeredById      String?
+  triggeredAt        DateTime                     @default(now())
+  respondedById      String?
+  respondedAt        DateTime?
+  responseSource     String?
+  escalatedAt        DateTime?
+  educatorId         String?
+  notes              String?
+  cancelledAt        DateTime?
+  cancelReason       String?
+  recipients         NotdienstAlarmRecipient[]
+  notifications      NotdienstAlarmNotification[]
+  emails             NotdienstAlarmEmail[]
+  history            NotdienstAlarmHistory[]
+  legacyAlerts       NotdienstAlert[]
+
+  @@index([kitaId, date])
+  @@index([status, deadline])
+  @@map("notdienst_alarms")
+}
+
+model NotdienstAlarmRecipient {
+  id      String         @id @default(cuid())
+  alarmId String
+  alarm   NotdienstAlarm @relation(fields: [alarmId], references: [id], onDelete: Cascade)
+  userId  String
+  user    User           @relation(fields: [userId], references: [id], onDelete: Cascade)
+  token   String         @unique
+
+  @@unique([alarmId, userId])
+  @@map("notdienst_alarm_recipients")
+}
+
+model NotdienstAlarmNotification {
+  id        String         @id @default(cuid())
+  alarmId   String
+  alarm     NotdienstAlarm @relation(fields: [alarmId], references: [id], onDelete: Cascade)
+  userId    String
+  user      User           @relation(fields: [userId], references: [id], onDelete: Cascade)
+  eventKey  String
+  message   String
+  createdAt DateTime       @default(now())
+  readAt    DateTime?
+
+  @@unique([alarmId, userId, eventKey])
+  @@index([userId, readAt])
+  @@map("notdienst_alarm_notifications")
+}
+
+model NotdienstAlarmEmail {
+  id         String         @id @default(cuid())
+  alarmId    String
+  alarm      NotdienstAlarm @relation(fields: [alarmId], references: [id], onDelete: Cascade)
+  userId     String
+  user       User           @relation(fields: [userId], references: [id], onDelete: Cascade)
+  eventKey   String
+  kind       String
+  subject    String
+  message    String
+  path       String
+  createdAt  DateTime       @default(now())
+  sentAt     DateTime?
+  skippedAt  DateTime?
+  leaseUntil DateTime?
+  failed     Boolean        @default(false)
+  attempts   Int            @default(0)
+
+  @@unique([alarmId, userId, eventKey])
+  @@index([sentAt, skippedAt, createdAt])
+  @@map("notdienst_alarm_emails")
+}
+
+model NotdienstAlarmHistory {
+  id        String         @id @default(cuid())
+  alarmId   String
+  alarm     NotdienstAlarm @relation(fields: [alarmId], references: [id], onDelete: Cascade)
+  actorId   String?
+  action    String
+  details   String
+  createdAt DateTime       @default(now())
+
+  @@index([alarmId, createdAt])
+  @@map("notdienst_alarm_history")
+}
+
+model NotdienstAlert {
+  id      String          @id @default(cuid())
+  alarmId String?
+  alarm   NotdienstAlarm? @relation(fields: [alarmId], references: [id], onDelete: SetNull)
+  kitaId  String
+  kita    Kita            @relation(fields: [kitaId], references: [id], onDelete: Cascade)
+
   assignmentId String
   assignment   NotdienstAssignment @relation(fields: [assignmentId], references: [id], onDelete: Cascade)
 
@@ -707,13 +1109,13 @@ model AuditLog {
   actorUser   User?   @relation("AuditLogActor", fields: [actorUserId], references: [id], onDelete: SetNull)
   actorEmail  String
 
-  action     String
+  action       String
-  targetType AuditTargetType
+  targetType   AuditTargetType
-  targetId   String
+  targetId     String
-  targetLabel String
+  targetLabel  String
   targetKitaId String?
 
-  metadata Json?
+  metadata  Json?
   createdAt DateTime @default(now())
 
   @@index([actorUserId])

scripts/notdienst-alarm-worker.mjs

@@ -0,0 +1,42 @@
+// Runs inside the application container. No external cron service or browser is required.
+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.",
+  );
+  process.exit(1);
+}
+const port = Number(process.env.PORT || 3000);
+if (!Number.isInteger(port) || port < 1 || port > 65535) process.exit(1);
+let stopped = false;
+let timer;
+async function tick() {
+  const started = Date.now();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${port}/api/jobs/notdienstalarme`,
+      {
+        method: "POST",
+        headers: { authorization: `Bearer ${secret}` },
+        signal: AbortSignal.timeout(50000),
+      },
+    );
+    if (!response.ok)
+      console.error(
+        `Notdienst-Fristprüfung: HTTP ${response.status}; erneuter Versuch in einer Minute.`,
+      );
+  } catch {
+    console.error(
+      "Notdienst-Fristprüfung momentan nicht erreichbar; erneuter Versuch in einer Minute.",
+    );
+  }
+  if (!stopped)
+    timer = setTimeout(tick, Math.max(1000, 60000 - (Date.now() - started)));
+}
+for (const signal of ["SIGINT", "SIGTERM"])
+  process.on(signal, () => {
+    stopped = true;
+    clearTimeout(timer);
+    process.exit(0);
+  });
+timer = setTimeout(tick, 5000);

scripts/start-production.sh

@@ -5,4 +5,13 @@ echo "Applying Prisma schema..."
 npx prisma db push --skip-generate
 
 echo "Starting Kita-Planer..."
+if [ -n "${NOTDIENST_JOB_SECRET:-}" ]; then
+  if [ "${#NOTDIENST_JOB_SECRET}" -lt 32 ]; then
+    echo "NOTDIENST_JOB_SECRET muss mindestens 32 Zeichen haben." >&2
+    exit 1
+  fi
+  node scripts/notdienst-alarm-worker.mjs &
+else
+  echo "Notdienst-Fristprüfung deaktiviert: NOTDIENST_JOB_SECRET fehlt."
+fi
 exec npm run start:prod

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

@@ -1,34 +1,39 @@
 "use server";
-
 import { revalidatePath } from "next/cache";
-import { NotdienstAlertStatus } from "@prisma/client";
+import { respondToAlarm } from "@/lib/alarms/service";
-import { prisma } from "@/lib/prisma";
+import { deliverAlarmEmails } from "@/lib/alarms/email";
+import { rateLimit } from "@/lib/rate-limit";
 
-export async function confirmAlertAction(token: string) {
+export async function respondAlertAction(token: string, approve: boolean) {
+  if (typeof token !== "string" || token.length > 128)
+    return { error: "Ungültiger Rückmeldelink." };
+  if (!rateLimit(`alarm-response:${token}`, 12, 60).allowed)
+    return { error: "Bitte kurz warten und erneut versuchen." };
   try {
-    const alert = await prisma.notdienstAlert.findUnique({
+    const result = await respondToAlarm(token, approve);
-      where: { confirmationToken: token },
+    // The household response is already committed; transport failure must not undo it.
-    });
+    try {
-
+      await deliverAlarmEmails(result.emailIds);
-    if (!alert) {
+    } catch {
-      return { error: "Ungültiger Bestätigungs-Link." };
+      /* Persistent jobs will retry. */
     }
-
+    revalidatePath("/alert/[token]", "page");
-    if (alert.status !== NotdienstAlertStatus.PENDING) {
-      return { error: "Dieser Alarm wurde bereits bestätigt oder abgebrochen." };
-    }
-
-    await prisma.notdienstAlert.update({
-      where: { id: alert.id },
-      data: {
-        status: NotdienstAlertStatus.CONFIRMED,
-        confirmedAt: new Date(),
-      },
-    });
-
     revalidatePath("/dashboard");
+    revalidatePath("/dashboard/notdienst/alarm");
     return { success: true };
-  } catch {
+  } catch (error) {
-    return { error: "Fehler bei der Bestätigung." };
+    if (
+      error instanceof Error &&
+      !error.message.includes("prisma") &&
+      !error.message.includes("Invalid `")
+    )
+      return { error: error.message };
+    return {
+      error:
+        "Die Rückmeldung konnte nicht gespeichert werden. Bitte den aktuellen Stand prüfen.",
+    };
   }
 }
+export async function confirmAlertAction(token: string) {
+  return respondAlertAction(token, true);
+}

src/app/alert/[token]/alert-confirm-form.tsx

@@ -1,37 +1,65 @@
 "use client";
-
+import { useState, useTransition } from "react";
-import { useTransition } from "react";
+import { useRouter } from "next/navigation";
-import { Loader2 } from "lucide-react";
-import { toast } from "sonner";
-
 import { Button } from "@/components/ui/button";
-import { confirmAlertAction } from "./actions";
+import { respondAlertAction } from "./actions";
 
 export function AlertConfirmForm({ token }: { token: string }) {
-  const [isPending, startTransition] = useTransition();
+  const [choice, setChoice] = useState<boolean | null>(null);
-
+  const [pending, start] = useTransition();
-  const handleConfirm = () => {
+  const [error, setError] = useState("");
-    startTransition(async () => {
+  const router = useRouter();
-      const result = await confirmAlertAction(token);
-      if ("error" in result && result.error) {
-        toast.error(result.error as string);
-      } else {
-        toast.success("Erfolgreich bestätigt!");
-      }
-    });
-  };
-
   return (
-    <Button
+    <div className="grid gap-4">
-      size="lg"
+      {choice === null ? (
-      className="w-full sm:w-auto font-semibold text-lg"
+        <div className="grid gap-3 sm:grid-cols-2">
-      onClick={handleConfirm}
+          <Button onClick={() => setChoice(true)}>Wir übernehmen</Button>
-      disabled={isPending}
+          <Button variant="outline" onClick={() => setChoice(false)}>
-    >
+            Wir können nicht
-      {isPending ? (
+          </Button>
-        <Loader2 className="mr-2 h-5 w-5 animate-spin" />
+        </div>
-      ) : null}
+      ) : (
-      Ich bestätige! (Bin auf dem Weg)
+        <div className="grid gap-3 rounded-xl border border-[var(--hairline)] bg-[var(--surface-2)] p-4">
-    </Button>
+          <p className="text-sm">
+            {choice
+              ? "Wir sagen für unseren Haushalt zu."
+              : "Unser Haushalt kann diesen Einsatz nicht übernehmen."}{" "}
+            Diese Antwort gilt für alle Elternkonten des Haushalts.
+          </p>
+          <div className="flex flex-wrap gap-2">
+            <Button
+              disabled={pending}
+              onClick={() =>
+                start(async () => {
+                  setError("");
+                  const result = await respondAlertAction(token, choice);
+                  if (result.error) {
+                    setError(result.error);
+                    router.refresh();
+                  } else router.refresh();
+                })
+              }
+            >
+              {pending ? "Wird gespeichert …" : "Antwort verbindlich speichern"}
+            </Button>
+            <Button
+              variant="ghost"
+              disabled={pending}
+              onClick={() => {
+                setChoice(null);
+                setError("");
+              }}
+            >
+              Zurück
+            </Button>
+          </div>
+        </div>
+      )}
+      {error && (
+        <p role="alert" className="text-sm text-[var(--danger)]">
+          {error}
+        </p>
+      )}
+    </div>
   );
 }

src/app/alert/[token]/page.tsx

@@ -1,127 +1,114 @@
 import { notFound } from "next/navigation";
-import { format } from "date-fns";
+import { BellRing, CheckCircle2 } from "lucide-react";
-import { de } from "date-fns/locale";
+import { getPublicAlarm } from "@/lib/alarms/service";
-import { BellRing, ShieldCheck, XCircle } from "lucide-react";
-import { NotdienstAlertStatus } from "@prisma/client";
-
-import { prisma } from "@/lib/prisma";
 import {
-  Card,
+  alarmLabel,
-  CardContent,
+  dateKey,
-  CardDescription,
+  durationLabel,
-  CardHeader,
+  instantLabel,
-  CardTitle,
+} from "@/lib/alarms/format";
-} from "@/components/ui/card";
 import { AlertConfirmForm } from "./alert-confirm-form";
 
-export const metadata = { title: "Notdienst Alarm · Kita-Planer" };
+export const metadata = {
-
+  title: "Notdienstalarm · Kita-Planer",
+  robots: { index: false, follow: false },
+  referrer: "no-referrer" as const,
+};
+export const dynamic = "force-dynamic";
 export default async function AlertPage({
   params,
 }: {
   params: Promise<{ token: string }>;
 }) {
   const { token } = await params;
-
+  const alarm = await getPublicAlarm(token);
-  const alert = await prisma.notdienstAlert.findUnique({
+  if (!alarm) notFound();
-    where: { confirmationToken: token },
+  const now = new Date(),
-    select: {
+    expired = alarm.expiresAt <= now;
-      status: true,
+  const canRespond = alarm.status === "PENDING" && !expired;
-      parentUser: {
+  const overdue = alarm.deadline <= now;
-        select: {
-          firstName: true,
-        },
-      },
-      kita: {
-        select: {
-          name: true,
-        },
-      },
-      assignment: {
-        select: {
-          date: true,
-          child: {
-            select: {
-              firstName: true,
-              lastName: true,
-            },
-          },
-        },
-      },
-    },
-  });
-
-  if (!alert) {
-    notFound();
-  }
-
-  const isPending = alert.status === NotdienstAlertStatus.PENDING;
-  const isConfirmed = alert.status === NotdienstAlertStatus.CONFIRMED;
-
   return (
-    <div className="flex min-h-screen flex-col items-center justify-center bg-muted/30 px-4 py-12">
+    <main className="flex min-h-screen items-center justify-center bg-[var(--bg)] px-5 py-12">
-      <Card className="w-full max-w-md shadow-lg border-primary/20">
+      <section className="w-full max-w-xl overflow-hidden rounded-2xl border border-[var(--hairline)] bg-[var(--surface)] shadow-sm">
-        <CardHeader className="text-center pb-2">
+        <header
-          <div className="mx-auto mb-4 flex h-16 w-16 items-center justify-center rounded-full bg-primary/10 text-primary">
+          className={`border-b border-[var(--hairline)] p-6 sm:p-8 ${alarm.status === "CONFIRMED" ? "bg-[var(--accent-soft)]" : "bg-[var(--surface-2)]"}`}
-            {isPending ? (
+        >
-              <BellRing className="h-8 w-8 animate-pulse text-destructive" />
+          <p className="text-xs font-semibold uppercase tracking-widest text-[var(--accent-deep)]">
-            ) : isConfirmed ? (
+            Kita-Planer · {alarm.kitaName}
-              <ShieldCheck className="h-8 w-8 text-success" />
+          </p>
-            ) : (
+          {alarm.status === "CONFIRMED" ? (
-              <XCircle className="h-8 w-8 text-muted-foreground" />
+            <CheckCircle2 className="mt-6 h-7 w-7 text-[var(--accent-deep)]" />
-            )}
+          ) : (
-          </div>
+            <BellRing className="mt-6 h-7 w-7 text-[var(--danger)]" />
-          <CardTitle className="text-2xl">
+          )}
-            {isPending
+          <h1 className="mt-3 text-3xl text-[var(--ink)]">
-              ? "Notdienst Einsatz!"
+            {alarm.status === "PENDING"
-              : isConfirmed
+              ? "Könnt ihr den Notdienst übernehmen?"
-                ? "Einsatz bestätigt"
+              : alarmLabel(alarm)}
-                : "Alarm abgebrochen"}
+          </h1>
-          </CardTitle>
+          <p className="mt-3 text-sm leading-6 text-[var(--ink-soft)]">
-          <CardDescription className="text-base mt-2">
+            Hallo {alarm.firstName}, diese Rückmeldung gilt für euren gesamten
-            Kita {alert.kita.name}
+            Haushalt.
-          </CardDescription>
+          </p>
-        </CardHeader>
+        </header>
-        <CardContent className="space-y-6 pt-4">
+        <div className="grid gap-6 p-6 sm:p-8">
-          <div className="rounded-lg bg-background border p-4 text-center space-y-1">
+          <dl className="grid grid-cols-2 gap-5 text-sm">
-            <p className="text-sm text-muted-foreground">Datum</p>
+            <div>
-            <p className="font-semibold text-lg">
+              <dt className="text-[var(--ink-muted)]">Datum</dt>
-              {format(alert.assignment.date, "EEEE, dd. MMMM yyyy", {
+              <dd className="mt-1 font-semibold">
-                locale: de,
+                {dateKey(alarm.date).split("-").reverse().join(".")}
-              })}
+              </dd>
-            </p>
+            </div>
-            <div className="h-2" />
+            <div>
-            <p className="text-sm text-muted-foreground">Eingeteiltes Kind</p>
+              <dt className="text-[var(--ink-muted)]">Einsatz</dt>
-            <p className="font-medium">
+              <dd className="mt-1 font-semibold">{durationLabel(alarm)}</dd>
-              {alert.assignment.child.firstName}{" "}
+            </div>
-              {alert.assignment.child.lastName}
+            <div>
-            </p>
+              <dt className="text-[var(--ink-muted)]">Haushalt</dt>
-          </div>
+              <dd className="mt-1 font-semibold">{alarm.familyName}</dd>
-
+            </div>
-          <div className="text-center">
+            <div>
-            {isPending ? (
+              <dt className="text-[var(--ink-muted)]">Antwortfrist</dt>
-              <>
+              <dd className="mt-1 font-semibold">
-                <p className="mb-6 text-sm text-muted-foreground">
+                {instantLabel(alarm.deadline)} Uhr
-                  Hallo {alert.parentUser.firstName}, eine Fachkraft hat sich
+              </dd>
-                  krankgemeldet und du bist heute für den Notdienst eingeteilt.
+            </div>
-                  Bitte bestätige deinen Einsatz schnellstmöglich!
+          </dl>
+          {canRespond ? (
+            <>
+              {overdue && (
+                <p className="rounded-lg bg-[var(--surface-2)] p-4 text-sm leading-6">
+                  Die Antwortfrist ist abgelaufen. Ihr könnt noch antworten.
+                  Eine verspätete Zusage muss die Koordination freigeben, da
+                  möglicherweise bereits Ersatz organisiert wird.
                 </p>
-                <AlertConfirmForm token={token} />
+              )}
-              </>
+              <AlertConfirmForm token={token} />
-            ) : isConfirmed ? (
+            </>
-              <p className="text-sm text-muted-foreground">
+          ) : (
-                Danke, {alert.parentUser.firstName}! Dein Einsatz wurde
+            <div
-                erfolgreich bestätigt. Die Kita rechnet mit dir.
+              role="status"
-              </p>
+              className="rounded-xl border border-[var(--hairline)] p-4 text-sm leading-6"
-            ) : (
+            >
-              <p className="text-sm text-muted-foreground">
+              {alarm.status === "CANCELLED"
-                Dieser Einsatz wurde vom Koordinator abgebrochen. Du musst nicht
+                ? "Der Einsatz wurde storniert. Ihr müsst für diesen Alarm nicht einspringen."
-                einspringen.
+                : alarm.status === "CONFIRMED"
-              </p>
+                  ? "Euer Haushalt hat zugesagt. Die Kita rechnet mit euch. Bei einer Änderung kontaktiert bitte die Koordination."
-            )}
+                  : alarm.status === "LATE_CONFIRMATION"
-          </div>
+                    ? "Eure verspätete Zusage ist gespeichert. Wartet bitte auf die Freigabe durch die Koordination."
-        </CardContent>
+                    : alarm.status === "DECLINED"
-      </Card>
+                      ? "Die Absage eures Haushalts ist gespeichert. Die Koordination kümmert sich um Ersatz."
-    </div>
+                      : alarm.status === "REVIEW_REQUIRED"
+                        ? "Die bisherigen Rückmeldungen müssen von der Koordination geprüft werden. Bitte kontaktiert die Kita."
+                        : "Der Einsatz ist beendet. Dieser Rückmeldelink ist abgelaufen."}
+            </div>
+          )}
+          <p className="text-xs leading-5 text-[var(--ink-muted)]">
+            Den persönlichen Link bitte innerhalb eures Haushalts behalten.
+            Änderungen einer gespeicherten Antwort klärt ihr mit der Kita.
+          </p>
+        </div>
+      </section>
+    </main>
   );
 }

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

@@ -0,0 +1,32 @@
+import { revalidatePath } from "next/cache";
+import { authorizeAlarmJob, runAlarmJob } from "@/lib/alarms/job";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+export async function POST(request: Request) {
+  const status = authorizeAlarmJob(request.headers.get("authorization"));
+  if (status !== 200)
+    return Response.json(
+      {
+        error:
+          status === 503
+            ? "Fristprüfung ist nicht konfiguriert."
+            : "Nicht autorisiert.",
+      },
+      { status },
+    );
+  try {
+    const result = await runAlarmJob();
+    revalidatePath("/dashboard");
+    revalidatePath("/dashboard/notdienst/alarm");
+    return Response.json(result);
+  } catch {
+    return Response.json(
+      {
+        error:
+          "Fristprüfung fehlgeschlagen; nächster Aufruf versucht es erneut.",
+      },
+      { status: 500 },
+    );
+  }
+}

src/app/dashboard/actions.ts

@@ -1,123 +1,10 @@
 "use server";
-
+import { alarmAction } from "./notdienst/alarm/actions";
-import crypto from "crypto";
+// Existing callers use the shared household workflow and the same guards.
-import { createElement } from "react";
-import { format } from "date-fns";
-import { de } from "date-fns/locale";
-import { revalidatePath } from "next/cache";
-import { NotdienstAlertStatus, UserRole } from "@prisma/client";
-
-import { AlertEmail } from "@/emails/AlertEmail";
-import { requireRole } from "@/lib/auth-utils";
-import { getAppEmailConfigError, sendAppEmail } from "@/lib/mail";
-import { prisma } from "@/lib/prisma";
-
-const BASE_URL =
-  process.env.NEXTAUTH_URL ?? process.env.AUTH_URL ?? "http://localhost:3000";
-
 export async function triggerAlertAction(assignmentId: string) {
-  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
+  return alarmAction("create", {
-  const kitaId = session.user.kitaId!;
+    assignmentId,
-
+    wholeDay: true,
-  try {
+    replyMinutes: 30,
-    const [existing, assignment] = await Promise.all([
+  });
-      // Prüfen ob es schon einen aktiven Alert für dieses Assignment gibt
-      prisma.notdienstAlert.findFirst({
-        where: { assignmentId, kitaId },
-      }),
-      prisma.notdienstAssignment.findFirst({
-        where: { id: assignmentId, kitaId },
-        include: {
-          child: {
-            select: {
-              id: true,
-              firstName: true,
-              lastName: true,
-              family: {
-                select: {
-                  users: {
-                    where: { role: UserRole.ELTERN },
-                    select: {
-                      id: true,
-                      email: true,
-                      firstName: true,
-                      lastName: true,
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      }),
-    ]);
-
-    if (existing) {
-      return { error: "Für diese Einteilung wurde bereits ein Alarm ausgelöst." };
-    }
-
-    if (!assignment) {
-      return { error: "Notdienst-Einteilung wurde nicht gefunden." };
-    }
-
-    const parents = assignment.child.family.users;
-
-    if (parents.length === 0) {
-      return { error: "Kein Elternteil für diesen Notdienst hinterlegt." };
-    }
-
-    const mailConfigError = getAppEmailConfigError();
-    if (mailConfigError) {
-      return { error: mailConfigError };
-    }
-
-    const dateLabel = format(assignment.date, "EEEE, dd. MMMM yyyy", {
-      locale: de,
-    });
-    const childName = `${assignment.child.firstName} ${assignment.child.lastName}`;
-    const alertJobs: { email: string; token: string }[] = [];
-
-    await prisma.$transaction(
-      parents.map((parent) => {
-        const token = crypto.randomUUID();
-        alertJobs.push({ email: parent.email, token });
-        return prisma.notdienstAlert.create({
-          data: {
-            kitaId,
-            assignmentId,
-            parentUserId: parent.id,
-            triggeredById: session.user.id,
-            status: NotdienstAlertStatus.PENDING,
-            confirmationToken: token,
-          },
-        });
-      }),
-    );
-
-    for (const job of alertJobs) {
-      const emailResult = await sendAppEmail({
-        to: job.email,
-        subject: `Dringender Notdienst-Alarm für ${dateLabel}`,
-        react: createElement(AlertEmail, {
-          date: dateLabel,
-          childName,
-          confirmLink: `${BASE_URL}/alert/${job.token}`,
-        }),
-      });
-
-      if (!emailResult.success) {
-        revalidatePath("/dashboard");
-        return {
-          error: `Alarm wurde angelegt, aber mindestens eine E-Mail konnte nicht versendet werden: ${emailResult.error}`,
-        };
-      }
-    }
-
-    revalidatePath("/dashboard");
-
-    return { success: true };
-  } catch (error) {
-    console.error(error);
-    return { error: "Fehler beim Auslösen des Alarms." };
-  }
 }

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

@@ -1,6 +1,7 @@
 "use client";
 
 import { useState, useTransition } from "react";
+import Link from "next/link";
 import { Plus, Pencil, Search, Trash2 } from "lucide-react";
 import { toast } from "sonner";
 
@@ -40,7 +41,9 @@ type EducatorDto = {
 
 export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
   const [openCreate, setOpenCreate] = useState(false);
-  const [editingEducator, setEditingEducator] = useState<EducatorDto | null>(null);
+  const [editingEducator, setEditingEducator] = useState<EducatorDto | null>(
+    null,
+  );
   const [educatorToDelete, setEducatorToDelete] = useState<EducatorDto | null>(
     null,
   );
@@ -132,8 +135,16 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
                 </div>
               </div>
               <DialogFooter>
-                <Button type="button" variant="ghost" onClick={() => setOpenCreate(false)}>Abbrechen</Button>
+                <Button
-                <Button type="submit" disabled={isPending}>Speichern</Button>
+                  type="button"
+                  variant="ghost"
+                  onClick={() => setOpenCreate(false)}
+                >
+                  Abbrechen
+                </Button>
+                <Button type="submit" disabled={isPending}>
+                  Speichern
+                </Button>
               </DialogFooter>
             </form>
           </DialogContent>
@@ -153,67 +164,88 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
           </Badge>
         </CardHeader>
         <CardContent className="px-0 pb-0">
-        <Table>
+          <Table>
-          <TableHeader>
+            <TableHeader>
-            <TableRow>
-              <TableHead className="pl-6">Vorname</TableHead>
-              <TableHead>Nachname</TableHead>
-              <TableHead>Status</TableHead>
-              <TableHead className="pr-6 text-right">Aktionen</TableHead>
-            </TableRow>
-          </TableHeader>
-          <TableBody>
-            {educators.length === 0 ? (
               <TableRow>
-                <TableCell colSpan={4} className="h-32 text-center">
+                <TableHead className="pl-6">Vorname</TableHead>
-                  <div className="flex max-h-[240px] min-h-[200px] flex-col items-center justify-center">
+                <TableHead>Nachname</TableHead>
-                    <div className="mb-3 flex h-12 w-12 items-center justify-center rounded-2xl bg-[var(--accent-soft)] text-[var(--accent-deep)]">
+                <TableHead>Status</TableHead>
-                      <Plus className="h-6 w-6 [stroke-width:1.7]" />
+                <TableHead className="pr-6 text-right">Aktionen</TableHead>
-                    </div>
-                    <p className="text-sm font-medium text-[var(--ink)]">
-                      Keine Einträge gefunden
-                    </p>
-                    <p className="mt-1 text-sm text-[var(--ink-soft)]">
-                      Lege die erste Person im Team an.
-                    </p>
-                  </div>
-                </TableCell>
               </TableRow>
-            ) : (
+            </TableHeader>
-              educators.map((ed) => (
+            <TableBody>
-                <TableRow key={ed.id}>
+              {educators.length === 0 ? (
-                  <TableCell className="pl-6 font-medium">{ed.firstName}</TableCell>
+                <TableRow>
-                  <TableCell>{ed.lastName}</TableCell>
+                  <TableCell colSpan={4} className="h-32 text-center">
-                  <TableCell>
+                    <div className="flex max-h-[240px] min-h-[200px] flex-col items-center justify-center">
-                    <Badge variant={ed.active ? "success" : "secondary"}>
+                      <div className="mb-3 flex h-12 w-12 items-center justify-center rounded-2xl bg-[var(--accent-soft)] text-[var(--accent-deep)]">
-                      {ed.active ? "Aktiv" : "Inaktiv"}
+                        <Plus className="h-6 w-6 [stroke-width:1.7]" />
-                    </Badge>
+                      </div>
-                  </TableCell>
+                      <p className="text-sm font-medium text-[var(--ink)]">
-                  <TableCell className="pr-6 text-right">
+                        Keine Einträge gefunden
-                    <Button variant="ghost" size="icon" onClick={() => setEditingEducator(ed)}>
+                      </p>
-                      <Pencil className="h-4 w-4 [stroke-width:1.7]" />
+                      <p className="mt-1 text-sm text-[var(--ink-soft)]">
-                    </Button>
+                        Lege die erste Person im Team an.
-                    <Button
+                      </p>
-                      variant="ghost"
+                    </div>
-                      size="icon"
-                      className="text-[var(--danger)] hover:bg-[var(--danger-soft)] hover:text-[var(--danger)]"
-                      onClick={() => setEducatorToDelete(ed)}
-                      disabled={isPending}
-                      aria-label={`${ed.firstName} ${ed.lastName} löschen`}
-                    >
-                      <Trash2 className="h-4 w-4 [stroke-width:1.7]" />
-                    </Button>
                   </TableCell>
                 </TableRow>
-              ))
+              ) : (
-            )}
+                educators.map((ed) => (
-          </TableBody>
+                  <TableRow key={ed.id}>
-        </Table>
+                    <TableCell className="pl-6 font-medium">
+                      {ed.firstName}
+                    </TableCell>
+                    <TableCell>{ed.lastName}</TableCell>
+                    <TableCell>
+                      <Badge variant={ed.active ? "success" : "secondary"}>
+                        {ed.active ? "Aktiv" : "Inaktiv"}
+                      </Badge>
+                    </TableCell>
+                    <TableCell className="pr-6 text-right">
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        asChild
+                        className="mr-2"
+                      >
+                        <Link
+                          href={`/dashboard/personal?tab=verwaltung&educator=${ed.id}`}
+                        >
+                          Personalprofil
+                        </Link>
+                      </Button>
+                      <Button
+                        variant="ghost"
+                        size="icon"
+                        onClick={() => setEditingEducator(ed)}
+                      >
+                        <Pencil className="h-4 w-4 [stroke-width:1.7]" />
+                      </Button>
+                      <Button
+                        variant="ghost"
+                        size="icon"
+                        className="text-[var(--danger)] hover:bg-[var(--danger-soft)] hover:text-[var(--danger)]"
+                        onClick={() => setEducatorToDelete(ed)}
+                        disabled={isPending}
+                        aria-label={`${ed.firstName} ${ed.lastName} löschen`}
+                      >
+                        <Trash2 className="h-4 w-4 [stroke-width:1.7]" />
+                      </Button>
+                    </TableCell>
+                  </TableRow>
+                ))
+              )}
+            </TableBody>
+          </Table>
         </CardContent>
       </Card>
 
       {/* Edit Dialog */}
-      <Dialog open={!!editingEducator} onOpenChange={(open) => !open && setEditingEducator(null)}>
+      <Dialog
+        open={!!editingEducator}
+        onOpenChange={(open) => !open && setEditingEducator(null)}
+      >
         <DialogContent>
           <form action={handleUpdate}>
             <DialogHeader>
@@ -223,21 +255,43 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
               <div className="grid gap-4 py-4">
                 <div className="grid gap-2">
                   <Label htmlFor="edit-firstName">Vorname</Label>
-                  <Input id="edit-firstName" name="firstName" defaultValue={editingEducator.firstName} required />
+                  <Input
+                    id="edit-firstName"
+                    name="firstName"
+                    defaultValue={editingEducator.firstName}
+                    required
+                  />
                 </div>
                 <div className="grid gap-2">
                   <Label htmlFor="edit-lastName">Nachname</Label>
-                  <Input id="edit-lastName" name="lastName" defaultValue={editingEducator.lastName} required />
+                  <Input
+                    id="edit-lastName"
+                    name="lastName"
+                    defaultValue={editingEducator.lastName}
+                    required
+                  />
                 </div>
                 <div className="flex items-center gap-2 mt-2">
-                  <Switch id="edit-active" name="active" defaultChecked={editingEducator.active} />
+                  <Switch
+                    id="edit-active"
+                    name="active"
+                    defaultChecked={editingEducator.active}
+                  />
                   <Label htmlFor="edit-active">Aktiv</Label>
                 </div>
               </div>
             )}
             <DialogFooter>
-              <Button type="button" variant="ghost" onClick={() => setEditingEducator(null)}>Abbrechen</Button>
+              <Button
-              <Button type="submit" disabled={isPending}>Aktualisieren</Button>
+                type="button"
+                variant="ghost"
+                onClick={() => setEditingEducator(null)}
+              >
+                Abbrechen
+              </Button>
+              <Button type="submit" disabled={isPending}>
+                Aktualisieren
+              </Button>
             </DialogFooter>
           </form>
         </DialogContent>

src/app/dashboard/erzieher/actions.ts

@@ -19,12 +19,12 @@ export async function createEducator(rawPayload: unknown) {
   if (!kitaId) {
     return { error: "Kein Mandant zugeordnet." };
   }
-  
+
   const parsed = educatorSchema.safeParse(rawPayload);
   if (!parsed.success) {
     return { error: "Ungültige Eingabedaten." };
   }
-  
+
   try {
     await prisma.educator.create({
       data: {
@@ -34,7 +34,7 @@ export async function createEducator(rawPayload: unknown) {
         active: parsed.data.active,
       },
     });
-    
+
     revalidatePath("/dashboard/erzieher");
     return { success: true };
   } catch (error) {
@@ -49,12 +49,12 @@ export async function updateEducator(id: string, rawPayload: unknown) {
   if (!kitaId) {
     return { error: "Kein Mandant zugeordnet." };
   }
-  
+
   const parsed = educatorSchema.safeParse(rawPayload);
   if (!parsed.success) {
     return { error: "Ungültige Eingabedaten." };
   }
-  
+
   try {
     await prisma.educator.update({
       where: {
@@ -67,7 +67,7 @@ export async function updateEducator(id: string, rawPayload: unknown) {
         active: parsed.data.active,
       },
     });
-    
+
     revalidatePath("/dashboard/erzieher");
     return { success: true };
   } catch (error) {
@@ -82,15 +82,23 @@ export async function deleteEducator(id: string) {
   if (!kitaId) {
     return { error: "Kein Mandant zugeordnet." };
   }
-  
+
   try {
+    const profile = await prisma.staffProfile.findFirst({
+      where: { educatorId: id, kitaId },
+    });
+    if (profile)
+      return {
+        error:
+          "Diese Fachkraft hat ein Personalprofil. Bitte auf inaktiv setzen, damit Zeiten und Konten erhalten bleiben.",
+      };
     await prisma.educator.delete({
       where: {
         id,
         kitaId,
       },
     });
-    
+
     revalidatePath("/dashboard/erzieher");
     return { success: true };
   } catch (error) {

src/app/dashboard/erzieher/page.tsx

@@ -36,8 +36,8 @@ export default async function ErzieherPage() {
             </em>
           </h1>
           <p className="mt-2 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
-            Stammdaten des Kita-Personals für interne Planung und spätere
+            Stammdaten des Teams und Zugang zu Beschäftigungsprofilen,
-            Notdienst-Alarmierung.
+            Urlaubsansprüchen und Arbeitszeitmodellen.
           </p>
         </div>
         <div className="flex shrink-0 flex-wrap gap-2">

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

@@ -4,8 +4,6 @@ import { useState, useMemo, useTransition } from "react";
 import {
   TerminType,
   TerminStatus,
-  EventParticipationStatus,
-  DutyAssignmentStatus,
 } from "@prisma/client";
 import {
   format,
@@ -30,9 +28,7 @@ import {
   MapPin,
   AlertTriangle,
   WashingMachine,
-  MoreHorizontal,
   Trash2,
-  Edit,
 } from "lucide-react";
 import { Input } from "@/components/ui/input";
 import { Button } from "@/components/ui/button";
@@ -49,11 +45,20 @@ import {
 } from "@/components/ui/dialog";
 import { toast } from "sonner";
 
-import { CalendarListItemDto } from "./termin-list";
+import {
-import { TerminList } from "./termin-list";
+  CalendarListItemDto,
+  NotdienstSwapDialog,
+  NotdienstSwapOptionDto,
+  TerminList,
+} from "./termin-list";
 import { MitbringselList } from "./mitbringsel-list";
 import { AdminTerminModal } from "./admin-termin-modal";
-import { deleteTerminAdmin } from "../actions";
+import {
+  acceptNotdienstSwapRequest,
+  cancelNotdienstSwapRequest,
+  declineNotdienstSwapRequest,
+  deleteTerminAdmin,
+} from "../actions";
 
 const categories = [
   { label: "Schließtag", type: TerminType.SCHLIESSTAG, color: "var(--danger)" },
@@ -68,14 +73,30 @@ const categories = [
   { label: "Sonstiges", type: TerminType.SONSTIGES, color: "var(--ink-muted)" },
 ];
 
+export type NotdienstSwapRequestDto = {
+  id: string;
+  direction: "incoming" | "outgoing";
+  targetDate: Date;
+  targetFamilyName: string;
+  targetChildName: string;
+  offeredDate: Date;
+  offeredFamilyName: string;
+  offeredChildName: string;
+  message: string | null;
+};
+
 export function CalendarOverviewClient({
   termine,
   userId,
   isAdmin,
+  notdienstSwapOptions = [],
+  pendingSwapRequests = [],
 }: {
   termine: CalendarListItemDto[];
   userId: string;
   isAdmin: boolean;
+  notdienstSwapOptions?: NotdienstSwapOptionDto[];
+  pendingSwapRequests?: NotdienstSwapRequestDto[];
 }) {
   const [view, setView] = useState<"liste" | "monat" | "agenda">("monat");
   const [searchQuery, setSearchQuery] = useState("");
@@ -185,6 +206,10 @@ export function CalendarOverviewClient({
 
   return (
     <div className="space-y-5">
+      {!isAdmin && pendingSwapRequests.length > 0 && (
+        <NotdienstSwapRequestsPanel requests={pendingSwapRequests} />
+      )}
+
       {/* Search and Filters Header */}
       <div className="flex flex-wrap items-center justify-between gap-3">
         <div className="flex items-center flex-wrap gap-3">
@@ -282,7 +307,12 @@ export function CalendarOverviewClient({
 
       {/* Main View Contents */}
       {view === "liste" && (
-        <TerminList termine={filteredEvents} userId={userId} isAdmin={isAdmin} />
+        <TerminList
+          termine={filteredEvents}
+          userId={userId}
+          isAdmin={isAdmin}
+          notdienstSwapOptions={notdienstSwapOptions}
+        />
       )}
 
       {view === "monat" && (
@@ -431,13 +461,26 @@ export function CalendarOverviewClient({
                         </p>
                         {isAdmin && (
                           <div className="mt-3 flex gap-2">
-                            <a href="/dashboard/notdienst/plan">
+                            <a 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 && (
+                          <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">
+                                  Tausch anfragen
+                                </Button>
+                              }
+                            />
+                          </div>
+                        )}
                       </div>
                     </div>
                   ) : (
@@ -564,6 +607,106 @@ export function CalendarOverviewClient({
   );
 }
 
+function NotdienstSwapRequestsPanel({
+  requests,
+}: {
+  requests: NotdienstSwapRequestDto[];
+}) {
+  return (
+    <Card className="p-0">
+      <div className="border-b border-[var(--hairline-soft)] px-5 py-4">
+        <h2 className="text-base font-semibold tracking-[-0.01em] text-[var(--ink)]">
+          Offene Notdienst-Tausche
+        </h2>
+      </div>
+      <div className="divide-y divide-[var(--hairline-soft)]">
+        {requests.map((request) => (
+          <NotdienstSwapRequestRow key={request.id} request={request} />
+        ))}
+      </div>
+    </Card>
+  );
+}
+
+function NotdienstSwapRequestRow({
+  request,
+}: {
+  request: NotdienstSwapRequestDto;
+}) {
+  const [isPending, startTransition] = useTransition();
+
+  const runAction = (
+    action: (requestId: string) => Promise<{ success?: boolean; error?: string }>,
+    successMessage: string,
+  ) => {
+    startTransition(async () => {
+      const result = await action(request.id);
+      if (result.error) {
+        toast.error(result.error);
+        return;
+      }
+      toast.success(successMessage);
+    });
+  };
+
+  return (
+    <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"}
+        </p>
+        <p className="mt-1 text-sm leading-5 text-[var(--ink-soft)]">
+          {format(request.targetDate, "dd.MM.yyyy", { locale: de })}{" "}
+          ({request.targetFamilyName}, {request.targetChildName}) gegen{" "}
+          {format(request.offeredDate, "dd.MM.yyyy", { locale: de })}{" "}
+          ({request.offeredFamilyName}, {request.offeredChildName})
+        </p>
+        {request.message && (
+          <p className="mt-1 text-xs leading-5 text-[var(--ink-muted)]">
+            {request.message}
+          </p>
+        )}
+      </div>
+      <div className="flex shrink-0 gap-2">
+        {request.direction === "incoming" ? (
+          <>
+            <Button
+              size="sm"
+              onClick={() =>
+                runAction(acceptNotdienstSwapRequest, "Tausch wurde angenommen.")
+              }
+              disabled={isPending}
+            >
+              Annehmen
+            </Button>
+            <Button
+              size="sm"
+              variant="ghost"
+              onClick={() =>
+                runAction(declineNotdienstSwapRequest, "Tausch wurde abgelehnt.")
+              }
+              disabled={isPending}
+            >
+              Ablehnen
+            </Button>
+          </>
+        ) : (
+          <Button
+            size="sm"
+            variant="ghost"
+            onClick={() =>
+              runAction(cancelNotdienstSwapRequest, "Tauschanfrage wurde zurückgezogen.")
+            }
+            disabled={isPending}
+          >
+            Zurückziehen
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
+
 // =====================================================================
 // Month Grid Component
 // =====================================================================

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

@@ -1,5 +1,6 @@
 "use client";
 
+import type { ReactNode } from "react";
 import { useState, useTransition } from "react";
 import { DutyAssignmentStatus, TerminStatus, TerminType } from "@prisma/client";
 import { format } from "date-fns";
@@ -11,8 +12,6 @@ import {
   MapPin,
   MoreHorizontal,
   WashingMachine,
-  Trash2,
-  ShieldAlert,
 } from "lucide-react";
 import { toast } from "sonner";
 
@@ -31,7 +30,7 @@ import {
 import { AdminTerminModal } from "./admin-termin-modal";
 import { TerminRequestModal } from "./termin-request-modal";
 import { MitbringselList } from "./mitbringsel-list";
-import { deleteTerminAdmin } from "../actions";
+import { createNotdienstSwapRequest, deleteTerminAdmin } from "../actions";
 
 export type TerminListItemDto = {
   kind: "termin";
@@ -69,24 +68,38 @@ export type DutyCalendarItemDto = {
 export type NotdienstCalendarItemDto = {
   kind: "notdienst";
   id: string;
+  planId: string;
+  planYear: number;
+  planMonth: number;
   title: string;
+  familyId: string;
   familyName: string;
   childName: string;
   isOwn: boolean;
+  canRequestSwap: boolean;
   startDate: Date;
   endDate: Date;
 };
 
+export type NotdienstSwapOptionDto = {
+  id: string;
+  date: Date;
+  childName: string;
+  familyName: string;
+};
+
 export type CalendarListItemDto = TerminListItemDto | DutyCalendarItemDto | NotdienstCalendarItemDto;
 
 export function TerminList({
   termine,
   userId,
   isAdmin,
+  notdienstSwapOptions = [],
 }: {
   termine: CalendarListItemDto[];
   userId: string;
   isAdmin: boolean;
+  notdienstSwapOptions?: NotdienstSwapOptionDto[];
 }) {
   if (termine.length === 0) {
     return (
@@ -137,7 +150,12 @@ export function TerminList({
                 item.kind === "duty" ? (
                   <DutyRow key={`duty-${item.id}`} duty={item} isAdmin={isAdmin} />
                 ) : item.kind === "notdienst" ? (
-                  <NotdienstRow key={`notdienst-${item.id}`} notdienst={item} isAdmin={isAdmin} />
+                  <NotdienstRow
+                    key={`notdienst-${item.id}`}
+                    notdienst={item}
+                    isAdmin={isAdmin}
+                    notdienstSwapOptions={notdienstSwapOptions}
+                  />
                 ) : (
                   <TerminRow key={`termin-${item.id}`} termin={item} userId={userId} isAdmin={isAdmin} />
                 ),
@@ -492,7 +510,123 @@ function getTypeLabel(type: TerminType): string {
   }
 }
 
-function NotdienstRow({ notdienst, isAdmin }: { notdienst: NotdienstCalendarItemDto; isAdmin: boolean }) {
+export function NotdienstSwapDialog({
+  target,
+  options,
+  trigger,
+}: {
+  target: NotdienstCalendarItemDto;
+  options: NotdienstSwapOptionDto[];
+  trigger: ReactNode;
+}) {
+  const selectableOptions = options.filter((option) => option.id !== target.id);
+  const [open, setOpen] = useState(false);
+  const [offeredAssignmentId, setOfferedAssignmentId] = useState(
+    selectableOptions[0]?.id ?? "",
+  );
+  const [message, setMessage] = useState("");
+  const [isPending, startTransition] = useTransition();
+
+  const handleSubmit = () => {
+    if (!offeredAssignmentId) {
+      toast.error("Bitte wähle einen eigenen Notdienst als Tausch-Angebot.");
+      return;
+    }
+
+    startTransition(async () => {
+      const result = await createNotdienstSwapRequest({
+        targetAssignmentId: target.id,
+        offeredAssignmentId,
+        message,
+      });
+
+      if ("error" in result && result.error) {
+        toast.error(result.error);
+        return;
+      }
+
+      toast.success("Tauschanfrage wurde versendet.");
+      setOpen(false);
+      setMessage("");
+    });
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>{trigger}</DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Notdienst tauschen</DialogTitle>
+          <DialogDescription>
+            Frage Familie {target.familyName}, ob ihr den Notdienst am{" "}
+            {format(target.startDate, "dd.MM.yyyy", { locale: de })} tauschen könnt.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <div>
+            <label className="mb-1.5 block text-sm font-medium text-[var(--ink)]">
+              Dein Tausch-Angebot
+            </label>
+            <select
+              className="w-full rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 py-2 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)]"
+              value={offeredAssignmentId}
+              disabled={isPending || selectableOptions.length === 0}
+              onChange={(event) => setOfferedAssignmentId(event.target.value)}
+            >
+              {selectableOptions.length === 0 ? (
+                <option value="">Kein eigener zukünftiger Notdienst verfügbar</option>
+              ) : (
+                selectableOptions.map((option) => (
+                  <option key={option.id} value={option.id}>
+                    {format(option.date, "dd.MM.yyyy", { locale: de })} - {option.childName}
+                  </option>
+                ))
+              )}
+            </select>
+          </div>
+
+          <div>
+            <label className="mb-1.5 block text-sm font-medium text-[var(--ink)]">
+              Nachricht optional
+            </label>
+            <textarea
+              value={message}
+              onChange={(event) => setMessage(event.target.value)}
+              maxLength={500}
+              rows={3}
+              className="w-full resize-none rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 py-2 text-sm text-[var(--ink)] ring-offset-[var(--surface)] placeholder:text-[var(--ink-muted)] hover:border-[var(--accent-mid)] focus-visible:border-[var(--accent)] focus-visible:outline-none focus-visible:ring-[3px] focus-visible:ring-[var(--focus-ring)]"
+              placeholder="Zum Beispiel: Wir sind an dem Tag verreist."
+              disabled={isPending}
+            />
+          </div>
+        </div>
+
+        <DialogFooter>
+          <Button variant="ghost" onClick={() => setOpen(false)} disabled={isPending}>
+            Abbrechen
+          </Button>
+          <Button
+            onClick={handleSubmit}
+            disabled={isPending || selectableOptions.length === 0}
+          >
+            Anfrage senden
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function NotdienstRow({
+  notdienst,
+  isAdmin,
+  notdienstSwapOptions,
+}: {
+  notdienst: NotdienstCalendarItemDto;
+  isAdmin: boolean;
+  notdienstSwapOptions: NotdienstSwapOptionDto[];
+}) {
   const color = notdienst.isOwn ? "oklch(0.60 0.18 45)" : "oklch(0.75 0.10 50)";
   const [menuOpen, setMenuOpen] = useState(false);
 
@@ -535,7 +669,7 @@ function NotdienstRow({ notdienst, isAdmin }: { notdienst: NotdienstCalendarItem
                 <div className="fixed inset-0 z-40" onClick={() => setMenuOpen(false)} />
                 <div className="absolute right-0 mt-1 w-56 rounded-xl border border-[var(--hairline)] bg-[var(--surface)] p-1.5 shadow-lg z-50 animate-in fade-in-50 slide-in-from-top-1 duration-150">
                   <a
-                    href="/dashboard/notdienst/plan"
+                    href={`/dashboard/notdienst/plan?year=${notdienst.planYear}&month=${notdienst.planMonth}`}
                     className="flex w-full items-center rounded-lg px-2.5 py-2 text-sm text-[var(--ink)] hover:bg-[var(--surface-2)]"
                     onClick={() => setMenuOpen(false)}
                   >
@@ -545,6 +679,16 @@ function NotdienstRow({ notdienst, isAdmin }: { notdienst: NotdienstCalendarItem
               </>
             )}
           </div>
+        ) : notdienst.canRequestSwap ? (
+          <NotdienstSwapDialog
+            target={notdienst}
+            options={notdienstSwapOptions}
+            trigger={
+              <Button size="sm" variant="outline" className="h-8 px-2.5 text-xs">
+                Tausch anfragen
+              </Button>
+            }
+          />
         ) : (
           <div className="w-9 h-9" />
         )}

src/app/dashboard/kalender/actions.ts

@@ -1,10 +1,22 @@
 "use server";
 
+import { createElement } from "react";
 import { revalidatePath } from "next/cache";
-import { TerminStatus, TerminType, UserRole } from "@prisma/client";
+import {
+  NotdienstAlertStatus,
+  NotdienstPlanStatus,
+  NotdienstSwapStatus,
+  TerminStatus,
+  TerminType,
+  UserRole,
+} from "@prisma/client";
+import { format } from "date-fns";
+import { de } from "date-fns/locale";
 import { z } from "zod";
 
+import { NotdienstSwapEmail } from "@/emails/NotdienstSwapEmail";
 import { requireKitaSession, requireRole } from "@/lib/auth-utils";
+import { sendAppEmail } from "@/lib/mail";
 import { prisma } from "@/lib/prisma";
 
 // =====================================================================
@@ -24,6 +36,244 @@ const terminSchema = z.object({
   participantInfo: z.string().trim().max(1000).optional(),
 });
 
+const swapRequestSchema = z.object({
+  targetAssignmentId: z.string().min(1),
+  offeredAssignmentId: z.string().min(1),
+  message: z.string().trim().max(500).optional(),
+});
+
+const swapIdSchema = z.string().min(1);
+
+const activeNotdienstAlertStatuses = [
+  NotdienstAlertStatus.PENDING,
+  NotdienstAlertStatus.CONFIRMED,
+];
+
+function getTodayUtcDateOnly() {
+  const today = new Date();
+  return new Date(
+    Date.UTC(today.getFullYear(), today.getMonth(), today.getDate()),
+  );
+}
+
+function getBaseUrl() {
+  return (
+    process.env.NEXTAUTH_URL ?? process.env.AUTH_URL ?? "http://localhost:3000"
+  );
+}
+
+function formatNotdienstDate(date: Date) {
+  return format(date, "EEEE, dd. MMMM yyyy", { locale: de });
+}
+
+function revalidateCalendarAndNotdienst() {
+  try {
+    revalidatePath("/dashboard/kalender");
+    revalidatePath("/dashboard/notdienst/plan");
+    revalidatePath("/dashboard/notdienst");
+    revalidatePath("/dashboard");
+  } catch {
+    // Ignore if called outside Next.js context
+  }
+}
+
+type SwapAssignmentWithFamily = {
+  id: string;
+  childId: string;
+  date: Date;
+  plan: {
+    status: NotdienstPlanStatus;
+  };
+  child: {
+    familyId: string;
+    family: {
+      name: string;
+      users: {
+        email: string;
+        firstName: string;
+        lastName: string;
+      }[];
+    };
+  };
+  alerts: {
+    id: string;
+  }[];
+  alarms?: { id: string }[];
+};
+
+async function getSwapAssignment(
+  assignmentId: string,
+  kitaId: string,
+): Promise<SwapAssignmentWithFamily | null> {
+  return prisma.notdienstAssignment.findFirst({
+    where: { id: assignmentId, kitaId },
+    select: {
+      id: true,
+      childId: true,
+      date: true,
+      plan: { select: { status: true } },
+      child: {
+        select: {
+          familyId: true,
+          family: {
+            select: {
+              name: true,
+              users: {
+                where: { role: UserRole.ELTERN },
+                select: {
+                  email: true,
+                  firstName: true,
+                  lastName: true,
+                },
+              },
+            },
+          },
+        },
+      },
+      alerts: {
+        where: { alarmId: null, status: { in: activeNotdienstAlertStatuses } },
+        select: { id: true },
+      },
+      alarms: {
+        where: { activeAssignmentId: { not: null } },
+        select: { id: true },
+      },
+    },
+  });
+}
+
+function validateSwapAssignmentPair({
+  targetAssignment,
+  offeredAssignment,
+  requesterFamilyId,
+  today,
+}: {
+  targetAssignment: SwapAssignmentWithFamily | null;
+  offeredAssignment: SwapAssignmentWithFamily | null;
+  requesterFamilyId: string;
+  today: Date;
+}) {
+  if (!targetAssignment || !offeredAssignment) {
+    return "Notdienst nicht gefunden.";
+  }
+
+  if (targetAssignment.id === offeredAssignment.id) {
+    return "Bitte wähle zwei unterschiedliche Notdienste aus.";
+  }
+
+  if (
+    targetAssignment.plan.status !== NotdienstPlanStatus.PUBLISHED ||
+    offeredAssignment.plan.status !== NotdienstPlanStatus.PUBLISHED
+  ) {
+    return "Es können nur veröffentlichte Notdienste getauscht werden.";
+  }
+
+  if (targetAssignment.date < today || offeredAssignment.date < today) {
+    return "Vergangene Notdienste können nicht getauscht werden.";
+  }
+
+  if (offeredAssignment.child.familyId !== requesterFamilyId) {
+    return "Du kannst nur eigene Notdienste als Tausch anbieten.";
+  }
+
+  if (targetAssignment.child.familyId === requesterFamilyId) {
+    return "Du kannst keinen Tausch mit deinem eigenen Haushalt anfragen.";
+  }
+
+  if (
+    targetAssignment.alerts.length > 0 ||
+    offeredAssignment.alerts.length > 0 ||
+    targetAssignment.alarms?.length ||
+    offeredAssignment.alarms?.length
+  ) {
+    return "Notdienste mit aktiver Alarmierung können nicht getauscht werden.";
+  }
+
+  return null;
+}
+
+async function sendSwapMail({
+  to,
+  parentName,
+  subject,
+  heading,
+  preview,
+  kitaName,
+  body,
+  targetDate,
+  offeredDate,
+}: {
+  to: string;
+  parentName: string;
+  subject: string;
+  heading: string;
+  preview: string;
+  kitaName: string;
+  body: string;
+  targetDate: Date;
+  offeredDate: Date;
+}) {
+  const result = await sendAppEmail({
+    to,
+    subject,
+    react: createElement(NotdienstSwapEmail, {
+      parentName,
+      heading,
+      preview,
+      kitaName,
+      body,
+      targetDateLabel: formatNotdienstDate(targetDate),
+      offeredDateLabel: formatNotdienstDate(offeredDate),
+      link: `${getBaseUrl()}/dashboard/kalender`,
+    }),
+  });
+
+  if (!result.success) {
+    console.error(
+      "Notdienst-Tausch-Mail konnte nicht versendet werden:",
+      result.error,
+    );
+  }
+}
+
+async function notifyFamilyAboutSwap({
+  family,
+  subject,
+  heading,
+  preview,
+  kitaName,
+  body,
+  targetDate,
+  offeredDate,
+}: {
+  family: SwapAssignmentWithFamily["child"]["family"];
+  subject: string;
+  heading: string;
+  preview: string;
+  kitaName: string;
+  body: string;
+  targetDate: Date;
+  offeredDate: Date;
+}) {
+  await Promise.all(
+    family.users
+      .filter((parent) => !!parent.email)
+      .map((parent) =>
+        sendSwapMail({
+          to: parent.email,
+          parentName: `${parent.firstName} ${parent.lastName}`,
+          subject,
+          heading,
+          preview,
+          kitaName,
+          body,
+          targetDate,
+          offeredDate,
+        }),
+      ),
+  );
+}
+
 function buildTerminData(data: z.infer<typeof terminSchema>) {
   const startDate = new Date(data.startDate);
   const endDate = new Date(data.endDate);
@@ -31,7 +281,9 @@ function buildTerminData(data: z.infer<typeof terminSchema>) {
   now.setSeconds(0, 0);
 
   if (startDate < now) {
-    return { error: "Der Startzeitpunkt darf nicht in der Vergangenheit liegen." };
+    return {
+      error: "Der Startzeitpunkt darf nicht in der Vergangenheit liegen.",
+    };
   }
 
   if (endDate < startDate) {
@@ -53,21 +305,490 @@ function buildTerminData(data: z.infer<typeof terminSchema>) {
           ? new Date(data.rsvpDeadline)
           : null,
       participantInfo:
-        data.requiresRsvp && data.participantInfo
+        data.requiresRsvp && data.participantInfo ? data.participantInfo : null,
-          ? data.participantInfo
-          : null,
     },
   };
 }
 
+export async function createNotdienstSwapRequest(rawPayload: unknown) {
+  const session = await requireKitaSession();
+  if (session.user.role !== UserRole.ELTERN) {
+    return { error: "Nur Eltern können Notdienst-Tausche anfragen." };
+  }
+  if (!session.user.familyId) {
+    return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
+  }
+
+  const parsed = swapRequestSchema.safeParse(rawPayload);
+  if (!parsed.success) {
+    return { error: "Ungültige Eingabedaten." };
+  }
+
+  const { targetAssignmentId, offeredAssignmentId, message } = parsed.data;
+  const today = getTodayUtcDateOnly();
+
+  try {
+    const [targetAssignment, offeredAssignment, kita, existingRequest] =
+      await Promise.all([
+        getSwapAssignment(targetAssignmentId, session.user.kitaId),
+        getSwapAssignment(offeredAssignmentId, session.user.kitaId),
+        prisma.kita.findUnique({
+          where: { id: session.user.kitaId },
+          select: { name: true },
+        }),
+        prisma.notdienstSwapRequest.findFirst({
+          where: {
+            kitaId: session.user.kitaId,
+            status: NotdienstSwapStatus.PENDING,
+            OR: [
+              { targetAssignmentId },
+              { offeredAssignmentId },
+              { targetAssignmentId: offeredAssignmentId },
+              { offeredAssignmentId: targetAssignmentId },
+            ],
+          },
+          select: { id: true },
+        }),
+      ]);
+
+    const validationError = validateSwapAssignmentPair({
+      targetAssignment,
+      offeredAssignment,
+      requesterFamilyId: session.user.familyId,
+      today,
+    });
+    if (validationError) {
+      return { error: validationError };
+    }
+    if (!targetAssignment || !offeredAssignment || !kita) {
+      return { error: "Notdienst nicht gefunden." };
+    }
+    if (existingRequest) {
+      return {
+        error:
+          "Für einen dieser Notdienste gibt es bereits eine offene Tauschanfrage.",
+      };
+    }
+
+    await prisma.notdienstSwapRequest.create({
+      data: {
+        kitaId: session.user.kitaId,
+        requesterUserId: session.user.id,
+        requesterFamilyId: session.user.familyId,
+        targetAssignmentId,
+        offeredAssignmentId,
+        message: message || null,
+      },
+    });
+
+    await notifyFamilyAboutSwap({
+      family: targetAssignment.child.family,
+      subject: `Notdienst-Tauschanfrage für ${formatNotdienstDate(targetAssignment.date)}`,
+      heading: "Neue Tauschanfrage",
+      preview: "Du hast eine neue Notdienst-Tauschanfrage.",
+      kitaName: kita.name,
+      body: `Ein Elternteil aus einem anderen Haushalt möchte einen Notdienst mit dir tauschen.${message ? ` Nachricht: ${message}` : ""}`,
+      targetDate: targetAssignment.date,
+      offeredDate: offeredAssignment.date,
+    });
+
+    revalidateCalendarAndNotdienst();
+    return { success: true };
+  } catch (error) {
+    console.error("Fehler beim Erstellen der Notdienst-Tauschanfrage:", error);
+    return { error: "Tauschanfrage konnte nicht erstellt werden." };
+  }
+}
+
+export async function acceptNotdienstSwapRequest(requestIdRaw: unknown) {
+  const session = await requireKitaSession();
+  if (!session.user.familyId) {
+    return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
+  }
+
+  const parsed = swapIdSchema.safeParse(requestIdRaw);
+  if (!parsed.success) {
+    return { error: "Ungültige Eingabedaten." };
+  }
+
+  const today = getTodayUtcDateOnly();
+
+  try {
+    const result = await prisma.$transaction(
+      async (tx) => {
+        const request = await tx.notdienstSwapRequest.findFirst({
+          where: {
+            id: parsed.data,
+            kitaId: session.user.kitaId,
+            status: NotdienstSwapStatus.PENDING,
+          },
+          select: {
+            id: true,
+            requesterFamilyId: true,
+            targetAssignmentId: true,
+            offeredAssignmentId: true,
+            targetAssignment: {
+              select: {
+                id: true,
+                childId: true,
+                date: true,
+                plan: { select: { status: true } },
+                child: {
+                  select: {
+                    familyId: true,
+                    family: {
+                      select: {
+                        name: true,
+                        users: {
+                          where: { role: UserRole.ELTERN },
+                          select: {
+                            email: true,
+                            firstName: true,
+                            lastName: true,
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+                alerts: {
+                  where: {
+                    alarmId: null,
+                    status: { in: activeNotdienstAlertStatuses },
+                  },
+                  select: { id: true },
+                },
+              },
+            },
+            offeredAssignment: {
+              select: {
+                id: true,
+                childId: true,
+                date: true,
+                plan: { select: { status: true } },
+                child: {
+                  select: {
+                    familyId: true,
+                    family: {
+                      select: {
+                        name: true,
+                        users: {
+                          where: { role: UserRole.ELTERN },
+                          select: {
+                            email: true,
+                            firstName: true,
+                            lastName: true,
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+                alerts: {
+                  where: {
+                    alarmId: null,
+                    status: { in: activeNotdienstAlertStatuses },
+                  },
+                  select: { id: true },
+                },
+              },
+            },
+          },
+        });
+
+        if (!request) {
+          throw new Error(
+            "Tauschanfrage nicht gefunden oder nicht mehr offen.",
+          );
+        }
+
+        if (
+          await tx.notdienstAlarm.count({
+            where: {
+              activeAssignmentId: {
+                in: [request.targetAssignmentId, request.offeredAssignmentId],
+              },
+            },
+          })
+        )
+          throw new Error(
+            "Notdienste mit aktiver Alarmierung können nicht getauscht werden.",
+          );
+
+        if (request.targetAssignment.child.familyId !== session.user.familyId) {
+          throw new Error(
+            "Nur der angefragte Haushalt kann diese Anfrage annehmen.",
+          );
+        }
+
+        const validationError = validateSwapAssignmentPair({
+          targetAssignment: request.targetAssignment,
+          offeredAssignment: request.offeredAssignment,
+          requesterFamilyId: request.requesterFamilyId,
+          today,
+        });
+        if (validationError) {
+          throw new Error(validationError);
+        }
+
+        await tx.notdienstAssignment.update({
+          where: { id: request.targetAssignmentId },
+          data: { childId: request.offeredAssignment.childId },
+        });
+        await tx.notdienstAssignment.update({
+          where: { id: request.offeredAssignmentId },
+          data: { childId: request.targetAssignment.childId },
+        });
+        await tx.notdienstSwapRequest.update({
+          where: { id: request.id },
+          data: {
+            status: NotdienstSwapStatus.ACCEPTED,
+            respondedById: session.user.id,
+            respondedAt: new Date(),
+          },
+        });
+        await tx.notdienstSwapRequest.updateMany({
+          where: {
+            id: { not: request.id },
+            kitaId: session.user.kitaId,
+            status: NotdienstSwapStatus.PENDING,
+            OR: [
+              {
+                targetAssignmentId: {
+                  in: [request.targetAssignmentId, request.offeredAssignmentId],
+                },
+              },
+              {
+                offeredAssignmentId: {
+                  in: [request.targetAssignmentId, request.offeredAssignmentId],
+                },
+              },
+            ],
+          },
+          data: {
+            status: NotdienstSwapStatus.CANCELLED,
+            respondedAt: new Date(),
+          },
+        });
+
+        return {
+          targetAssignment: request.targetAssignment,
+          offeredAssignment: request.offeredAssignment,
+        };
+      },
+      { isolationLevel: "Serializable" },
+    );
+
+    const kita = await prisma.kita.findUnique({
+      where: { id: session.user.kitaId },
+      select: { name: true },
+    });
+    if (kita) {
+      await Promise.all([
+        notifyFamilyAboutSwap({
+          family: result.targetAssignment.child.family,
+          subject: "Notdienst-Tausch bestätigt",
+          heading: "Tausch bestätigt",
+          preview: "Ein Notdienst-Tausch wurde bestätigt.",
+          kitaName: kita.name,
+          body: "die Tauschanfrage wurde angenommen. Der Notdienst-Plan wurde automatisch aktualisiert.",
+          targetDate: result.targetAssignment.date,
+          offeredDate: result.offeredAssignment.date,
+        }),
+        notifyFamilyAboutSwap({
+          family: result.offeredAssignment.child.family,
+          subject: "Notdienst-Tausch bestätigt",
+          heading: "Tausch bestätigt",
+          preview: "Ein Notdienst-Tausch wurde bestätigt.",
+          kitaName: kita.name,
+          body: "deine Tauschanfrage wurde angenommen. Der Notdienst-Plan wurde automatisch aktualisiert.",
+          targetDate: result.targetAssignment.date,
+          offeredDate: result.offeredAssignment.date,
+        }),
+      ]);
+    }
+
+    revalidateCalendarAndNotdienst();
+    return { success: true };
+  } catch (error) {
+    return {
+      error:
+        error instanceof Error
+          ? error.message
+          : "Tauschanfrage konnte nicht angenommen werden.",
+    };
+  }
+}
+
+export async function declineNotdienstSwapRequest(requestIdRaw: unknown) {
+  const session = await requireKitaSession();
+  if (!session.user.familyId) {
+    return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
+  }
+
+  const parsed = swapIdSchema.safeParse(requestIdRaw);
+  if (!parsed.success) {
+    return { error: "Ungültige Eingabedaten." };
+  }
+
+  try {
+    const request = await prisma.notdienstSwapRequest.findFirst({
+      where: {
+        id: parsed.data,
+        kitaId: session.user.kitaId,
+        status: NotdienstSwapStatus.PENDING,
+      },
+      select: {
+        id: true,
+        targetAssignment: {
+          select: {
+            date: true,
+            child: {
+              select: {
+                familyId: true,
+                family: {
+                  select: {
+                    name: true,
+                    users: {
+                      where: { role: UserRole.ELTERN },
+                      select: { email: true, firstName: true, lastName: true },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        offeredAssignment: {
+          select: {
+            date: true,
+            child: {
+              select: {
+                family: {
+                  select: {
+                    name: true,
+                    users: {
+                      where: { role: UserRole.ELTERN },
+                      select: { email: true, firstName: true, lastName: true },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!request) {
+      return { error: "Tauschanfrage nicht gefunden oder nicht mehr offen." };
+    }
+    if (request.targetAssignment.child.familyId !== session.user.familyId) {
+      return {
+        error: "Nur der angefragte Haushalt kann diese Anfrage ablehnen.",
+      };
+    }
+
+    await prisma.notdienstSwapRequest.update({
+      where: { id: request.id },
+      data: {
+        status: NotdienstSwapStatus.DECLINED,
+        respondedById: session.user.id,
+        respondedAt: new Date(),
+      },
+    });
+
+    const kita = await prisma.kita.findUnique({
+      where: { id: session.user.kitaId },
+      select: { name: true },
+    });
+    if (kita) {
+      await Promise.all([
+        notifyFamilyAboutSwap({
+          family: request.targetAssignment.child.family,
+          subject: "Notdienst-Tauschanfrage abgelehnt",
+          heading: "Tauschanfrage abgelehnt",
+          preview: "Eine Notdienst-Tauschanfrage wurde abgelehnt.",
+          kitaName: kita.name,
+          body: "du hast die Tauschanfrage abgelehnt. Der Notdienst-Plan bleibt unverändert.",
+          targetDate: request.targetAssignment.date,
+          offeredDate: request.offeredAssignment.date,
+        }),
+        notifyFamilyAboutSwap({
+          family: request.offeredAssignment.child.family,
+          subject: "Notdienst-Tauschanfrage abgelehnt",
+          heading: "Tauschanfrage abgelehnt",
+          preview: "Eine Notdienst-Tauschanfrage wurde abgelehnt.",
+          kitaName: kita.name,
+          body: "deine Tauschanfrage wurde abgelehnt. Der Notdienst-Plan bleibt unverändert.",
+          targetDate: request.targetAssignment.date,
+          offeredDate: request.offeredAssignment.date,
+        }),
+      ]);
+    }
+
+    revalidateCalendarAndNotdienst();
+    return { success: true };
+  } catch (error) {
+    console.error("Fehler beim Ablehnen der Notdienst-Tauschanfrage:", error);
+    return { error: "Tauschanfrage konnte nicht abgelehnt werden." };
+  }
+}
+
+export async function cancelNotdienstSwapRequest(requestIdRaw: unknown) {
+  const session = await requireKitaSession();
+  if (!session.user.familyId) {
+    return { error: "Dein Account ist noch keinem Haushalt zugeordnet." };
+  }
+
+  const parsed = swapIdSchema.safeParse(requestIdRaw);
+  if (!parsed.success) {
+    return { error: "Ungültige Eingabedaten." };
+  }
+
+  try {
+    const request = await prisma.notdienstSwapRequest.findFirst({
+      where: {
+        id: parsed.data,
+        kitaId: session.user.kitaId,
+        requesterFamilyId: session.user.familyId,
+        status: NotdienstSwapStatus.PENDING,
+      },
+      select: { id: true },
+    });
+
+    if (!request) {
+      return { error: "Tauschanfrage nicht gefunden oder nicht mehr offen." };
+    }
+
+    await prisma.notdienstSwapRequest.update({
+      where: { id: request.id },
+      data: {
+        status: NotdienstSwapStatus.CANCELLED,
+        respondedById: session.user.id,
+        respondedAt: new Date(),
+      },
+    });
+
+    revalidateCalendarAndNotdienst();
+    return { success: true };
+  } catch (error) {
+    console.error(
+      "Fehler beim Zurückziehen der Notdienst-Tauschanfrage:",
+      error,
+    );
+    return { error: "Tauschanfrage konnte nicht zurückgezogen werden." };
+  }
+}
+
 export async function createTerminRequest(rawPayload: unknown) {
   const session = await requireKitaSession();
-  
+
   const parsed = terminSchema.safeParse(rawPayload);
   if (!parsed.success) {
     return { error: "Ungültige Eingabedaten." };
   }
-  
+
   const data = parsed.data;
   const terminData = buildTerminData(data);
 
@@ -104,12 +825,12 @@ export async function createTerminAdmin(rawPayload: unknown) {
   if (!kitaId) {
     return { error: "Kein Mandant zugeordnet." };
   }
-  
+
   const parsed = terminSchema.safeParse(rawPayload);
   if (!parsed.success) {
     return { error: "Ungültige Eingabedaten." };
   }
-  
+
   const data = parsed.data;
   const terminData = buildTerminData(data);
 
@@ -234,7 +955,10 @@ export async function rejectTermin(terminId: string, reason?: string) {
   }
 }
 
-export async function toggleMitbringselList(terminId: string, enabled: boolean) {
+export async function toggleMitbringselList(
+  terminId: string,
+  enabled: boolean,
+) {
   const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
   const kitaId = session.user.kitaId;
   if (!kitaId) {
@@ -268,12 +992,12 @@ const mitbringselSchema = z.object({
 
 export async function addMitbringsel(rawPayload: unknown) {
   const session = await requireKitaSession();
-  
+
   const parsed = mitbringselSchema.safeParse(rawPayload);
   if (!parsed.success) {
     return { error: "Ungültige Eingabedaten." };
   }
-  
+
   const { terminId, content } = parsed.data;
 
   try {
@@ -282,7 +1006,11 @@ export async function addMitbringsel(rawPayload: unknown) {
       where: { id: terminId, kitaId: session.user.kitaId },
     });
 
-    if (!termin || termin.status !== TerminStatus.CONFIRMED || !termin.mitbringselListEnabled) {
+    if (
+      !termin ||
+      termin.status !== TerminStatus.CONFIRMED ||
+      !termin.mitbringselListEnabled
+    ) {
       return { error: "Mitbring-Liste ist für diesen Termin nicht aktiv." };
     }
 

src/app/dashboard/kalender/page.tsx

@@ -1,8 +1,8 @@
 import {
   DutyAssignmentStatus,
   EventParticipationStatus,
+  NotdienstSwapStatus,
   TerminStatus,
-  TerminType,
   UserRole,
 } from "@prisma/client";
 import { HelpCircle } from "lucide-react";
@@ -11,9 +11,12 @@ import { requireKitaSession } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
 import { AdminTerminModal } from "./_components/admin-termin-modal";
 import { PendingAnfragen, type PendingTerminDto } from "./_components/pending-anfragen";
-import { type CalendarListItemDto } from "./_components/termin-list";
+import { type CalendarListItemDto, type NotdienstSwapOptionDto } from "./_components/termin-list";
 import { TerminRequestModal } from "./_components/termin-request-modal";
-import { CalendarOverviewClient } from "./_components/calendar-overview-client";
+import {
+  CalendarOverviewClient,
+  type NotdienstSwapRequestDto,
+} from "./_components/calendar-overview-client";
 
 export const metadata = { title: "Terminkalender · Kita-Planer" };
 
@@ -31,6 +34,7 @@ export default async function KalenderPage({
   const resolvedSearchParams = await searchParams;
   const currentTab = resolvedSearchParams.tab || "übersicht";
   const now = new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
 
   const confirmedTermineRows = await prisma.termin.findMany({
     where: {
@@ -159,6 +163,13 @@ export default async function KalenderPage({
     select: {
       id: true,
       date: true,
+      planId: true,
+      plan: {
+        select: {
+          year: true,
+          month: true,
+        },
+      },
       child: {
         select: {
           firstName: true,
@@ -175,6 +186,56 @@ export default async function KalenderPage({
     orderBy: { date: "asc" },
   });
 
+  const pendingSwapRows =
+    !isAdmin && session.user.familyId
+      ? await prisma.notdienstSwapRequest.findMany({
+          where: {
+            kitaId: session.user.kitaId,
+            status: NotdienstSwapStatus.PENDING,
+            OR: [
+              { requesterFamilyId: session.user.familyId },
+              {
+                targetAssignment: {
+                  child: {
+                    familyId: session.user.familyId,
+                  },
+                },
+              },
+            ],
+          },
+          select: {
+            id: true,
+            requesterFamilyId: true,
+            message: true,
+            targetAssignment: {
+              select: {
+                date: true,
+                child: {
+                  select: {
+                    firstName: true,
+                    lastName: true,
+                    family: { select: { name: true } },
+                  },
+                },
+              },
+            },
+            offeredAssignment: {
+              select: {
+                date: true,
+                child: {
+                  select: {
+                    firstName: true,
+                    lastName: true,
+                    family: { select: { name: true } },
+                  },
+                },
+              },
+            },
+          },
+          orderBy: { createdAt: "desc" },
+        })
+      : [];
+
   const allUserTermine: CalendarListItemDto[] = [
     ...confirmedTermineRows.map((termin) => ({
       ...termin,
@@ -213,21 +274,59 @@ export default async function KalenderPage({
     }),
     ...notdienstAssignmentRows.map((assignment) => {
       const isOwn = assignment.child.familyId === familyIdForParticipation;
+      const canRequestSwap =
+        !isAdmin &&
+        !isOwn &&
+        !!session.user.familyId &&
+        assignment.date >= today;
       return {
         kind: "notdienst" as const,
         id: assignment.id,
+        planId: assignment.planId,
+        planYear: assignment.plan.year,
+        planMonth: assignment.plan.month,
         title: isOwn
           ? `Mein Notdienst (${assignment.child.firstName})`
           : `Notdienst (${assignment.child.family.name})`,
+        familyId: assignment.child.familyId,
         familyName: assignment.child.family.name,
         childName: `${assignment.child.firstName} ${assignment.child.lastName}`,
         isOwn,
+        canRequestSwap,
         startDate: assignment.date,
         endDate: assignment.date,
       };
     }),
   ].sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
 
+  const notdienstSwapOptions: NotdienstSwapOptionDto[] = notdienstAssignmentRows
+    .filter(
+      (assignment) =>
+        assignment.child.familyId === familyIdForParticipation &&
+        assignment.date >= today,
+    )
+    .map((assignment) => ({
+      id: assignment.id,
+      date: assignment.date,
+      childName: `${assignment.child.firstName} ${assignment.child.lastName}`,
+      familyName: assignment.child.family.name,
+    }));
+
+  const pendingSwapRequests: NotdienstSwapRequestDto[] = pendingSwapRows.map(
+    (request) => ({
+      id: request.id,
+      direction:
+        request.requesterFamilyId === session.user.familyId ? "outgoing" : "incoming",
+      targetDate: request.targetAssignment.date,
+      targetFamilyName: request.targetAssignment.child.family.name,
+      targetChildName: `${request.targetAssignment.child.firstName} ${request.targetAssignment.child.lastName}`,
+      offeredDate: request.offeredAssignment.date,
+      offeredFamilyName: request.offeredAssignment.child.family.name,
+      offeredChildName: `${request.offeredAssignment.child.firstName} ${request.offeredAssignment.child.lastName}`,
+      message: request.message,
+    }),
+  );
+
   let allPendingTermine: PendingTerminDto[] = [];
   if (isAdmin) {
     const pendingRows = await prisma.termin.findMany({
@@ -305,6 +404,8 @@ export default async function KalenderPage({
                 termine={allUserTermine}
                 userId={session.user.id}
                 isAdmin={isAdmin}
+                notdienstSwapOptions={notdienstSwapOptions}
+                pendingSwapRequests={pendingSwapRequests}
               />
             ) : currentTab === "anfragen" ? (
               <PendingAnfragen termine={allPendingTermine} />
@@ -313,6 +414,8 @@ export default async function KalenderPage({
                 termine={[]}
                 userId={session.user.id}
                 isAdmin={isAdmin}
+                notdienstSwapOptions={notdienstSwapOptions}
+                pendingSwapRequests={pendingSwapRequests}
               />
             )}
           </div>
@@ -322,6 +425,8 @@ export default async function KalenderPage({
           termine={allUserTermine}
           userId={session.user.id}
           isAdmin={isAdmin}
+          notdienstSwapOptions={notdienstSwapOptions}
+          pendingSwapRequests={pendingSwapRequests}
         />
       )}
     </div>
@@ -405,5 +510,3 @@ function TabLink({
     </a>
   );
 }
-
-

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

@@ -0,0 +1,59 @@
+"use server";
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+import { requireAlarmActor } from "@/lib/alarms/auth";
+import { executeAlarmCommand } from "@/lib/alarms/service";
+import { deliverAlarmEmails } from "@/lib/alarms/email";
+
+export type AlarmActionResult = {
+  error?: string;
+  warning?: string;
+  success?: boolean;
+  alarmId?: string;
+};
+export async function alarmAction(
+  command: string,
+  data: Record<string, unknown>,
+): Promise<AlarmActionResult> {
+  const actor = await requireAlarmActor(command !== "readNotice");
+  try {
+    const result = await executeAlarmCommand(actor, command, data);
+    let warning: string | undefined;
+    if (result.emailIds.length) {
+      try {
+        const delivery = await deliverAlarmEmails(result.emailIds);
+        if (delivery.failed)
+          warning =
+            "Gespeichert. Einige E-Mails warten noch auf den Versand. Bitte den Versandstand im Alarm prüfen.";
+        else if (
+          process.env.NODE_ENV === "development" &&
+          !process.env.RESEND_API_KEY
+        )
+          warning = "Gespeichert. E-Mail-Versand lokal simuliert.";
+      } catch {
+        warning = "Gespeichert. Der E-Mail-Versand ist noch ausstehend.";
+      }
+    }
+    for (const path of [
+      "/dashboard",
+      "/dashboard/notdienst/alarm",
+      "/dashboard/notdienst/plan",
+      "/dashboard/kalender",
+    ])
+      revalidatePath(path);
+    revalidatePath("/alert/[token]", "page");
+    return { success: true, alarmId: result.alarmId, warning };
+  } catch (error) {
+    if (error instanceof z.ZodError)
+      return {
+        error: error.issues[0]?.message ?? "Bitte die Eingaben prüfen.",
+      };
+    if (
+      error instanceof Error &&
+      !error.message.includes("prisma") &&
+      !error.message.includes("Invalid `")
+    )
+      return { error: error.message };
+    return { error: "Die Alarmaktion konnte nicht gespeichert werden." };
+  }
+}

src/app/dashboard/notdienst/alarm/dashboard-hints.tsx

@@ -0,0 +1,51 @@
+import Link from "next/link";
+import { requireKitaSession } from "@/lib/auth-utils";
+import { getAlarmFeed, managerRoles } from "@/lib/alarms/service";
+import {
+  alarmLabel,
+  durationLabel,
+  dateKey,
+  needsClarification,
+} from "@/lib/alarms/format";
+import { AlarmRefresh } from "./forms";
+
+export async function AlarmDashboardHints() {
+  const { user } = await requireKitaSession();
+  if (![...managerRoles, "ELTERN"].includes(user.role)) return null;
+  let alarms;
+  try {
+    alarms = await getAlarmFeed({
+      id: user.id!,
+      kitaId: user.kitaId,
+      role: user.role,
+    });
+  } catch {
+    return null;
+  }
+  if (!alarms.length) return null;
+  return (
+    <section className="mb-6 rounded-2xl border border-[var(--accent-mid)] bg-[var(--surface)] p-5">
+      <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
+        <h2 className="text-lg font-semibold">Aktuelle Notdienstalarme</h2>
+        <AlarmRefresh />
+      </div>
+      <div className="grid gap-3">
+        {alarms.map((a) => (
+          <Link
+            key={a.id}
+            href={`/dashboard/notdienst/alarm?alarm=${a.id}`}
+            className={`flex flex-wrap items-center justify-between gap-3 rounded-lg border p-3 text-sm ${needsClarification(a) ? "border-[var(--danger)] text-[var(--danger)]" : "border-[var(--hairline)]"}`}
+          >
+            <span>
+              {dateKey(a.date).split("-").reverse().join(".")} · {a.familyName}
+              <span className="mt-1 block text-xs text-[var(--ink-soft)]">
+                {durationLabel(a)}
+              </span>
+            </span>
+            <strong>{alarmLabel(a)} →</strong>
+          </Link>
+        ))}
+      </div>
+    </section>
+  );
+}

src/app/dashboard/notdienst/alarm/forms.tsx

@@ -0,0 +1,383 @@
+"use client";
+import { useEffect, useId, useState, useTransition } from "react";
+import { useRouter } from "next/navigation";
+import { toast } from "sonner";
+import { BellRing } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog";
+import { clockMinute } from "@/lib/staff/calculations";
+import { alarmAction } from "./actions";
+
+const control =
+  "w-full rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 py-2 text-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--accent-mid)]";
+export function AlarmRefresh() {
+  const router = useRouter();
+  useEffect(() => {
+    const timer = setInterval(() => {
+      if (!document.hidden) router.refresh();
+    }, 30000);
+    return () => clearInterval(timer);
+  }, [router]);
+  return (
+    <Button variant="outline" size="sm" onClick={() => router.refresh()}>
+      Stand aktualisieren
+    </Button>
+  );
+}
+export type AlarmCandidate = { id: string; label: string; emails: string[] };
+export function AlarmCreateForm({
+  candidates,
+  educators,
+  selected,
+}: {
+  candidates: AlarmCandidate[];
+  educators: { id: string; name: string }[];
+  selected?: string;
+}) {
+  const [open, setOpen] = useState(!!selected);
+  const [assignmentId, setAssignmentId] = useState(
+    candidates.find((c) => c.id === selected)?.id ?? candidates[0]?.id ?? "",
+  );
+  const [wholeDay, setWholeDay] = useState(true);
+  const [pending, start] = useTransition();
+  const [error, setError] = useState("");
+  const router = useRouter();
+  const prefix = useId();
+  const candidate = candidates.find((c) => c.id === assignmentId);
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button disabled={!candidates.length}>
+          <BellRing className="mr-2 h-4 w-4" />
+          Notdienstalarm auslösen
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="max-h-[90dvh] overflow-y-auto sm:max-w-xl">
+        <DialogHeader>
+          <DialogTitle>Notdienstalarm auslösen</DialogTitle>
+          <DialogDescription>
+            Die eingeteilte Familie wird per E-Mail und in der App informiert.
+            Eine Antwort gilt für den Haushalt.
+          </DialogDescription>
+        </DialogHeader>
+        <form
+          className="grid gap-4"
+          onSubmit={(event) => {
+            event.preventDefault();
+            const form = new FormData(event.currentTarget);
+            setError("");
+            start(async () => {
+              const result = await alarmAction("create", {
+                assignmentId,
+                wholeDay,
+                replyMinutes: Number(form.get("replyMinutes")),
+                ...(wholeDay
+                  ? {}
+                  : {
+                      startMinute: clockMinute(String(form.get("start"))),
+                      endMinute: clockMinute(String(form.get("end"))),
+                    }),
+                ...(form.get("educatorId")
+                  ? { educatorId: String(form.get("educatorId")) }
+                  : {}),
+                notes: String(form.get("notes") ?? ""),
+              });
+              if (result.error) {
+                setError(result.error);
+                return;
+              }
+              if (result.warning) toast.warning(result.warning);
+              else toast.success("Alarm ausgelöst.");
+              setOpen(false);
+              router.push(`/dashboard/notdienst/alarm?alarm=${result.alarmId}`);
+              router.refresh();
+            });
+          }}
+        >
+          <fieldset disabled={pending} className="grid gap-4">
+            <label
+              className="grid gap-1.5 text-sm"
+              htmlFor={`${prefix}-assignment`}
+            >
+              Eingeteilte Familie
+              <select
+                id={`${prefix}-assignment`}
+                className={control}
+                required
+                value={assignmentId}
+                onChange={(event) => setAssignmentId(event.target.value)}
+              >
+                {candidates.map((c) => (
+                  <option key={c.id} value={c.id}>
+                    {c.label}
+                  </option>
+                ))}
+              </select>
+            </label>
+            <div className="rounded-lg bg-[var(--surface-2)] p-3 text-sm">
+              <p className="font-medium">Empfänger</p>
+              {candidate?.emails.length ? (
+                <ul className="mt-1 grid gap-1 break-all">
+                  {candidate.emails.map((email) => (
+                    <li key={email}>{email}</li>
+                  ))}
+                </ul>
+              ) : (
+                <p className="mt-1 text-[var(--danger)]">
+                  Keine Elternkonten hinterlegt. Bitte den Haushalt zuerst
+                  vervollständigen.
+                </p>
+              )}
+            </div>
+            <label
+              className="grid gap-1.5 text-sm"
+              htmlFor={`${prefix}-duration`}
+            >
+              Einsatzdauer
+              <select
+                id={`${prefix}-duration`}
+                className={control}
+                value={wholeDay ? "whole" : "hours"}
+                onChange={(event) =>
+                  setWholeDay(event.target.value === "whole")
+                }
+              >
+                <option value="whole">Ganzer Kita-Tag</option>
+                <option value="hours">Bestimmte Uhrzeiten</option>
+              </select>
+            </label>
+            {!wholeDay && (
+              <div className="grid grid-cols-2 gap-3">
+                <label
+                  className="grid gap-1.5 text-sm"
+                  htmlFor={`${prefix}-start`}
+                >
+                  Beginn
+                  <Input
+                    id={`${prefix}-start`}
+                    type="time"
+                    name="start"
+                    required
+                    defaultValue="08:00"
+                  />
+                </label>
+                <label
+                  className="grid gap-1.5 text-sm"
+                  htmlFor={`${prefix}-end`}
+                >
+                  Ende
+                  <Input
+                    id={`${prefix}-end`}
+                    type="time"
+                    name="end"
+                    required
+                    defaultValue="16:00"
+                  />
+                </label>
+              </div>
+            )}
+            <label
+              className="grid gap-1.5 text-sm"
+              htmlFor={`${prefix}-minutes`}
+            >
+              Antwortfrist in Minuten
+              <Input
+                id={`${prefix}-minutes`}
+                name="replyMinutes"
+                type="number"
+                min={1}
+                max={1440}
+                step={1}
+                defaultValue={30}
+                required
+              />
+            </label>
+            <p className="text-xs leading-5 text-[var(--ink-soft)]">
+              Die Frist beginnt beim Auslösen und endet spätestens mit dem
+              Einsatz. Eine Absage erfordert sofort Klärung.
+            </p>
+            <label
+              className="grid gap-1.5 text-sm"
+              htmlFor={`${prefix}-educator`}
+            >
+              Ausgefallene Fachkraft (optional, intern)
+              <select
+                id={`${prefix}-educator`}
+                className={control}
+                name="educatorId"
+              >
+                <option value="">Ohne Zuordnung</option>
+                {educators.map((e) => (
+                  <option key={e.id} value={e.id}>
+                    {e.name}
+                  </option>
+                ))}
+              </select>
+            </label>
+            <label className="grid gap-1.5 text-sm" htmlFor={`${prefix}-notes`}>
+              Interne Notiz (optional)
+              <textarea
+                id={`${prefix}-notes`}
+                className={control}
+                name="notes"
+                maxLength={500}
+                rows={2}
+              />
+            </label>
+            <Button type="submit" disabled={!candidate?.emails.length}>
+              {pending
+                ? "Alarm wird gespeichert …"
+                : "Alarm auslösen und Familie informieren"}
+            </Button>
+          </fieldset>
+          {error && (
+            <p role="alert" className="text-sm text-[var(--danger)]">
+              {error}
+            </p>
+          )}
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+}
+export function AlarmCommand({
+  alarmId,
+  command,
+  label,
+}: {
+  alarmId: string;
+  command: "cancel" | "recordResponse" | "approveLate";
+  label: string;
+}) {
+  const [open, setOpen] = useState(false),
+    [pending, start] = useTransition(),
+    [error, setError] = useState("");
+  const router = useRouter(),
+    prefix = useId();
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button variant="outline" size="sm">
+          {label}
+        </Button>
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>{label}</DialogTitle>
+          <DialogDescription>
+            {command === "cancel"
+              ? "Alle angeschriebenen Elternkonten erhalten eine Stornierung. Ihre Rückmeldelinks erlauben danach keine weitere Antwort."
+              : "Die Rückmeldung gilt für den gesamten Haushalt. Die Familie und die Koordination werden über den Stand informiert."}
+          </DialogDescription>
+        </DialogHeader>
+        <form
+          className="grid gap-4"
+          onSubmit={(event) => {
+            event.preventDefault();
+            const data = new FormData(event.currentTarget);
+            setError("");
+            start(async () => {
+              const result = await alarmAction(command, {
+                alarmId,
+                reason: String(data.get("reason")),
+                ...(command === "recordResponse"
+                  ? { approve: data.get("response") === "yes" }
+                  : {}),
+              });
+              if (result.error) {
+                setError(result.error);
+                return;
+              }
+              if (result.warning) toast.warning(result.warning);
+              else toast.success("Gespeichert.");
+              setOpen(false);
+              router.refresh();
+            });
+          }}
+        >
+          {command === "recordResponse" && (
+            <label
+              className="grid gap-1.5 text-sm"
+              htmlFor={`${prefix}-response`}
+            >
+              Telefonische Rückmeldung / Korrektur
+              <select
+                id={`${prefix}-response`}
+                name="response"
+                className={control}
+              >
+                <option value="yes">Haushalt übernimmt</option>
+                <option value="no">Haushalt kann nicht übernehmen</option>
+              </select>
+            </label>
+          )}
+          <label className="grid gap-1.5 text-sm" htmlFor={`${prefix}-reason`}>
+            Interne Begründung
+            <textarea
+              id={`${prefix}-reason`}
+              className={control}
+              name="reason"
+              required
+              minLength={3}
+              maxLength={500}
+              rows={3}
+            />
+          </label>
+          <p className="text-xs text-[var(--ink-soft)]">
+            Die Begründung bleibt intern und wird nicht per E-Mail versendet.
+          </p>
+          {error && (
+            <p role="alert" className="text-sm text-[var(--danger)]">
+              {error}
+            </p>
+          )}
+          <Button disabled={pending} type="submit">
+            {pending
+              ? "Wird gespeichert …"
+              : command === "cancel"
+                ? "Alarm stornieren"
+                : "Rückmeldung speichern"}
+          </Button>
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+}
+export function AlarmSimpleAction({
+  command,
+  data,
+  children,
+}: {
+  command: "retry" | "readNotice";
+  data: Record<string, unknown>;
+  children: React.ReactNode;
+}) {
+  const [pending, start] = useTransition();
+  const router = useRouter();
+  return (
+    <Button
+      size="sm"
+      variant="outline"
+      disabled={pending}
+      onClick={() =>
+        start(async () => {
+          const result = await alarmAction(command, data);
+          if (result.error) toast.error(result.error);
+          else if (result.warning) toast.warning(result.warning);
+          else toast.success("Gespeichert.");
+          router.refresh();
+        })
+      }
+    >
+      {pending ? "Bitte warten …" : children}
+    </Button>
+  );
+}

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

@@ -0,0 +1,408 @@
+import Link from "next/link";
+import { BellRing } from "lucide-react";
+import { prisma } from "@/lib/prisma";
+import { requireAlarmActor } from "@/lib/alarms/auth";
+import { managerRoles, importLegacyAlarms } from "@/lib/alarms/service";
+import {
+  alarmLabel,
+  dateKey,
+  durationLabel,
+  instantLabel,
+  needsClarification,
+  todayKey,
+} from "@/lib/alarms/format";
+import { addDays, dateOnly } from "@/lib/staff/calculations";
+import {
+  AlarmCreateForm,
+  AlarmCommand,
+  AlarmSimpleAction,
+  AlarmRefresh,
+} from "./forms";
+
+export const metadata = { title: "Notdienstalarm · Kita-Planer" };
+const historyLabels: Record<string, string> = {
+  CONFIRMED: "Übernahme bestätigt",
+  DECLINED: "Absage",
+  LATE_CONFIRMATION: "Verspätete Zusage – Freigabe erforderlich",
+};
+export default async function AlarmPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ alarm?: string; assignment?: string }>;
+}) {
+  const actor = await requireAlarmActor(false),
+    manager = managerRoles.includes(actor.role);
+  const params = await searchParams,
+    now = new Date(),
+    today = todayKey(now);
+  if (manager) await importLegacyAlarms(actor.kitaId);
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: actor.id },
+    select: { familyId: true },
+  });
+  const [kita, alarms, assignments, educators, notifications] =
+    await Promise.all([
+      prisma.kita.findUniqueOrThrow({
+        where: { id: actor.kitaId },
+        select: { name: true, notdienstModuleEnabled: true },
+      }),
+      prisma.notdienstAlarm.findMany({
+        where: {
+          kitaId: actor.kitaId,
+          ...(manager ? {} : { familyId: user.familyId ?? "" }),
+          ...(params.alarm
+            ? { id: params.alarm }
+            : { date: { gte: dateOnly(addDays(today, -30)) } }),
+        },
+        include: {
+          recipients: {
+            include: { user: { select: { email: true, firstName: true } } },
+          },
+          emails: { orderBy: { createdAt: "desc" } },
+          history: manager
+            ? { orderBy: { createdAt: "desc" }, take: 20 }
+            : false,
+        },
+        orderBy: [{ date: "desc" }, { triggeredAt: "desc" }],
+        take: 100,
+      }),
+      manager
+        ? prisma.notdienstAssignment.findMany({
+            where: {
+              kitaId: actor.kitaId,
+              date: { gte: dateOnly(today), lt: dateOnly(addDays(today, 93)) },
+              plan: { status: "PUBLISHED" },
+              alarms: { none: { activeAssignmentId: { not: null } } },
+            },
+            include: {
+              child: {
+                include: {
+                  family: {
+                    include: {
+                      users: {
+                        where: { role: "ELTERN", kitaId: actor.kitaId },
+                        select: { email: true },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            orderBy: { date: "asc" },
+          })
+        : Promise.resolve([]),
+      manager
+        ? prisma.educator.findMany({
+            where: { kitaId: actor.kitaId, active: true },
+            select: { id: true, firstName: true, lastName: true },
+            orderBy: { lastName: "asc" },
+          })
+        : Promise.resolve([]),
+      prisma.notdienstAlarmNotification.findMany({
+        where: {
+          userId: actor.id,
+          alarm: {
+            kitaId: actor.kitaId,
+            ...(manager ? {} : { familyId: user.familyId ?? "" }),
+          },
+          readAt: null,
+        },
+        orderBy: { createdAt: "desc" },
+        take: 20,
+      }),
+    ]);
+  const candidates = assignments.map((a) => ({
+    id: a.id,
+    label: `${dateKey(a.date).split("-").reverse().join(".")} · ${a.child.family.name}`,
+    emails: a.child.family.users.map((u) => u.email),
+  }));
+  return (
+    <div className="mx-auto max-w-[1280px] px-11 py-9 pb-16 max-[760px]:px-5">
+      <header className="mb-7 flex flex-wrap items-end justify-between gap-5">
+        <div>
+          <p className="text-[11px] font-semibold uppercase tracking-[0.18em] text-[var(--accent-deep)]">
+            NOTDIENST · {kita.name}
+          </p>
+          <h1 className="mt-2 text-4xl tracking-tight text-[var(--ink)]">
+            Notdienst
+            <span className="italic text-[var(--accent-deep)]">alarm</span>
+          </h1>
+          <p className="mt-3 max-w-2xl text-sm leading-6 text-[var(--ink-soft)]">
+            {manager
+              ? "Familien anfragen, Rückmeldungen verfolgen und offene Einsätze klären."
+              : "Eure Rückmeldung gilt für den gesamten Haushalt."}
+          </p>
+        </div>
+        <div className="flex flex-wrap gap-2">
+          <AlarmRefresh />
+          {manager && kita.notdienstModuleEnabled && (
+            <AlarmCreateForm
+              candidates={candidates}
+              educators={educators.map((e) => ({
+                id: e.id,
+                name: `${e.firstName} ${e.lastName}`,
+              }))}
+              selected={params.assignment}
+            />
+          )}
+        </div>
+      </header>
+      {manager &&
+        (!process.env.NOTDIENST_JOB_SECRET ||
+          process.env.NOTDIENST_JOB_SECRET.length < 32) && (
+          <p className="mb-6 rounded-xl border border-[var(--hairline)] bg-[var(--surface-2)] p-4 text-sm leading-6">
+            Die automatische Fristprüfung ist noch nicht eingerichtet. Für
+            Erinnerungen bei geschlossener App muss die Hosting-Konfiguration
+            ergänzt werden. Fristabläufe sind hier bereits sichtbar.
+          </p>
+        )}
+      {!kita.notdienstModuleEnabled && (
+        <p className="mb-6 text-sm">
+          Das Notdienstmodul ist deaktiviert; vorhandene Alarme bleiben
+          einsehbar.
+        </p>
+      )}
+      {notifications.length > 0 && (
+        <details className="mb-6 rounded-xl border border-[var(--hairline)] bg-[var(--surface)] p-4">
+          <summary className="cursor-pointer text-sm font-semibold">
+            {notifications.length} neue Hinweise
+          </summary>
+          <div className="mt-3 grid gap-3">
+            {notifications.map((n) => (
+              <div
+                key={n.id}
+                className="flex flex-wrap items-center justify-between gap-3 border-t border-[var(--hairline-soft)] pt-3"
+              >
+                <Link
+                  className="max-w-3xl text-sm underline decoration-[var(--accent-mid)] underline-offset-4"
+                  href={`/dashboard/notdienst/alarm?alarm=${n.alarmId}`}
+                >
+                  {n.message}
+                </Link>
+                <AlarmSimpleAction command="readNotice" data={{ id: n.id }}>
+                  Gelesen
+                </AlarmSimpleAction>
+              </div>
+            ))}
+          </div>
+        </details>
+      )}
+      {params.alarm && (
+        <Link
+          className="mb-5 inline-block text-sm text-[var(--accent-deep)] underline"
+          href="/dashboard/notdienst/alarm"
+        >
+          Alle Alarme anzeigen
+        </Link>
+      )}
+      {manager && !candidates.length && !params.alarm && (
+        <p className="mb-5 text-sm text-[var(--ink-soft)]">
+          Neue Alarme benötigen eine aktuelle oder zukünftige Einteilung in
+          einem veröffentlichten Plan.{" "}
+          <Link href="/dashboard/notdienst/plan" className="underline">
+            Notdienstplan öffnen
+          </Link>
+        </p>
+      )}
+      <div className="grid gap-5">
+        {alarms.length ? (
+          alarms.map((a) => {
+            const clarify = needsClarification(a, now),
+              ended = a.expiresAt <= now;
+            const pending = a.emails.filter((e) => !e.sentAt && !e.skippedAt);
+            const ownRecipient = a.recipients.find(
+              (r) => r.userId === actor.id,
+            );
+            return (
+              <article
+                key={a.id}
+                id={`alarm-${a.id}`}
+                className={`overflow-hidden rounded-2xl border bg-[var(--surface)] ${clarify ? "border-[var(--danger)]" : "border-[var(--hairline)]"}`}
+              >
+                <div
+                  className={`flex flex-wrap items-start justify-between gap-4 border-b border-[var(--hairline-soft)] p-5 sm:p-6 ${clarify ? "bg-[var(--surface-2)]" : ""}`}
+                >
+                  <div>
+                    <p className="flex items-center gap-2 text-xs font-semibold uppercase tracking-wider text-[var(--ink-soft)]">
+                      <BellRing className="h-4 w-4" />
+                      {dateKey(a.date) === today ? "Heute · " : ""}
+                      {dateKey(a.date).split("-").reverse().join(".")}
+                    </p>
+                    <h2 className="mt-2 text-2xl">{a.familyName}</h2>
+                    <p className="mt-1 text-sm text-[var(--ink-soft)]">
+                      {durationLabel(a)}
+                      {ended ? " · Einsatz beendet" : ""}
+                    </p>
+                  </div>
+                  <span
+                    className={`max-w-full rounded-full border px-3 py-1.5 text-xs font-semibold ${clarify ? "border-[var(--danger)] text-[var(--danger)]" : "border-[var(--accent-mid)] bg-[var(--accent-soft)] text-[var(--accent-deep)]"}`}
+                  >
+                    {alarmLabel(a, now)}
+                  </span>
+                </div>
+                <div className="grid gap-5 p-5 sm:p-6">
+                  <div className="flex flex-wrap gap-x-8 gap-y-3 text-sm">
+                    <p>
+                      <span className="text-[var(--ink-muted)]">
+                        Antwortfrist
+                      </span>
+                      <br />
+                      <strong>{instantLabel(a.deadline)} Uhr</strong>
+                    </p>
+                    <p>
+                      <span className="text-[var(--ink-muted)]">Ausgelöst</span>
+                      <br />
+                      {instantLabel(a.triggeredAt)} Uhr
+                    </p>
+                    {a.respondedAt && (
+                      <p>
+                        <span className="text-[var(--ink-muted)]">
+                          Rückmeldung
+                        </span>
+                        <br />
+                        {instantLabel(a.respondedAt)} Uhr ·{" "}
+                        {a.responseSource === "PHONE"
+                          ? "Telefonisch dokumentiert"
+                          : a.responseSource === "COORDINATION"
+                            ? "Freigabe durch Koordination"
+                            : a.responseSource === "LEGACY"
+                              ? "Bisherige Alarmierung"
+                              : "Haushaltsantwort"}
+                      </p>
+                    )}
+                  </div>
+                  {manager ? (
+                    <>
+                      <div className="flex flex-wrap gap-2">
+                        {a.status === "LATE_CONFIRMATION" && !ended && (
+                          <AlarmCommand
+                            command="approveLate"
+                            alarmId={a.id}
+                            label="Verspätete Zusage freigeben"
+                          />
+                        )}
+                        {a.status !== "CANCELLED" && !ended && (
+                          <AlarmCommand
+                            command="recordResponse"
+                            alarmId={a.id}
+                            label="Telefonische Rückmeldung / Korrektur"
+                          />
+                        )}
+                        {a.status !== "CANCELLED" && (
+                          <AlarmCommand
+                            command="cancel"
+                            alarmId={a.id}
+                            label="Alarm stornieren"
+                          />
+                        )}
+                        {pending.length > 0 && (
+                          <AlarmSimpleAction
+                            command="retry"
+                            data={{ alarmId: a.id }}
+                          >
+                            Ausstehende E-Mails erneut senden ({pending.length})
+                          </AlarmSimpleAction>
+                        )}
+                      </div>
+                      {clarify && (
+                        <p className="rounded-lg bg-[var(--surface-2)] p-3 text-sm leading-6">
+                          Bitte den Haushalt kontaktieren oder Ersatz manuell
+                          organisieren. Weitere Familien werden nicht
+                          automatisch alarmiert.
+                        </p>
+                      )}
+                      <details className="border-t border-[var(--hairline-soft)] pt-4">
+                        <summary className="cursor-pointer text-sm font-medium">
+                          Versandstand (
+                          {a.emails.filter((e) => e.sentAt).length} angenommen,{" "}
+                          {pending.length} ausstehend)
+                        </summary>
+                        <div className="mt-3 grid gap-2 text-sm">
+                          {a.emails.map((e) => (
+                            <p key={e.id} className="break-all">
+                              {a.recipients.find((r) => r.userId === e.userId)
+                                ?.user.email ?? "Koordination / Admin"}{" "}
+                              ·{" "}
+                              {e.kind === "REQUEST"
+                                ? "Anfrage"
+                                : e.kind === "CANCEL"
+                                  ? "Stornierung"
+                                  : "Hinweis"}
+                              :{" "}
+                              {e.sentAt
+                                ? "Vom Maildienst angenommen"
+                                : e.skippedAt
+                                  ? "Nicht mehr erforderlich / Empfänger geändert"
+                                  : e.failed
+                                    ? "Versand fehlgeschlagen – wiederholbar"
+                                    : "Versand ausstehend"}
+                            </p>
+                          ))}
+                        </div>
+                      </details>
+                      <details className="border-t border-[var(--hairline-soft)] pt-4">
+                        <summary className="cursor-pointer text-sm font-medium">
+                          Interne Details und Verlauf
+                        </summary>
+                        <div className="mt-3 grid gap-2 text-sm">
+                          {a.educatorId && (
+                            <p>
+                              Ausgefallene Fachkraft:{" "}
+                              {educators.find((e) => e.id === a.educatorId)
+                                ?.firstName ??
+                                "Ehemalige / inaktive Fachkraft"}{" "}
+                              {educators.find((e) => e.id === a.educatorId)
+                                ?.lastName ?? ""}
+                            </p>
+                          )}
+                          {a.notes && <p>Interne Notiz: {a.notes}</p>}
+                          {a.cancelReason && (
+                            <p>Stornierungsgrund: {a.cancelReason}</p>
+                          )}
+                          {a.history.map((h) => (
+                            <p key={h.id}>
+                              {instantLabel(h.createdAt)} · {h.action}:{" "}
+                              {historyLabels[h.details] ?? h.details}
+                            </p>
+                          ))}
+                        </div>
+                      </details>
+                    </>
+                  ) : (
+                    <>
+                      {ownRecipient && a.status === "PENDING" && !ended && (
+                        <Link
+                          className="inline-flex w-fit rounded-lg bg-[var(--accent-deep)] px-4 py-2 text-sm font-semibold text-white"
+                          href={`/alert/${ownRecipient.token}`}
+                        >
+                          Für unseren Haushalt antworten
+                        </Link>
+                      )}
+                      <p className="text-sm text-[var(--ink-soft)]">
+                        {a.status === "LATE_CONFIRMATION"
+                          ? "Eure verspätete Zusage wartet auf Freigabe durch die Koordination."
+                          : a.status === "CONFIRMED"
+                            ? "Die Kita rechnet mit euch. Änderungen bitte mit der Koordination klären."
+                            : a.status === "CANCELLED"
+                              ? "Ihr müsst für diesen Alarm nicht einspringen."
+                              : a.status === "DECLINED"
+                                ? "Eure Absage ist gespeichert. Die Koordination organisiert Ersatz."
+                                : "Eine Antwort eines Elternteils gilt für euren ganzen Haushalt."}
+                      </p>
+                    </>
+                  )}
+                </div>
+              </article>
+            );
+          })
+        ) : (
+          <div className="rounded-2xl border border-[var(--hairline)] bg-[var(--surface)] p-8 text-sm text-[var(--ink-soft)]">
+            {params.alarm
+              ? "Kein zugänglicher Alarm gefunden."
+              : "Noch keine Notdienstalarme in diesem Zeitraum."}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

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

@@ -11,7 +11,12 @@ import { prisma } from "@/lib/prisma";
 import { getTargetMonthData, getWorkingDaysOfMonth } from "@/lib/date-utils";
 import { getAppEmailConfigError, sendAppEmail } from "@/lib/mail";
 import { NotdienstAvailabilityReminderEmail } from "@/emails/NotdienstAvailabilityReminderEmail";
-import { NotdienstAssignmentEmail } from "@/emails/NotdienstAssignmentEmail";
+import { NotdienstAssignmentChangeEmail } from "@/emails/NotdienstAssignmentChangeEmail";
+import { requireAlarmActor } from "@/lib/alarms/auth";
+import {
+  validateAlarmActor,
+  assertAssignmentNotAlarmed,
+} from "@/lib/alarms/service";
 
 // =====================================================================
 // /dashboard/notdienst/plan · Server Actions
@@ -153,138 +158,236 @@ export async function updateAssignmentAction(
   date: string,
   newChildId: string | null,
 ) {
-  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
+  const actor = await requireAlarmActor();
-  const kitaId = session.user.kitaId!;
+  const kitaId = actor.kitaId;
 
   const [yr, mo, dy] = date.slice(0, 10).split("-").map(Number);
   const parsedDate = new Date(Date.UTC(yr, mo - 1, dy));
 
   try {
-    const { shouldSendEmails, assignedChildInfo } = await prisma.$transaction(async (tx) => {
+    const notifications = await prisma.$transaction(
-      let txShouldSendEmails = false;
+      async (tx) => {
-      let txAssignedChildInfo: {
+        await validateAlarmActor(tx, actor);
-        parentEmails: string[];
+        const plan = await tx.notdienstPlan.findUnique({
-        parentNames: string[];
+          where: { id: planId, kitaId },
-        dateLabel: string;
+        });
-      } | null = null;
 
-      const plan = await tx.notdienstPlan.findUnique({
+        if (!plan) {
-        where: { id: planId, kitaId },
+          throw new Error("Plan nicht gefunden.");
-      });
-
-      if (!plan) {
-        throw new Error("Plan nicht gefunden.");
-      }
-
-      const isDraft = plan.status === NotdienstPlanStatus.DRAFT;
-      const isPublished = plan.status === NotdienstPlanStatus.PUBLISHED;
-
-      if (!isDraft && !isPublished) {
-        throw new Error("Plan kann nicht bearbeitet werden.");
-      }
-
-      // Wenn der Plan bereits veröffentlicht ist, dürfen nur unbesetzte Termine geändert werden.
-      // Ein Termin gilt als "unbesetzt", wenn am Veröffentlichungstag kein Assignment existierte
-      // bzw. das Assignment erst nach dem Veröffentlichungs-Zeitpunkt erstellt wurde.
-      const existingAssignment = await tx.notdienstAssignment.findFirst({
-        where: { planId, date: parsedDate },
-      });
-
-      if (isPublished && existingAssignment) {
-        if (!plan.publishedAt || existingAssignment.createdAt <= plan.publishedAt) {
-          throw new Error("In einem bereits veröffentlichten Plan können nur unbesetzte Termine geändert werden.");
         }
-      }
 
-      // Altes Assignment für diesen Tag löschen
+        const isDraft = plan.status === NotdienstPlanStatus.DRAFT;
-      await tx.notdienstAssignment.deleteMany({
+        const isPublished = plan.status === NotdienstPlanStatus.PUBLISHED;
-        where: { planId, date: parsedDate },
-      });
 
-      // Neues anlegen, falls ausgewählt
+        if (!isDraft && !isPublished) {
-      if (newChildId) {
+          throw new Error("Plan kann nicht bearbeitet werden.");
-        const child = await tx.child.findFirst({
+        }
-          where: {
+
-            id: newChildId,
+        if (isPublished) {
-            kitaId,
+          const today = new Date();
-            active: true,
+          const todayUtc = new Date(
-          },
+            Date.UTC(today.getFullYear(), today.getMonth(), today.getDate()),
+          );
+          if (parsedDate < todayUtc) {
+            throw new Error(
+              "Vergangene Notdienste können nicht geändert werden.",
+            );
+          }
+        }
+
+        const existingAssignment = await tx.notdienstAssignment.findFirst({
+          where: { planId, date: parsedDate },
           include: {
-            family: {
+            child: {
               include: {
-                users: {
+                family: {
-                  where: { role: UserRole.ELTERN },
+                  include: {
-                  select: { email: true, firstName: true, lastName: true },
+                    users: {
+                      where: { role: UserRole.ELTERN },
+                      select: { email: true, firstName: true, lastName: true },
+                    },
+                  },
                 },
               },
             },
           },
         });
 
-        if (!child) {
+        let newChild: {
-          throw new Error("Kind gehört nicht zu dieser Kita.");
+          id: string;
-        }
+          family: {
+            users: { email: string; firstName: string; lastName: string }[];
+          };
+        } | null = null;
 
-        await tx.notdienstAssignment.create({
+        if (newChildId) {
-          data: {
+          newChild = await tx.child.findFirst({
-            kitaId,
+            where: {
-            planId,
+              id: newChildId,
-            childId: newChildId,
+              kitaId,
-            date: parsedDate,
+              active: true,
-          },
+            },
-        });
+            include: {
+              family: {
+                include: {
+                  users: {
+                    where: { role: UserRole.ELTERN },
+                    select: { email: true, firstName: true, lastName: true },
+                  },
+                },
+              },
+            },
+          });
 
-        // Wenn der Plan bereits veröffentlicht ist, bereiten wir E-Mail-Benachrichtigungen vor
+          if (!newChild) {
-        if (isPublished) {
+            throw new Error("Kind gehört nicht zu dieser Kita.");
-          const parents = child.family.users.filter((u) => !!u.email);
-          if (parents.length > 0) {
-            const localFormatDate = new Date(yr, mo - 1, dy);
-            txAssignedChildInfo = {
-              parentEmails: parents.map((p) => p.email!),
-              parentNames: parents.map((p) => `${p.firstName} ${p.lastName}`),
-              dateLabel: format(localFormatDate, "EEEE, dd. MMMM yyyy", { locale: de }),
-            };
-            txShouldSendEmails = true;
           }
         }
-      }
 
-      return {
+        if (existingAssignment?.childId === newChildId) {
-        shouldSendEmails: txShouldSendEmails,
+          return [];
-        assignedChildInfo: txAssignedChildInfo,
+        }
-      };
+
-    });
+        if (existingAssignment)
+          await assertAssignmentNotAlarmed(tx, existingAssignment.id, kitaId);
+
+        if (!newChildId) {
+          if (existingAssignment) {
+            await tx.notdienstAssignment.delete({
+              where: { id: existingAssignment.id },
+            });
+          }
+        } else if (existingAssignment) {
+          await tx.notdienstAssignment.update({
+            where: { id: existingAssignment.id },
+            data: { childId: newChildId },
+          });
+        } else {
+          await tx.notdienstAssignment.create({
+            data: {
+              kitaId,
+              planId,
+              childId: newChildId,
+              date: parsedDate,
+            },
+          });
+        }
+
+        if (existingAssignment) {
+          await tx.notdienstSwapRequest.updateMany({
+            where: {
+              kitaId,
+              status: "PENDING",
+              OR: [
+                { targetAssignmentId: existingAssignment.id },
+                { offeredAssignmentId: existingAssignment.id },
+              ],
+            },
+            data: {
+              status: "CANCELLED",
+              respondedAt: new Date(),
+            },
+          });
+        }
+
+        if (!isPublished) {
+          return [];
+        }
+
+        const dateLabel = format(
+          new Date(yr, mo - 1, dy),
+          "EEEE, dd. MMMM yyyy",
+          { locale: de },
+        );
+        const messages: {
+          parentEmails: string[];
+          parentNames: string[];
+          subject: string;
+          heading: string;
+          preview: string;
+          body: string;
+          dateLabel: string;
+        }[] = [];
+
+        if (existingAssignment) {
+          const oldParents = existingAssignment.child.family.users.filter(
+            (u) => !!u.email,
+          );
+          if (oldParents.length > 0) {
+            messages.push({
+              parentEmails: oldParents.map((p) => p.email),
+              parentNames: oldParents.map(
+                (p) => `${p.firstName} ${p.lastName}`,
+              ),
+              subject: `Notdienst-Einteilung geändert am ${dateLabel}`,
+              heading: "Notdienst wurde geändert",
+              preview: `Deine Notdienst-Einteilung am ${dateLabel} wurde geändert.`,
+              body: "Du bist für diesen Notdienst nicht mehr eingeteilt.",
+              dateLabel,
+            });
+          }
+        }
+
+        if (newChild && existingAssignment?.childId !== newChild.id) {
+          const newParents = newChild.family.users.filter((u) => !!u.email);
+          if (newParents.length > 0) {
+            messages.push({
+              parentEmails: newParents.map((p) => p.email),
+              parentNames: newParents.map(
+                (p) => `${p.firstName} ${p.lastName}`,
+              ),
+              subject: `Notdienst-Einteilung am ${dateLabel}`,
+              heading: "Neuer Notdienst-Termin zugewiesen",
+              preview: `Du wurdest für den Notdienst am ${dateLabel} eingeteilt.`,
+              body: "Du wurdest für folgenden Tag für den Notdienst eingeteilt.",
+              dateLabel,
+            });
+          }
+        }
+
+        return messages;
+      },
+      { isolationLevel: "Serializable" },
+    );
 
     // E-Mails außerhalb der DB-Transaktion senden
-    if (shouldSendEmails && assignedChildInfo) {
+    if (notifications.length > 0) {
       const kita = await prisma.kita.findUnique({
         where: { id: kitaId },
         select: { name: true },
       });
 
       if (kita) {
-        const BASE_URL = process.env.NEXTAUTH_URL ?? process.env.AUTH_URL ?? "http://localhost:3000";
+        const BASE_URL =
+          process.env.NEXTAUTH_URL ??
+          process.env.AUTH_URL ??
+          "http://localhost:3000";
         const link = `${BASE_URL}/dashboard/notdienst`;
 
-        for (let i = 0; i < assignedChildInfo.parentEmails.length; i++) {
+        for (const notification of notifications) {
-          const email = assignedChildInfo.parentEmails[i];
+          for (let i = 0; i < notification.parentEmails.length; i++) {
-          const name = assignedChildInfo.parentNames[i];
+            const email = notification.parentEmails[i];
+            const name = notification.parentNames[i];
 
-          await sendAppEmail({
+            await sendAppEmail({
-            to: email,
+              to: email,
-            subject: `Notdienst-Einteilung am ${assignedChildInfo.dateLabel}`,
+              subject: notification.subject,
-            react: createElement(NotdienstAssignmentEmail, {
+              react: createElement(NotdienstAssignmentChangeEmail, {
-              parentName: name,
+                parentName: name,
-              kitaName: kita.name,
+                heading: notification.heading,
-              dateLabel: assignedChildInfo.dateLabel,
+                preview: notification.preview,
-              link,
+                body: notification.body,
-            }),
+                dateLabel: notification.dateLabel,
-          });
+                link,
+              }),
+            });
+          }
         }
       }
     }
 
     revalidatePath("/dashboard/notdienst/plan");
+    revalidatePath("/dashboard/kalender");
     return { success: true };
   } catch (error) {
     return {
@@ -320,7 +423,10 @@ export async function updateKitaNotdienstSettingsAction(
   }
 }
 
-export async function sendNotdienstRemindersAction(year: number, month: number) {
+export async function sendNotdienstRemindersAction(
+  year: number,
+  month: number,
+) {
   const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
   const kitaId = session.user.kitaId;
   if (!kitaId) {
@@ -376,7 +482,9 @@ export async function sendNotdienstRemindersAction(year: number, month: number)
       },
     });
 
-    const respondedFamilyIds = new Set(respondedFamilies.map((a) => a.child.familyId));
+    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));
@@ -388,7 +496,10 @@ export async function sendNotdienstRemindersAction(year: number, month: number)
     // 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 BASE_URL =
+      process.env.NEXTAUTH_URL ??
+      process.env.AUTH_URL ??
+      "http://localhost:3000";
     const link = `${BASE_URL}/dashboard/notdienst`;
 
     let sentCount = 0;
@@ -410,7 +521,10 @@ export async function sendNotdienstRemindersAction(year: number, month: number)
         if (result.success) {
           sentCount++;
         } else {
-          console.error(`E-Mail konnte nicht an ${parent.email} gesendet werden:`, result.error);
+          console.error(
+            `E-Mail konnte nicht an ${parent.email} gesendet werden:`,
+            result.error,
+          );
         }
       }
     }
@@ -441,7 +555,9 @@ export async function resetPlanAction(planId: string) {
       }
 
       if (plan.status !== NotdienstPlanStatus.DRAFT) {
-        throw new Error("Nur Pläne im Entwurfsstatus können zurückgesetzt werden.");
+        throw new Error(
+          "Nur Pläne im Entwurfsstatus können zurückgesetzt werden.",
+        );
       }
 
       // Delete all assignments
@@ -459,7 +575,11 @@ export async function resetPlanAction(planId: string) {
     return { success: true };
   } catch (error) {
     console.error("Fehler beim Zurücksetzen des Plans:", error);
-    return { error: error instanceof Error ? error.message : "Fehler beim Zurücksetzen des Plans." };
+    return {
+      error:
+        error instanceof Error
+          ? error.message
+          : "Fehler beim Zurücksetzen des Plans.",
+    };
   }
 }
-

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

@@ -1,14 +1,15 @@
 import Link from "next/link";
 import { addMonths, getYear, getMonth, format } from "date-fns";
 import { de } from "date-fns/locale";
-import { TerminType, UserRole } from "@prisma/client";
+import { TerminType } from "@prisma/client";
 import { ChevronLeft, ChevronRight } from "lucide-react";
 
-import { requireRole } from "@/lib/auth-utils";
 import { prisma } from "@/lib/prisma";
 import { getWorkingDaysOfMonth } from "@/lib/date-utils";
 import { PlanView } from "./plan-view";
 import { SettingsModal } from "./_components/settings-modal";
+import { requireAlarmActor } from "@/lib/alarms/auth";
+import { todayKey } from "@/lib/alarms/format";
 
 export const metadata = { title: "Plan-Generierung · Kita-Planer" };
 
@@ -17,14 +18,18 @@ export default async function PlanungsZentralePage({
 }: {
   searchParams: Promise<{ year?: string; month?: string }>;
 }) {
-  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
+  const actor = await requireAlarmActor();
-  const kitaId = session.user.kitaId!;
+  const kitaId = actor.kitaId;
 
   const resolvedSearchParams = await searchParams;
   const now = new Date();
   const nextMonth = addMonths(now, 1);
-  const targetYear = resolvedSearchParams.year ? parseInt(resolvedSearchParams.year, 10) : getYear(nextMonth);
+  const targetYear = resolvedSearchParams.year
-  const targetMonth = resolvedSearchParams.month ? parseInt(resolvedSearchParams.month, 10) : (getMonth(nextMonth) + 1);
+    ? parseInt(resolvedSearchParams.year, 10)
+    : getYear(nextMonth);
+  const targetMonth = resolvedSearchParams.month
+    ? parseInt(resolvedSearchParams.month, 10)
+    : getMonth(nextMonth) + 1;
 
   const monthDate = new Date(targetYear, targetMonth - 1, 1);
   const monthName = format(monthDate, "MMMM", { locale: de });
@@ -33,79 +38,84 @@ export default async function PlanungsZentralePage({
   const monthStart = new Date(targetYear, targetMonth - 1, 1);
   const monthEnd = new Date(targetYear, targetMonth, 1);
 
-  const [plan, families, availabilities, closureCount, kita] = await Promise.all([
+  const [plan, families, availabilities, closureCount, kita] =
-    prisma.notdienstPlan.findUnique({
+    await Promise.all([
-      where: {
+      prisma.notdienstPlan.findUnique({
-        kitaId_year_month: { kitaId, year: targetYear, month: targetMonth },
+        where: {
-      },
+          kitaId_year_month: { kitaId, year: targetYear, month: targetMonth },
-      select: {
+        },
-        id: true,
+        select: {
-        status: true,
+          id: true,
-        publishedAt: true,
+          status: true,
-        assignments: {
+          publishedAt: true,
-          select: {
+          assignments: {
-            id: true,
+            select: {
-            childId: true,
+              id: true,
-            date: true,
+              childId: true,
-            createdAt: true,
+              date: true,
+              createdAt: true,
+              alarms: {
+                where: { activeAssignmentId: { not: null } },
+                select: { id: true },
+              },
+            },
           },
         },
-      },
+      }),
-    }),
+      prisma.family.findMany({
-    prisma.family.findMany({
+        where: {
-      where: {
+          kitaId,
-        kitaId,
+          children: { some: { active: true } },
-        children: { some: { active: true } },
-      },
-      select: {
-        id: true,
-        name: true,
-        children: {
-          where: { active: true },
-          select: { id: true },
         },
-      },
+        select: {
-      orderBy: { name: "asc" },
+          id: true,
-    }),
+          name: true,
-    prisma.notdienstAvailability.findMany({
+          children: {
-      where: {
+            where: { active: true },
-        kitaId,
+            select: { id: true },
-        date: {
-          gte: monthStart,
-          lt: monthEnd,
-        },
-      },
-      select: {
-        date: true,
-        child: {
-          select: {
-            familyId: true,
           },
         },
-      },
+        orderBy: { name: "asc" },
-      orderBy: { date: "asc" },
+      }),
-    }),
+      prisma.notdienstAvailability.findMany({
-    prisma.termin.count({
+        where: {
-      where: {
+          kitaId,
-        kitaId,
+          date: {
-        type: TerminType.SCHLIESSTAG,
+            gte: monthStart,
-        startDate: {
+            lt: monthEnd,
-          gte: monthStart,
+          },
-          lt: monthEnd,
         },
-      },
+        select: {
-    }),
+          date: true,
-    prisma.kita.findUniqueOrThrow({
+          child: {
-      where: { id: kitaId },
+            select: {
-      select: {
+              familyId: true,
-        notdienstMinPerChildPerMonth: true,
+            },
-        notdienstReminderDaysBefore: true,
+          },
-      },
+        },
-    }),
+        orderBy: { date: "asc" },
-  ]);
+      }),
+      prisma.termin.count({
+        where: {
+          kitaId,
+          type: TerminType.SCHLIESSTAG,
+          startDate: {
+            gte: monthStart,
+            lt: monthEnd,
+          },
+        },
+      }),
+      prisma.kita.findUniqueOrThrow({
+        where: { id: kitaId },
+        select: {
+          notdienstMinPerChildPerMonth: true,
+          notdienstReminderDaysBefore: true,
+        },
+      }),
+    ]);
 
   // 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", 
+  // 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 },
@@ -179,7 +189,7 @@ export default async function PlanungsZentralePage({
   // Wir mappen die Assignments auf die Werktage
   const daysWithAssignments = workingDays.map((day) => {
     const assignment = plan?.assignments.find(
-      (a) => a.date.getTime() === day.getTime()
+      (a) => a.date.getTime() === day.getTime(),
     );
     const isOriginallyUnassigned =
       !assignment ||
@@ -190,6 +200,11 @@ export default async function PlanungsZentralePage({
       assignmentId: assignment?.id || null,
       childId: assignment?.childId || null,
       isOriginallyUnassigned: !!isOriginallyUnassigned,
+      activeAlarmId: assignment?.alarms[0]?.id ?? null,
+      canAlarm:
+        !!assignment &&
+        plan?.status === "PUBLISHED" &&
+        day.toISOString().slice(0, 10) >= todayKey(),
     };
   });
 

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

@@ -1,6 +1,7 @@
 "use client";
 
 import { useMemo, useState, useTransition } from "react";
+import Link from "next/link";
 import { format } from "date-fns";
 import { de } from "date-fns/locale";
 import { NotdienstPlanStatus } from "@prisma/client";
@@ -40,6 +41,8 @@ interface PlanViewProps {
   days: {
     date: string;
     assignmentId: string | null;
+    activeAlarmId?: string | null;
+    canAlarm?: boolean;
     childId: string | null;
     isOriginallyUnassigned?: boolean;
   }[];
@@ -92,7 +95,9 @@ export function PlanView({
   const [resetDialogOpen, setResetDialogOpen] = useState(false);
 
   const responsePercent =
-    totalFamilies > 0 ? Math.round((respondedFamilies / totalFamilies) * 100) : 0;
+    totalFamilies > 0
+      ? Math.round((respondedFamilies / totalFamilies) * 100)
+      : 0;
 
   const handleGenerate = () => {
     startTransition(async () => {
@@ -123,7 +128,9 @@ export function PlanView({
       if ("error" in result && result.error) {
         toast.error(result.error as string);
       } else if (result.success) {
-        toast.success(`${result.count} Erinnerungs-E-Mail(s) erfolgreich versendet.`);
+        toast.success(
+          `${result.count} Erinnerungs-E-Mail(s) erfolgreich versendet.`,
+        );
       }
     });
   };
@@ -173,7 +180,11 @@ export function PlanView({
             <Button disabled={isPending} onClick={handleGenerate}>
               Trotzdem generieren
             </Button>
-            <Button variant="ghost" onClick={handleSendReminders} disabled={isPending}>
+            <Button
+              variant="ghost"
+              onClick={handleSendReminders}
+              disabled={isPending}
+            >
               {isPending ? (
                 <Loader2 className="h-4 w-4 animate-spin [stroke-width:1.7]" />
               ) : (
@@ -386,7 +397,7 @@ export function PlanView({
           <span className="text-sm text-[var(--ink-soft)]">
             {isDraft
               ? "Du kannst die Liste jetzt manuell anpassen."
-              : "Dieser Plan ist verbindlich."}
+              : "Dieser Plan ist veröffentlicht und kann bei Änderungen nachbearbeitet werden."}
           </span>
         </div>
       </Card>
@@ -408,7 +419,8 @@ export function PlanView({
           <DialogHeader>
             <DialogTitle>Plan zurücksetzen?</DialogTitle>
             <DialogDescription>
-              Möchtest du den Plan wirklich zurücksetzen? Alle Zuteilungen für diesen Monat gehen unwiderruflich verloren.
+              Möchtest du den Plan wirklich zurücksetzen? Alle Zuteilungen für
+              diesen Monat gehen unwiderruflich verloren.
             </DialogDescription>
           </DialogHeader>
           <DialogFooter>
@@ -524,7 +536,6 @@ function PlanPreviewTable({
           const assignedChild = allChildren.find(
             (child) => child.id === day.childId,
           );
-
           return (
             <div
               key={day.date}
@@ -543,6 +554,21 @@ function PlanPreviewTable({
                     ({assignedChild.name})
                   </span>
                 )}
+                {day.activeAlarmId ? (
+                  <Link
+                    className="mt-2 block text-xs font-semibold text-[var(--accent-deep)] hover:underline"
+                    href={`/dashboard/notdienst/alarm?alarm=${day.activeAlarmId}`}
+                  >
+                    Aktiven Alarm öffnen
+                  </Link>
+                ) : day.canAlarm && day.assignmentId ? (
+                  <Link
+                    className="mt-2 block text-xs font-semibold text-[var(--accent-deep)] hover:underline"
+                    href={`/dashboard/notdienst/alarm?assignment=${day.assignmentId}`}
+                  >
+                    Notdienstalarm auslösen
+                  </Link>
+                ) : null}
               </div>
               <div className="italic text-[var(--ink-faint)]">Noch offen</div>
               <div>
@@ -604,9 +630,6 @@ 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 assignedChild = allChildren.find(
-            (child) => child.id === day.childId,
-          );
 
           return (
             <div
@@ -616,46 +639,47 @@ function ManualAssignmentTable({
               <div className="font-medium text-[var(--ink)]">
                 {format(dateObj, "EE, dd.MM.", { locale: de })}
               </div>
-              <div>
+              <div className="flex flex-wrap items-center gap-2">
-                {isDraft || day.isOriginallyUnassigned ? (
+                <select
-                  <div className="flex flex-wrap items-center gap-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"}
-                      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)]"
+                  disabled={isPending || !!day.activeAlarmId}
-                      value={day.childId || "empty"}
+                  onChange={(event) =>
-                      disabled={isPending}
+                    onAssignmentChange(day.date, event.target.value)
-                      onChange={(event) =>
+                  }
-                        onAssignmentChange(day.date, event.target.value)
+                >
-                      }
+                  <option value="empty">-- Unbesetzt --</option>
-                    >
+                  {allChildren.map((child) => {
-                      <option value="empty">-- Unbesetzt --</option>
+                    const famId = child.familyId;
-                      {allChildren.map((child) => {
+                    const count = famId
-                        const famId = child.familyId;
+                      ? (familyAssignmentCounts.get(famId) ?? 0)
-                        const count = famId ? (familyAssignmentCounts.get(famId) ?? 0) : 0;
+                      : 0;
-                        return (
+                    return (
-                          <option key={child.id} value={child.id}>
+                      <option key={child.id} value={child.id}>
-                            {child.parentName} ({child.name}) — {count}x
+                        {child.parentName} ({child.name}) — {count}x
-                          </option>
+                      </option>
-                        );
+                    );
-                      })}
+                  })}
-                    </select>
+                </select>
-                    {!isDraft && (
+                {!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">
+                  <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">
-                        Nachträglich änderbar
+                    Veröffentlicht
-                      </span>
-                    )}
-                  </div>
-                ) : assignedChild ? (
-                  <span className="text-sm text-[var(--ink)]">
-                    {assignedChild.parentName}{" "}
-                    <span className="text-[var(--ink-muted)]">
-                      ({assignedChild.name})
-                    </span>
-                  </span>
-                ) : (
-                  <span className="text-sm font-medium text-[var(--danger)]">
-                    Unbesetzt!
                   </span>
                 )}
+                {day.assignmentId && day.canAlarm && (
+                  <Link
+                    className="text-xs font-semibold text-[var(--accent-deep)] underline underline-offset-4"
+                    href={
+                      day.activeAlarmId
+                        ? `/dashboard/notdienst/alarm?alarm=${day.activeAlarmId}`
+                        : `/dashboard/notdienst/alarm?assignment=${day.assignmentId}`
+                    }
+                  >
+                    {day.activeAlarmId
+                      ? "Aktiven Alarm öffnen"
+                      : "Notdienstalarm auslösen"}
+                  </Link>
+                )}
               </div>
             </div>
           );

src/app/dashboard/page.tsx

@@ -19,6 +19,7 @@ import { prisma } from "@/lib/prisma";
 import { Stat } from "@/components/ui/stat";
 import { OnboardingDialog } from "@/components/OnboardingDialog";
 import { AbsenceCard, UpcomingAbsencesCard } from "./absence-card";
+import { AlarmDashboardHints } from "./notdienst/alarm/dashboard-hints";
 
 export const metadata = { title: "Übersicht · Kita-Planer" };
 
@@ -191,8 +192,7 @@ export default async function DashboardPage() {
           </h1>
           <p className="mt-3 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
             Heute, {format(now, "EEEE, d. MMMM yyyy", { locale: de })}. Hier
-            siehst du auf einen Blick, was bei {kita.name} ansteht und kannst
+            siehst du auf einen Blick, was bei {kita.name} ansteht.
-            dein Kind schnell für Abwesenheiten melden.
           </p>
         </div>
         <div className="mt-9 inline-flex shrink-0 items-center gap-2 rounded-full border border-[var(--hairline)] bg-[var(--surface)] px-4 py-2 text-[13px] font-semibold text-[var(--ink-soft)]">
@@ -201,8 +201,17 @@ export default async function DashboardPage() {
         </div>
       </header>
 
+      <AlarmDashboardHints />
       <div className="grid grid-cols-[minmax(0,1fr)_360px] gap-5 max-[1100px]:grid-cols-1">
         <div className="min-w-0">
+          {session.user.role === UserRole.ERZIEHER && (
+            <QuickCard
+              href="/dashboard/personal"
+              icon={Clock3}
+              title="Meine Arbeitszeit & Urlaub"
+              sub="Stunden erfassen, Urlaub beantragen und dein Zeitkonto ansehen."
+            />
+          )}
           {canReportAbsences ? (
             <AbsenceCard
               today={format(today, "yyyy-MM-dd")}
@@ -237,7 +246,11 @@ export default async function DashboardPage() {
       </div>
 
       <section className="mt-5 grid grid-cols-4 gap-3.5 max-[1100px]:grid-cols-2 max-[640px]:grid-cols-1">
-        <Stat label="Familien" value={familyCount} hint="registrierte Familien" />
+        <Stat
+          label="Familien"
+          value={familyCount}
+          hint="registrierte Familien"
+        />
         <Stat label="Kinder" value={childCount} hint="in der Einrichtung" />
         <Stat
           label={`Notdienst ${targetData.monthName}`}
@@ -260,12 +273,22 @@ export default async function DashboardPage() {
           Häufige Aktionen für Vorstand und Koordination.
         </p>
         <div className="mt-4 grid grid-cols-3 gap-3 max-[1100px]:grid-cols-1">
-          <QuickCard
+          {session.user.role === UserRole.ADMIN && (
-            href="/dashboard/families"
+            <QuickCard
-            icon={Users}
+              href="/dashboard/personal"
-            title="Familien verwalten"
+              icon={Clock3}
-            sub="Familien anlegen, Kinder zuordnen, Kontakte pflegen."
+              title="Personal & Freigaben"
-          />
+              sub="Urlaub, Arbeitswochen und Beschäftigungsprofile verwalten."
+            />
+          )}
+          {session.user.role === UserRole.ADMIN && (
+            <QuickCard
+              href="/dashboard/families"
+              icon={Users}
+              title="Familien verwalten"
+              sub="Familien anlegen, Kinder zuordnen, Kontakte pflegen."
+            />
+          )}
           {kita.terminModuleEnabled ? (
             <QuickCard
               href="/dashboard/kalender"
@@ -274,7 +297,10 @@ export default async function DashboardPage() {
               sub="Schließtage, Elternabende und Feste planen."
             />
           ) : null}
-          {kita.notdienstModuleEnabled ? (
+          {kita.notdienstModuleEnabled &&
+          [UserRole.ADMIN, UserRole.KOORDINATOR].includes(
+            session.user.role as "ADMIN" | "KOORDINATOR",
+          ) ? (
             <QuickCard
               href="/dashboard/notdienst/plan"
               icon={ListTodo}

src/app/dashboard/personal/actions.ts

@@ -0,0 +1,72 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+import { requireStaffActor } from "@/lib/staff/auth";
+import { executeStaffCommand } from "@/lib/staff/service";
+import { deliverStaffEmails } from "@/lib/staff/email";
+
+export type StaffActionResult = {
+  error?: string;
+  success?: boolean;
+  invitePath?: string;
+  warning?: string;
+  message?: string;
+};
+
+export async function staffAction(
+  command: string,
+  data: Record<string, unknown>,
+): Promise<StaffActionResult> {
+  const actor = await requireStaffActor();
+  try {
+    const result = await executeStaffCommand(actor, { command, data });
+    let warning: string | undefined;
+    let message: string | undefined;
+    if (result.emailIds?.length) {
+      try {
+        const delivery = await deliverStaffEmails(result.emailIds);
+        if (delivery.failed)
+          warning =
+            "Gespeichert. Einige E-Mails konnten nicht versendet werden. Im Personalbereich kannst du den Versand erneut versuchen.";
+        else if (
+          process.env.NODE_ENV === "development" &&
+          !process.env.RESEND_API_KEY
+        )
+          warning = "Gespeichert. Der E-Mail-Versand wurde lokal simuliert.";
+        else if (result.invite && delivery.sent)
+          message = "Aktivierungslink per E-Mail versendet.";
+        else if (command === "emailRetry")
+          message = "Ausstehende E-Mails wurden verarbeitet.";
+      } catch {
+        warning =
+          "Gespeichert. E-Mail-Versand ist noch ausstehend; bitte im Personalbereich erneut versuchen.";
+      }
+    }
+    revalidatePath("/dashboard/personal");
+    revalidatePath("/dashboard/profil");
+    revalidatePath("/dashboard/erzieher");
+    revalidatePath("/dashboard");
+    // Returned only to the authenticated admin who generated this single-use link.
+    return {
+      success: true,
+      warning,
+      message,
+      ...(result.invite
+        ? { invitePath: `/invite/${result.invite.token}` }
+        : {}),
+    };
+  } catch (error) {
+    if (error instanceof z.ZodError)
+      return {
+        error: error.issues[0]?.message ?? "Bitte die Eingaben prüfen.",
+      };
+    if (
+      error instanceof Error &&
+      !error.message.includes("prisma") &&
+      !error.message.includes("Invalid `")
+    )
+      return { error: error.message };
+    return { error: "Speichern fehlgeschlagen. Bitte erneut versuchen." };
+  }
+}

src/app/dashboard/personal/forms.tsx

@@ -0,0 +1,784 @@
+"use client";
+
+import { useId, useState, useTransition, type ReactNode } from "react";
+import { useRouter } from "next/navigation";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog";
+import {
+  DAY_NAMES,
+  clockMinute,
+  minuteClock,
+  todayKey,
+} from "@/lib/staff/calculations";
+import { staffAction, type StaffActionResult } from "./actions";
+
+const control =
+  "w-full rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 py-2 text-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--accent-mid)]";
+export function Field({
+  label,
+  name,
+  type = "text",
+  value,
+  required = true,
+  min,
+  max,
+  step,
+}: {
+  label: string;
+  name: string;
+  type?: string;
+  value?: string | number;
+  required?: boolean;
+  min?: string | number;
+  max?: string | number;
+  step?: string | number;
+}) {
+  const id = useId();
+  return (
+    <div className="grid gap-1.5">
+      <label htmlFor={id} className="text-sm font-medium">
+        {label}
+      </label>
+      <Input
+        id={id}
+        name={name}
+        type={type}
+        defaultValue={value}
+        required={required}
+        min={min}
+        max={max}
+        step={step}
+      />
+    </div>
+  );
+}
+function transform(command: string, form: FormData) {
+  const text = (key: string) => String(form.get(key) ?? "");
+  const num = (key: string) => Number(text(key));
+  const hours = (key: string) => Math.round(num(key) * 60);
+  switch (command) {
+    case "emailPreference":
+      return { enabled: form.get("enabled") === "on" };
+    case "setup":
+      return {
+        educatorId: text("educatorId"),
+        employmentStart: text("employmentStart"),
+        employmentEnd: text("employmentEnd") || null,
+        trackingStart: text("trackingStart"),
+        openingMinutes: hours("openingHours"),
+        reason: text("reason"),
+      };
+    case "invite":
+      return { email: text("email") };
+    case "employmentEnd":
+      return {
+        employmentEnd: text("employmentEnd") || null,
+        reason: text("reason"),
+      };
+    case "pattern":
+      return {
+        effectiveFrom: text("effectiveFrom"),
+        dailyMinutes: DAY_NAMES.map((_, i) => hours(`day${i}`)),
+        reason: text("reason"),
+      };
+    case "account":
+      return {
+        year: num("year"),
+        entitlementUnits: Math.round(num("entitlement") * 2),
+        carryUnits: Math.round(num("carry") * 2),
+        reason: text("reason"),
+      };
+    case "override":
+      return {
+        date: text("date"),
+        minutes: hours("hours"),
+        reason: text("reason"),
+      };
+    case "adjust":
+      return {
+        date: text("date"),
+        minutes: hours("hours"),
+        reason: text("reason"),
+      };
+    case "holiday":
+      return { date: text("date"), name: text("name") };
+    case "time":
+      return {
+        date: text("date"),
+        startMinute: clockMinute(text("start")),
+        endMinute: clockMinute(text("end")),
+        breakMinutes: num("breakMinutes"),
+        note: text("note"),
+      };
+    case "leave":
+      return {
+        kind: text("kind"),
+        startDate: text("startDate"),
+        endDate: text("endDate"),
+        halfDay: form.get("halfDay") === "on",
+        ...(text("kind") === "TIME_OFF" ? { minutes: hours("hours") } : {}),
+        note: text("note"),
+      };
+    case "leaveReview":
+    case "weekReview":
+      return { reason: text("reason") };
+    default:
+      return {};
+  }
+}
+function StaffForm({
+  command,
+  profileId,
+  extra = {},
+  children,
+  label = "Speichern",
+  onSuccess,
+}: {
+  command: string;
+  profileId?: string;
+  extra?: Record<string, unknown>;
+  children: ReactNode;
+  label?: string;
+  onSuccess?: (result: StaffActionResult) => void;
+}) {
+  const [pending, start] = useTransition();
+  const [error, setError] = useState("");
+  const router = useRouter();
+  return (
+    <form
+      className="grid gap-4"
+      onSubmit={(event) => {
+        event.preventDefault();
+        const form = new FormData(event.currentTarget);
+        setError("");
+        start(async () => {
+          try {
+            const result = await staffAction(command, {
+              ...transform(command, form),
+              ...extra,
+              ...(profileId ? { profileId } : {}),
+            });
+            if (result.error) {
+              setError(result.error);
+              return;
+            }
+            if (result.warning) toast.warning(result.warning);
+            else toast.success(result.message ?? "Gespeichert.");
+            onSuccess?.(result);
+            router.refresh();
+          } catch (error) {
+            setError(
+              error instanceof Error
+                ? error.message
+                : "Speichern fehlgeschlagen.",
+            );
+          }
+        });
+      }}
+    >
+      <fieldset disabled={pending} className="grid gap-4 disabled:opacity-60">
+        {children}
+        <div>
+          <Button type="submit">
+            {pending ? "Wird gespeichert …" : label}
+          </Button>
+        </div>
+      </fieldset>
+      {error && (
+        <p role="alert" className="text-sm text-[var(--danger)]">
+          {error}
+        </p>
+      )}
+    </form>
+  );
+}
+export function CommandButton({
+  command,
+  profileId,
+  data,
+  children,
+  variant = "outline",
+}: {
+  command: string;
+  profileId: string;
+  data: Record<string, unknown>;
+  children: ReactNode;
+  variant?: "outline" | "ghost" | "default";
+}) {
+  const [pending, start] = useTransition();
+  const router = useRouter();
+  return (
+    <Button
+      type="button"
+      variant={variant}
+      size="sm"
+      disabled={pending}
+      onClick={() =>
+        start(async () => {
+          const result = await staffAction(command, { ...data, profileId });
+          if (result.error) toast.error(result.error);
+          else {
+            if (result.warning) toast.warning(result.warning);
+            else toast.success(result.message ?? "Gespeichert.");
+            router.refresh();
+          }
+        })
+      }
+    >
+      {pending ? "Bitte warten …" : children}
+    </Button>
+  );
+}
+export function ReviewButton({
+  command,
+  profileId,
+  data,
+  label,
+  approve,
+}: {
+  command: "leaveReview" | "weekReview";
+  profileId: string;
+  data: Record<string, unknown>;
+  label: string;
+  approve: boolean;
+}) {
+  const [open, setOpen] = useState(false);
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button size="sm" variant={approve ? "default" : "outline"}>
+          {label}
+        </Button>
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>{label}</DialogTitle>
+          <DialogDescription>
+            Die Entscheidung wird im Personalverlauf dokumentiert.
+          </DialogDescription>
+        </DialogHeader>
+        <StaffForm
+          command={command}
+          profileId={profileId}
+          extra={{ ...data, approve }}
+          label={label}
+          onSuccess={() => setOpen(false)}
+        >
+          <Field label="Begründung / Rückmeldung" name="reason" />
+        </StaffForm>
+      </DialogContent>
+    </Dialog>
+  );
+}
+export function SetupForm({
+  educatorId,
+  values,
+}: {
+  educatorId: string;
+  values?: {
+    employmentStart: string;
+    employmentEnd: string | null;
+    trackingStart: string;
+    openingMinutes: number;
+  };
+}) {
+  return (
+    <StaffForm
+      command="setup"
+      extra={{ educatorId }}
+      label="Beschäftigungsprofil speichern"
+    >
+      <input type="hidden" name="educatorId" value={educatorId} />
+      <div className="grid gap-4 sm:grid-cols-2">
+        <Field
+          label="Beschäftigung ab"
+          name="employmentStart"
+          type="date"
+          value={values?.employmentStart ?? todayKey()}
+        />
+        <Field
+          label="Beschäftigung bis (optional)"
+          name="employmentEnd"
+          type="date"
+          value={values?.employmentEnd ?? ""}
+          required={false}
+        />
+        <Field
+          label="Zeiterfassung ab"
+          name="trackingStart"
+          type="date"
+          value={values?.trackingStart ?? todayKey()}
+        />
+        <Field
+          label="Anfangssaldo in Stunden"
+          name="openingHours"
+          type="number"
+          step="any"
+          value={(values?.openingMinutes ?? 0) / 60}
+        />
+      </div>
+      <Field label="Begründung" name="reason" value="Ersteinrichtung" />
+    </StaffForm>
+  );
+}
+export function TimeForm({
+  profileId,
+  initial,
+}: {
+  profileId: string;
+  initial?: {
+    id: string;
+    date: string;
+    startMinute: number;
+    endMinute: number;
+    breakMinutes: number;
+    note: string | null;
+  };
+}) {
+  const [open, setOpen] = useState(false);
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button
+          variant={initial ? "outline" : "default"}
+          size={initial ? "sm" : "default"}
+        >
+          {initial ? "Bearbeiten" : "+ Arbeitszeit erfassen"}
+        </Button>
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>
+            {initial ? "Arbeitszeit bearbeiten" : "Arbeitszeit erfassen"}
+          </DialogTitle>
+          <DialogDescription>
+            Erfasse Beginn, Ende und die gesamte Pause dieses Arbeitsblocks.
+            Weitere Blöcke am selben Tag sind möglich.
+          </DialogDescription>
+        </DialogHeader>
+        <StaffForm
+          command="time"
+          profileId={profileId}
+          extra={initial ? { id: initial.id } : {}}
+          label="Arbeitszeit speichern"
+          onSuccess={() => setOpen(false)}
+        >
+          <Field
+            label="Datum"
+            name="date"
+            type="date"
+            value={initial?.date ?? todayKey()}
+            max={todayKey()}
+          />
+          <div className="grid grid-cols-2 gap-4">
+            <Field
+              label="Beginn"
+              name="start"
+              type="time"
+              value={minuteClock(initial?.startMinute ?? 480)}
+            />
+            <Field
+              label="Ende"
+              name="end"
+              type="time"
+              value={minuteClock(initial?.endMinute ?? 960)}
+            />
+          </div>
+          <Field
+            label="Pause in Minuten"
+            name="breakMinutes"
+            type="number"
+            min={0}
+            step={1}
+            value={initial?.breakMinutes ?? 30}
+          />
+          <Field
+            label="Notiz (optional)"
+            name="note"
+            value={initial?.note ?? ""}
+            required={false}
+          />
+        </StaffForm>
+      </DialogContent>
+    </Dialog>
+  );
+}
+export function LeaveForm({
+  profileId,
+  admin,
+  initial,
+}: {
+  profileId: string;
+  admin: boolean;
+  initial?: {
+    id: string;
+    kind: string;
+    startDate: string;
+    endDate: string;
+    halfDay: boolean;
+    minutes: number | null;
+    note: string | null;
+  };
+}) {
+  const [open, setOpen] = useState(false);
+  const [kind, setKind] = useState(initial?.kind ?? "VACATION");
+  const id = useId();
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button size={initial ? "sm" : "default"} variant="outline">
+          {initial ? "Ändern" : "+ Abwesenheit beantragen"}
+        </Button>
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>
+            {initial ? "Antrag ändern" : "Abwesenheit beantragen"}
+          </DialogTitle>
+          <DialogDescription>
+            Urlaub verbraucht nur deine vorgesehenen Arbeitstage.
+            Freizeitausgleich wird in Stunden für einen einzelnen Tag beantragt.
+          </DialogDescription>
+        </DialogHeader>
+        <StaffForm
+          command="leave"
+          profileId={profileId}
+          extra={initial ? { id: initial.id } : {}}
+          label={
+            kind === "SICKNESS" ? "Krankheit hinterlegen" : "Antrag speichern"
+          }
+          onSuccess={() => setOpen(false)}
+        >
+          <div className="grid gap-1.5">
+            <label htmlFor={`${id}-kind`} className="text-sm font-medium">
+              Art
+            </label>
+            <select
+              id={`${id}-kind`}
+              name="kind"
+              className={control}
+              value={kind}
+              onChange={(e) => setKind(e.target.value)}
+            >
+              <option value="VACATION">Urlaub</option>
+              <option value="TIME_OFF">Freizeitausgleich</option>
+              {admin && <option value="SICKNESS">Krankheit</option>}
+            </select>
+          </div>
+          <div className="grid grid-cols-2 gap-4">
+            <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}
+              />
+              Halber Urlaubstag (Von = Bis)
+            </label>
+          )}
+          {kind === "TIME_OFF" && (
+            <Field
+              label="Freizeitausgleich in Stunden (Von = Bis)"
+              name="hours"
+              type="number"
+              min={1 / 60}
+              max={16}
+              step="any"
+              value={(initial?.minutes ?? 60) / 60}
+            />
+          )}
+          <Field
+            label="Notiz (optional)"
+            name="note"
+            value={initial?.note ?? ""}
+            required={false}
+          />
+          <p className="text-xs leading-5 text-[var(--ink-soft)]">
+            Der Antrag wird anhand deines Wochenmodells, der Tagesausnahmen und
+            der Feiertage geprüft. Ein halber Tag entspricht der Hälfte der
+            Sollzeit.
+          </p>
+        </StaffForm>
+      </DialogContent>
+    </Dialog>
+  );
+}
+function SettingsSection({
+  title,
+  children,
+}: {
+  title: string;
+  children: ReactNode;
+}) {
+  return (
+    <details className="rounded-xl border border-[var(--hairline)] bg-[var(--surface)] p-5">
+      <summary className="cursor-pointer font-semibold">{title}</summary>
+      <div className="mt-5">{children}</div>
+    </details>
+  );
+}
+export function StaffEmailSettings({ enabled }: { enabled: boolean }) {
+  return (
+    <StaffForm command="emailPreference" label="E-Mail-Einstellung speichern">
+      <label className="flex items-start gap-3 text-sm">
+        <input
+          type="checkbox"
+          name="enabled"
+          defaultChecked={enabled}
+          className="mt-1 accent-[var(--accent-deep)]"
+        />
+        <span>
+          Entscheidungen zu Urlaub, Freizeitausgleich und Arbeitswochen per
+          E-Mail erhalten.
+        </span>
+      </label>
+      <p className="text-sm text-[var(--ink-soft)]">
+        Aktivierungslinks und Hinweise innerhalb der App bleiben davon
+        unabhängig.
+      </p>
+    </StaffForm>
+  );
+}
+
+export function SettingsPanel({
+  profileId,
+  educatorId,
+  employment,
+  email,
+  verified,
+  pattern,
+  year,
+  account,
+}: {
+  profileId: string;
+  educatorId: string;
+  employment: {
+    employmentStart: string;
+    employmentEnd: string | null;
+    trackingStart: string;
+    openingMinutes: number;
+  };
+  email?: string;
+  verified: boolean;
+  pattern?: { effectiveFrom: string; dailyMinutes: number[] };
+  year: number;
+  account?: { entitlementUnits: number; carryUnits: number };
+}) {
+  const [invitePath, setInvitePath] = useState("");
+  return (
+    <div className="grid gap-3">
+      <SettingsSection title="Zugang zur Zeiterfassung">
+        {verified ? (
+          <p className="text-sm">Aktives Konto: {email}</p>
+        ) : (
+          <StaffForm
+            command="invite"
+            profileId={profileId}
+            label="Per E-Mail einladen / Account verknüpfen"
+            onSuccess={(r) => setInvitePath(r.invitePath ?? "")}
+          >
+            <Field
+              label="E-Mail-Adresse"
+              name="email"
+              type="email"
+              value={email ?? ""}
+            />
+            <p className="text-sm text-[var(--ink-soft)]">
+              Erstellt oder verknüpft einen ErzieherInnen-Account. Der
+              persönliche Aktivierungslink wird per E-Mail versendet und ist
+              sieben Tage gültig. Ein neuer Link ersetzt den vorherigen.
+            </p>
+          </StaffForm>
+        )}
+        {invitePath && (
+          <div className="mt-4 grid gap-2 rounded-lg bg-[var(--accent-soft)] p-4">
+            <label htmlFor="activation-link" className="text-sm font-medium">
+              Persönlicher Aktivierungslink
+            </label>
+            <Input
+              id="activation-link"
+              readOnly
+              value={`${window.location.origin}${invitePath}`}
+            />
+            <Button
+              variant="outline"
+              onClick={async () => {
+                await navigator.clipboard.writeText(
+                  `${window.location.origin}${invitePath}`,
+                );
+                toast.success("Link kopiert.");
+              }}
+            >
+              Link kopieren
+            </Button>
+            <p className="text-xs">
+              Bitte persönlich an die Fachkraft weitergeben. Es wird keine
+              E-Mail versendet.
+            </p>
+          </div>
+        )}
+      </SettingsSection>
+      <SettingsSection title="Feste Wochentage & Sollstunden">
+        <StaffForm
+          command="pattern"
+          profileId={profileId}
+          label="Wochenmodell speichern"
+        >
+          <Field
+            label="Gültig ab"
+            name="effectiveFrom"
+            type="date"
+            value={pattern?.effectiveFrom ?? employment.trackingStart}
+          />
+          <div className="grid gap-3 sm:grid-cols-2">
+            {DAY_NAMES.map((day, i) => (
+              <Field
+                key={day}
+                label={`${day} · Stunden`}
+                name={`day${i}`}
+                type="number"
+                min={0}
+                max={16}
+                step="any"
+                value={(pattern?.dailyMinutes[i] ?? 0) / 60}
+              />
+            ))}
+          </div>
+          <Field label="Begründung" name="reason" />
+          <p className="text-xs text-[var(--ink-soft)]">
+            0 Stunden = frei. Stunden sind Nettozeiten ohne Pause. Änderungen
+            gelten ab dem gewählten Datum; ältere Modelle bleiben erhalten.
+          </p>
+        </StaffForm>
+      </SettingsSection>
+      <SettingsSection title={`Urlaubsanspruch & Übertrag · ${year}`}>
+        <StaffForm command="account" profileId={profileId}>
+          <Field
+            label="Jahr"
+            name="year"
+            type="number"
+            min={2000}
+            max={2100}
+            value={year}
+          />
+          <div className="grid grid-cols-2 gap-4">
+            <Field
+              label="Jahresanspruch in Tagen"
+              name="entitlement"
+              type="number"
+              min={0}
+              max={400}
+              step={0.5}
+              value={(account?.entitlementUnits ?? 0) / 2}
+            />
+            <Field
+              label="Übertrag in Tagen"
+              name="carry"
+              type="number"
+              min={0}
+              max={400}
+              step={0.5}
+              value={(account?.carryUnits ?? 0) / 2}
+            />
+          </div>
+          <Field label="Begründung" name="reason" />
+          <p className="text-xs text-[var(--ink-soft)]">
+            Anspruch individuell für die Arbeitstage dieser Person hinterlegen.
+            Der Übertrag wird ausdrücklich festgelegt.
+          </p>
+        </StaffForm>
+      </SettingsSection>
+      <SettingsSection title="Ausnahme für einen einzelnen Tag">
+        <StaffForm command="override" profileId={profileId}>
+          <Field label="Datum" name="date" type="date" value={todayKey()} />
+          <Field
+            label="Abweichende Sollstunden (0 = frei)"
+            name="hours"
+            type="number"
+            min={0}
+            max={16}
+            step="any"
+            value={0}
+          />
+          <Field label="Begründung" name="reason" />
+          <p className="text-xs text-[var(--ink-soft)]">
+            Bei einem Tausch beide Tage erfassen: den ursprünglichen Tag auf 0
+            setzen und den neuen Arbeitstag mit Sollstunden hinterlegen.
+          </p>
+        </StaffForm>
+      </SettingsSection>
+      <SettingsSection title="Zeitkonto korrigieren">
+        <StaffForm command="adjust" profileId={profileId}>
+          <Field
+            label="Buchungsdatum"
+            name="date"
+            type="date"
+            value={todayKey()}
+          />
+          <Field
+            label="Korrektur in Stunden (mit Vorzeichen)"
+            name="hours"
+            type="number"
+            step="any"
+          />
+          <Field label="Begründung" name="reason" />
+          <p className="text-xs text-[var(--ink-soft)]">
+            Korrekturen bleiben im Verlauf erhalten. Falsche Buchungen durch
+            eine Gegenbuchung berichtigen.
+          </p>
+        </StaffForm>
+      </SettingsSection>
+      <SettingsSection title="Beschäftigungsbeginn & Anfangssaldo">
+        <SetupForm educatorId={educatorId} values={employment} />
+        <p className="mt-3 text-xs text-[var(--ink-soft)]">
+          Die Grunddaten sind geschützt, sobald Zeiten, Wochen oder Anträge
+          erfasst wurden.
+        </p>
+      </SettingsSection>
+      <SettingsSection title="Beschäftigungsende ändern">
+        <StaffForm command="employmentEnd" profileId={profileId}>
+          <Field
+            label="Beschäftigung bis (leer = unbefristet)"
+            name="employmentEnd"
+            type="date"
+            value={employment.employmentEnd ?? ""}
+            required={false}
+          />
+          <Field label="Begründung" name="reason" />
+        </StaffForm>
+      </SettingsSection>
+    </div>
+  );
+}
+export function HolidayForm() {
+  return (
+    <StaffForm command="holiday" label="Feiertag speichern">
+      <div className="grid gap-4 sm:grid-cols-2">
+        <Field label="Datum" name="date" type="date" />
+        <Field label="Bezeichnung" name="name" />
+      </div>
+    </StaffForm>
+  );
+}

src/app/dashboard/profil/page.tsx

@@ -1,5 +1,7 @@
 import { format } from "date-fns";
 import { de } from "date-fns/locale";
+import Link from "next/link";
+import { UserRole } from "@prisma/client";
 import {
   AtSign,
   Baby,
@@ -27,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 { StaffEmailSettings } from "../personal/forms";
 
 export const metadata = { title: "Mein Profil · Kita-Planer" };
 
@@ -52,6 +55,7 @@ export default async function ProfilPage() {
         postalCode: true,
         city: true,
         directoryOptInAt: true,
+        staffDecisionEmails: true,
         createdAt: true,
         family: {
           select: {
@@ -96,7 +100,9 @@ export default async function ProfilPage() {
           </em>
         </h1>
         <p className="mt-3 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
-          Deine persönlichen Daten, verknüpfte Kinder und DSGVO-Einstellungen.
+          {user.role === UserRole.ERZIEHER
+            ? "Deine persönlichen Daten, dein Arbeitsbereich und Datenschutzeinstellungen."
+            : "Deine persönlichen Daten, verknüpfte Kinder und DSGVO-Einstellungen."}
         </p>
       </header>
 
@@ -124,25 +130,31 @@ export default async function ProfilPage() {
                 label="Telefon"
                 value={user.phone ? user.phone : <EmptyDefValue />}
               />
-              <DefItem icon={Shield} label="Rolle" value={<RoleBadge role={user.role} />} />
               <DefItem
-                icon={Home}
+                icon={Shield}
-                label="Haushalt"
+                label="Rolle"
-                value={
+                value={<RoleBadge role={user.role} />}
-                  user.family ? (
-                    user.family.name
-                  ) : (
-                    <div className="grid gap-3 rounded-lg border border-dashed border-[var(--hairline)] bg-[var(--surface-2)] p-3">
-                      <p className="text-sm font-normal leading-5 text-[var(--ink-soft)]">
-                        Dein Account ist noch keinem Haushalt zugeordnet.
-                      </p>
-                      <CreateFamilyDialog
-                        defaultFamilyName={`Familie ${user.lastName}`}
-                      />
-                    </div>
-                  )
-                }
               />
+              {user.role !== UserRole.ERZIEHER && (
+                <DefItem
+                  icon={Home}
+                  label="Haushalt"
+                  value={
+                    user.family ? (
+                      user.family.name
+                    ) : (
+                      <div className="grid gap-3 rounded-lg border border-dashed border-[var(--hairline)] bg-[var(--surface-2)] p-3">
+                        <p className="text-sm font-normal leading-5 text-[var(--ink-soft)]">
+                          Dein Account ist noch keinem Haushalt zugeordnet.
+                        </p>
+                        <CreateFamilyDialog
+                          defaultFamilyName={`Familie ${user.lastName}`}
+                        />
+                      </div>
+                    )
+                  }
+                />
+              )}
               <DefItem
                 icon={CalendarHeart}
                 label="Mitglied seit"
@@ -153,6 +165,24 @@ export default async function ProfilPage() {
         </Card>
 
         <div className="grid gap-4">
+          {user.role === UserRole.ERZIEHER && (
+            <Card>
+              <CardHeader>
+                <CardTitle>Meine Arbeitszeit & Urlaub</CardTitle>
+                <CardDescription>
+                  Wochenmodell, Urlaubsanspruch, Zeiterfassung und Überstunden.
+                </CardDescription>
+              </CardHeader>
+              <CardContent>
+                <Link
+                  href="/dashboard/personal"
+                  className="font-medium text-[var(--accent-deep)] underline underline-offset-4"
+                >
+                  Personalbereich öffnen →
+                </Link>
+              </CardContent>
+            </Card>
+          )}
           <Card>
             <CardHeader className="pb-5">
               <div className="flex items-start gap-3">
@@ -180,87 +210,104 @@ export default async function ProfilPage() {
             </CardContent>
           </Card>
 
-          <Card>
+          {user.role === UserRole.ERZIEHER && (
-            <CardHeader className="pb-5">
+            <Card>
-              <div className="flex items-start gap-3">
+              <CardHeader>
-                <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-[var(--accent-soft)] text-[var(--accent-deep)]">
+                <CardTitle>E-Mail-Hinweise</CardTitle>
-                  <Baby className="h-4 w-4 [stroke-width:1.7]" />
+                <CardDescription>
-                </div>
+                  Benachrichtigungen aus dem Personalbereich.
-                <div>
+                </CardDescription>
-                  <CardTitle>Meine Kinder</CardTitle>
+              </CardHeader>
-                  <CardDescription className="mt-2">
+              <CardContent>
-                    Kinder deines Haushalts verwalten.
+                <StaffEmailSettings enabled={user.staffDecisionEmails} />
-                  </CardDescription>
+              </CardContent>
-                </div>
+            </Card>
-              </div>
+          )}
-            </CardHeader>
+          {user.role !== UserRole.ERZIEHER && (
-            <CardContent>
+            <>
-              <MyChildrenManager
+              <Card>
-                items={(user.family?.children ?? []).map((child) => ({
+                <CardHeader className="pb-5">
-                  id: child.id,
+                  <div className="flex items-start gap-3">
-                  firstName: child.firstName,
+                    <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-[var(--accent-soft)] text-[var(--accent-deep)]">
-                  lastName: child.lastName,
+                      <Baby className="h-4 w-4 [stroke-width:1.7]" />
-                  dateOfBirth: child.dateOfBirth
-                    ? child.dateOfBirth.toISOString().slice(0, 10)
-                    : null,
-                }))}
-                canManage={!!user.familyId}
-              />
-            </CardContent>
-          </Card>
-
-          <Card>
-            <CardHeader className="pb-5">
-              <div className="flex items-start gap-3">
-                <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-[var(--accent-soft)] text-[var(--accent-deep)]">
-                  <Shield className="h-4 w-4 [stroke-width:1.7]" />
-                </div>
-                <div>
-                  <CardTitle>Meine Ämter & Dienste</CardTitle>
-                  <CardDescription className="mt-2">
-                    Feste Aufgaben und laufende Zuständigkeiten.
-                  </CardDescription>
-                </div>
-              </div>
-            </CardHeader>
-            <CardContent>
-              {user.dutyAssignments.length === 0 ? (
-                <div className="flex min-h-32 flex-col items-center justify-center rounded-[14px] border border-dashed border-[var(--hairline)] bg-[var(--surface-2)] p-5 text-center">
-                  <div className="flex h-9 w-9 items-center justify-center rounded-full bg-[var(--accent-soft)] text-[var(--accent-deep)]">
-                    <Shield className="h-4 w-4 [stroke-width:1.7]" />
-                  </div>
-                  <p className="mt-3 text-sm font-medium text-[var(--ink)]">
-                    Keine festen Ämter übernommen
-                  </p>
-                  <p className="mt-1 text-xs text-[var(--ink-soft)]">
-                    Dienste und Rollen erscheinen hier, sobald sie zugewiesen
-                    sind.
-                  </p>
-                </div>
-              ) : (
-                <div className="grid gap-2">
-                  {user.dutyAssignments.map((assignment) => (
-                    <div
-                      key={assignment.id}
-                      className="flex items-center justify-between gap-3 rounded-lg bg-[var(--surface-2)] p-[10px_12px]"
-                    >
-                      <div>
-                        <p className="text-sm font-semibold text-[var(--ink)]">
-                          {assignment.duty.name}
-                        </p>
-                        <p className="text-xs text-[var(--ink-soft)]">
-                          laufender Dienst
-                        </p>
-                      </div>
-                      <span className="rounded-full border border-[var(--accent-mid)] bg-[var(--accent-soft)] px-2.5 py-1 text-[10.5px] font-semibold uppercase text-[var(--accent-deep)] [letter-spacing:0.1em]">
-                        Aktiv
-                      </span>
                     </div>
-                  ))}
+                    <div>
-                </div>
+                      <CardTitle>Meine Kinder</CardTitle>
-              )}
+                      <CardDescription className="mt-2">
-            </CardContent>
+                        Kinder deines Haushalts verwalten.
-          </Card>
+                      </CardDescription>
+                    </div>
+                  </div>
+                </CardHeader>
+                <CardContent>
+                  <MyChildrenManager
+                    items={(user.family?.children ?? []).map((child) => ({
+                      id: child.id,
+                      firstName: child.firstName,
+                      lastName: child.lastName,
+                      dateOfBirth: child.dateOfBirth
+                        ? child.dateOfBirth.toISOString().slice(0, 10)
+                        : null,
+                    }))}
+                    canManage={!!user.familyId}
+                  />
+                </CardContent>
+              </Card>
+
+              <Card>
+                <CardHeader className="pb-5">
+                  <div className="flex items-start gap-3">
+                    <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-[var(--accent-soft)] text-[var(--accent-deep)]">
+                      <Shield className="h-4 w-4 [stroke-width:1.7]" />
+                    </div>
+                    <div>
+                      <CardTitle>Meine Ämter & Dienste</CardTitle>
+                      <CardDescription className="mt-2">
+                        Feste Aufgaben und laufende Zuständigkeiten.
+                      </CardDescription>
+                    </div>
+                  </div>
+                </CardHeader>
+                <CardContent>
+                  {user.dutyAssignments.length === 0 ? (
+                    <div className="flex min-h-32 flex-col items-center justify-center rounded-[14px] border border-dashed border-[var(--hairline)] bg-[var(--surface-2)] p-5 text-center">
+                      <div className="flex h-9 w-9 items-center justify-center rounded-full bg-[var(--accent-soft)] text-[var(--accent-deep)]">
+                        <Shield className="h-4 w-4 [stroke-width:1.7]" />
+                      </div>
+                      <p className="mt-3 text-sm font-medium text-[var(--ink)]">
+                        Keine festen Ämter übernommen
+                      </p>
+                      <p className="mt-1 text-xs text-[var(--ink-soft)]">
+                        Dienste und Rollen erscheinen hier, sobald sie
+                        zugewiesen sind.
+                      </p>
+                    </div>
+                  ) : (
+                    <div className="grid gap-2">
+                      {user.dutyAssignments.map((assignment) => (
+                        <div
+                          key={assignment.id}
+                          className="flex items-center justify-between gap-3 rounded-lg bg-[var(--surface-2)] p-[10px_12px]"
+                        >
+                          <div>
+                            <p className="text-sm font-semibold text-[var(--ink)]">
+                              {assignment.duty.name}
+                            </p>
+                            <p className="text-xs text-[var(--ink-soft)]">
+                              laufender Dienst
+                            </p>
+                          </div>
+                          <span className="rounded-full border border-[var(--accent-mid)] bg-[var(--accent-soft)] px-2.5 py-1 text-[10.5px] font-semibold uppercase text-[var(--accent-deep)] [letter-spacing:0.1em]">
+                            Aktiv
+                          </span>
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                </CardContent>
+              </Card>
+            </>
+          )}
         </div>
       </div>
 

src/components/dashboard/sidebar-nav.tsx

@@ -12,6 +12,8 @@ import {
   ClipboardList,
   Stethoscope,
   Megaphone,
+  Clock3,
+  BellRing,
 } from "lucide-react";
 
 import { NavItem } from "@/components/ui/nav-item";
@@ -19,6 +21,22 @@ import { NavItem } from "@/components/ui/nav-item";
 import { UserRole } from "@prisma/client";
 
 const navItems = [
+  {
+    section: "Heute",
+    href: "/dashboard/notdienst/alarm",
+    label: "Notdienstalarm",
+    icon: BellRing,
+    exact: true,
+    allowedRoles: [UserRole.ADMIN, UserRole.KOORDINATOR, UserRole.ELTERN],
+  },
+  {
+    section: "Heute",
+    href: "/dashboard/personal",
+    label: "Personal & Arbeitszeit",
+    icon: Clock3,
+    exact: false,
+    allowedRoles: [UserRole.ADMIN, UserRole.ERZIEHER],
+  },
   {
     section: "Heute",
     href: "/dashboard",
@@ -33,6 +51,7 @@ const navItems = [
     icon: CalendarCheck2,
     exact: true,
     badge: "4",
+    allowedRoles: [UserRole.ADMIN, UserRole.KOORDINATOR, UserRole.ELTERN],
   },
   {
     section: "Heute",

src/emails/InviteEmail.tsx

@@ -16,12 +16,14 @@ type InviteEmailProps = {
   parentName: string;
   kitaName: string;
   inviteLink: string;
+  staffAccount?: boolean;
 };
 
 export function InviteEmail({
   parentName,
   kitaName,
   inviteLink,
+  staffAccount = false,
 }: InviteEmailProps) {
   return (
     <Html lang="de">
@@ -36,13 +38,16 @@ export function InviteEmail({
             <Text style={styles.kicker}>Einladung zur Kita-App</Text>
             <Heading style={styles.heading}>Willkommen bei {kitaName}</Heading>
             <Text style={styles.lead}>
-              Hallo {parentName}, dein Eltern-Account wurde vorbereitet.
+              Hallo {parentName}, dein {staffAccount ? "Fachkraft" : "Eltern"}
+              -Account wurde vorbereitet.
             </Text>
 
             <Text style={styles.text}>
               Über den folgenden Link kannst du dein Passwort setzen und deinen
-              Account aktivieren. Danach hast du Zugriff auf die Kita-Planung,
+              Account aktivieren.{" "}
-              Termine und deine Familiendaten.
+              {staffAccount
+                ? "Danach kannst du deine Arbeitszeiten erfassen, Urlaub beantragen und dein Zeitkonto einsehen. Der Link ist sieben Tage gültig und kann einmal verwendet werden."
+                : "Danach hast du Zugriff auf die Kita-Planung, Termine und deine Familiendaten."}
             </Text>
 
             <Button href={inviteLink} style={styles.button}>

src/emails/NotdienstAlarmEmail.tsx

@@ -0,0 +1,87 @@
+import {
+  Body,
+  Button,
+  Container,
+  Head,
+  Heading,
+  Html,
+  Preview,
+  Text,
+} from "@react-email/components";
+import { baseBodyStyle, colors, fontStack } from "./_styles";
+
+export function NotdienstAlarmEmail({
+  name,
+  kitaName,
+  message,
+  link,
+  request,
+  cancelled,
+}: {
+  name: string;
+  kitaName: string;
+  message: string;
+  link: string;
+  request: boolean;
+  cancelled: boolean;
+}) {
+  const title = request
+    ? "Notdienst: Eure Rückmeldung zählt"
+    : cancelled
+      ? "Notdiensteinsatz storniert"
+      : "Neuer Stand beim Notdienst";
+  return (
+    <Html lang="de">
+      <Head />
+      <Preview>
+        {title} · {kitaName}
+      </Preview>
+      <Body style={baseBodyStyle}>
+        <Container
+          style={{
+            maxWidth: "600px",
+            padding: "32px 24px",
+            fontFamily: fontStack,
+          }}
+        >
+          <Text
+            style={{
+              color: colors.textMuted,
+              fontSize: "12px",
+              letterSpacing: "0.08em",
+            }}
+          >
+            KITA-PLANER · {kitaName}
+          </Text>
+          <Heading style={{ color: request ? "#9f1239" : colors.textPrimary }}>
+            {title}
+          </Heading>
+          <Text>Hallo {name},</Text>
+          <Text style={{ lineHeight: "26px" }}>{message}</Text>
+          {request && (
+            <Text>
+              Eine Antwort gilt für euren ganzen Haushalt. Bitte wählt auf der
+              Rückmeldeseite „Wir übernehmen“ oder „Wir können nicht“.
+            </Text>
+          )}
+          <Button
+            href={link}
+            style={{
+              backgroundColor: request ? "#9f1239" : colors.brandGreen,
+              color: "#fff",
+              padding: "14px 20px",
+              borderRadius: "6px",
+            }}
+          >
+            {request
+              ? "Für unseren Haushalt antworten"
+              : "Notdienstalarm öffnen"}
+          </Button>
+          <Text style={{ fontSize: "12px", color: colors.textMuted }}>
+            Falls der Button nicht funktioniert: {link}
+          </Text>
+        </Container>
+      </Body>
+    </Html>
+  );
+}

src/emails/NotdienstAssignmentChangeEmail.tsx

@@ -0,0 +1,178 @@
+import {
+  Body,
+  Button,
+  Container,
+  Head,
+  Heading,
+  Html,
+  Preview,
+  Section,
+  Text,
+} from "@react-email/components";
+
+import { baseBodyStyle, colors, fontStack } from "./_styles";
+
+type NotdienstAssignmentChangeEmailProps = {
+  parentName: string;
+  heading: string;
+  preview: string;
+  body: string;
+  dateLabel: string;
+  link: string;
+};
+
+export function NotdienstAssignmentChangeEmail({
+  parentName,
+  heading,
+  preview,
+  body,
+  dateLabel,
+  link,
+}: NotdienstAssignmentChangeEmailProps) {
+  return (
+    <Html lang="de">
+      <Head />
+      <Preview>{preview}</Preview>
+      <Body style={styles.body}>
+        <Container style={styles.container}>
+          <Section style={styles.card}>
+            <Section style={styles.brandBar}>
+              <Text style={styles.brand}>Kita-Planer</Text>
+            </Section>
+            <Text style={styles.kicker}>Notdienst-Einteilung</Text>
+            <Heading style={styles.heading}>{heading}</Heading>
+            <Text style={styles.lead}>Hallo {parentName},</Text>
+            <Text style={styles.text}>{body}</Text>
+            <Section style={styles.dateBadge}>
+              <Text style={styles.dateText}>{dateLabel}</Text>
+            </Section>
+            <Button href={link} style={styles.button}>
+              Zum Kita-Planer
+            </Button>
+            <Text style={styles.fallbackText}>
+              Falls der Button nicht funktioniert, kopiere diesen Link in deinen Browser:
+            </Text>
+            <Text style={styles.linkText}>{link}</Text>
+          </Section>
+          <Text style={styles.footer}>
+            Diese Nachricht wurde automatisch vom Kita-Planer deiner Kita versendet.
+          </Text>
+        </Container>
+      </Body>
+    </Html>
+  );
+}
+
+const styles = {
+  body: baseBodyStyle,
+  container: {
+    width: "100%",
+    maxWidth: "600px",
+    margin: "0 auto",
+    padding: "32px 20px",
+    fontFamily: fontStack,
+  },
+  card: {
+    padding: "0 28px 28px",
+    backgroundColor: colors.cardBg,
+    borderRadius: "10px",
+    border: `1px solid ${colors.border}`,
+    boxShadow: "0 10px 26px rgba(31, 59, 45, 0.08)",
+    overflow: "hidden",
+    fontFamily: fontStack,
+  },
+  brandBar: {
+    margin: "0 -28px 28px",
+    padding: "14px 28px",
+    backgroundColor: colors.brandGreen,
+    fontFamily: fontStack,
+  },
+  brand: {
+    margin: 0,
+    color: colors.eyebrow,
+    fontSize: "12px",
+    fontWeight: 800,
+    letterSpacing: "0.08em",
+    textTransform: "uppercase" as const,
+    fontFamily: fontStack,
+  },
+  kicker: {
+    margin: "0 0 10px",
+    color: colors.brandGreenAccent,
+    fontSize: "12px",
+    fontWeight: 800,
+    letterSpacing: "0.06em",
+    textTransform: "uppercase" as const,
+    fontFamily: fontStack,
+  },
+  heading: {
+    margin: "0 0 14px",
+    color: colors.textPrimary,
+    fontSize: "28px",
+    lineHeight: "34px",
+    fontWeight: 800,
+    fontFamily: fontStack,
+  },
+  lead: {
+    margin: "0 0 18px",
+    color: colors.textBody,
+    fontSize: "16px",
+    lineHeight: "24px",
+    fontFamily: fontStack,
+  },
+  text: {
+    margin: "0 0 22px",
+    color: colors.textBody,
+    fontSize: "15px",
+    lineHeight: "24px",
+    fontFamily: fontStack,
+  },
+  dateBadge: {
+    margin: "0 0 24px",
+    padding: "16px 18px",
+    backgroundColor: colors.bgAlt,
+    border: `1px solid ${colors.border}`,
+    borderRadius: "8px",
+  },
+  dateText: {
+    margin: 0,
+    color: colors.textPrimary,
+    fontSize: "17px",
+    lineHeight: "24px",
+    fontWeight: 800,
+    fontFamily: fontStack,
+  },
+  button: {
+    display: "inline-block",
+    padding: "12px 18px",
+    backgroundColor: colors.brandGreenAccent,
+    color: "#ffffff",
+    borderRadius: "8px",
+    textDecoration: "none",
+    fontWeight: 700,
+    fontFamily: fontStack,
+  },
+  fallbackText: {
+    margin: "22px 0 6px",
+    color: colors.textMuted,
+    fontSize: "12px",
+    lineHeight: "18px",
+    fontFamily: fontStack,
+  },
+  linkText: {
+    margin: 0,
+    color: colors.link,
+    fontSize: "12px",
+    lineHeight: "18px",
+    wordBreak: "break-all" as const,
+    fontFamily: fontStack,
+  },
+  footer: {
+    margin: "18px 0 0",
+    color: colors.textFaint,
+    fontSize: "12px",
+    lineHeight: "18px",
+    textAlign: "center" as const,
+    fontFamily: fontStack,
+  },
+};

src/emails/NotdienstSwapEmail.tsx

@@ -0,0 +1,199 @@
+import {
+  Body,
+  Button,
+  Container,
+  Head,
+  Heading,
+  Html,
+  Preview,
+  Section,
+  Text,
+} from "@react-email/components";
+
+import { baseBodyStyle, colors, fontStack } from "./_styles";
+
+type NotdienstSwapEmailProps = {
+  parentName: string;
+  heading: string;
+  preview: string;
+  kitaName: string;
+  body: string;
+  targetDateLabel: string;
+  offeredDateLabel: string;
+  link: string;
+};
+
+export function NotdienstSwapEmail({
+  parentName,
+  heading,
+  preview,
+  kitaName,
+  body,
+  targetDateLabel,
+  offeredDateLabel,
+  link,
+}: NotdienstSwapEmailProps) {
+  return (
+    <Html lang="de">
+      <Head />
+      <Preview>{preview}</Preview>
+      <Body style={styles.body}>
+        <Container style={styles.container}>
+          <Section style={styles.card}>
+            <Section style={styles.brandBar}>
+              <Text style={styles.brand}>Kita-Planer</Text>
+            </Section>
+            <Text style={styles.kicker}>Notdienst-Tausch</Text>
+            <Heading style={styles.heading}>{heading}</Heading>
+            <Text style={styles.lead}>Hallo {parentName},</Text>
+            <Text style={styles.text}>
+              in der Kita <strong>{kitaName}</strong>: {body}
+            </Text>
+
+            <Section style={styles.dateBox}>
+              <Text style={styles.dateLabel}>Angefragter Notdienst</Text>
+              <Text style={styles.dateText}>{targetDateLabel}</Text>
+              <Text style={styles.dateLabel}>Angebotener Tauschdienst</Text>
+              <Text style={styles.dateText}>{offeredDateLabel}</Text>
+            </Section>
+
+            <Button href={link} style={styles.button}>
+              Zum Kalender
+            </Button>
+
+            <Text style={styles.fallbackText}>
+              Falls der Button nicht funktioniert, kopiere diesen Link in deinen Browser:
+            </Text>
+            <Text style={styles.linkText}>{link}</Text>
+          </Section>
+          <Text style={styles.footer}>
+            Diese Nachricht wurde automatisch vom Kita-Planer deiner Kita versendet.
+          </Text>
+        </Container>
+      </Body>
+    </Html>
+  );
+}
+
+const styles = {
+  body: baseBodyStyle,
+  container: {
+    width: "100%",
+    maxWidth: "600px",
+    margin: "0 auto",
+    padding: "32px 20px",
+    fontFamily: fontStack,
+  },
+  card: {
+    padding: "0 28px 28px",
+    backgroundColor: colors.cardBg,
+    borderRadius: "10px",
+    border: `1px solid ${colors.border}`,
+    boxShadow: "0 10px 26px rgba(31, 59, 45, 0.08)",
+    overflow: "hidden",
+    fontFamily: fontStack,
+  },
+  brandBar: {
+    margin: "0 -28px 28px",
+    padding: "14px 28px",
+    backgroundColor: colors.brandGreen,
+    fontFamily: fontStack,
+  },
+  brand: {
+    margin: 0,
+    color: colors.eyebrow,
+    fontSize: "12px",
+    fontWeight: 800,
+    letterSpacing: "0.08em",
+    textTransform: "uppercase" as const,
+    fontFamily: fontStack,
+  },
+  kicker: {
+    margin: "0 0 10px",
+    color: colors.brandGreenAccent,
+    fontSize: "12px",
+    fontWeight: 800,
+    letterSpacing: "0.06em",
+    textTransform: "uppercase" as const,
+    fontFamily: fontStack,
+  },
+  heading: {
+    margin: "0 0 14px",
+    color: colors.textPrimary,
+    fontSize: "28px",
+    lineHeight: "34px",
+    fontWeight: 800,
+    fontFamily: fontStack,
+  },
+  lead: {
+    margin: "0 0 18px",
+    color: colors.textBody,
+    fontSize: "16px",
+    lineHeight: "24px",
+    fontFamily: fontStack,
+  },
+  text: {
+    margin: "0 0 22px",
+    color: colors.textBody,
+    fontSize: "15px",
+    lineHeight: "24px",
+    fontFamily: fontStack,
+  },
+  dateBox: {
+    margin: "0 0 24px",
+    padding: "18px",
+    backgroundColor: colors.bgAlt,
+    border: `1px solid ${colors.border}`,
+    borderRadius: "8px",
+  },
+  dateLabel: {
+    margin: "0 0 4px",
+    color: colors.textMuted,
+    fontSize: "12px",
+    fontWeight: 700,
+    textTransform: "uppercase" as const,
+    letterSpacing: "0.04em",
+    fontFamily: fontStack,
+  },
+  dateText: {
+    margin: "0 0 16px",
+    color: colors.textPrimary,
+    fontSize: "16px",
+    lineHeight: "24px",
+    fontWeight: 700,
+    fontFamily: fontStack,
+  },
+  button: {
+    display: "inline-block",
+    padding: "12px 18px",
+    backgroundColor: colors.brandGreenAccent,
+    color: "#ffffff",
+    borderRadius: "8px",
+    textDecoration: "none",
+    fontWeight: 700,
+    fontFamily: fontStack,
+  },
+  fallbackText: {
+    margin: "22px 0 6px",
+    color: colors.textMuted,
+    fontSize: "12px",
+    lineHeight: "18px",
+    fontFamily: fontStack,
+  },
+  linkText: {
+    margin: 0,
+    color: colors.link,
+    fontSize: "12px",
+    lineHeight: "18px",
+    wordBreak: "break-all" as const,
+    fontFamily: fontStack,
+  },
+  footer: {
+    margin: "18px 0 0",
+    color: colors.textFaint,
+    fontSize: "12px",
+    lineHeight: "18px",
+    textAlign: "center" as const,
+    fontFamily: fontStack,
+  },
+};

src/emails/StaffNotificationEmail.tsx

@@ -0,0 +1,63 @@
+import {
+  Body,
+  Button,
+  Container,
+  Head,
+  Heading,
+  Html,
+  Preview,
+  Text,
+} from "@react-email/components";
+import { baseBodyStyle, colors, fontStack } from "./_styles";
+
+export function StaffNotificationEmail({
+  name,
+  kitaName,
+  message,
+  link,
+}: {
+  name: string;
+  kitaName: string;
+  message: string;
+  link: string;
+}) {
+  return (
+    <Html lang="de">
+      <Head />
+      <Preview>Neuer Hinweis im Personalbereich von {kitaName}</Preview>
+      <Body style={baseBodyStyle}>
+        <Container
+          style={{
+            maxWidth: "600px",
+            padding: "32px 24px",
+            fontFamily: fontStack,
+          }}
+        >
+          <Heading style={{ color: colors.textPrimary }}>
+            Personalbereich · {kitaName}
+          </Heading>
+          <Text>Hallo {name},</Text>
+          <Text style={{ lineHeight: "24px" }}>{message}</Text>
+          <Text>
+            Die Einzelheiten findest du nach der Anmeldung im Personalbereich.
+          </Text>
+          <Button
+            href={link}
+            style={{
+              backgroundColor: colors.brandGreen,
+              color: "#fff",
+              padding: "14px 20px",
+              borderRadius: "6px",
+            }}
+          >
+            Personalbereich öffnen
+          </Button>
+          <Text style={{ fontSize: "12px", color: colors.textMuted }}>
+            Fachkräfte können Entscheidungshinweise unter „Mein Profil“
+            abschalten. Hinweise innerhalb der App bleiben erhalten.
+          </Text>
+        </Container>
+      </Body>
+    </Html>
+  );
+}

src/lib/alarms/auth.ts

@@ -0,0 +1,20 @@
+import { redirect } from "next/navigation";
+import { requireKitaSession } from "@/lib/auth-utils";
+import { prisma } from "@/lib/prisma";
+import { managerRoles, validateAlarmActor, type AlarmActor } from "./service";
+
+export async function requireAlarmActor(manager = true): Promise<AlarmActor> {
+  const session = await requireKitaSession();
+  const actor = {
+    id: session.user.id!,
+    kitaId: session.user.kitaId,
+    role: session.user.role,
+  };
+  if (manager && !managerRoles.includes(actor.role)) redirect("/forbidden");
+  try {
+    await validateAlarmActor(prisma, actor, manager);
+  } catch {
+    redirect("/forbidden");
+  }
+  return actor;
+}

src/lib/alarms/email.ts

@@ -0,0 +1,98 @@
+import { createElement } from "react";
+import { prisma } from "@/lib/prisma";
+import { sendAppEmail } from "@/lib/mail";
+import { NotdienstAlarmEmail } from "@/emails/NotdienstAlarmEmail";
+import { managerRoles } from "./service";
+
+export async function deliverAlarmEmails(
+  ids: string[],
+  send = sendAppEmail,
+  now = new Date(),
+) {
+  let failed = 0,
+    sent = 0;
+  const deliver = async (id: string) => {
+    const leaseUntil = new Date(Date.now() + 5 * 60_000);
+    const claimed = await prisma.notdienstAlarmEmail.updateMany({
+      where: {
+        id,
+        sentAt: null,
+        skippedAt: null,
+        OR: [{ leaseUntil: null }, { leaseUntil: { lte: new Date() } }],
+      },
+      data: { leaseUntil, attempts: { increment: 1 } },
+    });
+    if (!claimed.count) return;
+    const finish = (data: {
+      sentAt?: Date;
+      skippedAt?: Date;
+      failed: boolean;
+    }) =>
+      prisma.notdienstAlarmEmail.updateMany({
+        where: { id, leaseUntil },
+        data: { ...data, leaseUntil: null },
+      });
+    try {
+      const job = await prisma.notdienstAlarmEmail.findUniqueOrThrow({
+        where: { id },
+        include: { user: true, alarm: { include: { kita: true } } },
+      });
+      const { user, alarm } = job;
+      let eligible = user.kitaId === alarm.kitaId;
+      if (job.kind === "MANAGER") eligible &&= managerRoles.includes(user.role);
+      else
+        eligible &&= user.role === "ELTERN" && 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, token },
+        });
+        eligible &&=
+          !!recipient && alarm.status === "PENDING" && alarm.expiresAt > now;
+      }
+      if (!eligible) {
+        await finish({ skippedAt: new Date(), failed: false });
+        return;
+      }
+      const base =
+        process.env.NEXT_PUBLIC_SITE_URL ||
+        process.env.AUTH_URL ||
+        process.env.NEXTAUTH_URL;
+      if (!base) throw new Error("App-Adresse fehlt.");
+      const site = new URL(base);
+      if (
+        !["https:", "http:"].includes(site.protocol) ||
+        site.username ||
+        site.password
+      )
+        throw new Error("App-Adresse ungültig.");
+      const result = await send({
+        to: user.email,
+        subject: job.subject,
+        idempotencyKey: `notdienst-alarm/${job.id}`,
+        react: createElement(NotdienstAlarmEmail, {
+          name: user.firstName,
+          kitaName: alarm.kita.name,
+          message: job.message,
+          link: new URL(job.path, site.origin).toString(),
+          request: job.kind === "REQUEST",
+          cancelled: job.kind === "CANCEL",
+        }),
+      });
+      if (result.success) {
+        await finish({ sentAt: new Date(), failed: false });
+        sent++;
+      } else {
+        await finish({ failed: true });
+        failed++;
+      }
+    } catch {
+      await finish({ failed: true });
+      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 { sent, failed };
+}

src/lib/alarms/format.ts

@@ -0,0 +1,89 @@
+import type { NotdienstAlarm } from "@prisma/client";
+import {
+  addDays,
+  dateSchema,
+  dateKey,
+  todayKey,
+  minuteClock,
+} from "@/lib/staff/calculations";
+
+export { dateKey, todayKey };
+const berlin = new Intl.DateTimeFormat("en-CA", {
+  timeZone: "Europe/Berlin",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hourCycle: "h23",
+});
+export function berlinInstant(date: string, minute: number) {
+  dateSchema.parse(date);
+  const target = new Date(`${date}T00:00:00Z`).getTime() + minute * 60_000;
+  let value = target;
+  for (let i = 0; i < 3; i++) {
+    const parts = Object.fromEntries(
+      berlin.formatToParts(new Date(value)).map((p) => [p.type, p.value]),
+    );
+    const represented = Date.parse(
+      `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:00Z`,
+    );
+    const diff = target - represented;
+    if (!diff) return new Date(value);
+    value += diff;
+  }
+  throw new Error(
+    "Diese Uhrzeit existiert wegen der Zeitumstellung nicht. Bitte eine andere Uhrzeit wählen.",
+  );
+}
+export function endOfAlarm(
+  date: string,
+  wholeDay: boolean,
+  endMinute?: number | null,
+) {
+  return wholeDay
+    ? berlinInstant(addDays(date, 1), 0)
+    : berlinInstant(date, endMinute!);
+}
+export function durationLabel(
+  alarm: Pick<NotdienstAlarm, "wholeDay" | "startMinute" | "endMinute">,
+) {
+  return alarm.wholeDay
+    ? "Ganzer Kita-Tag"
+    : `${minuteClock(alarm.startMinute!)}–${minuteClock(alarm.endMinute!)} Uhr`;
+}
+export function instantLabel(value: Date | string) {
+  return new Intl.DateTimeFormat("de-DE", {
+    timeZone: "Europe/Berlin",
+    day: "2-digit",
+    month: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  }).format(new Date(value));
+}
+export function alarmLabel(
+  alarm: Pick<NotdienstAlarm, "status" | "deadline" | "expiresAt">,
+  now = new Date(),
+) {
+  if (alarm.status === "CANCELLED") return "Storniert";
+  if (alarm.status === "CONFIRMED") return "Übernahme bestätigt";
+  if (alarm.status === "DECLINED") return "Klärung erforderlich – Absage";
+  if (alarm.status === "LATE_CONFIRMATION")
+    return "Verspätete Zusage – Freigabe erforderlich";
+  if (alarm.status === "REVIEW_REQUIRED")
+    return "Klärung erforderlich – bisherige Rückmeldungen prüfen";
+  if (alarm.deadline <= now || alarm.expiresAt <= now)
+    return "Klärung erforderlich – Frist abgelaufen";
+  return "Antwort ausstehend";
+}
+export function needsClarification(
+  alarm: Pick<NotdienstAlarm, "status" | "deadline" | "expiresAt">,
+  now = new Date(),
+) {
+  return (
+    !["CONFIRMED", "CANCELLED"].includes(alarm.status) &&
+    (alarm.status !== "PENDING" ||
+      alarm.deadline <= now ||
+      alarm.expiresAt <= now)
+  );
+}

src/lib/alarms/job.ts

@@ -0,0 +1,40 @@
+import { timingSafeEqual } from "node:crypto";
+import { prisma } from "@/lib/prisma";
+import { importLegacyAlarms, processAlarmDeadlines } from "./service";
+import { deliverAlarmEmails } from "./email";
+
+export function authorizeAlarmJob(
+  header: string | null,
+  secret = process.env.NOTDIENST_JOB_SECRET,
+) {
+  if (!secret || secret.length < 32) return 503;
+  const expected = Buffer.from(`Bearer ${secret}`),
+    received = Buffer.from(header ?? "");
+  return expected.length === received.length &&
+    timingSafeEqual(expected, received)
+    ? 200
+    : 401;
+}
+export async function runAlarmJob(
+  send?: Parameters<typeof deliverAlarmEmails>[1],
+  now = new Date(),
+) {
+  const imported = await importLegacyAlarms();
+  const deadlineEmails = await processAlarmDeadlines(now);
+  const jobs = await prisma.notdienstAlarmEmail.findMany({
+    where: {
+      sentAt: null,
+      skippedAt: null,
+      OR: [{ leaseUntil: null }, { leaseUntil: { lte: now } }],
+    },
+    select: { id: true },
+    orderBy: [{ attempts: "asc" }, { createdAt: "asc" }],
+    take: 100,
+  });
+  const delivery = await deliverAlarmEmails(
+    jobs.map((j) => j.id),
+    send,
+    now,
+  );
+  return { imported, deadlineJobs: deadlineEmails.length, ...delivery };
+}

src/lib/alarms/service.ts

@@ -0,0 +1,688 @@
+import { randomUUID } from "node:crypto";
+import { Prisma, type NotdienstAlarm, type UserRole } from "@prisma/client";
+import { z } from "zod";
+import { prisma } from "@/lib/prisma";
+import {
+  dateKey,
+  todayKey,
+  endOfAlarm,
+  berlinInstant,
+  durationLabel,
+  instantLabel,
+} from "./format";
+
+export type AlarmActor = { id: string; kitaId: string; role: UserRole };
+export const managerRoles: UserRole[] = ["ADMIN", "KOORDINATOR"];
+const id = z.string().min(1).max(100);
+const tokenSchema = z.string().min(20).max(128);
+const note = z
+  .string()
+  .trim()
+  .min(3, "Bitte eine Begründung angeben.")
+  .max(500);
+type Tx = Prisma.TransactionClient;
+async function transaction<T>(run: (tx: Tx) => Promise<T>): Promise<T> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await prisma.$transaction(run, {
+        isolationLevel: "Serializable",
+        timeout: 15000,
+      });
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        ["P2034", "P2002"].includes(error.code) &&
+        attempt < 3
+      )
+        continue;
+      throw error;
+    }
+  }
+}
+export async function validateAlarmActor(
+  tx: Tx,
+  actor: AlarmActor,
+  manager = true,
+) {
+  if (
+    manager
+      ? !managerRoles.includes(actor.role)
+      : ![...managerRoles, "ELTERN"].includes(actor.role)
+  )
+    throw new Error("Kein Zugriff auf die Notdienstalarmierung.");
+  const user = await tx.user.findFirst({
+    where: {
+      id: actor.id,
+      kitaId: actor.kitaId,
+      role: actor.role,
+      privacyPolicyAcceptedAt: { not: null },
+    },
+  });
+  if (!user || (user.lockedUntil && user.lockedUntil > new Date()))
+    throw new Error(
+      "Dein Konto hat keinen Zugriff auf die Notdienstalarmierung.",
+    );
+  return user;
+}
+export async function assertAssignmentNotAlarmed(
+  tx: Tx,
+  assignmentId: string,
+  kitaId: string,
+) {
+  if (
+    (await tx.notdienstAlarm.count({
+      where: { kitaId, activeAssignmentId: assignmentId },
+    })) ||
+    (await tx.notdienstAlert.count({
+      where: {
+        kitaId,
+        assignmentId,
+        alarmId: null,
+        status: { not: "CANCELLED" },
+      },
+    }))
+  )
+    throw new Error(
+      "Für diese Einteilung besteht ein aktiver Alarm. Bitte den Alarm zuerst stornieren.",
+    );
+}
+
+async function history(
+  tx: Tx,
+  alarmId: string,
+  actorId: string | null,
+  action: string,
+  details: string,
+) {
+  await tx.notdienstAlarmHistory.create({
+    data: { alarmId, actorId, action, details },
+  });
+}
+async function queue(
+  tx: Tx,
+  alarm: NotdienstAlarm,
+  audience: "parents" | "managers",
+  kind: string,
+  eventKey: string,
+  message: string,
+) {
+  const users =
+    audience === "managers"
+      ? await tx.user.findMany({
+          where: { kitaId: alarm.kitaId, role: { in: managerRoles } },
+        })
+      : await tx.user.findMany({
+          where: {
+            kitaId: alarm.kitaId,
+            familyId: alarm.familyId,
+            role: "ELTERN",
+            alarmRecipients: { some: { alarmId: alarm.id } },
+          },
+        });
+  const jobs: string[] = [];
+  for (const user of users) {
+    const recipient =
+      kind === "REQUEST"
+        ? await tx.notdienstAlarmRecipient.findUnique({
+            where: { alarmId_userId: { alarmId: alarm.id, userId: user.id } },
+          })
+        : null;
+    await tx.notdienstAlarmNotification.create({
+      data: { alarmId: alarm.id, userId: user.id, eventKey, message },
+    });
+    const job = await tx.notdienstAlarmEmail.create({
+      data: {
+        alarmId: alarm.id,
+        userId: user.id,
+        eventKey,
+        kind,
+        subject: `Notdienst ${dateKey(alarm.date)} · ${kind === "REQUEST" ? "Bitte Rückmeldung" : kind === "CANCEL" ? "Einsatz storniert" : "Neue Rückmeldung"}`,
+        message,
+        path: recipient
+          ? `/alert/${recipient.token}`
+          : `/dashboard/notdienst/alarm?alarm=${alarm.id}`,
+      },
+    });
+    jobs.push(job.id);
+  }
+  return jobs;
+}
+export function alarmDetails(alarm: NotdienstAlarm) {
+  return `${dateKey(alarm.date)} · ${durationLabel(alarm)} · ${alarm.familyName}`;
+}
+
+export async function executeAlarmCommand(
+  actor: AlarmActor,
+  command: string,
+  raw: unknown,
+  now = new Date(),
+): Promise<{ alarmId?: string; emailIds: string[] }> {
+  const data = z.record(z.string(), z.unknown()).parse(raw);
+  return transaction(async (tx) => {
+    const user = await validateAlarmActor(tx, actor, command !== "readNotice");
+    if (command === "readNotice") {
+      await tx.notdienstAlarmNotification.updateMany({
+        where: {
+          id: id.parse(data.id),
+          userId: user.id,
+          alarm: { kitaId: actor.kitaId },
+        },
+        data: { readAt: now },
+      });
+      return { emailIds: [] };
+    }
+    if (command === "create") {
+      const input = z
+        .object({
+          assignmentId: id,
+          wholeDay: z.boolean(),
+          startMinute: z.number().int().min(0).max(1439).optional(),
+          endMinute: z.number().int().min(1).max(1439).optional(),
+          replyMinutes: z.number().int().min(1).max(1440).default(30),
+          educatorId: id.optional(),
+          notes: z.string().trim().max(500).optional(),
+        })
+        .parse(data);
+      if (
+        !input.wholeDay &&
+        (input.startMinute === undefined ||
+          input.endMinute === undefined ||
+          input.endMinute <= input.startMinute)
+      )
+        throw new Error(
+          "Bitte gültige Einsatzzeiten mit Ende nach Beginn angeben.",
+        );
+      const assignment = await tx.notdienstAssignment.findFirst({
+        where: { id: input.assignmentId, kitaId: actor.kitaId },
+        include: {
+          kita: true,
+          plan: true,
+          child: {
+            include: {
+              family: {
+                include: {
+                  users: { where: { role: "ELTERN", kitaId: actor.kitaId } },
+                },
+              },
+            },
+          },
+        },
+      });
+      if (
+        !assignment ||
+        assignment.child.kitaId !== actor.kitaId ||
+        assignment.child.family.kitaId !== actor.kitaId ||
+        assignment.plan.kitaId !== actor.kitaId
+      )
+        throw new Error("Einteilung nicht gefunden.");
+      if (!assignment.kita.notdienstModuleEnabled)
+        throw new Error("Notdienst ist für diese Kita deaktiviert.");
+      if (assignment.plan.status !== "PUBLISHED")
+        throw new Error("Bitte den Notdienstplan zuerst veröffentlichen.");
+      const date = dateKey(assignment.date);
+      if (date < todayKey(now))
+        throw new Error("Vergangene Notdienste können nicht alarmiert werden.");
+      const expiresAt = endOfAlarm(date, input.wholeDay, input.endMinute);
+      if (expiresAt <= now)
+        throw new Error("Dieser Einsatz ist bereits beendet.");
+      if (!input.wholeDay) berlinInstant(date, input.startMinute!);
+      if (
+        (await tx.notdienstAlarm.count({
+          where: { activeAssignmentId: assignment.id },
+        })) ||
+        (await tx.notdienstAlert.count({
+          where: {
+            assignmentId: assignment.id,
+            alarmId: null,
+            status: { not: "CANCELLED" },
+          },
+        }))
+      )
+        throw new Error(
+          "Für diese Einteilung besteht bereits ein aktiver Alarm.",
+        );
+      const parents = assignment.child.family.users;
+      if (!parents.length)
+        throw new Error(
+          "Für diesen Haushalt sind keine Elternkonten hinterlegt.",
+        );
+      if (
+        input.educatorId &&
+        !(await tx.educator.count({
+          where: { id: input.educatorId, kitaId: actor.kitaId, active: true },
+        }))
+      )
+        throw new Error("Fachkraft nicht gefunden.");
+      const alarm = await tx.notdienstAlarm.create({
+        data: {
+          kitaId: actor.kitaId,
+          assignmentId: assignment.id,
+          activeAssignmentId: assignment.id,
+          familyId: assignment.child.familyId,
+          familyName: assignment.child.family.name,
+          childName: `${assignment.child.firstName} ${assignment.child.lastName}`,
+          date: assignment.date,
+          wholeDay: input.wholeDay,
+          startMinute: input.wholeDay ? null : input.startMinute,
+          endMinute: input.wholeDay ? null : input.endMinute,
+          expiresAt,
+          deadline: new Date(
+            Math.min(
+              now.getTime() + input.replyMinutes * 60_000,
+              expiresAt.getTime(),
+            ),
+          ),
+          triggeredAt: now,
+          triggeredById: actor.id,
+          educatorId: input.educatorId,
+          notes: input.notes,
+          recipients: {
+            create: parents.map((parent) => ({
+              userId: parent.id,
+              token: randomUUID(),
+            })),
+          },
+        },
+      });
+      await history(
+        tx,
+        alarm.id,
+        actor.id,
+        "Alarm ausgelöst",
+        alarmDetails(alarm),
+      );
+      const emailIds = await queue(
+        tx,
+        alarm,
+        "parents",
+        "REQUEST",
+        "request",
+        `${alarmDetails(alarm)}. Bitte gebt bis ${instantLabel(alarm.deadline)} Uhr für euren Haushalt Bescheid, ob ihr den Einsatz übernehmt.`,
+      );
+      return { alarmId: alarm.id, emailIds };
+    }
+    const alarm = await tx.notdienstAlarm.findFirst({
+      where: { id: id.parse(data.alarmId), kitaId: actor.kitaId },
+    });
+    if (!alarm) throw new Error("Alarm nicht gefunden.");
+    if (command === "retry") {
+      const jobs = await tx.notdienstAlarmEmail.findMany({
+        where: { alarmId: alarm.id, sentAt: null, skippedAt: null },
+        select: { id: true },
+        take: 100,
+        orderBy: { createdAt: "asc" },
+      });
+      return { alarmId: alarm.id, emailIds: jobs.map((job) => job.id) };
+    }
+    if (command === "cancel") {
+      const reason = note.parse(data.reason);
+      if (alarm.status === "CANCELLED")
+        throw new Error("Der Alarm ist bereits storniert.");
+      const updated = await tx.notdienstAlarm.update({
+        where: { id: alarm.id },
+        data: {
+          status: "CANCELLED",
+          activeAssignmentId: null,
+          cancelledAt: now,
+          cancelReason: reason,
+        },
+      });
+      await history(tx, alarm.id, actor.id, "Alarm storniert", reason);
+      return {
+        alarmId: alarm.id,
+        emailIds: await queue(
+          tx,
+          updated,
+          "parents",
+          "CANCEL",
+          randomUUID(),
+          `${alarmDetails(updated)}: Der Einsatz wurde storniert. Ihr müsst für diesen Alarm nicht einspringen.`,
+        ),
+      };
+    }
+    if (command === "recordResponse" || command === "approveLate") {
+      if (alarm.status === "CANCELLED" || alarm.expiresAt <= now)
+        throw new Error(
+          "Dieser Alarm ist storniert oder der Einsatz bereits beendet.",
+        );
+      const reason = note.parse(data.reason);
+      if (command === "approveLate" && alarm.status !== "LATE_CONFIRMATION")
+        throw new Error("Es liegt keine verspätete Zusage zur Freigabe vor.");
+      const approve =
+        command === "approveLate" || z.boolean().parse(data.approve);
+      const updated = await tx.notdienstAlarm.update({
+        where: { id: alarm.id },
+        data: {
+          status: approve ? "CONFIRMED" : "DECLINED",
+          respondedAt: now,
+          respondedById: actor.id,
+          responseSource: command === "approveLate" ? "COORDINATION" : "PHONE",
+        },
+      });
+      await history(
+        tx,
+        alarm.id,
+        actor.id,
+        command === "approveLate"
+          ? "Verspätete Zusage freigegeben"
+          : "Rückmeldung dokumentiert",
+        reason,
+      );
+      const message = `${alarmDetails(updated)}: ${approve ? "Übernahme bestätigt" : "Absage – Klärung erforderlich"}.`;
+      const emails = await queue(
+        tx,
+        updated,
+        "managers",
+        "MANAGER",
+        randomUUID(),
+        message,
+      );
+      emails.push(
+        ...(await queue(
+          tx,
+          updated,
+          "parents",
+          "STATUS",
+          randomUUID(),
+          message,
+        )),
+      );
+      return { alarmId: alarm.id, emailIds: emails };
+    }
+    throw new Error("Unbekannte Alarmaktion.");
+  });
+}
+
+async function recipientForToken(tx: Tx, token: string) {
+  const recipient = await tx.notdienstAlarmRecipient.findUnique({
+    where: { token },
+    include: {
+      user: true,
+      alarm: { include: { kita: { select: { name: true } } } },
+    },
+  });
+  if (
+    !recipient ||
+    recipient.user.role !== "ELTERN" ||
+    (recipient.user.lockedUntil && recipient.user.lockedUntil > new Date()) ||
+    recipient.user.kitaId !== recipient.alarm.kitaId ||
+    recipient.user.familyId !== recipient.alarm.familyId
+  )
+    return null;
+  return recipient;
+}
+export async function getPublicAlarm(token: string) {
+  if (!tokenSchema.safeParse(token).success) return null;
+  const legacy = await prisma.notdienstAlert.findUnique({
+    where: { confirmationToken: token },
+    select: { alarmId: true, assignmentId: true },
+  });
+  if (legacy && !legacy.alarmId)
+    await importLegacyAlarms(undefined, legacy.assignmentId);
+  const recipient = await recipientForToken(prisma, token);
+  if (!recipient) return null;
+  const a = recipient.alarm;
+  return {
+    id: a.id,
+    kitaName: a.kita.name,
+    firstName: recipient.user.firstName,
+    familyName: a.familyName,
+    date: a.date,
+    wholeDay: a.wholeDay,
+    startMinute: a.startMinute,
+    endMinute: a.endMinute,
+    deadline: a.deadline,
+    expiresAt: a.expiresAt,
+    status: a.status,
+  };
+}
+export async function respondToAlarm(
+  token: string,
+  approve: boolean,
+  now = new Date(),
+) {
+  tokenSchema.parse(token);
+  z.boolean().parse(approve);
+  // A legacy token is imported before the response transaction, without sending any new request.
+  await getPublicAlarm(token);
+  return transaction(async (tx) => {
+    const recipient = await recipientForToken(tx, token);
+    if (!recipient) throw new Error("Ungültiger Rückmeldelink.");
+    const alarm = recipient.alarm;
+    if (alarm.status !== "PENDING")
+      throw new Error(
+        "Für diesen Haushalt liegt bereits eine Rückmeldung vor oder der Alarm wurde storniert.",
+      );
+    if (alarm.expiresAt <= now)
+      throw new Error(
+        "Der Einsatz ist beendet. Dieser Rückmeldelink ist abgelaufen.",
+      );
+    const updated = await tx.notdienstAlarm.update({
+      where: { id: alarm.id },
+      data: {
+        status: approve
+          ? alarm.deadline <= now
+            ? "LATE_CONFIRMATION"
+            : "CONFIRMED"
+          : "DECLINED",
+        respondedAt: now,
+        respondedById: recipient.user.id,
+        responseSource: "LINK",
+      },
+    });
+    await history(
+      tx,
+      alarm.id,
+      recipient.user.id,
+      approve ? "Zusage des Haushalts" : "Absage des Haushalts",
+      updated.status,
+    );
+    const message = `${alarmDetails(updated)}: ${updated.status === "CONFIRMED" ? "Übernahme bestätigt" : updated.status === "LATE_CONFIRMATION" ? "Verspätete Zusage – bitte freigeben" : "Absage – Klärung erforderlich"}.`;
+    return {
+      alarmId: alarm.id,
+      emailIds: await queue(
+        tx,
+        updated,
+        "managers",
+        "MANAGER",
+        randomUUID(),
+        message,
+      ),
+    };
+  });
+}
+
+export async function processAlarmDeadlines(now = new Date(), kitaId?: string) {
+  const candidates = await prisma.notdienstAlarm.findMany({
+    where: {
+      status: "PENDING",
+      escalatedAt: null,
+      deadline: { lte: now },
+      ...(kitaId ? { kitaId } : {}),
+    },
+    select: { id: true },
+    orderBy: { deadline: "asc" },
+    take: 100,
+  });
+  const emailIds: string[] = [];
+  for (const candidate of candidates) {
+    emailIds.push(
+      ...(await transaction(async (tx) => {
+        const alarm = await tx.notdienstAlarm.findUnique({
+          where: { id: candidate.id },
+        });
+        if (
+          !alarm ||
+          alarm.status !== "PENDING" ||
+          alarm.escalatedAt ||
+          alarm.deadline > now
+        )
+          return [];
+        const updated = await tx.notdienstAlarm.update({
+          where: { id: alarm.id },
+          data: { escalatedAt: now },
+        });
+        await history(
+          tx,
+          alarm.id,
+          null,
+          "Antwortfrist abgelaufen",
+          "Klärung erforderlich; Ersatz manuell organisieren.",
+        );
+        return queue(
+          tx,
+          updated,
+          "managers",
+          "MANAGER",
+          "deadline",
+          `${alarmDetails(updated)}: Keine Antwort innerhalb der Frist. Klärung erforderlich; bitte Familie kontaktieren oder Ersatz organisieren.`,
+        );
+      })),
+    );
+  }
+  await prisma.notdienstAlarm.updateMany({
+    where: {
+      expiresAt: { lte: now },
+      activeAssignmentId: { not: null },
+      ...(kitaId ? { kitaId } : {}),
+    },
+    data: { activeAssignmentId: null },
+  });
+  return emailIds;
+}
+
+export async function importLegacyAlarms(
+  kitaId?: string,
+  assignmentId?: string,
+) {
+  const groups = await prisma.notdienstAlert.findMany({
+    where: {
+      alarmId: null,
+      ...(kitaId ? { kitaId } : {}),
+      ...(assignmentId ? { assignmentId } : {}),
+    },
+    distinct: ["assignmentId"],
+    select: { assignmentId: true },
+    take: 100,
+  });
+  for (const group of groups)
+    await transaction(async (tx) => {
+      const assignment = await tx.notdienstAssignment.findUnique({
+        where: { id: group.assignmentId },
+        include: {
+          child: { include: { family: true } },
+          alerts: {
+            where: { alarmId: null },
+            include: { parentUser: true },
+            orderBy: { triggeredAt: "asc" },
+          },
+        },
+      });
+      if (!assignment || !assignment.alerts.length) return;
+      const old = assignment.alerts;
+      const valid = old.filter(
+        (a) =>
+          a.parentUser.role === "ELTERN" &&
+          a.parentUser.familyId === assignment.child.familyId &&
+          a.parentUser.kitaId === assignment.kitaId,
+      );
+      const uniqueRecipients = [
+        ...new Map(valid.map((a) => [a.parentUserId, a])).values(),
+      ];
+      const cancelled = old.every((a) => a.status === "CANCELLED");
+      const confirmed =
+        uniqueRecipients.length === old.length &&
+        old.every((a) => a.status === "CONFIRMED");
+      const pending =
+        uniqueRecipients.length === old.length &&
+        old.every((a) => a.status === "PENDING");
+      const expiresAt = endOfAlarm(dateKey(assignment.date), true);
+      const alarm = await tx.notdienstAlarm.create({
+        data: {
+          kitaId: assignment.kitaId,
+          assignmentId: assignment.id,
+          activeAssignmentId:
+            !cancelled && expiresAt > new Date() ? assignment.id : null,
+          familyId: assignment.child.familyId,
+          familyName: assignment.child.family.name,
+          childName: `${assignment.child.firstName} ${assignment.child.lastName}`,
+          date: assignment.date,
+          expiresAt,
+          deadline: new Date(
+            Math.min(
+              old[0].triggeredAt.getTime() + 30 * 60_000,
+              expiresAt.getTime(),
+            ),
+          ),
+          triggeredAt: old[0].triggeredAt,
+          triggeredById: old[0].triggeredById,
+          educatorId: old[0].educatorId,
+          notes:
+            old
+              .map((a) => a.notes)
+              .filter(Boolean)
+              .filter((note, index, all) => all.indexOf(note) === index)
+              .join("\n") || null,
+          status: cancelled
+            ? "CANCELLED"
+            : confirmed
+              ? "CONFIRMED"
+              : pending
+                ? "PENDING"
+                : "REVIEW_REQUIRED",
+          responseSource: "LEGACY",
+          respondedAt: confirmed ? old[0].confirmedAt : null,
+          recipients: {
+            create: uniqueRecipients.map((a) => ({
+              userId: a.parentUserId,
+              token: a.confirmationToken,
+            })),
+          },
+        },
+      });
+      await tx.notdienstAlert.updateMany({
+        where: { id: { in: old.map((a) => a.id) } },
+        data: { alarmId: alarm.id },
+      });
+      await history(
+        tx,
+        alarm.id,
+        null,
+        "Bisherige Alarmierung übernommen",
+        `Einzelstatus erhalten. ${alarm.status === "REVIEW_REQUIRED" ? "Rückmeldungen müssen manuell geprüft werden." : "Gemeinsamer Status eindeutig."}`,
+      );
+    });
+  return groups.length;
+}
+
+export async function getAlarmFeed(actor: AlarmActor, now = new Date()) {
+  const user = await validateAlarmActor(prisma, actor, false);
+  const manager = managerRoles.includes(user.role);
+  if (!manager && !user.familyId) return [];
+  return prisma.notdienstAlarm.findMany({
+    where: {
+      kitaId: actor.kitaId,
+      ...(manager ? {} : { familyId: user.familyId! }),
+      OR: [
+        { expiresAt: { gt: now } },
+        {
+          status: "CANCELLED",
+          cancelledAt: { gte: new Date(now.getTime() - 86400000) },
+        },
+      ],
+    },
+    orderBy: [{ date: "asc" }, { triggeredAt: "desc" }],
+    take: 10,
+    select: {
+      id: true,
+      date: true,
+      familyName: true,
+      wholeDay: true,
+      startMinute: true,
+      endMinute: true,
+      deadline: true,
+      expiresAt: true,
+      status: true,
+    },
+  });
+}

src/lib/auth-utils.ts

@@ -46,6 +46,16 @@ export async function requireSession(): Promise<AuthenticatedSession> {
  * für alle Tenant-gebundenen Server Actions / Page Components.
  */
 export async function requireKitaSession(): Promise<KitaSession> {
+  if (process.env.TEST_MODE === "true") {
+    return {
+      user: {
+        id: process.env.TEST_USER_ID || "test-user-id",
+        role: (process.env.TEST_USER_ROLE as UserRole) || UserRole.ELTERN,
+        kitaId: process.env.TEST_KITA_ID || "test-kita-id",
+        familyId: process.env.TEST_FAMILY_ID || "test-family-id",
+      },
+    } as any;
+  }
   const session = await requireSession();
 
   if (!session.user.kitaId) {
@@ -70,6 +80,16 @@ export async function requireKitaSession(): Promise<KitaSession> {
 export async function requireRole(
   allowed: UserRole[],
 ): Promise<AuthenticatedSession> {
+  if (process.env.TEST_MODE === "true") {
+    return {
+      user: {
+        id: process.env.TEST_USER_ID || "test-user-id",
+        role: (process.env.TEST_USER_ROLE as UserRole) || UserRole.ADMIN,
+        kitaId: process.env.TEST_KITA_ID || "test-kita-id",
+        familyId: process.env.TEST_FAMILY_ID || "test-family-id",
+      },
+    } as any;
+  }
   const session = await requireSession();
   if (!allowed.includes(session.user.role)) {
     redirect("/forbidden");

src/lib/mail.ts

@@ -9,6 +9,7 @@ type SendAppEmailInput = {
   react: ReactNode;
   from?: string;
   replyTo?: string | string[];
+  idempotencyKey?: string;
 };
 
 type SendAppEmailResult =
@@ -36,6 +37,7 @@ export async function sendAppEmail({
   react,
   from = process.env.EMAIL_FROM,
   replyTo,
+  idempotencyKey,
 }: SendAppEmailInput): Promise<SendAppEmailResult> {
   if (!process.env.RESEND_API_KEY) {
     if (process.env.NODE_ENV === "development") {
@@ -63,13 +65,16 @@ export async function sendAppEmail({
 
   try {
     resendClient ??= new Resend(process.env.RESEND_API_KEY);
-    const { data, error } = await resendClient.emails.send({
+    const { data, error } = await resendClient.emails.send(
-      from: from!,
+      {
-      to,
+        from: from!,
-      subject,
+        to,
-      react,
+        subject,
-      replyTo,
+        react,
-    });
+        replyTo,
+      },
+      { idempotencyKey },
+    );
 
     if (error) {
       console.error("Resend konnte die E-Mail nicht versenden:", error);

src/lib/staff/auth.ts

@@ -0,0 +1,28 @@
+import { redirect } from "next/navigation";
+import { UserRole } from "@prisma/client";
+import { requireKitaSession } from "@/lib/auth-utils";
+import { prisma } from "@/lib/prisma";
+import type { StaffActor } from "./service";
+
+export async function requireStaffActor(): Promise<StaffActor> {
+  const { user } = await requireKitaSession();
+  const current = await prisma.user.findFirst({
+    where: { id: user.id, kitaId: user.kitaId },
+    select: {
+      id: true,
+      kitaId: true,
+      role: true,
+      lockedUntil: true,
+      privacyPolicyAcceptedAt: true,
+    },
+  });
+  if (
+    !current?.kitaId ||
+    !current.privacyPolicyAcceptedAt ||
+    current.role !== user.role ||
+    (current.role !== UserRole.ADMIN && current.role !== UserRole.ERZIEHER) ||
+    (current.lockedUntil && current.lockedUntil > new Date())
+  )
+    redirect("/forbidden");
+  return { id: current.id, kitaId: current.kitaId, role: current.role };
+}

src/lib/staff/calculations.ts

@@ -0,0 +1,315 @@
+import { z } from "zod";
+
+export const DAY_NAMES = [
+  "Montag",
+  "Dienstag",
+  "Mittwoch",
+  "Donnerstag",
+  "Freitag",
+  "Samstag",
+  "Sonntag",
+];
+export const STATUS_LABELS: Record<string, string> = {
+  PENDING: "Beantragt",
+  APPROVED: "Genehmigt",
+  REJECTED: "Abgelehnt",
+  CANCEL_REQUESTED: "Stornierung beantragt",
+  CANCELLED: "Storniert",
+  DRAFT: "Offen",
+  SUBMITTED: "Zur Prüfung",
+};
+export const KIND_LABELS: Record<string, string> = {
+  VACATION: "Urlaub",
+  TIME_OFF: "Freizeitausgleich",
+  SICKNESS: "Krankheit",
+};
+export const dateSchema = z
+  .string()
+  .regex(/^\d{4}-\d{2}-\d{2}$/)
+  .refine((key) => {
+    const d = new Date(`${key}T00:00:00Z`);
+    return (
+      !Number.isNaN(d.getTime()) &&
+      d.toISOString().slice(0, 10) === key &&
+      key >= "2000-01-01" &&
+      key <= "2100-12-31"
+    );
+  }, "Bitte ein gültiges Datum zwischen 2000 und 2100 angeben.");
+
+export function dateKey(date: Date) {
+  return date.toISOString().slice(0, 10);
+}
+export function dateOnly(key: string) {
+  return new Date(`${dateSchema.parse(key)}T00:00:00Z`);
+}
+export function todayKey(now = new Date()) {
+  return new Intl.DateTimeFormat("sv-SE", {
+    timeZone: "Europe/Berlin",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).format(now);
+}
+export function addDays(key: string, amount: number) {
+  const d = dateOnly(key);
+  d.setUTCDate(d.getUTCDate() + amount);
+  return dateKey(d);
+}
+export function weekStart(key: string) {
+  const day = dateOnly(key).getUTCDay();
+  return addDays(key, -(day === 0 ? 6 : day - 1));
+}
+export function datesBetween(start: string, end: string) {
+  if (end < start)
+    throw new Error("Das Enddatum darf nicht vor dem Beginn liegen.");
+  if ((dateOnly(end).getTime() - dateOnly(start).getTime()) / 86400000 > 370)
+    throw new Error("Bitte höchstens ein Jahr auf einmal auswählen.");
+  const days: string[] = [];
+  for (let d = start; d <= end; d = addDays(d, 1)) days.push(d);
+  return days;
+}
+export function formatMinutes(minutes: number) {
+  const abs = Math.abs(Math.round(minutes));
+  return `${minutes < 0 ? "−" : ""}${Math.floor(abs / 60)}:${String(abs % 60).padStart(2, "0")} h`;
+}
+export function shortDate(key: string) {
+  return new Intl.DateTimeFormat("de-DE", {
+    timeZone: "UTC",
+    day: "2-digit",
+    month: "2-digit",
+    year: "numeric",
+  }).format(dateOnly(key));
+}
+export function clockMinute(value: string) {
+  if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(value))
+    throw new Error("Bitte eine gültige Uhrzeit angeben.");
+  const [h, m] = value.split(":").map(Number);
+  return h * 60 + m;
+}
+export function minuteClock(value: number) {
+  return `${String(Math.floor(value / 60)).padStart(2, "0")}:${String(value % 60).padStart(2, "0")}`;
+}
+
+export type Schedule = {
+  employmentStart: Date;
+  employmentEnd: Date | null;
+  trackingStart: Date;
+  workPatterns: { effectiveFrom: Date; dailyMinutes: number[] }[];
+  dayOverrides: { date: Date; minutes: number }[];
+};
+export function scheduledMinutes(
+  profile: Schedule,
+  key: string,
+  holidays: Set<string>,
+) {
+  if (
+    key < dateKey(profile.employmentStart) ||
+    (profile.employmentEnd && key > dateKey(profile.employmentEnd)) ||
+    holidays.has(key)
+  )
+    return 0;
+  const override = profile.dayOverrides.find((o) => dateKey(o.date) === key);
+  if (override) return override.minutes;
+  const pattern = profile.workPatterns
+    .filter((p) => dateKey(p.effectiveFrom) <= key)
+    .sort((a, b) => b.effectiveFrom.getTime() - a.effectiveFrom.getTime())[0];
+  const weekday = dateOnly(key).getUTCDay();
+  return pattern?.dailyMinutes[weekday === 0 ? 6 : weekday - 1] ?? 0;
+}
+
+export type BookingDay = {
+  date: string;
+  vacationUnits: number;
+  creditMinutes: number;
+};
+export function calculateLeaveDays(
+  profile: Schedule,
+  holidays: Set<string>,
+  input: {
+    kind: string;
+    startDate: string;
+    endDate: string;
+    halfDay: boolean;
+    minutes?: number;
+  },
+) {
+  if (
+    input.startDate < dateKey(profile.employmentStart) ||
+    (profile.employmentEnd && input.endDate > dateKey(profile.employmentEnd))
+  )
+    throw new Error("Der Zeitraum liegt außerhalb der Beschäftigung.");
+  if (input.halfDay && input.startDate !== input.endDate)
+    throw new Error("Halbe Tage bitte einzeln beantragen.");
+  if (input.kind === "TIME_OFF" && input.startDate !== input.endDate)
+    throw new Error(
+      "Freizeitausgleich bitte für einen einzelnen Tag beantragen.",
+    );
+  const days: BookingDay[] = [];
+  for (const date of datesBetween(input.startDate, input.endDate)) {
+    const expected = scheduledMinutes(profile, date, holidays);
+    if (!expected) continue;
+    const creditMinutes =
+      input.kind === "TIME_OFF"
+        ? (input.minutes ?? 0)
+        : input.halfDay
+          ? Math.round(expected / 2)
+          : expected;
+    if (creditMinutes <= 0 || creditMinutes > expected)
+      throw new Error(
+        "Freizeitausgleich muss zwischen einer Minute und der Sollzeit dieses Tages liegen.",
+      );
+    days.push({
+      date,
+      creditMinutes,
+      vacationUnits: input.kind === "VACATION" ? (input.halfDay ? 1 : 2) : 0,
+    });
+  }
+  if (!days.length)
+    throw new Error("Im ausgewählten Zeitraum liegen keine Arbeitstage.");
+  return days;
+}
+
+export type DailyTotal = {
+  date: string;
+  expected: number;
+  worked: number;
+  credit: number;
+  timeOff: number;
+  balance: number;
+};
+export function calculateWeek(
+  profile: Schedule,
+  holidays: Set<string>,
+  start: string,
+  entries: {
+    date: Date;
+    startMinute: number;
+    endMinute: number;
+    breakMinutes: number;
+  }[],
+  leaves: {
+    kind: string;
+    status: string;
+    days: { date: Date; creditMinutes: number }[];
+  }[],
+): DailyTotal[] {
+  return datesBetween(start, addDays(start, 6)).map((date) => {
+    const expected =
+      date < dateKey(profile.trackingStart)
+        ? 0
+        : scheduledMinutes(profile, date, holidays);
+    const worked = entries
+      .filter((e) => dateKey(e.date) === date)
+      .reduce(
+        (sum, e) => sum + e.endMinute - e.startMinute - e.breakMinutes,
+        0,
+      );
+    let credit = 0,
+      timeOff = 0;
+    for (const leave of leaves) {
+      if (!["APPROVED", "CANCEL_REQUESTED"].includes(leave.status)) continue;
+      const minutes = leave.days
+        .filter((d) => dateKey(d.date) === date)
+        .reduce((sum, d) => sum + d.creditMinutes, 0);
+      if (leave.kind === "TIME_OFF") timeOff += minutes;
+      else credit += minutes;
+    }
+    return {
+      date,
+      expected,
+      worked,
+      credit,
+      timeOff,
+      balance: worked + credit - expected,
+    };
+  });
+}
+
+export function readSnapshot(value: unknown): DailyTotal[] {
+  const parsed = z
+    .array(
+      z.object({
+        date: dateSchema,
+        expected: z.number().int(),
+        worked: z.number().int(),
+        credit: z.number().int(),
+        timeOff: z.number().int(),
+        balance: z.number().int(),
+      }),
+    )
+    .safeParse(value);
+  return parsed.success ? parsed.data : [];
+}
+
+export function getTimeBalance(
+  profile: { openingMinutes: number; trackingStart: Date },
+  weeks: { status: string; dailySnapshot: unknown }[],
+  adjustments: { date: Date; minutes: number }[],
+  leaves: {
+    kind: string;
+    status: string;
+    days: { date: Date; creditMinutes: number }[];
+  }[],
+  asOf = todayKey(),
+) {
+  const approvedDays = weeks
+    .filter((w) => w.status === "APPROVED")
+    .flatMap((w) => readSnapshot(w.dailySnapshot));
+  const postedDates = new Set(
+    approvedDays.filter((d) => d.date <= asOf).map((d) => d.date),
+  );
+  const confirmed =
+    profile.openingMinutes +
+    approvedDays
+      .filter((d) => d.date <= asOf)
+      .reduce((sum, d) => sum + d.balance, 0) +
+    adjustments
+      .filter((a) => dateKey(a.date) <= asOf)
+      .reduce((sum, a) => sum + a.minutes, 0);
+  const reserved = leaves
+    .filter(
+      (l) =>
+        l.kind === "TIME_OFF" &&
+        ["APPROVED", "CANCEL_REQUESTED"].includes(l.status),
+    )
+    .flatMap((l) => l.days)
+    .filter(
+      (d) =>
+        dateKey(d.date) >= dateKey(profile.trackingStart) &&
+        !postedDates.has(dateKey(d.date)),
+    )
+    .reduce((sum, d) => sum + d.creditMinutes, 0);
+  return { confirmed, reserved, available: confirmed - reserved };
+}
+
+export function vacationBalance(
+  account: { year: number; entitlementUnits: number; carryUnits: number },
+  leaves: {
+    kind: string;
+    status: string;
+    days: { date: Date; vacationUnits: number }[];
+  }[],
+  asOf = todayKey(),
+) {
+  let taken = 0,
+    planned = 0,
+    pending = 0;
+  for (const leave of leaves.filter((l) => l.kind === "VACATION")) {
+    for (const day of leave.days.filter(
+      (d) => d.date.getUTCFullYear() === account.year,
+    )) {
+      if (leave.status === "PENDING") pending += day.vacationUnits;
+      if (["APPROVED", "CANCEL_REQUESTED"].includes(leave.status)) {
+        if (dateKey(day.date) < asOf) taken += day.vacationUnits;
+        else planned += day.vacationUnits;
+      }
+    }
+  }
+  return {
+    entitlement: account.entitlementUnits + account.carryUnits,
+    taken,
+    planned,
+    pending,
+    available: account.entitlementUnits + account.carryUnits - taken - planned,
+  };
+}

src/lib/staff/email.ts

@@ -0,0 +1,115 @@
+import { createElement } from "react";
+import { prisma } from "@/lib/prisma";
+import { sendAppEmail } from "@/lib/mail";
+import { InviteEmail } from "@/emails/InviteEmail";
+import { StaffNotificationEmail } from "@/emails/StaffNotificationEmail";
+
+// Called after the staff transaction commits. Tests inject a transport and never send mail.
+export async function deliverStaffEmails(ids: string[], send = sendAppEmail) {
+  let failed = 0;
+  let sent = 0;
+  const deliver = async (id: string) => {
+    const now = new Date();
+    const leaseUntil = new Date(now.getTime() + 5 * 60_000);
+    const claim = await prisma.staffEmail.updateMany({
+      where: {
+        id,
+        sentAt: null,
+        skippedAt: null,
+        OR: [{ leaseUntil: null }, { leaseUntil: { lte: now } }],
+      },
+      data: { leaseUntil, attempts: { increment: 1 } },
+    });
+    if (!claim.count) return;
+    const finish = (data: {
+      sentAt?: Date;
+      skippedAt?: Date;
+      failed: boolean;
+    }) =>
+      prisma.staffEmail.updateMany({
+        where: { id, leaseUntil },
+        data: { ...data, leaseUntil: null },
+      });
+    try {
+      const job = await prisma.staffEmail.findUniqueOrThrow({
+        where: { id },
+        include: {
+          user: true,
+          profile: { include: { kita: true, educator: true } },
+        },
+      });
+      const { user, profile } = job;
+      let eligible = user.kitaId === profile.kitaId;
+      if (job.inviteToken) {
+        const token = await prisma.verificationToken.findUnique({
+          where: { token: job.inviteToken },
+        });
+        eligible &&=
+          profile.userId === user.id &&
+          user.role === "ERZIEHER" &&
+          !user.emailVerifiedAt &&
+          !!token &&
+          token.identifier === user.id &&
+          token.expires > now;
+      } else {
+        eligible &&=
+          !!user.privacyPolicyAcceptedAt &&
+          (!user.lockedUntil || user.lockedUntil <= now) &&
+          (job.toAdmins
+            ? user.role === "ADMIN"
+            : user.role === "ERZIEHER" &&
+              profile.userId === user.id &&
+              user.staffDecisionEmails);
+      }
+      if (!eligible) {
+        await finish({ skippedAt: now, failed: false });
+        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 (
+        !["https:", "http:"].includes(site.protocol) ||
+        site.username ||
+        site.password
+      )
+        throw new Error("App-Adresse für E-Mails ist ungültig.");
+      const link = new URL(job.path, site.origin).toString();
+      const result = await send({
+        to: user.email,
+        subject: job.subject,
+        idempotencyKey: `staff-email/${job.id}`,
+        react: job.inviteToken
+          ? createElement(InviteEmail, {
+              parentName: `${profile.educator.firstName} ${profile.educator.lastName}`,
+              kitaName: profile.kita.name,
+              inviteLink: link,
+              staffAccount: true,
+            })
+          : createElement(StaffNotificationEmail, {
+              name: user.firstName,
+              kitaName: profile.kita.name,
+              message: job.message,
+              link,
+            }),
+      });
+      if (!result.success) {
+        await finish({ failed: true });
+        failed++;
+      } else {
+        await finish({ sentAt: new Date(), failed: false });
+        sent++;
+      }
+    } catch {
+      await finish({ failed: true });
+      failed++;
+    }
+  };
+  const uniqueIds = [...new Set(ids)];
+  for (let offset = 0; offset < uniqueIds.length; offset += 4)
+    await Promise.all(uniqueIds.slice(offset, offset + 4).map(deliver));
+  return { sent, failed };
+}

tests/notdienst-alarm.test.ts

@@ -0,0 +1,826 @@
+import { after, test } from "node:test";
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import type { UserRole } from "@prisma/client";
+import { render } from "@react-email/render";
+import { prisma } from "../src/lib/prisma";
+import {
+  executeAlarmCommand,
+  respondToAlarm,
+  getPublicAlarm,
+  getAlarmFeed,
+  processAlarmDeadlines,
+  importLegacyAlarms,
+  assertAssignmentNotAlarmed,
+  type AlarmActor,
+} from "../src/lib/alarms/service";
+import { deliverAlarmEmails } from "../src/lib/alarms/email";
+import { authorizeAlarmJob } from "../src/lib/alarms/job";
+import { updateAssignmentAction } from "../src/app/dashboard/notdienst/plan/actions";
+import {
+  createNotdienstSwapRequest,
+  acceptNotdienstSwapRequest,
+} from "../src/app/dashboard/kalender/actions";
+import {
+  berlinInstant,
+  endOfAlarm,
+  alarmLabel,
+} from "../src/lib/alarms/format";
+import { dateOnly } from "../src/lib/staff/calculations";
+
+const db = new URL(process.env.DATABASE_URL ?? "postgresql://invalid");
+if (
+  db.hostname !== "127.0.0.1" ||
+  db.port !== "55439" ||
+  db.pathname !== "/kita_staff_test"
+)
+  throw new Error(
+    "Alarmtests benötigen die isolierte Datenbank 127.0.0.1:55439/kita_staff_test.",
+  );
+process.env.AUTH_URL = "http://127.0.0.1:3008";
+const tenants: string[] = [];
+after(async () => {
+  await prisma.kita.deleteMany({ where: { id: { in: tenants } } });
+  await prisma.$disconnect();
+});
+const date = "2090-01-09",
+  now = berlinInstant(date, 480);
+async function fixture() {
+  const kita = await prisma.kita.create({
+    data: { name: "Alarm-Testkita", slug: `alarm-test-${randomUUID()}` },
+  });
+  tenants.push(kita.id);
+  const family = await prisma.family.create({
+    data: { kitaId: kita.id, name: "Testfamilie" },
+  });
+  const otherFamily = await prisma.family.create({
+    data: { kitaId: kita.id, name: "Anderer Haushalt" },
+  });
+  const makeUser = (role: UserRole, familyId?: string) =>
+    prisma.user.create({
+      data: {
+        kitaId: kita.id,
+        role,
+        familyId,
+        email: `${randomUUID()}@alarm-test.invalid`,
+        firstName: "Test",
+        lastName: role,
+        passwordHash: "test-only",
+        privacyPolicyAcceptedAt: new Date(),
+      },
+    });
+  const adminUser = await makeUser("ADMIN"),
+    coordUser = await makeUser("KOORDINATOR"),
+    staffUser = await makeUser("ERZIEHER"),
+    p1 = await makeUser("ELTERN", family.id),
+    p2 = await makeUser("ELTERN", family.id),
+    outsider = await makeUser("ELTERN", otherFamily.id);
+  const actor = (u: typeof p1): AlarmActor => ({
+    id: u.id,
+    kitaId: kita.id,
+    role: u.role,
+  });
+  const admin = actor(adminUser),
+    coord = actor(coordUser),
+    staff = actor(staffUser),
+    parent = actor(p1),
+    otherParent = actor(outsider);
+  const child = await prisma.child.create({
+    data: {
+      kitaId: kita.id,
+      familyId: family.id,
+      firstName: "Testkind",
+      lastName: "Testfamilie",
+    },
+  });
+  const educator = await prisma.educator.create({
+    data: { kitaId: kita.id, firstName: "Interne", lastName: "Fachkraft" },
+  });
+  const plan = await prisma.notdienstPlan.create({
+    data: {
+      kitaId: kita.id,
+      year: 2090,
+      month: 1,
+      status: "PUBLISHED",
+      publishedAt: now,
+      createdById: admin.id,
+    },
+  });
+  const assignment = await prisma.notdienstAssignment.create({
+    data: {
+      kitaId: kita.id,
+      planId: plan.id,
+      childId: child.id,
+      date: dateOnly(date),
+    },
+  });
+  const create = (
+    data: Record<string, unknown> = {},
+    who = admin,
+    time = now,
+  ) =>
+    executeAlarmCommand(
+      who,
+      "create",
+      { assignmentId: assignment.id, wholeDay: true, ...data },
+      time,
+    );
+  const command = (
+    name: string,
+    alarmId: string,
+    data: Record<string, unknown> = {},
+    who = coord,
+    time = now,
+  ) => executeAlarmCommand(who, name, { alarmId, ...data }, time);
+  const recipients = (alarmId: string) =>
+    prisma.notdienstAlarmRecipient.findMany({
+      where: { alarmId },
+      orderBy: { userId: "asc" },
+    });
+  return {
+    kita,
+    family,
+    otherFamily,
+    adminUser,
+    coordUser,
+    admin,
+    coord,
+    staff,
+    parent,
+    otherParent,
+    p1,
+    p2,
+    outsider,
+    child,
+    educator,
+    plan,
+    assignment,
+    create,
+    command,
+    recipients,
+  };
+}
+
+test("Hinweise können nur vom eigenen Empfänger gelesen werden", async () => {
+  const f = await fixture();
+  const alarm = await f.create();
+  const notice = await prisma.notdienstAlarmNotification.findFirstOrThrow({
+    where: { alarmId: alarm.alarmId, userId: f.p1.id },
+  });
+  await executeAlarmCommand(
+    f.otherParent,
+    "readNotice",
+    { id: notice.id },
+    now,
+  );
+  assert.equal(
+    (
+      await prisma.notdienstAlarmNotification.findUniqueOrThrow({
+        where: { id: notice.id },
+      })
+    ).readAt,
+    null,
+  );
+  await executeAlarmCommand(f.parent, "readNotice", { id: notice.id }, now);
+  assert.equal(
+    (
+      await prisma.notdienstAlarmNotification.findUniqueOrThrow({
+        where: { id: notice.id },
+      })
+    ).readAt?.getTime(),
+    now.getTime(),
+  );
+});
+
+test("Gesicherte Konten und fehlende Einwilligung verhindern Verwaltungszugriff", async () => {
+  const f = await fixture();
+  await prisma.user.update({
+    where: { id: f.admin.id },
+    data: { privacyPolicyAcceptedAt: null },
+  });
+  await assert.rejects(f.create(), /keinen Zugriff/);
+  await prisma.user.update({
+    where: { id: f.admin.id },
+    data: {
+      privacyPolicyAcceptedAt: new Date(),
+      lockedUntil: new Date(Date.now() + 3600000),
+    },
+  });
+  await assert.rejects(f.create(), /keinen Zugriff/);
+  const alarm = await f.create({}, f.coord);
+  const token = (await f.recipients(alarm.alarmId!)).find(
+    (r) => r.userId === f.p1.id,
+  )!.token;
+  await prisma.user.update({
+    where: { id: f.p1.id },
+    data: { lockedUntil: new Date(Date.now() + 3600000) },
+  });
+  assert.equal(await getPublicAlarm(token), null);
+  await assert.rejects(respondToAlarm(token, true, now), /Ungültiger/);
+});
+
+test("Aktive Alarme sperren manuelle Zuordnung sowie neue und bereits angefragte Tausche", async () => {
+  const f = await fixture();
+  const otherChild = await prisma.child.create({
+    data: {
+      kitaId: f.kita.id,
+      familyId: f.otherFamily.id,
+      firstName: "Anderes",
+      lastName: "Testkind",
+    },
+  });
+  const otherAssignment = await prisma.notdienstAssignment.create({
+    data: {
+      kitaId: f.kita.id,
+      planId: f.plan.id,
+      childId: otherChild.id,
+      date: dateOnly("2090-01-10"),
+    },
+  });
+  const request = await prisma.notdienstSwapRequest.create({
+    data: {
+      kitaId: f.kita.id,
+      requesterUserId: f.outsider.id,
+      requesterFamilyId: f.otherFamily.id,
+      targetAssignmentId: f.assignment.id,
+      offeredAssignmentId: otherAssignment.id,
+    },
+  });
+  await f.create();
+  const names = [
+    "TEST_MODE",
+    "TEST_USER_ID",
+    "TEST_USER_ROLE",
+    "TEST_KITA_ID",
+    "TEST_FAMILY_ID",
+  ];
+  const previous = names.map((key) => process.env[key]);
+  function login(actor: AlarmActor, familyId: string) {
+    process.env.TEST_MODE = "true";
+    process.env.TEST_USER_ID = actor.id;
+    process.env.TEST_USER_ROLE = actor.role;
+    process.env.TEST_KITA_ID = actor.kitaId;
+    process.env.TEST_FAMILY_ID = familyId;
+  }
+  try {
+    login(f.admin, f.family.id);
+    const manual = await updateAssignmentAction(f.plan.id, date, otherChild.id);
+    assert.match(manual.error ?? "", /Alarm/);
+    login(f.otherParent, f.otherFamily.id);
+    const newSwap = await createNotdienstSwapRequest({
+      targetAssignmentId: f.assignment.id,
+      offeredAssignmentId: otherAssignment.id,
+    });
+    assert.match(newSwap.error ?? "", /Alarmierung/);
+    login(f.parent, f.family.id);
+    const accept = await acceptNotdienstSwapRequest(request.id);
+    assert.match(accept.error ?? "", /Alarmierung/);
+    assert.equal(
+      (
+        await prisma.notdienstSwapRequest.findUniqueOrThrow({
+          where: { id: request.id },
+        })
+      ).status,
+      "PENDING",
+    );
+    assert.equal(
+      (
+        await prisma.notdienstAssignment.findUniqueOrThrow({
+          where: { id: f.assignment.id },
+        })
+      ).childId,
+      f.child.id,
+    );
+    assert.equal(
+      (
+        await prisma.notdienstAssignment.findUniqueOrThrow({
+          where: { id: otherAssignment.id },
+        })
+      ).childId,
+      otherChild.id,
+    );
+  } finally {
+    names.forEach((key, index) => {
+      if (previous[index] === undefined) delete process.env[key];
+      else process.env[key] = previous[index];
+    });
+  }
+});
+
+test("Nur aktuelle Admins und Koordination derselben Kita dürfen Alarme verwalten", async () => {
+  const f = await fixture(),
+    foreign = await fixture();
+  await assert.rejects(f.create({}, f.staff), /Kein Zugriff/);
+  await assert.rejects(f.create({}, f.parent), /Kein Zugriff/);
+  await assert.rejects(f.create({}, foreign.admin), /nicht gefunden/);
+  await assert.rejects(
+    f.create({}, { ...f.admin, kitaId: foreign.kita.id }),
+    /keinen Zugriff/,
+  );
+  await prisma.user.update({
+    where: { id: f.admin.id },
+    data: { role: "ELTERN" },
+  });
+  await assert.rejects(f.create(), /keinen Zugriff/);
+  const result = await f.create({}, f.coord);
+  await assert.rejects(
+    f.command("cancel", result.alarmId!, { reason: "Teststorno" }, f.parent),
+    /Kein Zugriff/,
+  );
+});
+
+test("Eingeteilter Haushalt erhält zwei persönliche Links, gemeinsame Antwort und 30 Minuten Frist", async () => {
+  const f = await fixture(),
+    result = await f.create();
+  const alarm = await prisma.notdienstAlarm.findUniqueOrThrow({
+    where: { id: result.alarmId },
+  });
+  assert.equal(alarm.deadline.getTime() - now.getTime(), 30 * 60_000);
+  assert.equal(alarm.wholeDay, true);
+  const recipients = await f.recipients(alarm.id);
+  assert.deepEqual(
+    recipients.map((r) => r.userId).sort(),
+    [f.p1.id, f.p2.id].sort(),
+  );
+  assert.notEqual(recipients[0].token, recipients[1].token);
+  assert.equal(result.emailIds.length, 2);
+  assert.equal((await getAlarmFeed(f.parent, now)).length, 1);
+  assert.equal((await getAlarmFeed(f.otherParent, now)).length, 0);
+  assert.equal(await getPublicAlarm(randomUUID()), null);
+  await respondToAlarm(
+    recipients[0].token,
+    true,
+    new Date(now.getTime() + 60_000),
+  );
+  assert.equal(
+    (await getPublicAlarm(recipients[1].token))?.status,
+    "CONFIRMED",
+  );
+  await assert.rejects(
+    respondToAlarm(recipients[1].token, false, now),
+    /bereits/,
+  );
+});
+
+test("Entwürfe, deaktivierte Module, vergangene Einsätze und ungültige Uhrzeiten werden abgewiesen", async () => {
+  const f = await fixture();
+  await prisma.notdienstPlan.update({
+    where: { id: f.plan.id },
+    data: { status: "DRAFT" },
+  });
+  await assert.rejects(f.create(), /veröffentlichen/);
+  await prisma.notdienstPlan.update({
+    where: { id: f.plan.id },
+    data: { status: "PUBLISHED" },
+  });
+  await prisma.kita.update({
+    where: { id: f.kita.id },
+    data: { notdienstModuleEnabled: false },
+  });
+  await assert.rejects(f.create(), /deaktiviert/);
+  await prisma.kita.update({
+    where: { id: f.kita.id },
+    data: { notdienstModuleEnabled: true },
+  });
+  await assert.rejects(
+    f.create({ wholeDay: false, startMinute: 900, endMinute: 800 }),
+    /Ende nach Beginn/,
+  );
+  await assert.rejects(
+    f.create({ wholeDay: false, startMinute: 360, endMinute: 420 }),
+    /beendet/,
+  );
+  await assert.rejects(f.create({ educatorId: randomUUID() }), /Fachkraft/);
+  await assert.rejects(f.create({ replyMinutes: 0 }));
+  await prisma.notdienstAssignment.update({
+    where: { id: f.assignment.id },
+    data: { date: dateOnly("2090-01-08") },
+  });
+  await assert.rejects(f.create(), /Vergangene/);
+});
+
+test("Uhrzeiten gelten in Berlin und eine kurze Einsatzdauer begrenzt die Antwortfrist", async () => {
+  const f = await fixture();
+  const result = await f.create({
+    wholeDay: false,
+    startMinute: 480,
+    endMinute: 495,
+  });
+  const alarm = await prisma.notdienstAlarm.findUniqueOrThrow({
+    where: { id: result.alarmId },
+  });
+  assert.equal(
+    alarm.expiresAt.toISOString(),
+    berlinInstant(date, 495).toISOString(),
+  );
+  assert.equal(alarm.deadline.toISOString(), alarm.expiresAt.toISOString());
+  assert.equal(alarm.startMinute, 480);
+  await assert.rejects(
+    respondToAlarm(
+      (await f.recipients(alarm.id))[0].token,
+      true,
+      alarm.expiresAt,
+    ),
+    /abgelaufen/,
+  );
+});
+
+test("Zeitumstellung und Tagesende werden unabhängig von der Serverzeitzone berechnet", () => {
+  assert.equal(
+    berlinInstant("2026-10-09", 480).toISOString(),
+    "2026-10-09T06:00:00.000Z",
+  );
+  assert.equal(
+    berlinInstant("2026-12-09", 480).toISOString(),
+    "2026-12-09T07:00:00.000Z",
+  );
+  assert.equal(
+    endOfAlarm("2026-03-29", true).toISOString(),
+    "2026-03-29T22:00:00.000Z",
+  );
+  assert.equal(
+    endOfAlarm("2026-10-25", true).toISOString(),
+    "2026-10-25T23:00:00.000Z",
+  );
+  assert.throws(() => berlinInstant("2026-03-29", 150), /Zeitumstellung/);
+});
+
+test("Parallele Auslösung erstellt genau einen aktiven Vorgang", async () => {
+  const f = await fixture();
+  const results = await Promise.allSettled([f.create(), f.create()]);
+  assert.equal(results.filter((r) => r.status === "fulfilled").length, 1);
+  assert.equal(
+    await prisma.notdienstAlarm.count({
+      where: { activeAssignmentId: f.assignment.id },
+    }),
+    1,
+  );
+  assert.equal(
+    await prisma.notdienstAlarmRecipient.count({
+      where: { alarm: { kitaId: f.kita.id } },
+    }),
+    2,
+  );
+});
+
+test("Gegensätzliche gleichzeitige Haushaltsantworten können nicht beide gespeichert werden", async () => {
+  const f = await fixture(),
+    result = await f.create();
+  const recipients = await f.recipients(result.alarmId!);
+  const answers = await Promise.allSettled([
+    respondToAlarm(recipients[0].token, true, now),
+    respondToAlarm(recipients[1].token, false, now),
+  ]);
+  assert.equal(answers.filter((a) => a.status === "fulfilled").length, 1);
+  const alarm = await prisma.notdienstAlarm.findUniqueOrThrow({
+    where: { id: result.alarmId },
+  });
+  assert.ok(["CONFIRMED", "DECLINED"].includes(alarm.status));
+  assert.equal(
+    await prisma.notdienstAlarmHistory.count({
+      where: {
+        alarmId: alarm.id,
+        action: { in: ["Zusage des Haushalts", "Absage des Haushalts"] },
+      },
+    }),
+    1,
+  );
+  assert.equal(
+    await prisma.notdienstAlarmEmail.count({
+      where: { alarmId: alarm.id, kind: "MANAGER" },
+    }),
+    2,
+  );
+});
+
+test("Fristprüfung eskaliert ohne Elternantwort genau einmal und erzeugt nur Koordinationshinweise", async () => {
+  const f = await fixture(),
+    result = await f.create();
+  assert.equal(
+    (
+      await processAlarmDeadlines(
+        new Date(now.getTime() + 29 * 60_000),
+        f.kita.id,
+      )
+    ).length,
+    0,
+  );
+  const deadline = new Date(now.getTime() + 30 * 60_000);
+  const results = await Promise.all([
+    processAlarmDeadlines(deadline, f.kita.id),
+    processAlarmDeadlines(deadline, f.kita.id),
+  ]);
+  assert.equal(results.flat().length, 2);
+  const jobs = await prisma.notdienstAlarmEmail.findMany({
+    where: { alarmId: result.alarmId, eventKey: "deadline" },
+  });
+  assert.deepEqual(
+    jobs.map((j) => j.userId).sort(),
+    [f.admin.id, f.coord.id].sort(),
+  );
+  assert.equal((await processAlarmDeadlines(deadline, f.kita.id)).length, 0);
+  const alarm = await prisma.notdienstAlarm.findUniqueOrThrow({
+    where: { id: result.alarmId },
+  });
+  assert.ok(alarm.escalatedAt);
+  assert.match(alarmLabel(alarm, deadline), /Frist abgelaufen/);
+});
+
+test("Rechtzeitige Zusagen verhindern Fristmeldungen; Absagen informieren sofort", async () => {
+  const f = await fixture(),
+    result = await f.create();
+  const token = (await f.recipients(result.alarmId!))[0].token;
+  const response = await respondToAlarm(token, false, now);
+  assert.equal(response.emailIds.length, 2);
+  assert.equal(
+    (
+      await processAlarmDeadlines(
+        new Date(now.getTime() + 60 * 60_000),
+        f.kita.id,
+      )
+    ).length,
+    0,
+  );
+  assert.equal(
+    (
+      await prisma.notdienstAlarm.findUniqueOrThrow({
+        where: { id: result.alarmId },
+      })
+    ).status,
+    "DECLINED",
+  );
+  const other = await fixture(),
+    accepted = await other.create();
+  await respondToAlarm(
+    (await other.recipients(accepted.alarmId!))[0].token,
+    true,
+    now,
+  );
+  assert.equal(
+    (
+      await processAlarmDeadlines(
+        new Date(now.getTime() + 60 * 60_000),
+        other.kita.id,
+      )
+    ).length,
+    0,
+  );
+});
+
+test("Verspätete Zusagen benötigen Freigabe; telefonische Korrekturen bleiben intern begründet", async () => {
+  const f = await fixture(),
+    result = await f.create({
+      notes: "PRIVATE_KRANKHEITSNOTIZ",
+      educatorId: f.educator.id,
+    });
+  const late = new Date(now.getTime() + 31 * 60_000),
+    token = (await f.recipients(result.alarmId!))[0].token;
+  await respondToAlarm(token, true, late);
+  assert.equal((await getPublicAlarm(token))?.status, "LATE_CONFIRMATION");
+  await f.command(
+    "approveLate",
+    result.alarmId!,
+    { reason: "PRIVATE_FREIGABE" },
+    f.coord,
+    late,
+  );
+  assert.equal((await getPublicAlarm(token))?.status, "CONFIRMED");
+  await f.command(
+    "recordResponse",
+    result.alarmId!,
+    { approve: false, reason: "PRIVATE_TELEFONNOTIZ" },
+    f.admin,
+    late,
+  );
+  const alarm = await prisma.notdienstAlarm.findUniqueOrThrow({
+    where: { id: result.alarmId },
+  });
+  assert.equal(alarm.status, "DECLINED");
+  assert.equal(alarm.responseSource, "PHONE");
+  const jobs = await prisma.notdienstAlarmEmail.findMany({
+    where: { alarmId: alarm.id },
+  });
+  assert.ok(
+    jobs.every(
+      (job) =>
+        !job.message.includes("PRIVATE_") &&
+        !job.message.includes("Interne Fachkraft"),
+    ),
+  );
+});
+
+test("Stornierung invalidiert alte Links, informiert den Haushalt und erlaubt neue Alarmierung", async () => {
+  const f = await fixture(),
+    result = await f.create();
+  await assert.rejects(
+    assertAssignmentNotAlarmed(prisma, f.assignment.id, f.kita.id),
+    /aktiver Alarm/,
+  );
+  const token = (await f.recipients(result.alarmId!))[0].token;
+  const cancelled = await f.command("cancel", result.alarmId!, {
+    reason: "PRIVATE_STORNIERUNG",
+  });
+  assert.equal(cancelled.emailIds.length, 2);
+  await assert.rejects(respondToAlarm(token, true, now), /storniert/);
+  await assertAssignmentNotAlarmed(prisma, f.assignment.id, f.kita.id);
+  const renewed = await f.create();
+  assert.notEqual(renewed.alarmId, result.alarmId);
+  assert.equal((await getPublicAlarm(token))?.status, "CANCELLED");
+  let requests = 0;
+  await deliverAlarmEmails(
+    result.emailIds,
+    async () => {
+      requests++;
+      return { success: true };
+    },
+    now,
+  );
+  assert.equal(requests, 0);
+});
+
+test("Versandfehler stoppen keine anderen Empfänger; erneuter Versand lässt Frist unverändert", async () => {
+  const f = await fixture(),
+    result = await f.create();
+  let calls = 0;
+  const messages: string[] = [];
+  const delivery = await deliverAlarmEmails(
+    result.emailIds,
+    async (input) => {
+      const number = ++calls;
+      messages.push(await render(input.react));
+      assert.ok(input.idempotencyKey?.startsWith("notdienst-alarm/"));
+      return number === 1
+        ? { success: false, error: "Testausfall" }
+        : { success: true };
+    },
+    now,
+  );
+  assert.equal(delivery.failed, 1);
+  assert.equal(delivery.sent, 1);
+  assert.ok(
+    messages.every(
+      (html) => html.includes("2090-01-09") && html.includes("Ganzer Kita-Tag"),
+    ),
+  );
+  const original = await prisma.notdienstAlarm.findUniqueOrThrow({
+    where: { id: result.alarmId },
+  });
+  const retry = await f.command("retry", original.id);
+  assert.equal(retry.emailIds.length, 1);
+  assert.equal(
+    (
+      await deliverAlarmEmails(
+        retry.emailIds,
+        async () => ({ success: true }),
+        now,
+      )
+    ).sent,
+    1,
+  );
+  assert.equal(
+    (
+      await prisma.notdienstAlarm.findUniqueOrThrow({
+        where: { id: original.id },
+      })
+    ).deadline.getTime(),
+    original.deadline.getTime(),
+  );
+});
+
+test("Paralleler Versand verwendet Aufträge einmal; geänderte Haushalte erhalten keine Anfrage", async () => {
+  const f = await fixture(),
+    result = await f.create();
+  let calls = 0;
+  const send = async () => {
+    calls++;
+    return { success: true as const };
+  };
+  await Promise.all([
+    deliverAlarmEmails(result.emailIds, send, now),
+    deliverAlarmEmails(result.emailIds, send, now),
+  ]);
+  assert.equal(calls, 2);
+  const next = await fixture(),
+    queued = await next.create();
+  await prisma.user.update({
+    where: { id: next.p1.id },
+    data: { familyId: next.otherFamily.id },
+  });
+  const token = (await next.recipients(queued.alarmId!)).find(
+    (r) => r.userId === next.p1.id,
+  )!.token;
+  assert.equal(await getPublicAlarm(token), null);
+  const sent = await deliverAlarmEmails(queued.emailIds, send, now);
+  assert.equal(sent.sent, 1);
+});
+
+test("Abgelaufene Tokens können nicht antworten und abgelaufene Anfragen werden nicht versendet", async () => {
+  const f = await fixture(),
+    result = await f.create({
+      wholeDay: false,
+      startMinute: 480,
+      endMinute: 540,
+    });
+  const alarm = await prisma.notdienstAlarm.findUniqueOrThrow({
+    where: { id: result.alarmId },
+  });
+  await assert.rejects(
+    respondToAlarm(
+      (await f.recipients(alarm.id))[0].token,
+      true,
+      alarm.expiresAt,
+    ),
+    /abgelaufen/,
+  );
+  let calls = 0;
+  await deliverAlarmEmails(
+    result.emailIds,
+    async () => {
+      calls++;
+      return { success: true };
+    },
+    alarm.expiresAt,
+  );
+  assert.equal(calls, 0);
+  await processAlarmDeadlines(alarm.expiresAt, f.kita.id);
+  assert.equal(
+    (await prisma.notdienstAlarm.findUniqueOrThrow({ where: { id: alarm.id } }))
+      .activeAssignmentId,
+    null,
+  );
+});
+
+test("Bisherige Einzelalarme werden vorsichtig übernommen und Originalstatus bleibt erhalten", async () => {
+  const f = await fixture();
+  for (const [user, status] of [
+    [f.p1, "CONFIRMED"],
+    [f.p2, "PENDING"],
+  ] as const)
+    await prisma.notdienstAlert.create({
+      data: {
+        kitaId: f.kita.id,
+        assignmentId: f.assignment.id,
+        parentUserId: user.id,
+        confirmationToken: randomUUID(),
+        status,
+        triggeredAt: now,
+      },
+    });
+  await assert.rejects(
+    assertAssignmentNotAlarmed(prisma, f.assignment.id, f.kita.id),
+    /aktiver Alarm/,
+  );
+  assert.equal(await importLegacyAlarms(f.kita.id), 1);
+  assert.equal(await importLegacyAlarms(f.kita.id), 0);
+  const alarm = await prisma.notdienstAlarm.findFirstOrThrow({
+    where: { kitaId: f.kita.id },
+  });
+  assert.equal(alarm.status, "REVIEW_REQUIRED");
+  assert.equal(
+    await prisma.notdienstAlarmEmail.count({ where: { alarmId: alarm.id } }),
+    0,
+  );
+  const legacy = await prisma.notdienstAlert.findMany({
+    where: { kitaId: f.kita.id },
+  });
+  assert.deepEqual(legacy.map((l) => l.status).sort(), [
+    "CONFIRMED",
+    "PENDING",
+  ]);
+  assert.equal(
+    (await getPublicAlarm(legacy[0].confirmationToken))?.status,
+    "REVIEW_REQUIRED",
+  );
+});
+
+test("Gültige alte Links werden gemeinsam übernommen; unzuständige Konten können sie nicht benutzen", async () => {
+  const f = await fixture();
+  const tokens = [randomUUID(), randomUUID()];
+  for (const [index, user] of [f.p1, f.p2].entries())
+    await prisma.notdienstAlert.create({
+      data: {
+        kitaId: f.kita.id,
+        assignmentId: f.assignment.id,
+        parentUserId: user.id,
+        confirmationToken: tokens[index],
+        triggeredAt: now,
+      },
+    });
+  assert.equal((await getPublicAlarm(tokens[0]))?.status, "PENDING");
+  await respondToAlarm(tokens[0], true, now);
+  assert.equal((await getPublicAlarm(tokens[1]))?.status, "CONFIRMED");
+  await prisma.user.update({
+    where: { id: f.p2.id },
+    data: { role: "ERZIEHER" },
+  });
+  assert.equal(await getPublicAlarm(tokens[1]), null);
+  await assert.rejects(respondToAlarm(tokens[1], false, now), /Ungültiger/);
+});
+
+test("Jobzugriff benötigt ein eigenes langes Secret und validiert den Bearer-Header", () => {
+  const secret = "test-only-notdienst-alarm-secret-0123456789";
+  assert.equal(authorizeAlarmJob(null, ""), 503);
+  assert.equal(authorizeAlarmJob(null, secret), 401);
+  assert.equal(authorizeAlarmJob(`Bearer ${secret}x`, secret), 401);
+  assert.equal(authorizeAlarmJob(`Bearer ${secret}`, secret), 200);
+});

tests/staff-calculations.test.ts

@@ -0,0 +1,237 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  calculateLeaveDays,
+  calculateWeek,
+  dateOnly,
+  dateSchema,
+  getTimeBalance,
+  scheduledMinutes,
+  todayKey,
+  vacationBalance,
+  weekStart,
+} from "../src/lib/staff/calculations";
+
+const profile = {
+  employmentStart: dateOnly("2026-01-01"),
+  employmentEnd: null,
+  trackingStart: dateOnly("2026-01-01"),
+  openingMinutes: 120,
+  workPatterns: [
+    {
+      effectiveFrom: dateOnly("2026-01-01"),
+      dailyMinutes: [360, 360, 0, 360, 0, 0, 0],
+    },
+  ],
+  dayOverrides: [],
+};
+const holidays = new Set(["2026-01-06"]);
+const days = (date: string, vacationUnits: number, creditMinutes = 360) => [
+  { date: dateOnly(date), vacationUnits, creditMinutes },
+];
+
+test("Teilzeiturlaub verbraucht nur feste Arbeitstage, Feiertage werden übersprungen", () => {
+  const result = calculateLeaveDays(profile, holidays, {
+    kind: "VACATION",
+    startDate: "2026-01-05",
+    endDate: "2026-01-11",
+    halfDay: false,
+  });
+  assert.deepEqual(
+    result.map((d) => d.date),
+    ["2026-01-05", "2026-01-08"],
+  );
+  assert.equal(
+    result.reduce((s, d) => s + d.vacationUnits, 0),
+    4,
+  );
+});
+test("Halber Urlaubstag entspricht halbem Tages-Soll", () => {
+  assert.deepEqual(
+    calculateLeaveDays(profile, new Set(), {
+      kind: "VACATION",
+      startDate: "2026-01-05",
+      endDate: "2026-01-05",
+      halfDay: true,
+    }),
+    [{ date: "2026-01-05", vacationUnits: 1, creditMinutes: 180 }],
+  );
+  assert.throws(() =>
+    calculateLeaveDays(profile, holidays, {
+      kind: "VACATION",
+      startDate: "2026-01-05",
+      endDate: "2026-01-08",
+      halfDay: true,
+    }),
+  );
+});
+test("Tagesausnahmen und datierte Modelle verändern nur den vorgesehenen Zeitraum", () => {
+  const schedule = {
+    ...profile,
+    dayOverrides: [{ date: dateOnly("2026-01-07"), minutes: 240 }],
+    workPatterns: [
+      ...profile.workPatterns,
+      {
+        effectiveFrom: dateOnly("2026-02-01"),
+        dailyMinutes: [480, 0, 480, 0, 0, 0, 0],
+      },
+    ],
+  };
+  assert.equal(scheduledMinutes(schedule, "2026-01-07", holidays), 240);
+  assert.equal(scheduledMinutes(schedule, "2026-01-05", holidays), 360);
+  assert.equal(scheduledMinutes(schedule, "2026-02-02", holidays), 480);
+  assert.equal(scheduledMinutes(schedule, "2026-01-06", holidays), 0);
+  assert.equal(
+    scheduledMinutes(
+      { ...schedule, employmentEnd: dateOnly("2026-01-31") },
+      "2026-02-02",
+      holidays,
+    ),
+    0,
+  );
+});
+test("Urlaub über Jahreswechsel wird auf die Jahreskonten verteilt", () => {
+  const leave = [
+    {
+      kind: "VACATION",
+      status: "APPROVED",
+      days: [...days("2026-12-31", 2), ...days("2027-01-04", 1)],
+    },
+  ];
+  assert.equal(
+    vacationBalance(
+      { year: 2026, entitlementUnits: 40, carryUnits: 2 },
+      leave,
+      "2026-10-01",
+    ).planned,
+    2,
+  );
+  assert.equal(
+    vacationBalance(
+      { year: 2027, entitlementUnits: 40, carryUnits: 0 },
+      leave,
+      "2026-10-01",
+    ).planned,
+    1,
+  );
+});
+test("Offene Stornierung bleibt gebucht, Ablehnung und Stornierung verbrauchen nichts", () => {
+  const leave = [
+    {
+      kind: "VACATION",
+      status: "CANCEL_REQUESTED",
+      days: days("2026-01-05", 2),
+    },
+    { kind: "VACATION", status: "PENDING", days: days("2026-01-08", 1) },
+    ...["CANCELLED", "REJECTED"].map((status) => ({
+      kind: "VACATION",
+      status,
+      days: days("2026-01-12", 2),
+    })),
+  ];
+  assert.deepEqual(
+    vacationBalance(
+      { year: 2026, entitlementUnits: 40, carryUnits: 4 },
+      leave,
+      "2026-01-07",
+    ),
+    { entitlement: 44, taken: 2, planned: 0, pending: 1, available: 42 },
+  );
+});
+test("Mehrere Arbeitsblöcke abzüglich Pausen, Urlaub und Krankheit ergeben die Wochenbilanz", () => {
+  const entries = [
+    {
+      date: dateOnly("2026-01-05"),
+      startMinute: 480,
+      endMinute: 720,
+      breakMinutes: 30,
+    },
+    {
+      date: dateOnly("2026-01-05"),
+      startMinute: 780,
+      endMinute: 960,
+      breakMinutes: 0,
+    },
+  ];
+  const leave = [
+    { kind: "SICKNESS", status: "APPROVED", days: days("2026-01-08", 0) },
+  ];
+  const result = calculateWeek(profile, holidays, "2026-01-05", entries, leave);
+  assert.equal(result[0].worked, 390);
+  assert.equal(result[0].balance, 30);
+  assert.equal(result[1].expected, 0);
+  assert.equal(result[3].credit, 360);
+  assert.equal(result[3].balance, 0);
+});
+test("Nur genehmigte Snapshots zählen; Zukunftskorrekturen zählen erst ab Datum", () => {
+  const snapshot = [
+    {
+      date: "2026-01-05",
+      expected: 360,
+      worked: 420,
+      credit: 0,
+      timeOff: 0,
+      balance: 60,
+    },
+  ];
+  const result = getTimeBalance(
+    profile,
+    [
+      { status: "APPROVED", dailySnapshot: snapshot },
+      { status: "SUBMITTED", dailySnapshot: snapshot },
+    ],
+    [{ date: dateOnly("2026-02-01"), minutes: 100 }],
+    [],
+    "2026-01-10",
+  );
+  assert.equal(result.confirmed, 180);
+});
+test("Freizeitausgleich wird reserviert und nach Wochenbuchung genau einmal abgezogen", () => {
+  const leave = [
+    { kind: "TIME_OFF", status: "APPROVED", days: days("2026-01-05", 0, 60) },
+  ];
+  const initial = getTimeBalance(profile, [], [], leave, "2026-01-04");
+  assert.deepEqual(initial, { confirmed: 120, reserved: 60, available: 60 });
+  const snapshot = [
+    {
+      date: "2026-01-05",
+      expected: 360,
+      worked: 300,
+      credit: 0,
+      timeOff: 60,
+      balance: -60,
+    },
+  ];
+  assert.deepEqual(
+    getTimeBalance(
+      profile,
+      [{ status: "APPROVED", dailySnapshot: snapshot }],
+      [],
+      leave,
+      "2026-01-06",
+    ),
+    { confirmed: 60, reserved: 0, available: 60 },
+  );
+  const computed = calculateWeek(
+    profile,
+    new Set(),
+    "2026-01-05",
+    [
+      {
+        date: dateOnly("2026-01-05"),
+        startMinute: 480,
+        endMinute: 780,
+        breakMinutes: 0,
+      },
+    ],
+    leave,
+  );
+  assert.equal(computed[0].credit, 0);
+  assert.equal(computed[0].balance, -60);
+});
+test("Ungültige Kalendertage werden abgewiesen; Tagesdatum wird in Berlin bestimmt", () => {
+  assert.equal(dateSchema.safeParse("2026-02-30").success, false);
+  assert.equal(dateSchema.safeParse("2028-02-29").success, true);
+  assert.equal(todayKey(new Date("2026-01-04T23:30:00Z")), "2026-01-05");
+  assert.equal(weekStart("2026-01-11"), "2026-01-05");
+});

tests/staff-service.test.ts

@@ -0,0 +1,711 @@
+import { after, test } from "node:test";
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { UserRole } from "@prisma/client";
+import { prisma } from "../src/lib/prisma";
+import {
+  executeStaffCommand,
+  getStaffProfile,
+  type StaffActor,
+} from "../src/lib/staff/service";
+import { dateOnly, getTimeBalance } from "../src/lib/staff/calculations";
+import { deliverStaffEmails } from "../src/lib/staff/email";
+import { render } from "@react-email/render";
+
+process.env.AUTH_URL = "http://127.0.0.1:3008";
+
+// Never run integration tests against a user's application database.
+const db = new URL(process.env.DATABASE_URL ?? "postgresql://invalid");
+if (
+  db.hostname !== "127.0.0.1" ||
+  db.port !== "55439" ||
+  db.pathname !== "/kita_staff_test"
+)
+  throw new Error(
+    "Integrationstests benötigen die isolierte Datenbank 127.0.0.1:55439/kita_staff_test.",
+  );
+const tenants: string[] = [];
+after(async () => {
+  await prisma.kita.deleteMany({ where: { id: { in: tenants } } });
+  await prisma.$disconnect();
+});
+async function fixture() {
+  const kita = await prisma.kita.create({
+    data: { name: "Testkita", slug: `staff-test-${randomUUID()}` },
+  });
+  tenants.push(kita.id);
+  const createUser = (role: UserRole) =>
+    prisma.user.create({
+      data: {
+        kitaId: kita.id,
+        email: `${randomUUID()}@staff-test.invalid`,
+        passwordHash: "test-only",
+        firstName: "Test",
+        lastName: role,
+        role,
+        privacyPolicyAcceptedAt: new Date(),
+      },
+    });
+  const adminUser = await createUser("ADMIN"),
+    staffUser = await createUser("ERZIEHER"),
+    otherUser = await createUser("ERZIEHER"),
+    parentUser = await createUser("ELTERN");
+  const actor = (u: typeof adminUser): StaffActor => ({
+    id: u.id,
+    kitaId: kita.id,
+    role: u.role,
+  });
+  const admin = actor(adminUser),
+    staff = actor(staffUser),
+    other = actor(otherUser),
+    parent = actor(parentUser);
+  const educator = await prisma.educator.create({
+    data: { kitaId: kita.id, firstName: "Test", lastName: "Fachkraft" },
+  });
+  await executeStaffCommand(admin, {
+    command: "setup",
+    data: {
+      educatorId: educator.id,
+      employmentStart: "2026-01-01",
+      employmentEnd: null,
+      trackingStart: "2026-01-01",
+      openingMinutes: 600,
+      reason: "Testeinrichtung",
+    },
+  });
+  const profile = await prisma.staffProfile.update({
+    where: { educatorId: educator.id },
+    data: { userId: staffUser.id },
+  });
+  const run = (
+    who: StaffActor,
+    command: string,
+    data: Record<string, unknown> = {},
+  ) =>
+    executeStaffCommand(who, {
+      command,
+      data: { profileId: profile.id, ...data },
+    });
+  await run(admin, "pattern", {
+    effectiveFrom: "2026-01-01",
+    dailyMinutes: [360, 360, 0, 360, 0, 0, 0],
+    reason: "Feste Teilzeit",
+  });
+  await run(admin, "account", {
+    year: 2026,
+    entitlementUnits: 40,
+    carryUnits: 0,
+    reason: "Jahresanspruch",
+  });
+  return {
+    kita,
+    profile,
+    educator,
+    admin,
+    staff,
+    other,
+    parent,
+    run,
+    staffUser,
+  };
+}
+test("E-Mail-Aufträge gehen an alle Admins derselben Kita; Versandfehler bleiben wiederholbar", async () => {
+  const f = await fixture(),
+    foreign = await fixture();
+  const second = await prisma.user.create({
+    data: {
+      kitaId: f.kita.id,
+      email: `${randomUUID()}@staff-test.invalid`,
+      passwordHash: "test-only",
+      firstName: "Zweiter",
+      lastName: "Admin",
+      role: "ADMIN",
+      privacyPolicyAcceptedAt: new Date(),
+    },
+  });
+  const result = await f.run(f.staff, "leave", {
+    ...vacation(),
+    note: "VERTRAULICHE_NOTIZ",
+  });
+  const jobs = await prisma.staffEmail.findMany({
+    where: { id: { in: result.emailIds! } },
+  });
+  assert.deepEqual(
+    jobs.map((j) => j.userId).sort(),
+    [f.admin.id, second.id].sort(),
+  );
+  assert.ok(jobs.every((j) => !j.message.includes("VERTRAULICHE_NOTIZ")));
+  assert.equal((await f.run(f.other, "emailRetry")).emailIds?.length, 0);
+  assert.equal(
+    (await foreign.run(foreign.admin, "emailRetry")).emailIds?.length,
+    0,
+  );
+  const failure = await deliverStaffEmails(result.emailIds!, async () => ({
+    success: false,
+    error: "Testausfall",
+  }));
+  assert.equal(failure.failed, 2);
+  assert.equal(
+    await prisma.staffLeave.count({ where: { profileId: f.profile.id } }),
+    1,
+  );
+  const retry = await f.run(f.admin, "emailRetry");
+  const messages: string[] = [];
+  const delivered = await deliverStaffEmails(retry.emailIds!, async (input) => {
+    messages.push(await render(input.react));
+    assert.ok(input.idempotencyKey?.startsWith("staff-email/"));
+    return { success: true, id: "test-only" };
+  });
+  assert.equal(delivered.sent, 2);
+  assert.ok(
+    messages.every(
+      (html) =>
+        html.includes("2026-01-05") && !html.includes("VERTRAULICHE_NOTIZ"),
+    ),
+  );
+  assert.equal((await f.run(f.admin, "emailRetry")).emailIds?.length, 0);
+});
+
+test("Fachkräfte schalten nur eigene Entscheidungsmails ab; interne Hinweise bleiben erhalten", async () => {
+  const f = await fixture();
+  await f.run(f.staff, "leave", vacation());
+  const leave = await prisma.staffLeave.findFirstOrThrow({
+    where: { profileId: f.profile.id },
+  });
+  const decision = await f.run(f.admin, "leaveReview", {
+    id: leave.id,
+    approve: true,
+    reason: "PRIVATE_BEGRUENDUNG",
+  });
+  assert.equal(decision.emailIds?.length, 1);
+  const queued = await prisma.staffEmail.findUniqueOrThrow({
+    where: { id: decision.emailIds![0] },
+  });
+  assert.equal(queued.userId, f.staff.id);
+  assert.ok(!queued.message.includes("PRIVATE_BEGRUENDUNG"));
+  await f.run(f.staff, "emailPreference", { enabled: false });
+  assert.equal(
+    (await prisma.user.findUniqueOrThrow({ where: { id: f.other.id } }))
+      .staffDecisionEmails,
+    true,
+  );
+  let calls = 0;
+  await deliverStaffEmails(decision.emailIds!, async () => {
+    calls++;
+    return { success: true };
+  });
+  assert.equal(calls, 0);
+  await f.run(f.staff, "leave", vacation("2026-01-06"));
+  const next = await prisma.staffLeave.findFirstOrThrow({
+    where: { profileId: f.profile.id, startDate: dateOnly("2026-01-06") },
+  });
+  const disabled = await f.run(f.admin, "leaveReview", {
+    id: next.id,
+    approve: false,
+    reason: "Testentscheidung",
+  });
+  assert.equal(disabled.emailIds?.length, 0);
+  assert.ok(
+    (await prisma.staffNotification.count({ where: { userId: f.staff.id } })) >=
+      2,
+  );
+  const sickness = await f.run(f.admin, "leave", {
+    ...vacation("2026-01-08"),
+    kind: "SICKNESS",
+  });
+  assert.equal(sickness.emailIds?.length, 0);
+  await assert.rejects(
+    f.run(f.admin, "emailPreference", { enabled: false }),
+    /Fachkräfte/,
+  );
+});
+
+test("Arbeitswochen erzeugen getrennte Einreichungs- und Entscheidungsmails ohne private Rückmeldung", async () => {
+  const f = await fixture();
+  const submitted = await f.run(f.staff, "weekSubmit", {
+    weekStart: "2026-01-05",
+  });
+  const adminJob = await prisma.staffEmail.findUniqueOrThrow({
+    where: { id: submitted.emailIds![0] },
+  });
+  assert.equal(adminJob.userId, f.admin.id);
+  assert.ok(adminJob.path.includes("week=2026-01-05"));
+  const reviewed = await f.run(f.admin, "weekReview", {
+    weekStart: "2026-01-05",
+    approve: false,
+    reason: "PRIVATE_RUECKMELDUNG",
+  });
+  const job = await prisma.staffEmail.findUniqueOrThrow({
+    where: { id: reviewed.emailIds![0] },
+  });
+  assert.equal(job.userId, f.staff.id);
+  assert.ok(job.message.includes("zur Korrektur"));
+  assert.ok(!job.message.includes("PRIVATE_RUECKMELDUNG"));
+});
+
+test("Erneuerte Aktivierungslinks ersetzen ausstehende alte Mails und funktionieren trotz Opt-out", async () => {
+  const f = await fixture();
+  await prisma.staffProfile.update({
+    where: { id: f.profile.id },
+    data: { userId: null },
+  });
+  const email = `${randomUUID()}@staff-test.invalid`;
+  const old = await f.run(f.admin, "invite", { email });
+  const linked = await prisma.user.findUniqueOrThrow({ where: { email } });
+  await prisma.user.update({
+    where: { id: linked.id },
+    data: { staffDecisionEmails: false },
+  });
+  const renewed = await f.run(f.admin, "invite", { email });
+  const html: string[] = [];
+  const result = await deliverStaffEmails(
+    [...old.emailIds!, ...renewed.emailIds!],
+    async (input) => {
+      assert.equal(input.to, email);
+      html.push(await render(input.react, { plainText: true }));
+      return { success: true };
+    },
+  );
+  assert.equal(result.sent, 1);
+  assert.ok(html[0].includes(renewed.invite!.token));
+  assert.ok(!html[0].includes(old.invite!.token));
+  assert.ok(
+    html[0].includes("Fachkraft-Account") && html[0].includes("sieben Tage"),
+  );
+});
+
+test("Parallele Versandversuche senden einmal und beachten inzwischen entzogene Rollen", async () => {
+  const f = await fixture();
+  const result = await f.run(f.staff, "leave", vacation());
+  let calls = 0;
+  const send = async () => {
+    calls++;
+    return { success: true as const };
+  };
+  await Promise.all([
+    deliverStaffEmails(result.emailIds!, send),
+    deliverStaffEmails(result.emailIds!, send),
+  ]);
+  assert.equal(calls, 1);
+  await deliverStaffEmails(result.emailIds!, send);
+  assert.equal(calls, 1);
+  const changed = await f.run(f.staff, "leave", vacation("2026-01-06"));
+  await prisma.user.update({
+    where: { id: f.admin.id },
+    data: { role: "ELTERN" },
+  });
+  await deliverStaffEmails(changed.emailIds!, send);
+  assert.equal(calls, 1);
+});
+
+const vacation = (date = "2026-01-05") => ({
+  kind: "VACATION",
+  startDate: date,
+  endDate: date,
+  halfDay: false,
+  note: "Testurlaub",
+});
+const time = (date = "2026-01-05", startMinute = 480, endMinute = 840) => ({
+  date,
+  startMinute,
+  endMinute,
+  breakMinutes: 0,
+});
+
+test("Mandanten, Rollen und Eigentümer werden für Lesen und Schreiben geprüft", async () => {
+  const f = await fixture(),
+    foreign = await fixture();
+  await assert.rejects(
+    f.run(f.other, "time", time()),
+    /eigenes Personalprofil/,
+  );
+  await assert.rejects(f.run(f.parent, "time", time()), /Kein Zugriff/);
+  await assert.rejects(
+    f.run(f.staff, "account", {
+      year: 2026,
+      entitlementUnits: 100,
+      carryUnits: 0,
+      reason: "Versuch",
+    }),
+    /Nur Kita-Admins/,
+  );
+  await assert.rejects(f.run(foreign.admin, "time", time()), /nicht gefunden/);
+  await assert.rejects(
+    f.run({ ...f.admin, kitaId: foreign.kita.id }, "time", time()),
+    /keinen Zugriff/,
+  );
+  assert.equal(await getStaffProfile(f.other, f.profile.id), null);
+  assert.equal(await getStaffProfile(foreign.admin, f.profile.id), null);
+  await assert.rejects(getStaffProfile(f.parent, f.profile.id), /Kein Zugriff/);
+});
+test("Urlaubsantrag, Freigabe, Stornierung und interne Hinweise bleiben konsistent", async () => {
+  const f = await fixture();
+  await f.run(f.staff, "leave", vacation());
+  const leave = await prisma.staffLeave.findFirstOrThrow({
+    where: { profileId: f.profile.id },
+    include: { days: true },
+  });
+  assert.equal(leave.days[0].vacationUnits, 2);
+  assert.equal(
+    await prisma.staffNotification.count({ where: { userId: f.admin.id } }),
+    1,
+  );
+  await f.run(f.admin, "leaveReview", {
+    id: leave.id,
+    approve: true,
+    reason: "Freigegeben",
+  });
+  await f.run(f.staff, "leaveCancel", { id: leave.id });
+  assert.equal(
+    (await prisma.staffLeave.findUniqueOrThrow({ where: { id: leave.id } }))
+      .status,
+    "CANCEL_REQUESTED",
+  );
+  await f.run(f.admin, "leaveReview", {
+    id: leave.id,
+    approve: true,
+    reason: "Stornierung bestätigt",
+  });
+  assert.equal(
+    (await prisma.staffLeave.findUniqueOrThrow({ where: { id: leave.id } }))
+      .status,
+    "CANCELLED",
+  );
+  assert.equal(
+    await prisma.staffNotification.count({ where: { userId: f.staff.id } }),
+    2,
+  );
+  const notice = await prisma.staffNotification.findFirstOrThrow({
+    where: { userId: f.staff.id },
+  });
+  await f.run(f.admin, "noticeRead", { id: notice.id });
+  assert.equal(
+    (
+      await prisma.staffNotification.findUniqueOrThrow({
+        where: { id: notice.id },
+      })
+    ).readAt,
+    null,
+  );
+  await f.run(f.staff, "noticeRead", { id: notice.id });
+  assert.ok(
+    (
+      await prisma.staffNotification.findUniqueOrThrow({
+        where: { id: notice.id },
+      })
+    ).readAt,
+  );
+});
+test("Offene Urlaube reservieren den Anspruch und lassen sich nur im offenen Status ändern", async () => {
+  const f = await fixture();
+  await f.run(f.admin, "account", {
+    year: 2026,
+    entitlementUnits: 2,
+    carryUnits: 0,
+    reason: "Ein Tag",
+  });
+  await f.run(f.staff, "leave", vacation());
+  await assert.rejects(
+    f.run(f.staff, "leave", vacation("2026-01-08")),
+    /reichen.*nicht aus/,
+  );
+  const leave = await prisma.staffLeave.findFirstOrThrow({
+    where: { profileId: f.profile.id },
+  });
+  await f.run(f.staff, "leave", { ...vacation("2026-01-08"), id: leave.id });
+  await f.run(f.admin, "leaveReview", {
+    id: leave.id,
+    approve: true,
+    reason: "Genehmigung",
+  });
+  await assert.rejects(
+    f.run(f.staff, "leave", { ...vacation(), id: leave.id }),
+    /Nur offene/,
+  );
+});
+test("Überlappende Arbeitsblöcke und parallele Urlaubsanträge werden verhindert", async () => {
+  const f = await fixture();
+  await f.run(f.staff, "time", time());
+  await assert.rejects(
+    f.run(f.staff, "time", time("2026-01-05", 800, 900)),
+    /überschneidet/,
+  );
+  await f.run(f.admin, "account", {
+    year: 2026,
+    entitlementUnits: 2,
+    carryUnits: 0,
+    reason: "Ein Tag",
+  });
+  const results = await Promise.allSettled([
+    f.run(f.staff, "leave", vacation("2026-01-08")),
+    f.run(f.staff, "leave", vacation("2026-01-12")),
+  ]);
+  assert.equal(results.filter((r) => r.status === "fulfilled").length, 1);
+  assert.equal(
+    await prisma.staffLeave.count({ where: { profileId: f.profile.id } }),
+    1,
+  );
+});
+test("Wochenfreigabe schützt Zeiten, Modelle und Feiertage; Rückgabe erlaubt Korrektur", async () => {
+  const f = await fixture();
+  for (const date of ["2026-01-05", "2026-01-06", "2026-01-08"])
+    await f.run(
+      f.staff,
+      "time",
+      time(date, 480, date === "2026-01-05" ? 900 : 840),
+    );
+  await f.run(f.staff, "weekSubmit", { weekStart: "2026-01-05" });
+  await assert.rejects(
+    f.run(f.staff, "time", time("2026-01-05", 1000, 1100)),
+    /zuerst.*zurückgeben/,
+  );
+  await f.run(f.admin, "weekReview", {
+    weekStart: "2026-01-05",
+    approve: true,
+    reason: "Zeiten geprüft",
+  });
+  let p = await getStaffProfile(f.staff);
+  assert.ok(p);
+  assert.equal(
+    getTimeBalance(p, p.weeks, p.adjustments, p.leaves).confirmed,
+    660,
+  );
+  await assert.rejects(
+    f.run(f.admin, "pattern", {
+      effectiveFrom: "2026-01-01",
+      dailyMinutes: [480, 480, 0, 480, 0, 0, 0],
+      reason: "Änderung",
+    }),
+    /bestehen bereits Freigaben/,
+  );
+  await assert.rejects(
+    f.run(f.admin, "holiday", { date: "2026-01-05", name: "Feiertag" }),
+    /bestehen bereits Freigaben/,
+  );
+  await f.run(f.admin, "weekReview", {
+    weekStart: "2026-01-05",
+    approve: false,
+    reason: "Bitte Pause prüfen",
+  });
+  p = await getStaffProfile(f.staff);
+  assert.ok(p);
+  assert.equal(
+    getTimeBalance(p, p.weeks, p.adjustments, p.leaves).confirmed,
+    600,
+  );
+  await f.run(f.staff, "time", time("2026-01-05", 1000, 1100));
+});
+test("Freizeitausgleich bleibt bei Storno reserviert und wird mit der Woche einmal verrechnet", async () => {
+  const f = await fixture();
+  await f.run(f.staff, "leave", {
+    kind: "TIME_OFF",
+    startDate: "2026-01-05",
+    endDate: "2026-01-05",
+    halfDay: false,
+    minutes: 60,
+  });
+  const leave = await prisma.staffLeave.findFirstOrThrow({
+    where: { profileId: f.profile.id },
+  });
+  await f.run(f.admin, "leaveReview", {
+    id: leave.id,
+    approve: true,
+    reason: "Guthaben geprüft",
+  });
+  let p = await getStaffProfile(f.staff);
+  assert.ok(p);
+  assert.equal(
+    getTimeBalance(p, p.weeks, p.adjustments, p.leaves).available,
+    540,
+  );
+  for (const date of ["2026-01-05", "2026-01-06", "2026-01-08"])
+    await f.run(
+      f.staff,
+      "time",
+      time(date, 480, date === "2026-01-05" ? 780 : 840),
+    );
+  await f.run(f.staff, "weekSubmit", { weekStart: "2026-01-05" });
+  await f.run(f.staff, "leaveCancel", { id: leave.id });
+  await assert.rejects(
+    f.run(f.admin, "weekReview", {
+      weekStart: "2026-01-05",
+      approve: true,
+      reason: "Geprüft",
+    }),
+    /offene Abwesenheiten/,
+  );
+  await f.run(f.admin, "leaveReview", {
+    id: leave.id,
+    approve: false,
+    reason: "Stornierung abgelehnt",
+  });
+  await f.run(f.admin, "weekReview", {
+    weekStart: "2026-01-05",
+    approve: true,
+    reason: "Geprüft",
+  });
+  p = await getStaffProfile(f.staff);
+  assert.ok(p);
+  assert.deepEqual(getTimeBalance(p, p.weeks, p.adjustments, p.leaves), {
+    confirmed: 540,
+    reserved: 0,
+    available: 540,
+  });
+});
+test("Halbtagsurlaub lässt nur die verbleibende Sollzeit als Arbeitszeit zu", async () => {
+  const f = await fixture();
+  await f.run(f.staff, "leave", { ...vacation(), halfDay: true });
+  const leave = await prisma.staffLeave.findFirstOrThrow({
+    where: { profileId: f.profile.id },
+  });
+  await f.run(f.admin, "leaveReview", {
+    id: leave.id,
+    approve: true,
+    reason: "Halber Tag",
+  });
+  await f.run(f.staff, "time", time("2026-01-05", 480, 660));
+  await assert.rejects(
+    f.run(f.staff, "time", time("2026-01-05", 700, 760)),
+    /überschreiten.*Sollzeit/,
+  );
+});
+test("Aktivierungslinks verknüpfen nur passende Accounts und werden bei Erneuerung ersetzt", async () => {
+  const f = await fixture();
+  const educator = await prisma.educator.create({
+    data: { kitaId: f.kita.id, firstName: "Neue", lastName: "Fachkraft" },
+  });
+  await f.run(f.admin, "setup", {
+    educatorId: educator.id,
+    employmentStart: "2026-01-01",
+    employmentEnd: null,
+    trackingStart: "2026-01-01",
+    openingMinutes: 0,
+    reason: "Einrichtung",
+  });
+  const profile = await prisma.staffProfile.findUniqueOrThrow({
+    where: { educatorId: educator.id },
+  });
+  const email = `${randomUUID()}@staff-test.invalid`;
+  const first = await f.run(f.admin, "invite", {
+    profileId: profile.id,
+    email,
+  });
+  assert.ok(first.invite);
+  const second = await f.run(f.admin, "invite", {
+    profileId: profile.id,
+    email,
+  });
+  assert.ok(second.invite);
+  assert.equal(
+    await prisma.verificationToken.count({
+      where: { token: first.invite.token },
+    }),
+    0,
+  );
+  const linked = await prisma.staffProfile.findUniqueOrThrow({
+    where: { id: profile.id },
+    include: { user: true },
+  });
+  assert.equal(linked.user?.role, "ERZIEHER");
+  assert.equal(linked.user?.passwordHash, "");
+  await assert.rejects(
+    f.run(f.admin, "invite", {
+      profileId: profile.id,
+      email: f.staffUser.email,
+    }),
+    /bereits einen Account/,
+  );
+  await prisma.verificationToken.deleteMany({
+    where: { identifier: linked.userId! },
+  });
+});
+test("Krankheit ist adminverwaltet, entlastet Sollzeit und verbraucht keinen Urlaub", async () => {
+  const f = await fixture();
+  const input = {
+    kind: "SICKNESS",
+    startDate: "2026-01-08",
+    endDate: "2026-01-08",
+    halfDay: false,
+  };
+  await assert.rejects(f.run(f.staff, "leave", input), /Nur Kita-Admins/);
+  await f.run(f.admin, "leave", input);
+  const leave = await prisma.staffLeave.findFirstOrThrow({
+    where: { profileId: f.profile.id },
+    include: { days: true },
+  });
+  assert.equal(leave.status, "APPROVED");
+  assert.equal(leave.days[0].creditMinutes, 360);
+  assert.equal(leave.days[0].vacationUnits, 0);
+  assert.equal(leave.days[0].date.getTime(), dateOnly("2026-01-08").getTime());
+});
+
+test("Beschäftigungsende bleibt nach Erfassungsstart verwaltbar und schützt vorhandene Zeiten", async () => {
+  const f = await fixture();
+  await f.run(f.staff, "time", time());
+  await f.run(f.admin, "employmentEnd", {
+    employmentEnd: "2026-01-31",
+    reason: "Vertragsende",
+  });
+  await assert.rejects(
+    f.run(f.staff, "time", time("2026-02-02")),
+    /innerhalb des Erfassungszeitraums/,
+  );
+  await assert.rejects(
+    f.run(f.admin, "employmentEnd", {
+      employmentEnd: "2026-01-04",
+      reason: "Zu früh",
+    }),
+    /aktive Anträge/,
+  );
+  await f.run(f.admin, "employmentEnd", {
+    employmentEnd: null,
+    reason: "Vertrag verlängert",
+  });
+  await f.run(f.staff, "time", time("2026-02-02"));
+});
+
+test("Personalaufzeichnungen sind vor Fachkraftlöschung geschützt und bleiben nach Accountlöschung erhalten", async () => {
+  const f = await fixture();
+  await f.run(f.staff, "time", time());
+  await assert.rejects(
+    prisma.educator.delete({ where: { id: f.educator.id } }),
+    (error: unknown) =>
+      typeof error === "object" &&
+      error !== null &&
+      "code" in error &&
+      error.code === "P2003",
+  );
+  await prisma.user.delete({ where: { id: f.staff.id } });
+  const profile = await prisma.staffProfile.findUniqueOrThrow({
+    where: { id: f.profile.id },
+    include: { timeEntries: true },
+  });
+  assert.equal(profile.userId, null);
+  assert.equal(profile.timeEntries.length, 1);
+});
+
+test("Entzogene Rollen, fehlender Consent und gesperrte Accounts können keine Personalaktionen ausführen", async () => {
+  const f = await fixture();
+  await assert.rejects(
+    f.run({ ...f.staff, role: "ADMIN" }, "account", {
+      year: 2026,
+      entitlementUnits: 100,
+      carryUnits: 0,
+      reason: "Manipulation",
+    }),
+    /keinen Zugriff/,
+  );
+  await prisma.user.update({
+    where: { id: f.staff.id },
+    data: { privacyPolicyAcceptedAt: null },
+  });
+  await assert.rejects(f.run(f.staff, "time", time()), /keinen Zugriff/);
+  await prisma.user.update({
+    where: { id: f.staff.id },
+    data: {
+      privacyPolicyAcceptedAt: new Date(),
+      lockedUntil: new Date(Date.now() + 60000),
+    },
+  });
+  await assert.rejects(f.run(f.staff, "time", time()), /keinen Zugriff/);
+});